State Stacker · Food for Thought
Every block above the foundation must rest on a geographic neighbour, transforming a simple stacking game into a test of the map's adjacency structure.
The game engine fuses two distinct domains: trivia knowledge and geographic adjacency. The player earns a state as a block by answering a question about it, then places that block on top of a growing tower. The twist lies in the stability rule: a placed block is stable only if the state directly beneath it, the current top of the tower, shares a land border with it. Only the first block, the foundation, is exempt; it always sits steady. This adjacency requirement turns the tower into a physical manifestation of the map's connectivity, where each placement must respect the real-world neighbour relationships encoded in the dataset.2
The foundation of this design is the game's own state dataset, which contains all fifty entries from the U.S. state collection. Each entry holds a name, a two-letter postal abbreviation, a capital city, a Census region, a list of neighbours, and a short fact. The neighbour list is particularly critical: it contains only land-border neighbours, recorded by postal abbreviation. States that face each other across one of the Great Lakes, such as Michigan and Illinois, are therefore not neighbours, and Alaska and Hawaii have no land neighbours at all. This precise definition of adjacency becomes the rule by which every placement is judged.2
When a player places a block, the engine checks it against the block on top of the tower. Two states count as adjacent only when each lists the other as a land neighbour. Because the check demands both listings, the relation is symmetric by construction: state A supports state B exactly when state B would support state A. This symmetry ensures consistency across the entire tower, where any stable connection must satisfy the same bilateral condition regardless of which of the two states arrives first.2
Before a block can be earned, the player must answer a multiple-choice question about a state, picking from four answers. The engine generates questions of four distinct kinds, each drawing on a different part of the state's record. The capital kind asks for the capital city of the state. The region kind asks which of the four Census regions, Northeast, Midwest, South, or West, the state belongs to. The fact kind asks which of four short facts is true of the state, the other three being borrowed from other states. The neighbour kind asks which of four states borders it: one real neighbour and three states that do not. Between them, the four kinds draw on four of the six fields in each entry, capital, region, fact, and neighbours, while the name and abbreviation label the question and the block.2
Each question kind serves a different purpose in the loop. The capital and region questions test knowledge of fixed attributes. A state's capital is a single city, and its Census region is one of four possibilities, so every region question offers the same four choices. The fact question tests recall of a short descriptive statement. The neighbour question tests knowledge of the adjacency list itself, which is the very structure that will later determine stability. Each state is asked about only once in a round, and the kinds rotate in a fixed order, capital, region, fact, neighbour, then capital again, so a round of twenty-four questions mixes all four evenly.2
A correct answer earns the state as a block; a wrong answer earns nothing, and play moves on to the next question. With a block in hand, the player has exactly one decision: stack it or discard it. There is no choosing a position, since every block goes on top, but the game says in advance whether the block will sit steady, naming the state currently on top and whether the earned state borders it. This separation of earning and placing creates a strategic layer: a block that would wobble can be thrown away rather than stacked, and it should be, because stacking it brings the whole tower down.2
The stability rule is the design element that distinguishes this stacking game from others. In a conventional stacking game, stability is a matter of physics: whether a block's footprint rests safely on the one below. This game has no physics at all. Stability is decided entirely by geography: a block is steady only if, according to the game's dataset, it is a true neighbour of the block beneath it. This transforms the tower from a physical structure into a topological one, where connections represent real-world adjacency.2
The adjacency check implements this constraint. It takes two states and checks whether each lists the other among its neighbours. This is a stricter condition than simply sharing a border in some abstract sense: the relation must be explicitly recorded in the dataset. For example, two states that face each other across the Great Lakes are not considered adjacent, because the dataset records land borders only. Alaska and Hawaii, with no land neighbours at all, could never form a stable connection, so the game never asks about them; their names and facts can still turn up among the wrong answer choices. These design choices reflect a deliberate decision to ground adjacency in a specific definition rather than in geographic intuition alone.2
The symmetry of the relation is essential for consistency. If state A can support state B, then state B could equally support state A. A connection is either valid or invalid based on the fixed neighbour lists, regardless of which of the two states happened to arrive first. This property simplifies the player's reasoning: whatever state is on top, any of its neighbours can rest on it, and the only question is whether the block just earned is one of them.2
The winning condition is defined by two related numbers: the goal height and the secure height. The engine takes the goal height as a parameter and the game always passes its default, eight; it is the number of stable blocks the tower must hold, the foundation counted among them, so eight means the foundation plus seven blocks placed on neighbours. The secure height counts stable blocks from the foundation upward, and because a single unstable placement ends the round on the spot, every block in a tower still standing is stable: the secure height is simply the height of the tower. Each stable placement raises it by one. When a placement is unstable, the block wobbles and the tower topples.2
This distinction between secure and insecure blocks creates a real risk. Because nothing stacked above a wobbling block could ever count toward the secure height, the game does not make the player play on: a single unstable placement ends the round at once as a loss, under the heading “Tower Toppled!”, naming the state that did not border the block beneath it. The points already scored are kept. That is why the game offers a discard button and warns before every placement whether the block will wobble; the warning says plainly that a wobbling block will topple the tower and end the round. The tension comes from the fact that earning a block does not guarantee progress: only stable placements on an unbroken tower advance the player toward the goal.2
A round has twenty-four questions, so reaching the goal of eight means turning exactly a third of them into steady blocks. A wrong answer does not damage the tower, but it costs a chance, and because the questions are chained from neighbour to neighbour, a missed state can leave the next one without a border to the state on top. Each correct answer is worth 10 points, each stable placement another 15, and reaching the goal adds a 100-point bonus and ends the round at once. If the questions run out first, the tower has “topped out” short of the line; if a wobbling block is stacked first, it has toppled.2
Every set of questions is generated from a seeded random number generator. Given the same seed, the engine produces the identical sequence of questions, in the same order, with the same answer choices in the same positions. This determinism serves several purposes. It enables shared experiences: the Daily mode derives its seed from the date, so everyone playing that day faces the same questions and can compare results, while Practice mode draws a fresh random seed for each game. It also makes the game testable, since any game can be reproduced exactly from its seed. Finally, it makes the game's behaviour predictable for analysis, since the entire question sequence is a function of the seed.2
The seed decides which states appear and in what order, but the order is not arbitrary. The engine builds it as a chain: it starts from a random state, and each following subject is, where possible, an unused neighbour of the one before; only at a dead end does it jump to some other unused state. That chaining is what gives the player a fair shot at a connected tower: answer a run of questions correctly and the earned states tend to border one another. The player cannot control which state comes next, so the strategy lies in answering well and in deciding, block by block, whether to stack or discard. The seed determines the rhythm of the game, but the player determines how well that rhythm is followed.2
The stability rule is grounded in graph theory, the study of graphs as mathematical structures used to model pairwise relations between objects.1 In this framework, the states are vertices, and shared land borders are edges. Two states are adjacent if and only if they are joined by an edge. Each state's neighbour list is the set of vertices adjacent to it, and the adjacency check asks whether an edge exists between two given vertices. The tower, when fully stable, represents a path through this graph: a sequence of edges joining a sequence of vertices that are all distinct, distinct here because no state is asked about twice in a round.3
This graph-theoretic interpretation clarifies why some states are harder to build on than others. Alaska and Hawaii have no edges in the graph at all, which is why the game never asks about them. Among the contiguous forty-eight, the number of edges varies widely: Maine borders only New Hampshire, while Missouri and Tennessee each border eight states. A well-connected state on top of the tower gives many earned states a place to land; a poorly connected one, like Maine, leaves almost none. The connectivity of the graph shapes the difficulty of the stacking task.2
A path in a graph is a sequence of edges joining a sequence of vertices.3 The tower, when built stably, is a physical realization of such a path. Each stable block extends the path by one vertex, connected to the previous vertex by an edge. The goal height of eight means that the player must find a path through eight vertices, seven edges long. The challenge is that the path must be constructed incrementally, with each new vertex earned through trivia before it can be added to the tower.2
The engine's design synthesizes trivia, adjacency, and stacking into a single coherent loop. The trivia questions draw from the game's state dataset, testing knowledge of capitals, regions, facts, and neighbours. The adjacency check mirrors graph theory, treating states as vertices and land borders as edges. The stacking mechanic provides a physical metaphor for building a path through the graph. Each element reinforces the others: trivia earns blocks, adjacency determines stability, and stacking builds toward the goal.2
This synthesis creates a unique gameplay experience. The player must think simultaneously about knowledge and geography. A correct trivia answer earns a block, but that block is worse than useless if it does not border the state on top of the tower: stacking it would end the round. The top may be a well-connected state, yet the player may not have earned one of its neighbours. The interplay between these constraints creates strategic depth, as the player must weigh each earned block against the state currently on top.2
The effect is a game that is simultaneously simple and complex. The rules are easy to state: answer trivia, earn blocks, stack them on neighbours, reach the goal. But the execution requires constant evaluation of the state on top, its neighbours, and the block just earned. The adjacency constraint transforms what could be a trivial stacking task into a test of the map's structure, where every placement must respect the real-world geography that the dataset encodes.2