144 lines
3.7 KiB
Nim
144 lines
3.7 KiB
Nim
import algorithm, math, options, tables, sequtils, sugar
|
|
|
|
|
|
type
|
|
Color = enum
|
|
cRed, cGreen, cBlue, cYellow, cPurple
|
|
|
|
Tile = enum
|
|
tForward = -1,
|
|
tBackward = 1
|
|
|
|
Square = object
|
|
camels: seq[Color]
|
|
tile: Option[Tile]
|
|
|
|
Die = tuple[color: Color, value: range[1..3]]
|
|
|
|
ScoreSet = array[Color, int]
|
|
|
|
Board = object
|
|
squares: array[1..16, Square]
|
|
camels: array[Color, range[1..16]]
|
|
leader: Color
|
|
gameOver: bool
|
|
|
|
|
|
proc `[]`[T](b: var Board, idx: T): var Square =
|
|
b.squares[idx]
|
|
|
|
|
|
proc display(b: Board, start, stop: int) =
|
|
for i in start..stop:
|
|
let sq = b.squares[i]
|
|
let lead = $i & ": "
|
|
if sq.tile.isSome:
|
|
echo lead, sq.tile.get
|
|
else:
|
|
echo lead, sq.camels
|
|
echo ""
|
|
|
|
|
|
proc setLeader(b: var Board) =
|
|
b.leader = b[b.camels.max].camels[^1] # top camel in the last currently-occupied space
|
|
|
|
|
|
proc setState[T](b: var Board, state: T) =
|
|
for (color, dest) in state: # note that `state` is ordered, as this determines stacking
|
|
b[dest].camels.add(color)
|
|
b.camels[color] = dest
|
|
b.setLeader
|
|
|
|
|
|
proc advance(b: var Board, die: Die) =
|
|
let
|
|
(color, roll) = die
|
|
startPos = b.camels[color]
|
|
var prepend = false
|
|
var endPos = startPos + roll
|
|
|
|
if endPos > 16: # camel has passed the finish line
|
|
b.leader = color
|
|
b.gameOver = true
|
|
return
|
|
if b[endPos].tile.isSome:
|
|
endPos += int(b[endPos].tile.get)
|
|
if b[endPos].tile.get == tBackward: prepend = true # if moving backward, we will prepend camel to the seq
|
|
|
|
for i, c in b[startPos].camels:
|
|
if c == color:
|
|
let subStack = b[startPos].camels[i .. ^1]
|
|
if prepend:
|
|
b[endPos].camels.insert(subStack)
|
|
else:
|
|
b[endPos].camels.add(subStack)
|
|
|
|
b[startPos].camels[i .. ^1] = @[]
|
|
for moved in subStack:
|
|
b.camels[moved] = endPos
|
|
b.setLeader
|
|
break # breaking the outer loop here, not the inner - but only conditionally! gah!
|
|
|
|
|
|
iterator allPermutations[T](x: seq[T]): seq[T] =
|
|
# returns all permutations of a given seq. Order is wonky but we don't care.
|
|
var workingCopy = x
|
|
yield workingCopy
|
|
while workingCopy.nextPermutation: # this mutates workingCopy
|
|
yield workingCopy
|
|
workingCopy = x
|
|
while workingCopy.prevPermutation:
|
|
yield workingCopy
|
|
|
|
|
|
proc update(scores: var ScoreSet, toAdd: ScoreSet) =
|
|
for i, s in toAdd:
|
|
scores[i] += s
|
|
|
|
|
|
proc simOrdering(b: Board, ordering: seq[Color]): ScoreSet =
|
|
for color in ordering:
|
|
for roll in 1..3:
|
|
let d = (color, range[1..3](roll))
|
|
let nextBoardState = b.dup(advance(d)) # make a copy instead of mutating
|
|
# only continue recursing if this is not the last die AND the game is not over
|
|
if ordering.len > 1 and not nextBoardState.gameOver:
|
|
let nextResult = simOrdering(nextBoardState, ordering[1 .. ^1])
|
|
result.update(nextResult)
|
|
else:
|
|
inc result[nextBoardState.leader]
|
|
|
|
|
|
iterator possibleFutures(dice: seq[Color]): seq[Die]
|
|
# iterate over all possible sequences of die rolls. Each outcome
|
|
# is returned as a 5-sequence of (color, number) tuples.
|
|
yield (cRed, range[1..3]3)
|
|
|
|
|
|
proc sumLegResults(b: Board, diceRemaining: seq[Color]): ScoreSet =
|
|
var count = 0
|
|
for perm in diceRemaining.allPermutations:
|
|
let permResult = simOrdering(b, perm)
|
|
result.update(permResult)
|
|
let total = result.sum
|
|
stdout.write("simulated: " & $total & "\r")
|
|
stdout.flushFile
|
|
count += 1
|
|
echo ""
|
|
echo count
|
|
|
|
|
|
var b: Board
|
|
b.display(1, 5)
|
|
|
|
b.setState({cGreen: 4, cYellow: 3, cPurple: 4, cBlue: 3, cRed: 2})
|
|
b.display(1, 5)
|
|
|
|
b.advance((cRed, range[1..3](2)))
|
|
b.display(1, 5)
|
|
|
|
let r = b.sumLegResults(@[cRed, cGreen, cBlue, cYellow, cPurple])
|
|
let total = r.sum
|
|
for i, c in r:
|
|
echo Color(i), ": ", (c / total).round(4) * 100, "% (", c, " / ", total, ")"
|