graham's blog (#video games)

I'm Working On A Game

2026-07-10T06:30:00.000Z

Ever since I first read about My Friends the Monster Trainers by Jamwitch via Laura Michet's blogpost about it, I've been completely enamored by that game. I love the not-technically-pokemon designs about it. I love the believable-in-fiction setup for the game's premise. I love how toyetic the design of the whole webpage where you play the game is. And what I found was that I also craved more: more not-pokemon to try to determine from clues, more detailed typings and how those types overlap with the real world, more keeping track of which creatures turn into which other creatures, among many more notes I wrote down to try to come back come development-time.

Since roughly June 1st of this year, I have been working on putting together a list of 50 names of not-pokemon followed by illustrating simple contour drawings of them by hand on my phone. Here are the names in alphabetical order.

Aboara
Arcupine
Blaazé
Bluega
Boarealis
Boouoy
Bowvine
Brewelée
Buffalloy
Bullbil
Calvine
Canaro
Capyterra
Chinchiller
Coltage
Cragmite
Dextsnail
Dragonet
Ducktile
Fincho
Flambébé
Gumchu
Hogtide
Hogwash
Hydromedary
Icebis
Joltergeist
Koalala
Llamina
Magmoo
Malleabard
Ossilot
Pneumatoad
Psycculent
Ratarot
Rockoon
Sanguin
Scorchion
Scorchling
Serindigo
Shrewdinger
Silverant
Sinisnail
Smolten
Snowflee
Spoonswill
Stingrazor
Tamanoir
Tsooienami
Ziprunner

As of tonight, (and the reason for this blogpost) I have also now completed the 50th hand-made drawing on my phone of each of the names above, which marks a sort of milestone for this game. I've included the drawings below in a random order to try to prevent any accidental spoilers for the eventual game, since presumably a major goal of the game will be to figure out which name goes with which picture.

There's still a lot of work to do on this game. There's a whole story that contains logical clues to deduce the various not-pokemon, their names, their types, what they'll become, and where they live. I've never had to do much writing for any game I've worked on, so I imagine that will take a lot of effort.

Then there's all the coding. I don't want to just copy the UX from MFtMT, as much as I like that game, since that feels lazy. However, there are parts that I imagine will get reused: some of the game being organized around jotting down clues and facts while the other part is organized around analyzing info for new logical conclusions, for instance.

I'm excited about this milestone and I am hopeful to continue to use this momentum to make something fun.

Phonetic Pangram Tool

2026-01-03T06:30:00.000Z

After spending last night writing that blog post about pokemon phonetic pangrams, I felt like I was done with this hyperfixation and could move onto other things^[1]. This morning proved me wrong when I had the thought

Hey isn't making a pangram kind of just a very specific case of that daily word game you made last year?

Suffice it to say that that inkling was correct, and it only took me all day to remember how that all worked, copy it into a new project, modify that into working for phonetic pangrams, set that project up with Render^[2] for hosting, upload the iframe pointed there from itch.io, and build out a new itch.io page for the project. Take a look below:

Phonetic Pangrams by graham

It works with pokemon and the CMU phonetic dictionary, which covers a bunch of English words and names. It only supports General American English^[3] for now, but I think there are ways to extend that to other dialects going forward, with enough data about how the phonemes change.

Anyway, in the interest of keeping it short, that's it! Enjoy, and please share your phonetic pangrams with each other and me on there. As far as I know, there does not yet exist a solved solution for phonetic pangrams in English the way that there are now for pokemon names.

Like finishing up the hxh fanart, or reading, or touching grass between rainstorms in the Bay, that sort of thing. ↩︎
I once again really wanted to be able to rely on websockets for checking whether a given word matched the corpus on the server. Otherwise, everyone using the tool would have to download a big file of all possible words and names and their pronunciations. Shout-outs to Render! ↩︎
And if you want a bonus difficulty level, I recommend using the /x/ phoneme of loch /lɑx/. ↩︎

Pokemon Phonetic Pangram

2026-01-02T16:00:00.000Z

As a follow-up to my previous post, I have uploaded the data and my previous solution to codeberg. Last time, I learned that Slither Wing is the only pokemon across all current generations to contain the ð phoneme, which meant that only datasets that included gen-9 could form true phonetic pangrams for General American English. With this in mind, I scraped the rest of the generations and compiled them into one unified dataset for all pokemon. As expected, I was able to find several 11-pokemon pangrams^[1] by simply using the new dataset, but it made me wonder if there existed any pangrams with even fewer pokemon. I tried running the 10-mon pangram attempt across all gens and found that nothing happened for a while, even with the caching I had explained in the previous post.

Technical Hurdles

After discussing this with some of my friends on Discord, it became clear that the size of the problem-space being explored had grown very quickly with the size of the dataset of pokemon, just as predicted. For gen-1, there were at most (151 choose 10) combinations of pokemon to find a set that covered all 37 represented phonemes in that set. For all gens, it was more like (1025 choose 10) combinations, which is roughly 269 million times more. Despite this, I tried to simply run the program and wait. I was rewarded with a new problem:

$ bun run main.ts
136 |           if (!cache.has(cacheKey)) {
137 |             if (solution.names.size < SetCoverSizeToBeat - 1) {
138 |               const idx = queue.findIndex(s => s.phones.size <= solution.phones.size)
139 |               queue.splice(idx, 0, solution)
140 |             }
141 |             cache.add(cacheKey)
                        ^
RangeError: Out of memory
      at <anonymous> (/Users/g/Documents/programming/pokemon/phonetic_pangram/main.ts:141:19)
      at forEach (1:11)
      at <anonymous> (/Users/g/Documents/programming/pokemon/phonetic_pangram/main.ts:133:17)
      at forEach (1:11)
      at main (/Users/g/Documents/programming/pokemon/phonetic_pangram/main.ts:132:22)
      at /Users/g/Documents/programming/pokemon/phonetic_pangram/main.ts:153:1
      at loadAndEvaluateModule (2:1)

Bun v1.3.3

It makes sense that this program would run out of memory because the cache is adding new paths that have been visited constantly until the program finishes. In the past, this was a small enough problem space to avoid memory issues, but now the problem space had simply ballooned too much for the cache to handle. I looked into how I could make the size of what I was storing smaller. For one, I was storing the cache key as a set of strings that contained all the letters of the pokemon being represented in the path. By replacing a given pokemon with a single character, I was able to shorten this from an average of 7.6 characters per pokemon name to 1, which reduced the cache size by a factor of ~7x. This did not solve my out of memory issue.

Googling around, I learned that Typescript has a hard-limit on the number of members in a set or a map. It turns out that this limit is far below the number of possible solutions to explore, even with the reduced dataset size. Similar to one of the suggestions on stackoverflow, I implemented a BigSet class that just created a new set every time the old one was about to be full. This allowed the program to run without hitting javascript memory limits. But it meant that it quickly used up 13GB of RAM on my computer, even when no other programs were running.

Next, I tried seeing if any of the pokemon I was considering had phonemes that were a subset of any other pokemon pronunciations. For example Kadabra clearly contains all the phonemes that Abra does. It's reasonable to skip Abra if the goal is just to find the existence of any phonetic pangram, since any one that would use Abra could instead use Kadabra. Continuing this pattern reduced the number of pokemon from 1025 down to 789, which reduced the problem space by a factor of about 13x. This also did not solve my out of memory issue.^[2]

To try to limit the remaining unknowns about the full pokemon dataset, I separately tried looking up pangrams for 1, 2, ..., 7, and 8 pokemon. I knew from size-10 and size-11 ones that even a single answer could come in much faster than my computer hitting its memory limits. I found that I was successfully able to exhaust the problem space for all 1-to-8-sized phonetic pangrams. This left just 9 and its memory issues as the only remaining hurdle.

It was clear I needed to try something else. My friends suggested a bloom filter, since those are really good at telling if a given thing (list of pokemon) is either "definitely not" or "maybe is" in a given collect. For a problem like this that has a lot of "wrong answers" relative to the number of "correct answers," it seemed like a well-tuned bloom filter could work great. That said, I had plans for New Years Eve, so I uploaded what I had to codeberg and let my friends try to nerdsnipe anybody else into solving it a different way.

The Same Sort of Algorithm, but in Rust

Micolous was able to make a number of algorithmic optimizations to what I had contributed so far:

Instead of storing sets of names in the cache as letters representing pokemon, and instead of storing the phonemes represented by those pokemon names as a set, liberal usage of bitmasking allowed for much smaller amounts of memory used
Instead of exhaustively searching for every solution to the problem, focus on finding even a single solution at the current desired length
While looking for a solution, throw out any path that would be worse (i.e. necessarily have more pokemon names) than the current best solution
Keep all previous optimizations like the limited data-set with pokemon like Abra removed

With these and a little fine-tuning for data-labelling issues from the pokemonlp wiki, it was finally possible to find the first valid 9-pokemon phonetic pangram for General American English:

Slither Wing
Heatmor
Typhlosion
Noibat
Vulpix
Growlithe
Poochyena
Shedinja
Illumise

As expected, it had Slither Wing. Unlike the previous post, Typhlosion took the place of Persian, undoubtedly because of how many more phonemes it contains (8 total versus 5). I was excited to see this news and have a new, clearer goal to work towards. Surely implementing all of the same optimizations in my own code would allow me to get similar results.

Hoisted by my Own Petard

I spent the better part of New Year's Day rewriting the set logic I used for determining which phonemes a given solution had so far to instead use bitmasking like Micolous's. It took some time, but I was happy once it was working. I had the thought that I could stop writing code on my laptop and instead practice with my new split keyboard^[3] on my desktop by pushing what I had to codeberg again and then pulling it down from the cloud.^[4]

Upon pulling the latest from main and getting the script set up to run, I ran my version on the 9-gram, and found that I got an answer too! This was exhilarating compared to my machine turning on its fans and maxing out RAM for hours with no results. But of course, this had to be because of the optimizations I had spent all day implementing, right?

I tried rewinding the code to what I had days prior when I had been trying to overcome the technical hurdles on my own. That also ran flawlessly on my desktop computer. It turns out that having similar but not exactly the same specs across a laptop and a desktop can lead to wildly different experiences when it comes to problems like this one. I'm embarrassed that I didn't try this sooner.

Conclusion

I have yet to get every 9-pokeon phonetic pangram across all generations, because I did eventually run into memory-hog issues and didn't want to keep working on optimizations for a problem with so many solutions.

Below are the first 20^[5] that my algorithm found:

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Basculegion
Shaymin
Charizard

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Exeggcute
Shaymin
Jirachi

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Chi-Yu
Aegislash
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Chi-Yu
Aegislash
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Chi-Yu
Shedinja
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Chi-Yu
Shedinja
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Poochyena
Aegislash
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Poochyena
Aegislash
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Poochyena
Shedinja
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Poochyena
Shedinja
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Charmeleon
Aegislash
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Charmeleon
Aegislash
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Charmeleon
Shedinja
Blaziken

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Houndoom
Charmeleon
Shedinja
Rayquaza

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Hawlucha
Shaymin

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Honchkrow
Shaymin

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Hitmonchan
Shaymin

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Shaymin
Hitmonchan

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Shaymin
Honchkrow

Slither Wing
Typhlosion
Noibat
Dragapult
Venomoth
Gouging Fire
Exeggcute
Shaymin
Hawlucha

Obviously, as mentioned before, every answer necessarily had to have Slither Wing. Additionally, every answer my program found contained Typhlosion and Noibat. While these 20 above all included Dragapult, there were eventually others like these following two that broke that pattern:

Slither Wing
Typhlosion
Noibat
Clobbopus
Meowth
Hariyama
Shedinja
Ninetales
Galvantula

Slither Wing
Typhlosion
Noibat
Rookidee
Venomoth
Gouging Fire
Poochyena
Iron Hands
Shaymin

Now that every pokemon generation has been included, now that the minimum-length phonetic pangram for General American English has been discovered, and now that we know several of the minimum-length one in particular, it seems like this problem is ready to be put away for a little while. Maybe when one of those things changes in the future, I'll unearth this problem again.

After all, when it comes to the world of pokemon pronunciation set-covering optimization problems:

I want to be the very best.

Any of the sets from gen 1 listed at the end of the previous post, plus Slither Wing, for example. ↩︎
However, I did learn that the phonemes in Arceus are a subset of the phonemes contained within Cofagrigous, which was surprising to me! ↩︎
A Moonlander that my job paid for, which I have yet to bring into the office because I'm still getting used to the layout. ↩︎
Decades ago, it used to be the case that transferring files between computers was most quickly done over USBs. These days, that feels like so much effort compared to pushing to a git repo, at least for small code repos like this that are already being stored in the cloud. ↩︎
By the time I stopped the program, I had found 933 9-pokemon pangrams. While this technically only represents a lower-limit, it seemed good enough to stop searching/optimizing for now. ↩︎

Pokemon Gen 1 Phonetic Pangram

2025-12-28T21:40:00.000Z

As I mentioned in my previous post, a phonetic pangram is a sentence or phrase that covers every one of the sounds in a given dialect of a language. Since proper nouns can form a phrase, a phonetic pangram could potentially be made from any sufficiently large collection of names.

This led me to the question: "Is it possible to make a phonetic pangram from pokemon names?" and more specifically, "Can we do so using only the 151 from the first generation of pokemon?"

Phonetics

For General American English, wikipedia lists the following sounds that comprise every commonly spoken word:

Consonants (24^[1])

m, n, ŋ, p, b, t, d, k, ɡ, tʃ, dʒ, f, v, θ, ð, s, z, ʃ, ʒ, h, l, r, j, w

Vowels (14)

ɪ, i, ʊ, u, ɛ, eɪ, ə, oʊ, æ, ɑ, aɪ, ɔɪ, aʊ, ɚ

To make a pangram, I simply needed pokemon names that encompassed each of these 38 phonemes. You could imagine a worst case of 38, where each pokemon is picked for having exactly on phoneme represented in its name, though I figured there was probably more overlap than that.

Pokemon name pronunciations

I was able to find the pronunciations of all 151 gen 1 pokemon. I copied the table and kept only the name and IPA pronunciation columns. A given pokemon name contains many phonemes:

ekans ɛkənz

First, I had to figure out whether the set of these pokemon match the 48 phonemes labeled above. To do this, I iterated over every row and added the phonemes for that pokemon's pronunciation to an ever-growing set. Once I reached the end, I found that there were more than 48 phonemes represented, which meant I needed to do some data cleanup.

Data Cleanup

There are four different kinds of cleanup that were necessary for this dataset:

Two-character phonemes: for diphthongs and dual-character phonemes like dʒ, I needed to replace these combos with single-character variants instead.
Americanized phonemes: because of the cot/caught merger and the hurry/furry merger, among others, it was necessary to map all present phonemes that other dialects used onto General American English.
Incorrect phonemes: There were a couple of places like Victreebel where phones like /r/^[2] which seemed like a mistake, to my ears.
Ambiguous phonemes: In the case of Nidoran♂ and Nidoran♀, it is unclear whether the names are supposed to include "male" and "female" in the pronunciations. Even canonical anime pronunciations differ depending on episode.^[3] For the purposes of this challenge, it seemed best to omit them.

After cleanup, I continued to work on the problem.

Set Cover

I got an old familiar feeling while doing this problem. I thought maybe it was from a previous advent of code or something. I couldn't remember what the problem I was thinking of was formally called -- only previous times that I had encountered it.

In designing levels for Snails and Sorcery^[4], I mapped out every single mechanic for every single level into a big spreadsheet so that I could tell at a glance whether a given level was introducing too many mechanics at once. Later, I wanted to see which levels would make the smallest set while representing every mechanic.

Another place this has come up is in Magic: the Gathering combos. There's a silver-bordered^[5] card that lets you win the game if you make a pangram with card names.

Trying to find the smallest combo of card names to achieve this pangram is the same problem, just put in a slightly different context.

When I asked around, my friends told me that this was a classic Set Cover problem and that it's a notoriously difficult problem once the problem size grows big enough.

Here I was, once again wondering if there was some collection of things (i.e. pokemon names) that would cover all of a set (i.e. General American English phonemes). Thankfully this problem has the benefit that the set of all pokemon (especially just gen 1) is plenty small compared to the set of all MTG cards and is also very small compared to the limit where solving this problem would take too long to complete.

A greedy approximation

Generally with Set Cover, it's a lot easier to get a solution that's pretty good than a solution that's provably the best. Instead of worrying about the best next step, a heuristic like "start by adding the item which has the fewest overlaps with other items" can get close enough. In this case, that'd be a pokemon whose names contain a phoneme or phonemes that are shared least by the other pokemons' names in the set.

Persian pɝʒən

Persian is the only gen one pokemon with the ʒ sound. This means that Persian must be included in every gen 1 phonetic pangram. It also means that p,ɝ,ə, and n get covered automatically.

For all other "least common remaining phonemes", there would be more than one pokemon which contained that phoneme in its name. For instance:

Vulpix vʊlpɪks, Bulbasaur bʊlbəsɑɹ

Blastoise blæstɔɪs, Cloyster klɔɪstɚ

Which of the pokemon names in these pairs is better to add? Is it better to add a pokemon from the first pair or the second one? For this greedy approximation, I went with "the one from the first-looked-at-phoneme that will cause the most phonemes to be added to the covering set, or go with the last pokemon if there's a tie." In this case, that's Bulbasaur because b ʊ l ə s ɑ ɹ is seven more phonemes covered, as compared with v ʊ l ɪ k s the six from Vulpix when you account for p already being covered by Persian. From here it's possible to continue and get an answer, but remember that that's still a heuristic (good enough) approximation rather than a provably best answer.

From here, there was a bunch of trial and error to discover and fix the points mentioned in the data cleanup. Originally, the next to choose from was Nidoran♀ because it contained an empty space ^[6]. Next, every answer included Victreebel because it was the only one containing /r/. Then, every answer contained Omanyte or Arcanine because they contained ɑɪ instead of aɪ. This continued for a while.

After working through cleaning up all of these edge cases, there was finally a reasonable approximate answer:

Persian 
Bulbasaur
Blastoise
Meowth
Sandshrew
Hypno
Exeggcute
Koffing
Squirtle
Ivysaur
Charmander
Pidgey

These 12 pokemon names looked to form a nice phonetic pangram. But could the same be achieved with 11? 10?

Minmaxing with Recursion™

I noticed while writing the greedy heuristic algorithm that one aspect (number of pokemon names which contain this next phoneme)was minimized while another aspect (the number of phonemes that would get added to the covering set) was maximized. By thinking of these steps as a two-player game, it's possible to reframe this problem as a version of Minimax. Similar to how humans and computers "think ahead" a number of moves in a game like chess, perhaps the best move (pokemon to choose) at a given step could be dependent on thinking X-many moves ahead?

I wrote a recursive algorithm in Typescript for solving this problem. If there were no phonemes that still needed to be added to the set, then the program could stop and return the solution. A given solution could be rated by its number of pokemon names. The best solution would be one that minimized the number of pokemon, which could be filtered for after exploring all of the possible solutions.

Searching without Recursion™

Javascript, which Typescript runs under the hood, has a max number of times that a recursive function can call itself (i.e. "max depth") of 10 times. I immediately ran into this limit. I should have known better when I selected this language for writing the algorithm in the first place, but I forgot. There are ways around the max depth restriction, but I find it's always good practice for code maintainability to unwind the recursion. Generally recursion asks the person reading the code to maintain the state of the program in their head, whereas other approaches can make that state much clearer and easier to inspect when things go wrong.

I rewrote the algorithm to be more like searching an N-dimensional grid, where each pokemon chosen was like a new direction through a maze, and the set of pokemon names at the end was like the path taken to get to the finish. The goal was to minimize the path length, and at each step along the way, I kept track of "the path so far" for every possible "next step to take". As I got to a branching point in the maze, I just added each of the "potential next steps to take" to a list. When the list was empty, I knew that all possible paths had been exhausted.

This time, when I ran the program, it didn't immediately error out. In fact, it didn't do much of anything for a very long time, and I got bored.

Speeding up the search with pruning

Given that the greedy heuristic solution found a way through the "maze" in 12 steps, I knew that I could get rid of any potential next step that would be greater than or equal to 12 steps long. This is sort of like a simple version of alpha-beta pruning, in that I was pruning out solutions that were known to be worse than the greedy approximation solution of 12. This optimization may have helped, but not enough for me to notice.

Next, I tried to keep the list ordered by how long the path had been so far. This helped avoid looking at bad solutions before good ones, but I found that the program still took a very long time.

When I looked at what was happening step by step towards the beginning of the search, I noticed that there were ways for the same list of pokemon to show up in a solution, just in a different order. Going back to the greedy algorithm example from before:

Vulpix vʊlpɪks, Bulbasaur bʊlbəsɑɹ

Blastoise blæstɔɪs, Cloyster klɔɪstɚ

In exploring each of these possibilities, there would be one that would look like Persian, Vulpix, Blastoise and another that would look like Persian, Blastoise, Vulpix. These two states are equivalent in terms of how much they cover the set of phonemes, but the paths to get to each were different-looking enough that my code was treating them as independent solutions.

I decided to make an in-memory cache that would tell me whether I had "been to this part of the maze" before. All I had to do was name each spot in the maze in a way that would give the same name every time I asked for the same spot. For instance, the first spot in the maze could be called Persian since the algorithm only had one choice. Then when I added new names, I could sort them all alphabetically, and then join them together into a single name like Persian|Vulpix or Blastoise|Persian|Vulpix. By storing each place name I had already been, I could avoid accidentally back-tracking through parts of the maze. This greatly sped up how long the search took to solve.

The final results

After running and re-running to find the best solutions, these were the solutions I found. Note that Persian, Blastoise, and Vulpix are in all of them:

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Ninetales
Cubone
Jigglypuff
Weezing

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Ninetales
Cubone
Jynx
Wigglytuff

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Primeape
Cubone
Jigglypuff
Weezing

Persian
Blastoise
Vulpix
Growlithe
Shellder
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Oddish
Clefable
Rhyhorn
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandshrew
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandshrew
Rhyhorn
Clefable
Charmeleon
Pidgeotto
Weezing

Persian
Blastoise
Vulpix
Growlithe
Rapidash
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandslash
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Meowth
Shellder
Hitmonchan
Primeape
Cubone
Jigglypuff
Weezing

Conclusion

While writing this post, I had to go back through and double check everything. After all, who would ever want to be wrong on the internet?

I took one of the sets of phonemes from these final results and checked each phoneme against the list at the beginning. There was one missing. Apparently, throughout my process cleaning, running, readjusting, etc I had thought that there were 38 phonemes present, but it was just an errant ˌ in /ˌpɪdʒiːˈoʊɾoʊ/ and a few others that had caused the number to look right when it wasn't. Upon cleaning that final non-phoneme up, my solutions all read 37. The missing phoneme throughout all of this has been ð.

Sure, there's some sunk cost aspect to have written all of this only to have the answers to:

"Is it possible to make a phonetic pangram from pokemon names?" and more specifically, "Can we do so using only the 151 from the first generation of pokemon?"

be "no." I double-checked that I hadn't missed any pronunciations. Was Growlithe maybe actually pronounced like "tithe"? No, it definitely used θ in the pronunciation guide.

Ok, so the above solutions are sufficient for 37/38 phonemes, which seems like as good as could be done for gen 1. What generation of pokemon does ð first show up in? According to the same dataset I got these gen 1 pronunciations from, it wasn't until Gen IX that there finally was a pokemon whose english pronunciation contained ð. It was Slither Wing. The only other pokemon to ever have ithe in its name was Growlithe.

To get a phonetic pangram with pokemon, it's possible to add Slither Wing to any of the above solutions and have 11 names cover it. I'll postpone looking into phonetic pangrams across all gens for a future post.

As for gen 1 specifically, maybe I'll try to start saying Growlithe with a ð from now on, and say it's 11 pokemon for gen 1 to make a phonetic pangram. You might say "but if Growlithe uses ð, then how will you get the θ you previously used it to cover?" and I would reply simply:

Meowth /miːˈaʊθ/, that's right.

Note that while my previous pangrams included the /x/ sound of "loch" and "chutzpah", this is a rare and often excluded phoneme for General American English. I included it in those because it was a fun constraint to work around, but I'm ignoring it here because no pokemon in any gen have that sound at all, and it'd be a kind of boring exercise. ↩︎
This is the rolled r trill that gets used in Spanish and Scottish English, among other places. ↩︎
Gen 1 didn't have the concept of pokemon gender outside of these two names. Gen 2 added gender for every pokemon, but never consolidated Nidoran into a single entry for legacy pokedex numbering reasons. The anime includes a pokedex entry that does say the gender but also includes the pokerap, which does not say the gender. Human characters in the anime tend not to say the gender, and I imagine this would be the case in real life too: you wouldn't say the gender unless specifically asked or unless you had to disambiguate. ↩︎
You may remember this as Wizard Sokoban prior to the name change last year. ↩︎
Silver-bordered in that game means "don't take this too seriously" and tends to involve meta-mechanics and humor. ↩︎
A space character in the pronunciation was treated as a distinct phoneme, and then /ˈniːdoʊɹæn (ˈfiːmeɪl)/ added a bunch more phonemes to the set, so it was always selected ↩︎

Unfair Flips World Record Strategy

2025-10-14T06:00:00.000Z

Unfair Flips is a game about flipping a coin to get 10 Heads flips in a row.

Unfair Flips is a game about how humans interact with variable probability.

Unfair Flips is a game about how people interpret the information presented to them, relative to the seemingly random outcomes they experience.

Unfair Flips is a game about why people play games at all, when there's only a finite amount of time to experience them.

Unfair Flips is a game with a speedrunning community. The rules of the speedrun say that time starts when the first coin is flipped and ends when one of the various endings occurs and then number of total flips is displayed. The current world-record strategy routeing seems like an optimal series of upgrades to minimize time played, along with a lot of luck. Statistically speaking, the variance in flips will eventally produce a relatively fast run. The minimum required number of flips per run is 10 Heads and no Tails. With enough time across enough runners, it's possible that someone will even get this lucky. Other speedruns tend to rely on memorization, dexterity, and endurance. While the orders of upgrades could land in those former categories, the repeated flipping of the coin lies squarely in the lattermost category.

Unfair Flips is a game made by Heather Flowers in Unity. Using JetBrains's dotPeek decompiler, I read through the CoinFlip.cs file, verifyng that the code for whether a coin lands Heads or Tails is solely^[1] based on Heads flip percentage and Unity's pseudorandom number generator:

// CoinFlip.cs
bool heads = (double) UnityEngine.Random.Range(0.0f, 1f) < (double) coinFlip.flipHeadsChance;

Unfair Flips is a game made in Unity 2022.3.62.f2, which relies on the default pseudorandom number generator, which is further reliant on an XORshift128-style algorithm. The seed of this pRNG algorithm is determined on app start:

It is statically initialized with a high-entropy seed from the operating system, and stored in native memory where it will survive domain reloads. This means that the generator is seeded exactly once on process start, and after that is left entirely under script control.

An approximate implementation of Unity's Random.Range function can be found here. Because XORshift128 is not cryptographically secure, it is possible to determine the seed of an XORshift128-style pRNG by observation of outputs alone. This could be done in as few as three sequential random numbers, if all of the bits of the number were revealed. By determining the seed, it would be possible to know whether the next number accessed from this generator would correspond to a Heads or a Tails. In fact, it would be possible to look arbitrarily far ahead and figure out when a sequence of numbers would produce 10 Heads and a game win. In addition to the Random.Range call for determining Heads or Tails, the code for flipping the coin includes a random call for number of turns of the coin in the flip animation, a random call for the sound to play during the flip, a random call on the 9th Heads flip to determine the ending, and - if the ending is Tails - another random call to determine the sound of the coin landing. This means that each flip could reveal about a half-dozen bits if all these parts were well-observed. However, according to the rules of the speedrun, time starts at first flip, which means time would be ticking while the flips are being performed to reverse engineer the seed.

Unfair Flips is a game with one non-player character: Gar, the mongoose-mask-wearing milk-drinking bar patron. Gar drinks this milk throughout the course of play. Gar's drink function is as follows:

// Gar.cs
private IEnumerator Drink()
  {
    while (true)
    {
      if (this.ableToDrink)
      {
        yield return (object) new WaitForSeconds(Random.Range(30f, 60f));
        if (this.ableToDrink)
          this.img.sprite = this.drink1;
        yield return (object) new WaitForSeconds(1f);
        if (this.ableToDrink)
          this.img.sprite = this.drink2;
        yield return (object) new WaitForSeconds(Random.Range(2f, 5f));
        if (this.ableToDrink)
          this.img.sprite = this.drink1;
        yield return (object) new WaitForSeconds(1f);
        if (this.ableToDrink)
          this.img.sprite = this.baseSprite;
      }
      yield return (object) null;
    }
  }

Gar's drinking is completely independent of the player's actions and continues even in the main menu, on start-up, just after the random seed is initialized. A "diligent observer" could note how many seconds it takes Gar to begin drinking, as well as how long it takes Gar to put down the milk glass, and those seconds could be used to reveal bits about the random seed, which could then be reverse engineered through the same mechanisms above. After enough careful observation, it could be possible to determine that a given seed would produce the right random numbers for exactly 10 Heads flips in a row at some future point.

Unfair Flips is a game that runs at 60fps. By observing frames of Gar's drinking habits, an "extraordinarily diligent observer" could note how many frames it takes Gar to begin drinking, thereby how many seconds, and also thereby gaining additional decimal places - meaning extra bits - of precision on what the Random.Range number is. The same is true for how many frames it takes Gar to put down the milk after drinking, though the total number of bits leaking through would be fewer, due to the smaller range bounds.

Unfair Flips is a game with a theoretical optimal strategy: use tools to determine the random seed over the course of days or weeks of the game running and Gar drinking milk, begin a timer and the first flip at exactly the moment when the tool says that there's a 100% chance, and then complete 10 Heads flips in a row. As of the timer starting, no tools would be necessary^[2]. The runner would flip Heads 8 times, gain access to the upgrades, mash the -0.2 seconds flip time button, flip a 9th Heads and have the upgrade menu disappear, and then flip the 10th Heads and stop the timer.

Unfair Flips is a game that will someday have a glitchless, tool-unassisted World Record of around ~19.6 seconds from start to finish of the recording. It will take days or weeks of observations^[3], followed by some random amount of time having to wait for the right opening, and then about 20 seconds of flipping. To me, this amount of work to get the World Record run is just barely too much to be worthwhile. I have loved the process of digging into how a run like this could be done,^[4] but I don't have plans on trying it myself.

Unfair Flips is a game about why people play games at all, when there's only a finite amount of time to experience them.

My apologies to The Red Duke and The Blue Baron for this existential threat to their existence. ↩︎
In fact, the recording instructions for the speedrun specifically state that the runner needs only submit a recording of the first flip through the 10th Heads, along with the total number of flips. This recording, if done according to the rules, could be impossible to differentiate from a recording of someone just happening to get extraordinarily lucky. ↩︎
Unless it's possible to speed up the framerate to compress the time that an automated tool takes to reverse-engineer the random seed. ↩︎
Shoutouts to both Colin and Cassie for helping me bounce ideas off of them while going through this process. ↩︎

Working on a game called Nimnim

2025-10-13T20:00:00.000Z

Background

Every game of Magic: the Gathering can technically be won by making another player try to draw a card when there are no cards left in their deck, a strategy called "milling."^[1] In custom fan formats like Dandân^[2], there is a single deck shared between the two players, which encourages milling as a more serious backup strategy if the whole "making your opponent lose life" thing doesn't work out. Recently, I became curious what a custom format might look like if milling was not only a backup but the only strategy? Constraints breed creativity, after all.

Nim is a much older game than MTG about trying not to be the last player to remove an object from a central pile. Every turn, each player can choose to pick up one object, pick up two objects, or pick up half of the remaining objects. It's often used as an example game with easy rules to implement in introductory computer-science classes, since the game strategy is solved and coding that strategy is simple to do. Part of what makes the strategy so simple is that both players always have the same actions they can take each turn, and the information of what a player can do and how it'll affect the game is publicly known.

The more I thought about a milling format in MTG, the more it reminded me of Nim: there's a central pile of objects which each player can affect each turn^[3] and when the pile runs out, a player loses. If you look deep enough into the history of MTG, you can even find cards that sort of do the same things as each of the actions in Nim:

The cards constraining the actions in MTG tend to be mostly hidden information, and player access to those actions is all dependent on card-drawing. Each player can only hold so many cards in their hand at the end of their turn, and having more cards tends to be better. Ultimately, a game of MTG like Nim boils down to "What happens to the last couple of cards left in the deck?" The rest of the time playing is just about trying to set up for that moment. Nim is turn-based with each player taking only one action. In contrast, MTG has "instants" and "activated abilities" which can be played outside that turn structure, and which follow MTG's "spells and abilities on the stack" rules for resolution.

From these two ideas, I set out to make a Nim-flavored format of MTG, which I've been calling Nimnim^[4]. Because Blue is the most draw-focused and mill-focused color identity, I decided to ignore all other color identities. I searched through hundreds of Blue and/or Colorless cards on scryfall, removing anything that relied on loss of life or other alternate win conditions, and collecting anything that felt similar in spirit to the goals of Nim. Because I was looking for individual cards that looked like they would fit in a format like this, I wound up with a singleton set of a few hundred.

Next, I began to think about what the end of the game would look like. If I wanted the stack to grow to 4-to-5 spells back and forth on the last turn of the game, then the vast majority of cards would have to be very cheap to play. It became difficult to continue to cull cards somewhere around 150 because there were so many that felt like great fits for the format, but eventually I decided that 114 should be the cut-off. The opening hand in magic contains 7 cards, so once the two people comprising a 1v1 match drew their starting hands, that would leave a nice round 100 to work with as the remaining colleciton for Nimnim.

Blue Herrings

When designing a 1v1 Blue mirror format, it was really tempting to throw in a bunch of counterspells, since that's such a core part of the Blue identity in MTG. However, I found that these tended to be too harsh of a play experience. When a counterspell is played, at least one player tends to wind up not getting to play MTG. I wanted Nimnim to have this momentum of inevitability behind it. No matter what you did, the end of the game would arrive and you had to plan for it rather than just planning to thwart your opponent's plans and win by default. I wound up removed every spell that outright countered^[5]. Instead, I only kept ones like Remand, Hinder, and Memory Lapse. The latter of these are particularly nice because they allow for continued battling over the top card of the deck, and they can disrupt the math around the total remaining number of cards in the deck.

Another natural Blue identity to lean on is manipulation of handsize. Things like Spellbook and Anvil of Bogardan were considered because they meant more actions per player, which meant more agency, and -- hopefully -- more fun and faster games. In practice, being able to keep more than 7 cards in your hand at the end of your turn absolutely exploded the possibility space to consider, and with the fact that there were no repeat cards except Islands, this led to extremely long turns and even longer games to weigh the many branching options. Those handsize effect cards were all cut. Obviously, drawing is still a hugely important part of the game, but now you simply have to balance between "getting the card you really want via casting extra draw spells" and "ending the turn with too many good cards in your hand and having to discard to hand-size."

In certain sets, Blue tends to have lots of artifacts and enchantments with abilities. I wanted to find some that generally provided a big benefit to both players and also ideally a little benefit to one of them, like Lantern of Insight. This proved difficult, though! Well of Knowledge allowed the player with a mana advantage to convert it into a card advantage, in addition to having an ability that could be performed many times in the final turn pretty cheaply. Cards like Horn of Greed and Ghirapur Orrey have symmetrically beneficial abilities, but with how much access to instant-speed bounce effects there are in this cube, the player who usually benefitted the most from the card tended to be the one who didn't play it.

While I wanted to include some permanents with one-sided abilities, after trying out Teferi's Ageless Insight and Crucible of Worlds, I realized that there were certain abilities that were simply too strong to be worth keeping in. Teferi's Ageless insight provided such a huge advantage for one player that the downside of potentially causing your own demise was heavily mitigated by sifting through for the best answers. Lands can be among the most valuable cards early on, with the player who gets ahead on them often being able to access more cards over the length of the game. This mean that more often, Crucible of Worlds wound up being a "win more" card rather than a means to get back into a game. With such little in terms of downsides, these one-sided benefit permanents were too much and I removed them and others like them from the set.

What's going well, so far?

With the aforementioned goal of inevitable momentum, I've found that heavily restraining cards that can recycle from the graveyard in any way has been extremely effective. The only ones currently which pull cards out of the graveyard are Conjurer's Bauble, Mystic Sanctuary, and Petrified Field, and only two of them return the recycled card to the deck. Because of this, we avoid situations where it feels like the number of remaining cards is ever increasing, and in the bauble's case, the drawn card makes up for the recycled card, so the endgame still arrives on-time.

Flashback is a wonderful mechanic for milling-centric decks in regular MTG, and it is absolutely at home in Nimnim as well. There are times where a powerful effect from a card has to be weighed against the ability for the opponent to cast the same card for its flashback cost soon after. On the other hand, flashback cards can create interesting emergent gameplay when the randomly milled cards from the deck include some of these flashback cards, which then generates new options.

Delve is another mechanic that balances flashback out well and makes use of the fact that there are going to be dozens of cards in the graveyard in every game of Nimnim at some point. Cards like Treasure Cruise and Dig Through Time were strong in their own right when they came out, but with the shared graveyard, and especially with cards with Flashback or Retrace or Escape being so valuable in Nimnim, these delve cards become some of the strongest in the whole format because of how much graveyard disruption they can manage.

Many of the cards are deceptively simple. Mental Note, for example, is a card I used to play in Nimnim whenever I saw it because it was cheap and was a cantrip.^[6]

However, with the cost being so low, it being at instant speed, and it disrupting 3 cards in the deck all make it a useful card in the late game. If your opponent began their turn with 3 cards left in the deck, you could play this just before their draw step and they would have to do something at instant speed to avoid losing the game. Meanwhile, you've only expended one mana, so there's still plenty of room to follow it up even if they do have an answer.

Finally, I've really enjoyed scry, surveil, and cards like Index, which all let you affect what's coming up next in the deck. There's this back-and-forth meta-game about how to order the cards that I find captivating. If left in order, each player will draw each card during their turn. This means the person sorting through the cards should give themselves the best cards and their opponent the worst ones. However, since neither players knows what cards are in the other's hand, it can be difficult to play around what instant-speed effects the opponent may have, even if you have a few of your own. I've seen cases during playtesting where both players know the top card is powerful and then several spells get played to try to fight over trying to draw it first. This sort of metagame of locking your opponent into bad cards encourages interesting play in the early-to-mid-game, from my experience, and it makes the skill ceiling and replayability of the format increase as well.

What's next?

I've played Nimnim a handful of times with my buddy, 2Blave, to playtest it, and I have yet to outright win.^[7] Playtesting has all been done on TableTopSimulator thus far, since the "only one deck", "shared graveyard", and "no keeping track of lifetotals" all deviate pretty significantly from the more commonly supported online MTG formats. There continues to be a set of mechanics that are a little bit awkward in TTS, like searching the deck for anything or putting the card on the bottom during a Scry ability, but we're able to make do for now. As we continue to refine, I'll probably eventually get to a point where I set up a mod in the workshop for playing it, though I can't promise I'll do any scripting.

As of writing this, Nimnim has 80+ unique cards that aren't basic Islands, and that complexity alone means it continues to be a game for absolute sickos with a bunch of time on their hands. It has been difficult to find people to test it with, even among various groups of MTG fans I'm connected to online. I'm hopeful that future iterations will be a lower time commitment. Ideally, something like 60-90 minutes per game would be nice.

These last few points have another solution: remove MTG altogether, create new and simplified cards that fit exactly what I'm looking for with this format, remove mana in favor of some easier to explain action economy, and then ideally start playtesting with folks who aren't familiar with MTG at all. It'd be a ton of work, but it'd be just as easy to playtest in TTS, and if it did wind up being fun, I could see there being two different style versions of the game based on difficulty, just like how Spiel des Jahres has different tiers for family-style games and connossieur-style games.

In the meantime, feel free to reach out if you have questions or anything, and hopefully I'll have more progress soon.

Because of https://scryfall.com/card/atq/56/millstone ↩︎
Named after the card Dandân, originally named after the mythical Arabian fish ↩︎
With a minimum of one card that must be drawn by default during their "draw step" each turn. ↩︎
From Nim + Dandân, though it could also have been called "Nimnîm" ↩︎
Meaning any spell that, once resolved, puts the countered spell into the graveyard with no upside for that spell's owner. ↩︎
A card which when played draws a new card, thereby replenishing the possible actions the player could take, as though they had spent nothing. ↩︎
Most recently, I won but as we looked closer at the end of the game, it became clear that he had me beat a couple of times over and it was more a fault of the way the deck number was being reported in-game than anything good I did. I'm counting it as a draw. ↩︎

Unfair Flips Friends at the Table Playthrough

2025-09-28T06:55:00.000Z

This weekend, I was overcome by the urge to make this extremely specific fanart.

I recently watched Austin and Jack from Friends at the Table play Hthrflwrs's extremely good new video game Unfair Flips by streaming it on Twitch

Over the course of the roughly three hour stream, Austin and Jack -- among other things^[1] -- invented a pair of delightfully frustrating fictional oligarchs named The Red Duke and The Blue Baron, who alternated between jabs at their subjects (the streamers) and talking to each other about the rousing match of coin flips the were playing vicariously through them.

Austin also read a long excerpt about how wine and milk are two ends of a spectrum among drinks. I forget which book excerpt it came from, but it was a great time. In my headcannon, The Blue Baron is a milk-drinker, while The Red Duke drinks wine. ↩︎

Poliwhirl's Mouth

2025-05-03T18:30:00.000Z

I spent some time this morning thinking about Pokémon. Specifically, I considered how the poliwag, poliwhirl, poliwrath evolution line mimics poliwogs, frogs, and frog-themed wrestlers. While considering this, I noticed that poliwag's mouth is separate from the hypnotic spiral on its front:

This led me to consider how poliwhirl's mouth must work. I came up with the following two options, which I illustrated by hand on my phone:

I think the one on the right is technically more frog-like, while the left just looks like a blue Dot Gobbler.

Crowdpleaser Words

2025-01-12T23:30:00.000Z

As part of the thinky puzzle games discord, some folks began running the Confounding Calendar project, which I got to experience for the first time this past year (2024). My favorite entry from those was a game called "Alphabet Soup for Picky Eaters" which is a combination of a code-breaking word-guessing game and a bunch of absolutely delightful little guys of different colors to make use of the yearly Confounding Calendar chosen color palette. If you haven't played it, I highly recommend doing so.

Alphabet Soup for Picky Eaters by Daniel Linssen

After playing it, I felt a similar feeling to how I felt when I first played Wordle. Here was a game that was a delightful 10-15 minute puzzle, it didn't overstay its welcome, and it also happened to have a handful of solutions that could all suffice. I began imagining trying to make a version that could handle the "new word every day" and more importantly "new set of rules every day."

This weekend, I had some free time and needed a distraction for a handful of reasons, and so I finally decided to dive into making a prototype. I've been building UI-heavy browser-focused games in React lately as a way to avoid having to learn the arcane and cursed UI programming behind more conventional game engines.

It took the better part of an afternoon, but I was able to set up a list of popular English words and various rules to clue them so that the game could provide a countdown and automatically choose a new word every day at midnight pacific and the rules could vary each day, as well. I aimed to have at least 5 words that appeased all the judges per day so that it's not too difficult. I also have made sure that it plays pretty smoothly on both mobile and desktop. You can play it on my itch.io page.

Crowdpleaser Words by graham

After getting some feedback from friends and a few discord servers I'm in, I added the ability to write down notes as you go along, and I've also added a way to get hints in the form of the game telling you what kind of rule a given judge is particular about. It won't give you all the info you need to solve the puzzle, but hopefully it's enough to be a stepping stone towards the solution. Additionally, if you finish the game with a guess unexpectedly, you can refresh to see what the rules were that you unintentionally satisfied.

Making this game was a lot of fun, and it was a much quicker feedback loop to prototype than other games I've tried to make this year like Wizard Sokoban or even UI games I haven't written about here. Here's hoping that I'll have more energy to throw some new ones together in the near future.

Slay the Spire Online

2025-01-11T05:00:00.000Z

Slay the Spire is the best roguelike deckbuilder of all time. I remember seeing it released in early access in 2017 and it took over all sorts of Twitch streams that I watched at the time. Despite loving card games and despite having enjoyed playing other hybrid-roguelikes^[1] of the era^[2], I didn't buy and play Slay the Spire until it officially launched on the Nintendo Switch in June of 2019 as a game for plane rides across the country for work and visiting friends.

Ever since, Slay the Spire has been a game that I play almost exclusively while traveling, whether while in transit or at my destination. I play each character's new ascension level in order before I move onto the next level. I have not beaten A20 on any character yet, but I'm at A10 on all of them, and the game hasn't lost its magic for me. In 2024, I began a completely different relationship with the game: one where I play it for hours at home and with friends.

Modded Slay the Spire

Over the years since its launch, I had learned about the Downfall mod from its original trailer and its updated version, and I'd also learned of the mod that Jorbs worked on, but I wasn't interested in trying either of them, since I wanted to get through A20 first before augmenting the 1-player experience.

Then, last year, my friend who I worked with on Wizard Sokoban^[3] introduced me to another set of mods. He and I had previously played Nuclear Throne together and been blown away at how well the mod community could execute multiplayer in a game like that. We took a look at Spire With Friends, but ultimately found it lacking.

While it does offer a free way to play an online game of Slay the Spire semi-cooperatively, Spire With Friends has you each battling your own regular enemy individually, as though you were just playing the one-player game at the same time, with minor changes to make it feel like you can have an effect on each other's progress. There are new nodes on the map called "Couriers" that allow for trading between players, but because the mod is all designed around asynchronous play, you don't need to both be at the Courier to trade: one of you can leave cards for the other to pick up (or ignore!) when they get to that node. Because of this, we found it was a little bit too easy to "cheese" the game by taking bad cards out of your deck to put in the courier's send slot, and having the other player simply not take them from that slot when they arrive.

After a few tries of Spire With Friends, we tried out a different mod, which we've now been happily going back to for months.

Together in Spire

Together in Spire is another cooperative mod, but you actually play the game simultaneously and next to each other. Everyone in the game enters into the same room against the same enemy -- whose max health is scaled with the number of players -- and then the enemy only takes their turn once everyone in the room has clicked the End Turn button. Play continues like this, synchronized depending on who is in the room at a given time. While this can be a little grueling in parts of the late game if your friend is going infinite and you're just hanging on, we found that the difficulty and playstyle far better matched what we were looking for out of cooperative Slay the Spire than any of the alternatives.

Each battle, there's usually a little bit of discussion about who will be able to apply negative effects like vulnerable or weak to the enemy, then everyone plays their damage in mostly whatever order, and sometimes we have some discussion about trying to end a given fight on a certain turn for relic or card reasons. The early fights, especially against elites can be difficult, while most of the rest of the game becomes trivially easy with more players. With two people, we find that ascension levels up to around 15 are pretty straightforward without having to do a lot of math or double-checking. With four, there's usually only one or two times in a run where anyone is in any serious danger of dying.

At every campfire, there's a new free (optional) action for trading and another new action called "Resurrect." Resurrect allows you to bring a dead teammate back to life. If they died far from a campfire, then you have to figure out a path to get to a campfire safely with whoever you have left. Trade allows any two people on the team to trade up to one relic, three potions, and three cards at a time. You both have to lock in the trade to make it take place, and unlike the Courier in Spire With Friends, you must take anything you agree to be traded. I really like that they made a way for the coop game to continue going even if one person dies, but also because Resurrect takes up the action that a person would normally do at the campfire, there's a real cost to having to do it. I find it makes the rest of the run feel earned, even if there's a death.

At shops, you can trade gold with any other player as much as you like, which is a nice quality of life thing without being game-breaking.

The game also autosaves, which means that even internet trouble or having to take a break doesn't get in the way of a good run.

Setup Instructions

Getting mods to work with Slay the Spire doesn't require Steam, but the workshop items tend to make it easy enough for non-technical people who can follow directions to be able to do. For Together in Spire, you need to own Slay the Spire and download the following mods, which you can do by clicking the subscribe button in the workshop:

Once all of these are installed properly, you'll have an option to start Slay the Spire with mods active. Depending on the operating system, we saw this fail the first attempt on Mac, followed by it working just fine every time after that. Make sure all of these mods are enabled, and then the game should boot up, and you should be able to see "Multiplayer" as an option in your starting menu.

One player can host a room for you all to play in, and they can set the settings they want to use in terms of both difficulty of the game once it's started and also who is allowed into the room. I'd highly recommend "Friends Only" so that only people you're friends with on Steam can access. One time, we had a troll try to join our game and use cheats to win faster than we could.

Joining a game can be done through the steam friends menu, and technically doesn't have to be at the very beginning of the game, though that's what we've always done so that we can play through everything together.

Note that A20 has had a bug for us where only 2/4 people wind up fighting the second boss of Act 3. Otherwise, there have been no bugs that have gotten in the way of a game, thankfully.

Future Considerations

As a way to play a cooperative card game with low stakes and interesting challenges, Together in Spire has absolutely delivered for us. There have been runs where we all roll random characters, runs where we each take one of the four main characters, and runs where we've all chosen the same character.^[4]

We find that as we all get comfortable playing, the game gets easier, so we look for harder challenges to impose. There's a "Hell" difficulty that's separate from the ascension levels that we'd like to try out. We've also talked about trying to do 2v2 races where you have to try to take different paths from one another and the first team to beat the heart wins.

At the very least, having a game that has very little timing-specific gameplay, only requires a mouse and a pretty unsubstantial computer and internet connection to play, and whose runs can be an interesting way to spend a few hours in a given evening hanging out on a voice call, I imagine my friends and I will continue to play this for a while going forward.

In conversation, I'd probably just use the shorthand "roguelikes" and let context clues do their thing, but I figure being extra intentional with word choice can help avoid "rogue/-like/-lite/etc" discourse. ↩︎
The ones I played were mostly Nuclear Throne, Enter the Gungeon, Dungeon of the Endless, and Don't Starve. I was also very familiar with Spelunkey, Binding of Isaac, and Crypt of the Necrodancer at that point, but had either bounced off of them or had never given them a fair shot. ↩︎
Now rebranded as Snails and Sorcery ↩︎
We all did Ironclad and realized that we could use the campfire trades to ensure one player had a deck that could go infinite on turn one every fight. It was goofy as hell, but it was also this person's first time playing online with the mods, so what better way to get acclimated, I suppose? ↩︎

Some Interesting Links From October

2024-11-01T09:45:00.000Z

I like reading about what other folks find interesting, but I often forget to write down what I myself have found. I've been meaning to talk about this first link ever since I came across it, but I kept forgetting to make time until now. I figure a new month is a good a time as any to make a link-retrospective post.

Video Games

This video is not only impressive on a technical level for being able to accomplish what it set out to do, but the animations and ways that the information is conveyed is on par with a pannenkoek video in terms of making complex ideas become understable.

Beating every possible game of Pokemon Platinum at the same time

Movies

I had never heard of this and it became the first RSS feed post that I've bookmarked since making the transition over from cohost to inoreader as my means of internet browsing.

Laura linked to a well-creafted treasure trove of (especially Lucasfilm) behind-the-scenes info

Fashion

I had meant to share this CJ video because I think it does an incredible job of explaining fashion through the lens of "conversation with community identity," and I was reminded that I wanted to share it when I saw Dante's post here. I don't know if Dante meant to be in conversation with this video, but I found watching the latter made me appreciate the former more:

Dante in defense of the Great Male Renunciation (sort of)

CJ the X talking about the longer historical context of fashion

Color Theory

One of my special interests is color theory. I think this video does a great job of explaining how color works across a number of different disciplines, but I wish it spent more time talking about refraction, polarization, and rayleigh scattering. That being said, this whole channel is full of interesting videos that are worth checking out, and even without that stuff, this one on color theory is still good:

Reactions on color theory

XOXO 2024 Festival Talks:

I didn't get to attend this year, but I really appreciated and resonated with these three talks moreso than the others, even though I enjoyed many more.

Politics

I found this retrospective of what working conditions were like under the Nevada State Democratic Party to be both insightful and harrowing. Regardless of your exact politics, I think there's a lot of stuff to think about, especially with respect to how campaigns are organized, where and how money is spent, and what the overall longterm goals are. I found reading it went by very quickly for me, and I also found that I kept thinking about it afterwards for a handful of days. Who could say why?

i became an anarchist while working for the nevada state democratic party

How my friend and I became Lords of Oblivion

2024-10-11T10:00:00.000Z

The Elder Scrolls IV: Oblivion came out for the Xbox 360 on March 20, 2006 -- almost two decades ago. It launched during an era when there weren't really game wikis to google, which meant that most of the bugs and strange discoveries in the game for me came from word of mouth in my social circle.

Beyond the more widely-known "horse-armor" DLC launched in April of 2006, there was a number of other DLC items. The only relevant one to this story was the Frostcrag Spire quest for the "Wizard's Tower". I did not buy it, but my friend did and we would regularly hang out. We found that if my friend logged in while he was at my house, then I was able to download and play the DLC on my console. However, either because of limitation in the storage of our hard-drives or because you could only associate your Xbox Live account with so many Xbox 360s at once, we got into this mess where I kept having to re-download the DLC every time he visited if I wanted to play it.

This went on for a few weeks until one of us accidentally tried to load a save from inside the DLC even though it was not downloaded. What we found was likely not supposed to be accessible except for the developers of the game.

This demo area existed outside of the bounds of the main game, and the underlying method for how we got to it seemed to be exploiting a memory pointer. Our best guess was that the DLC overwrote some "unused" (aka only used for developer testing) memory when it was installed, so removing it points the save state at that memory location.

I was spurred to undergo all of this work to reproduce the glitch because of a combination of wanting to port over the summarized version of this story from Twitter and from a Steam sale where Oblivion with all the DLC was bundled for $6. After making my way through the tutorial and going directly towards the DLC objective indicator, I summited some nearby mountains and entered the tower.

Once I saw the ice hand on the floor, my memories of this glitch came flooding back to me. This was the room in which we first found the glitch. I saved, exited the game, and then restarted -- this time making sure to uncheck the tower DLC on startup so that it wouldn't be loaded. I ignored the warning that my save was loading from a version of the game that had different content from the one I had running.

My character loaded into a black zone outside of a house looking in through one-way walls. It was impossible to travel through these walls by default, but by carefully jumping around the edges of the house, the front door became accessible, and it happened to be functional even through the invisible wall. This door led to the outside of the house, labeled "Wilderness", which was the village screenshot from before.

The village contained a number of empty houses that could not be entered -- they each had a "Door" that did not budge when interacted with. There were also a few houses which had functional doors labeled things like "Wooden Door to Bruma House Test" and "Wooden Door to TesterHouseBrumaMid".

While all of the exteriors of the houses matched those of homes and buildings in Bruma, there was one house whose insides did not match the exterior at all. Upon entering, it looked almost pitch black. Picking khajiit for this verification run wound up being a good choice because of access to night vision at level 1.

With night vision active, it was clear that the interior of this house was the final room of an Oblivion Gate. Following the ramps up to the top, a sigil stone sat just out of reach. If you have not played Oblivion in 16+ years, you can read up on what a sigil stone is here. The important parts to note for this are:

Sigil stones were extremely rare with only 70 total in the entire game.
Sigil stones could be used to enchant armor and weapons with magical effects that were randomly selected from a set of possible options upon collection.
For what seemed like balancing purposes, the strength of the magical effects from the sigil stones were dependent on the level of the character collecting them at collection time. At level 3, this meant they were "Descendent Sigil Stones" (the weakest), while my friend and I originally found this glitch as characters that were at least level 13, which meant "Ascendent Sigil Stones". Interacting with the stone at the top added the sigil stone into the inventory and the only exit was through the floating wooden door that also served as the entrance two floors below.

Trying to get this sigil stone at level 3 proved difficult. Despite a few ranks up in the acrobatics skill, falling from this height was an instant death upon impact due to fall damage. I spent a few minutes wedged under the ramp to the sigil stone platform so that I could jump repeatedly in rapid succession. These ranks allowed me to level up, so I could increase my endurance, which would increase my health and help me live through a fall. I went back to the other Bruma houses and one of them had a bed I could sleep in to level up. Between the health increase from endurance going up and the higher and longer jumps from acrobatics going up, it was finally possible to jump across the gap and land only one level below, immediately pause and heal, and then drop again to land directly next to the door.

This house wasn't just a test to refine the design of an Oblivion Gate final room. It also may have been a way to practice generating all of the different sigil stone types and potentially load testing as well. Being able to access the door was an essential part of this because part of grabbing the sigil stone was that it effectively became impossible to move after about a second or two of game-time.

It has been impossible for me to ever play an Elder Scrolls Game without having to deal with becoming over-encumbered. 16+ years ago, my friend and I learned that we could make our way through doors while over-encumbered. And it turned out that exiting the room back into the Wilderness would stop the sigil stones from replicating in the inventory. At this point, in the Xbox 360 version, removing sigil stones from the player's inventory would drop individual orbs one by one. Unpausing after removing all the excess sigil stones from the inventory would lead to the game freezing up or crashing on that console from having to render the collision physics of all of those great many orbs. On PC, they were dropped in large-quantity bunches. Either way, dropping sigil stones was required, and we could drop just about all types of them.

The most important sigil stone for us the one that provided chameleon on self. chameleon was a form of "soft invisibility" that usually rendered a user less-than-fully invisible. However, in a crucial difference from the invisibility spell, chameleon would not dispel after making an attack or doing an action. At the "ascendant" strength for a level 13+ character, these sigil stones would have magic effects of 25% chameleon per piece of clothing enchanted. This meant that with only 4/5 pieces of armor enchanted, we could get passive 100% chameleon. No one could see us no matter how many items we stole or people we attacked.

After no longer being over-encumbered, it was possible to fast travel out to any other city, which returned the game memory to the regular range in case any of the DLC areas continued to be important to access.

From here on, hardly any characters in the game would interact with us without trying to speak to them first. Finally, we had transcended combat or laws. We had become Lords.

Wizard Sokoban

2024-09-30T19:00:00.000Z

Today, my friend and I launched another new version of our puzzle game named Wizard Sokoban (working title). You can play it on itch.io for free, though it works best on a computer using firefox:

Wizard Sokoban by graham

I wanted to take some time to discuss the journey we've been through getting here because I'm proud of what we've made so far and I'm excited for what it'll be after we've applied another few rounds of polish.

Our second time game developing

In May of 2024, my friend Jules and I found ourselves simultaneously unemployed for the first time in our professional careers. With no structure to our days, we talked about some side projects that we'd been meaning to try out when we had more time. He mentioned wanting to try out Godot, and I mentioned that I had an idea for a puzzle game that could be pretty fun and simple to make.

We've been playing video games together for over a decade, and we most recently took on the idea of making our own when we went on a vacation to take part in Indie Train Jam 2017 from Chicago to Emeryville.^[1] Surrounded by professionals and friendly hobbiest game developers, we realized just how out of our depth we were when we discovered that we hadn't even both installed git on our computers before we lost wifi (my bad!). Train Jam was absolutely a once-in-a-lifetime experience for me, and I'm glad we managed to partake in it before it shut down. I've never been surrounded by so many talented people, and the excitement and beauty of the whole trip far outweighed the intense imposter syndrome feelings throughout.

So back in May, I sent over a simplified drawing I had done on my phone to describe a sort of box-pushing sokoban game where the user was a wizard^[2] who could cast spells to affect its surroundings. I scribbled a grid puzzle that would require a spell to complete on my phone and sent it over:

The crux was to have the difficulty of the puzzles come from both:

the regular diffculty of manipulating your surroundings in particular orders that a sokoban game tends to have
an added layer of which spells you had access to in a given level, which orders and targets to perform those spell casts, and how each of those affected the level manipulation aspect

My hope was that being a turn-based grid-based puzzle for one player, we'd be able to avoid a lot of the difficulties people have around the complexity of the systems, the interactions between players and each other or players and the game, etc. We talked about project setup and then met up for some IRL game jamming at his house across the bay. We quickly learned that despite shaving off a lot of the more complex things to do in a game, we were starting from scratch so we still had a plenty steep learning curve to overcome.

We've both grown a lot as developers since Train Jam 2017. It was cool to see how we approached this game versus our previous attempt. Back then, we made a list of features that we wanted and then tried to make them all work without necessarily having a broader vision, nor any idea how to program an engine to get the game to work like we wanted to. This time around, we talked about various architecture designs and weighed their pros and cons with plenty of experience from our day jobs. We settled on responding to player input with a queue of actions and generally modeled the game loop after board games and the ways that players are instructed to modify the game state in those after they take their turn. Where we ran into difficulty with art assets previously, I now knew how to sketch some art on my phone while I took BART over.

From my time on cohost, I had learned that a key part to making any video game is having a "little guy."

Once we needed more than just a character, a little guy, and a box, I downloaded some free assets from itch. By the end of a week of off-and-on work, we had a game that was playable. It had a level that could be completed, it supported undo, and I was just about ready to start making levels.

As things progressed over the months since then, we've done a lot of designing and redesigning. I 100%-ed Patrick's Parabox and most of Recursed for some puzzle and systems design inspiration. We booted up levels of Baba is You, Stephen's Sausage Roll, and even some Zelda games to understand their ways of teaching and exploring interactions. We talked about how the various spells should work and the ways they should modify each game object.

Time passed and each of us took breaks from thinking about or working on this game, but here and there, I'd make some progress on spells or the UI side, or Jules would have some refactor to the engine that would make adding new stuff a lot easier or cleaned up a bunch of bugs all at once. We also added our friend Brendan to help with art and sound. (He composed the main menu theme!)

By the end of August Jules had constructed a Level Editor that made level creation and revision much easier. It supported loading any level straight from the pause menu in debug mode. It allowed us to create new levels to test out buggy behaviors. It prevented me from setting up levels with the buttons on the same layer as the player by accident. And it allowed users to save and load each others' levels.

We released the itch.io alpha on cohost shortly after it was announced that cohost would be shutting down. We got a bunch of great feedback from folks in DMs and on Discord. Today marks another alpha release with a lot of that feedback being addressed.

There's still a ton of stuff to be done, art assets to swap out, sounds to add, etc. But I'm already really happy with how far we've come. This is a game that I feel like better shows off what a great game development team Jules and I are, and I'm excited for the future.

Rip to Indie Train Jam. Someday, I hope that we have sufficient health precautions that "spending 52 hours encased in a train with a bunch of other game devs" can be a safe thing to do for everyone again. ↩︎
It's the year of the wizard, after all. ↩︎

graham's blog (#video games)

I'm Working On A Game

Phonetic Pangram Tool

Pokemon Phonetic Pangram

Technical Hurdles

The Same Sort of Algorithm, but in Rust

Hoisted by my Own Petard

Conclusion

Pokemon Gen 1 Phonetic Pangram

Phonetics

Consonants (24[1])

Vowels (14)

Pokemon name pronunciations

Data Cleanup

Set Cover

A greedy approximation

Minmaxing with Recursion™

Searching without Recursion™

Speeding up the search with pruning

The final results

Conclusion

Unfair Flips World Record Strategy

Working on a game called Nimnim

Background

Blue Herrings

What's going well, so far?

What's next?

Unfair Flips Friends at the Table Playthrough

Poliwhirl's Mouth

Crowdpleaser Words

Slay the Spire Online

Modded Slay the Spire

Together in Spire

Setup Instructions

Future Considerations

Some Interesting Links From October

Video Games

Movies

Fashion

Color Theory

XOXO 2024 Festival Talks:

Politics

How my friend and I became Lords of Oblivion

Wizard Sokoban

Our second time game developing

Consonants (24^[1])