no need to track leader until game is over

config.nims

@@ -2,4 +2,4 @@
 --d: release
 --opt: speed
 --passC: -flto
---passL: -flto
+--passL: -flto

game.nim

@@ -53,15 +53,11 @@ type
     camels*: ColorStack
     tile*: Option[Tile]
 
-  CamelPos* = object
-    square*: range[1..16]
-    stackIdx*: int8
-
   Board* = object
     squares*: array[1..16, Square]
-    camels*: array[Color, CamelPos]
+    camels*: array[Color, range[1..16]]
     diceRolled*: array[Color, bool]
-    leader*: Option[Color]
+    winner*: Option[Color]
     gameOver*: bool
     initialized: bool
 
@@ -70,6 +66,10 @@ type
 template `[]`*[T](b: var Board, idx: T): var Square =
   b.squares[idx]
 
+# apparently we need separate ones for mutable and non-mutable
+template `[]`*[T](b: Board, idx: T): Square =
+  b.squares[idx]
+
 
 proc hash*(b: Board): Hash =
   var h: Hash = 0
@@ -91,6 +91,11 @@ proc init*(b: var Board) =
   b.initialized = true
 
 
+proc leader*(b: Board): Color =
+  let leadSquare = max(b.camels)
+  result = b[leadSquare].camels[^1]
+
+
 proc display*(b: Board, start, stop: int) =
   for i in start..stop:
     let sq = b.squares[i]
@@ -107,18 +112,11 @@ proc setState*(b: var Board;
                tiles: openArray[tuple[t: Tile, p: int]]) =
   for (color, dest) in camels: # note that `camels` is ordered, as this determines stacking
     b[dest].camels.add(color)
-    let height = b[dest].camels.high
+    b.camels[color] = dest
-    b.camels[color] = CamelPos(square: dest, stackIdx: height)
 
   for (tile, dest) in tiles:
     b[dest].tile = some(tile)
 
-  for sq in b.squares:
-    if sq.camels.len > 0:
-      let squareLeader = sq.camels[^1]
-      if b.leader.isNone or b.leader.get != squareLeader:
-        b.leader = some(squareLeader)
-
 
 proc diceRemaining*(b: Board): ColorStack =
   result.initFixedSeq
@@ -127,18 +125,18 @@ proc diceRemaining*(b: Board): ColorStack =
 
 
 proc resetDice*(b: var Board) =
-  for c, rolled in b.diceRolled:
+  for c in Color:
     b.diceRolled[c] = false
 
 
 proc advance*(b: var Board, die: Die) =
   let
     (color, roll) = die
-    startPos = b.camels[color].square
+    startPos = b.camels[color]
   var endPos = startPos + roll
   
   if endPos > 16: # camel has passed the finish line
-    b.leader = some(b[startPos].camels[^1])
+    b.winner = some(b[startPos].camels[^1])
     b.gameOver = true
     return
 
@@ -152,18 +150,14 @@ proc advance*(b: var Board, die: Die) =
   if prepend:
     b[startPos].camels.moveSubstackPre(b[endPos].camels, stackStart)
     let stackLen = b[startPos].camels.len - stackStart
-    for i in 0'i8 ..< stackLen:
+    for i in 0 ..< stackLen:
       # we know how many camels we added to the bottom, so set the position for each of those
-      b.camels[b[endPos].camels[i]] = CamelPos(square: endPos, stackIdx: i) # replace with cast later?
+      b.camels[b[endPos].camels[i]] = endPos
   else:
     let dstPrevHigh = b[endPos].camels.high
     b[startPos].camels.moveSubstack(b[endPos].camels, stackStart)
     # the camels that have moved start immediately after the previous high camel
     for i in (dstPrevHigh + 1) .. b[endPos].camels.high:
-      b.camels[b[endPos].camels[i]] = CamelPos(square: endPos, stackIdx: i)
+      b.camels[b[endPos].camels[i]] = endPos
-  
-  # if we are stacking on or moving past the previous leader
-  if endPos >= b.camels[b.leader.get].square:
-    b.leader = some(b[endPos].camels[^1])
   
   b.diceRolled[color] = true

simulation.nim

@@ -52,7 +52,7 @@ iterator legEndStates(b: Board): Board =
 
 proc getLegScores*(b: Board): ScoreSet =
   for prediction in b.legEndStates:
-    inc result[prediction.leader.get]
+    inc result[prediction.winner.get]
 
 
 # =====================
@@ -65,7 +65,7 @@ proc randomGame*(b: Board, r: var Rand): Color =
     for roll in randomFuture(projection.diceRemaining, r):
       projection.advance(roll)
       if projection.gameOver:
-        return projection.leader.get
+        return projection.winner.get
     projection.resetDice()