Football Highlights: The Dice Game

Digital implementation of the solo rules for Mike Fitzgerald's Football Highlights: The Dice Game 

NOTE: The graphics still need plenty of polish, the main focus so far has been on functionality.

I've generally tried to preserve the style of the original game while making adjustments where I saw fit and taking advantage of digital affordances.

Board games are somewhat of an obsession of mine and this is a fun one for some quick solo fun. I also figured it would be a good testing ground for my seeded dice roller Unity package as well as some other things I've wanted to explore:

Project Goals

1. Provide a context in which to use the Seeded Dice Roller project as a distributable Unity package.

2. Organize the logical control flow with async/await at the core of its structure.

3. Support undo operations.

1. One of the core purposes of the seeded dice roller project is to provide the foundational structure for rolling dice. Being a game whose core activity is rolling dice, Football Highlights seemed like the perfect way to test-drive development of a project that relies on this library and work out the kinks to improve usability. Part of that process has been to organize the dice roller project as a distributable Unity package so that any changes I make along the way can be easily propagated through Unity's Package Manager. This has been working very smoothly and I hope to make the package publicly available in the near future.

2. Ever since stumbling upon reactive extensions and the UniRx library, they've become a fixture in my personal projects. Interacting with UniRx led me to working with another of its creator's tools, a Unity-optimized reimplementation of .NET Tasks called UniTask. Given that much of a game's operations can be characterized as asynchronous processes, it seemed like a natural fit to define them with the C# built-in async features, yet I've rarely heard async brought up in the context of game development. Unity's answer for this is coroutines, but they can be a bit unwieldy, and UniTask makes async convenient as well as provides useful engine interactions like WaitForNextFrame(). I wanted to see what it would be like to structure a project around the async paradigm, and discover what benefits and drawbacks doing so might present.

3. One of those drawbacks is that the async/await architecture kept things rather clean until I started planning for undo support. All the neatly sequential wait-for-this-then-wait-for-that statements suddenly needed to account for cancelation, rewinding state, and knowing whether to proceed to the next thing or go back to the last one. Fortunately I started thinking about this early enough to account for it, and started breaking up actions into distinct Commands to simplify undoing or redoing execution. There's still some aspects of this that could be arranged more cleanly, but for the most part this appears to address the problems raised in pursuing the elusive undo.