Nuggets Game · Projects · Amittai Siavava

A multiplayer command-line game of nuggets. A single server holds the maze, the gold piles, and every player's position; clients connect over sockets, send keystrokes, and receive the slice of the map their character can currently see. The game ends when the last pile is collected, and the player with the most gold wins.

The server is authoritative: it owns the grid, the set of gold piles and their values, and each connected player's location and purse. A client is a thin terminal that captures movement keystrokes, ships them to the server as short messages over a socket, and redraws whatever display string the server sends back. The two speak a small line-based protocol: a join message and per-keystroke moves upstream, a grid string and a status banner downstream. Every state change, whether a move, a pickup, or a join, happens on the server and fans out to the clients, so no two clients can disagree about where the gold is or who holds it. The client keeps no authoritative state of its own; if its socket drops, the server can drop that player without the rest of the game noticing.

Visibility comes down to a line-of-sight test. Each player sees only what their position reveals, and the maze uncovers gradually as they walk; a wall, once seen, stays drawn, but gold and other players show only while in view. A cell $p$ is visible from the player at $q$ when the straight segment $q p$ is not interrupted by a wall. Walking the segment column by column, the row where it crosses column $x$ is

y = q_{y} + (p_{y} - q_{y}) \frac{x - q _{x}}{p _{x} - q _{x}},

and the cell there — or, when $y$ is fractional, the pair of cells it falls between — must be open for the sightline to survive:

Algorithm:

\textsc{Visible}(q, p, grid)

— can the player at

q

see cell

p

1
input: player cell $q$ , target cell $p$ , the maze $grid$
2
for each column $x$ strictly between $q_x$ and $p_x$ do
3
$y \gets q_y + (p_y - q_y)\,(x - q_x)/(p_x - q_x)$
4
if $y$ is an integer then
5
if $grid[x][y]$ is a wall then return false
6
else if $grid[x][\lfloor y \rfloor]$ and $grid[x][\lceil y \rceil]$ are both walls then return false
7
for each row $y$ strictly between $q_y$ and $p_y$ , symmetric in $x$ , do
8
if the crossing cell, or the pair it falls between, is wall then return false
9
return true

The player (circle) sees the gold (diamond) along the solid sightline, which crosses only open cells. The dashed segment to a second spot passes through a wall cell (filled), so that spot stays hidden until the player moves to a new vantage.

The server runs this test from every player against every cell it might reveal, then sends each client the visible region merged with the walls that player has already discovered. Because the visible set is a function of position, it is recomputed the moment a player moves: the old vantage's sightlines no longer hold, gold that was occluded may come into view, and cells that were open may fall behind a corner. Recomputing per move, rather than caching a fixed field of view, is what lets the map unfold as the player explores and keeps every client's picture of the world honest.

The sightline reduces to a segment-versus-grid intersection — a geometric primitive doing the work of a game mechanic.

Collaborative project with Alphonso Bradham and Zimehr Abbasi.

References

Project repository
Reference notes: Geometric Primitives & Orientation

╌╌ END ╌╌