FastAPI for a Simple Game

-

     Since I've been having fun with FastAPI, I decided to build an API for a simple game I learned about while studying my textbook for my Advanced Algorithms course. The game is described as two players attempting to move their pieces from one side of the grid to the opposite side. One player moves from the top to the bottom, the other from the left to the right. A piece can move forward one space into an empty space, or it can hop over one empty piece. Once a player's pieces have moved all the way over to the opposite end of the board, that player wins. The author of my textbook said this game was played on a table in a diner using sugar packets, so I decided to call my game 'Packet Swap'.

    Anyway, since I wanted to use FastAPI, the logic is in Python. I found what I thought was a pretty good solution by describing the board as a dictionary of tuple keys and strings describing the object in that location. Using tuples as the keys let me do some simple math on on my tuple when I wanted to find out if a piece could move where it wanted to. Depending on which player's turn it is, I decide if I need to check horizontally or vertically (since pieces can only move right or down).

    The API is where my seemingly elegant solution met some hard times, as I didn't realize that JSON doesn't like working with dictionaries that contain tuples. I tried several things, from turning the dictionary into a string to trying to convert each of the tuple keys into a string. The issue with that is that as I tried to iterate through my keys the size would change when I replaced the key. Ultimately instead of passing an entire object into JSON, I now have a global game board that I don't bother passing into my JSON. I'll admit it isn't the best solution but for now it will let me continue with my project.

    FastAPI is great because all of this logic is now accessed with a 32 line API and only three methods (and a bunch of background libraries working magic). The API will return a string of the board that can be printed, and will receive a tuple of the piece to be moved when a player takes their turn. Other than that, the tuple simply reaches out to my game logic to actually manage the game state. Eventually I will build a front-end for this game and make it playable, and maybe even get it working so multiple people can play across a network. You can check out the code here!

 

Comments

  1. Kale Co JakimAugust 12, 2026 at 6:51 AM

    nice

    ReplyDelete
  2. Kale Co JakimAugust 12, 2026 at 6:56 AM

    The article presents an engaging way to learn FastAPI by applying it to a simple game, combining Python game logic with API development. The use of tuple-based board coordinates, player movement rules, and a lightweight API demonstrates how algorithms can be connected to practical web services.

    The discussion of JSON serialization challenges is particularly useful because it shows a real development issue that can arise when Python data structures do not map directly to JSON. A structured FastAPI Course can help learners understand request handling, response formats, routing, and API design more systematically.

    ReplyDelete
  3. Kale Co JakimAugust 12, 2026 at 6:57 AM

    The article also demonstrates the value of keeping the game logic separate from the API layer. This approach makes the application easier to modify and provides a good foundation for adding a frontend or additional functionality later. A RESTful API Course can further develop these backend development concepts.

    ReplyDelete
  4. Kale Co JakimAugust 12, 2026 at 6:57 AM

    The planned frontend is an interesting next step because it could turn the API-based game into a complete interactive application. A client-side framework could communicate with the FastAPI endpoints to manage moves and display the board dynamically, making ReactJS Training a relevant complementary skill for extending this type of project.

    ReplyDelete

Post a Comment

Popular posts from this blog

Catching Unhandled Errors in .NET/C++

-
Most developers are familiar with the pain that comes from an application crashing in production, and not offering any helpful information why it crashed. I recently was tasked with trying to catch some mystery errors, and I learned a lot about how .NET has some built in tools to catch errors in C++. The SetUnhandledExceptionFilter function supersedes the top-level exception handler in a thread, so if you hit an error the function will catch and allow you to do something before everything goes up in flames. This is a great time to do things like creating logs that will give some insight about what went wrong. It'll allow you to get a better idea of why a program crashes in production. Keep in mind, this only works outside of the debugger, so even in Visual Studio you'll need to run without debugging to test this. This code snippet is probably the simplest proof of concept for this tool that I could come up with. Essentially we are going to set the function that will handle our...
Read more

Reviewing WPF and MVVM

-
Image
 I've been working in WPF (Windows Presentation Foundation) a lot lately. WPF is a great way to build a Windows desktop application, it's been around for many years and is very mature compared to UWP (Universal Windows Platform) which is a similar tool for creating desktop applications. It's not the newest, shiniest tool but it is definitely a great tool to be aware of. A while back I built a simple WPF program that worked with a .NET function library that did very simple distance calculations, and I decided to review that before really getting into more advanced concepts. When the program runs, it looks like this:   It's nothing too fancy, but it will show travel time, rate of travel and distance traveled over time. It also allows an excel spreadsheet to be inputted and it will run many calculations and then update the spreadsheet. The layout here is primarily built using the XAML grid, a staple of any WPF application. The grid specifies how many rows and columns the g...
Read more