Blog: Games of October 2019

October was a month where I didn't really have a game I was setting out to play. I've hit a point where I'm a little tired of Three Houses. I played a lot of Dragon Quest as a game to relax with and then somewhat distracted myself with EU 4 a few days in the month. It's also been one of those months where I've found myself watching more things rather than playing, which is often a mid-semester thing for me.

My top five games (by play time) for October were:

1. Dragon Quest XI - As a game to pick up in the evenings and play for a little bit, DQ XI has been great. The feel of the game is very good, even while I have some concerns with other factors about the game.
   
   

   

   Hello! Everything is fine! Perfect! Going exactly as expected.



2. Europa Universalis IV - EU 4 has an amazing capacity for "fun", where in once things start going a little wrong they immediately explode into many things going very wrong. So a lot of my play time has been me trying to crush either the Papel Seat, England or Poland in retribution for the thing they did to me last time.
   
   

   

   Whelp. Time for another vendetta play through.



3. Animal Crossing: Amiibo Festival - October is probably the most interesting month to play Amiibo Fest. They introduce an extra candy collecting mechanics which has a roughly 50/50 success rate and means that you actually have to play with a little thought. We still play a bit on autopilot these days, but Amiibo Fest is still a weekend morning tradition for us.
   
   

   

   Racoon butts.

   
   


4. Sunless Sea - Mark Brown produced a video about rogue-likes talking about how the player skill and the difficulty curve interact. I am bad enough at most rogue-likes that I never really seem to see the game change. Lately I've been trying to improve how I play, or experience, or something, Sunless Sea. The story elements are still interesting, although I had a couple of captains die in quick succession, which broke a little of the illusion of continuity in the story structure.
   
   

   

   Perfect. Totally not doomed.

   
   


5. Fire Emblem: Three Houses - Remember how I hadn't burned out on Three Houses last month? Well, now I have. The problem with the 4 endings the game has is that it does require a lot of replay of very similar missions and eventually it starts to feel like I've just done the same thing over and over again. The combat simply doesn't support the amount of story the game has and the reuse of maps is kinda disappointing, at least if you play the Golden Deer and the Blue Lions one after the other. The Black Eagles - Crimson Flower have definitely been more different so far, but I needed a break.
   
   

   

   Inconceivable!

   
   

Here's my total play time chart for October:

And here's a chart of how much I've played over the month:

Project 20 - That Code Click - Introduction

I like it when things click. When I’m programming I love that moment where things go together perfectly, and I love that moment in my own brain when a topic suddenly snaps into focus. I also like when I’m working with students and I see that moment for them.

via GIPHY

This next project is my attempt to share that feeling and to help people learn about all of the stuff in computing that I think is really cool. It’s a chance to look at how things work, how things fit together, how things were designed and how those elegant moments in problem solving come to be.

I hope this is a chance for me to stretch my writing, teaching and communication skills. Additionally there are a lot of other technical skills I should pick up such as video production and things like that. It’ll also be a nice chance to chase down those topics I’m interested in, but never really have the time to manage while I’m teaching (and then forget about when I’m not teaching).

For the short term I’m going to simply create a few written articles and upload them here while I start building out the idea. In the longer term I’d like to see a blog and then maybe a fully dedicated website to host those articles and other supporting material.

For this first iteration of the project, I’m planning to write one article on “Counting in Binary on Your Fingers” a fun trick I always enjoy using to introduce binary numbers. I’d like to get that finished some time before November 29, including text and my own photos to illustrate. I'll also put together a list of future topics I'm thinking of. If you happen to have a great computing "click" you'd like to suggest, let me know.

Project 19 - Pong - Phase 1

Project 19 - Pong

I am implementing Pong. Yes, that Pong. I’m implementing it both for fun, but also because it’s going to be necessary for a project for work in the fairly new future.

I figured since I was implementing Pong, I might as well make a project out of it. As a bonus since my implementation is basically finished, I get a free finished project out of the deal.

I decided, as is my wont, to work in Processing.org. This is pretty much my go to platform whenever I need to prototype something or do a thing with quick interactions. I’m also educating myself about P5.js which is proving to be fun as well.

My original take was to work with vectors, which has exposed me to all of the linear algebra I didn’t learn or have forgotten. This will also be helpful for my Bubble Puzzler work (which apparently I haven't updated here, to my surprise). I then remember that my Phase 2 for this project is to have a working version of Pong on the Atari ST, and so I’d be better off handling things like coordinates and motion as simple variables. You can find the source in on GitHub.

// player positions on the screen
int p1Y;
int p2Y;
int p1X;
int p2X;

// paddle display information
int paddleW = 10;
int paddleH = 75;

// player scores
int p1Score = 0;
int p2Score = 0;

// ball position on the screen and motion
int ballX;
int ballY;
int ballMoveX;
int ballMoveY;

int ballSize = 10;

Within the program my code is fairly basic, I’m relying on processing’s control of the framerate, and basically assign the ball a speed between 2 and -2 on the y axis and 2 and -2 on the x axis. This feels like a fairly workable implementation of speed, although increasing it as the game goes on would be an option (I suspect an actually competitive game would go on for quite a while).

The ball bounces off the top wall and off the paddles. If the ball hits a paddle near the edge (about 1/8th of its total length) then it bounces in the y direction as well as the x.

void bouncePaddle(int paddleX, int paddleY) {
    // bounces the ball off the paddle 
   if (((ballX + ballSize >= paddleX) && (ballX <= paddleX + paddleW)) && 
              ((ballY + ballSize >= paddleY) && (ballY <= paddleY + paddleH))) 
        {
     ballMoveX *= -1;
     
     // reflects the ball back on the y axis if it hits near the edge of the paddle
     // mostly for fun, not sure it was in pong, but I enjoy it in most clones
     if ((ballY + ballSize < (paddleY + (paddleH / 8))) || 
         (ballY + ballSize > (paddleY + 7 * (paddleH / 8)))) {
       ballMoveY *= -1;
     }
     
   }
   
}

This produces enough interesting effects that I’m calling this phase of the project done.

That being said, in the short term, I suppose I need some more inputs because solitaire pong seems not-too much fun. Beyond that I think that’s probably it for the Processing.org implementation. My next priority is to prepare to produce the Atari ST version of the game. I would also like to produce a version of Breakout because that seems fun and possibly also add in a few interesting visual effects.

I should be done the AtariST version by early January because I need my students to start on their projects by then.