1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
namespace LivingVillage.Kernel.Tests
open System
open Microsoft.VisualStudio.TestTools.UnitTesting
open LivingVillage.Kernel
open LivingVillage.Kernel.Sim
module private DriverHarness =
let segmentTicks = 900L
type Driver =
{ Rng: RngState
Until: int64
Input: Input }
let zeroInput = { MoveX = 0.0f; MoveY = 0.0f }
let nextSegment (rng: RngState) (until: int64) : Driver =
let a, r1 = Rng.nextUInt64 rng
let m, r2 = Rng.nextUInt64 r1
let diag = 0.70710678f
let dirX, dirY =
match int (a &&& 7UL) with
| 0 -> 1.0f, 0.0f
| 1 -> diag, diag
| 2 -> 0.0f, 1.0f
| 3 -> -diag, diag
| 4 -> -1.0f, 0.0f
| 5 -> -diag, -diag
| 6 -> 0.0f, -1.0f
| _ -> diag, -diag
let mag =
match int (m % 3UL) with
| 0 -> 0.4f
| 1 -> 0.7f
| _ -> 1.0f
{ Rng = r2
Until = until + segmentTicks
Input = { MoveX = dirX * mag; MoveY = dirY * mag } }
let run (seed: uint64) (ticks: int64) : World list =
let mutable world = Sim.initialWorld seed
let mutable driver = { Rng = Rng.ofSeed seed; Until = segmentTicks; Input = zeroInput }
let acc = ResizeArray<World> (int ticks + 1)
acc.Add world
for t in 1L .. ticks do
let d, input =
if t - 1L < driver.Until then driver, driver.Input
else
let d = nextSegment driver.Rng driver.Until
d, d.Input
driver <- d
world <- Sim.step { Input = input } world
acc.Add world
List.ofSeq acc
[<TestClass>]
type DeterminismTests () =
[<TestMethod>]
member _.SameSeedSameInputSequenceTracesAreTickByTickEqual () =
let a = DriverHarness.run 42UL 20000L
let b = DriverHarness.run 42UL 20000L
Assert.IsTrue(20001 = List.length a)
CollectionAssert.AreEqual(Array.ofList a, Array.ofList b)
[<TestMethod>]
member _.DifferentSeedsProduceDivergentTraces () =
let a = DriverHarness.run 42UL 20000L
let b = DriverHarness.run 43UL 20000L
let diverged =
Seq.exists2 (fun (x: World) (y: World) -> x.Avatar.Pos <> y.Avatar.Pos) a b
if not diverged then Assert.Fail("expected avatar positions to diverge across seeds")
if a = b then Assert.Fail("expected whole traces to differ across seeds")
[<TestMethod>]
member _.StepIsPureAndDoesNotMutateItsInput () =
let w = Sim.initialWorld 7UL
let ts = { Input = { MoveX = 1.0f; MoveY = -0.5f } }
let w1 = Sim.step ts w
let w1' = Sim.step ts w
if w1 <> w1' then Assert.Fail("step must be deterministic for identical (world, input)")
Assert.IsTrue(w.Tick = 0L)
Assert.IsTrue(w.Time = 0.0)
Assert.IsTrue(w1.Tick = 1L)
Assert.IsTrue(abs (w1.Time - Sim.dtSeconds) < 1e-12)
[<TestMethod>]
member _.WorldCarriesSeededRngState () =
let a = Sim.initialWorld 42UL
let b = Sim.initialWorld 43UL
Assert.IsTrue(a.Rng.State = 42UL)
Assert.IsTrue(b.Rng.State = 43UL)
Assert.IsTrue(a <> b)
[<TestMethod>]
member _.LongRunStaysFiniteBoundedAndTimeTracksTicks () =
let trace = DriverHarness.run 42UL 120000L
let maxX = float32 (Sim.mapWidthTiles * Sim.tilePixels - Sim.tilePixels)
let maxY = float32 (Sim.mapHeightTiles * Sim.tilePixels - Sim.tilePixels)
let mutable checkedTicks = 0
for w in trace do
let p = w.Avatar.Pos
if Single.IsNaN p.X then Assert.Fail($"NaN X at tick {w.Tick}")
if Single.IsNaN p.Y then Assert.Fail($"NaN Y at tick {w.Tick}")
if Single.IsInfinity p.X then Assert.Fail($"Infinity X at tick {w.Tick}")
if Single.IsInfinity p.Y then Assert.Fail($"Infinity Y at tick {w.Tick}")
if p.X < 0.0f || p.X > maxX then Assert.Fail($"X out of bounds at tick {w.Tick}: {p.X}")
if p.Y < 0.0f || p.Y > maxY then Assert.Fail($"Y out of bounds at tick {w.Tick}: {p.Y}")
if abs (float w.Tick * Sim.dtSeconds - w.Time) >= 1e-9 then
Assert.Fail($"Time/Tick mismatch at tick {w.Tick}: {w.Time}")
checkedTicks <- checkedTicks + 1
Assert.IsTrue(120001 = checkedTicks)
[<TestMethod>]
member _.SplitMix64MatchesKnownVectors () =
let expected : uint64 list =
[ 0xbdd732262feb6e95UL
0x28efe333b266f103UL
0x47526757130f9f52UL
0x581ce1ff0e4ae394UL ]
let mutable rng = Rng.ofSeed 42UL
for e in expected do
let v, rng' = Rng.nextUInt64 rng
if v <> e then Assert.Fail($"expected {e}, got {v}")
rng <- rng'
[<TestMethod>]
member _.NextFloat32StaysInUnitInterval () =
let mutable rng = Rng.ofSeed 1UL
for _ in 1 .. 1000 do
let f, rng' = Rng.nextFloat32 rng
if f < 0.0f || f >= 1.0f then Assert.Fail($"out of range: {f}")
rng <- rng'
[<TestMethod>]
member _.NpcDecisionTraceIsTickByTickDeterministic () =
let runNpc (seed: uint64) (ticks: int64) : World list =
let mutable world = Sim.initialWorld seed
let acc = ResizeArray<World> (int ticks + 1)
acc.Add world
let zero = { Input = { MoveX = 0.0f; MoveY = 0.0f } }
for _ in 1L .. ticks do
world <- Sim.step zero world
acc.Add world
List.ofSeq acc
let a = runNpc 42UL 20000L
let b = runNpc 42UL 20000L
Assert.IsTrue(20001 = List.length a)
CollectionAssert.AreEqual(Array.ofList a, Array.ofList b)
[<TestMethod>]
member _.NpcNeedsDecayOverTimeAndActionsDifferAcrossSeeds () =
let w0 = Sim.initialWorld 42UL
let npc0 = List.exactlyOne w0.Npcs
let zero = { Input = { MoveX = 0.0f; MoveY = 0.0f } }
let mutable w = w0
for _ in 1 .. 500 do
w <- Sim.step zero w
let npc1 = List.exactlyOne w.Npcs
let n0 = npc0.Mind.Needs
let n1 = npc1.Mind.Needs
Assert.IsTrue(n1.Hunger < n0.Hunger, "hunger must decay")
Assert.IsTrue(n1.Energy < n0.Energy, "energy must decay")
Assert.IsTrue(n1.Social < n0.Social, "social must decay")
Assert.IsTrue(n1.Money < n0.Money, "money must decay")
let wa = Sim.initialWorld 42UL
let wb = Sim.initialWorld 43UL
Assert.IsTrue(wa.Npcs.[0].Mind.Personality <> wb.Npcs.[0].Mind.Personality,
"personalities must differ across seeds")
let mutable ta = wa
let mutable tb = wb
let seqA = ResizeArray<NpcActionKind> 20000
let seqB = ResizeArray<NpcActionKind> 20000
for _ in 1 .. 20000 do
ta <- Sim.step zero ta
tb <- Sim.step zero tb
seqA.Add ta.Npcs.[0].Mind.Action
seqB.Add tb.Npcs.[0].Mind.Action
if Seq.compareWith compare seqA seqB = 0 then
Assert.Fail("npc action sequence must diverge across seeds")
|
