creeps kill towers

Author: theprimeagen

foo.json

@@ -1,10 +1,11 @@
 {
     "rows": 24,
     "cols": 80,
-    "creepRate": 2000000,
     "fps": 33333,
     "runCount": 50000,
-    "realtime": true,
+    "roundTimeUS": 5000000,
+    "realtime": false,
     "viz": true,
     "seed": 1234
+
 }

relay.toml

@@ -30,6 +30,6 @@ primary_region = 'ord'
     timeout = 2000
 
 [[vm]]
-  memory = '1gb'
-  cpu_kind = 'shared'
-  cpus = 1
+  memory = '16gb'
+  cpu_kind = 'performance'
+  cpus = 32

src/engine/creep.zig

@@ -109,25 +109,37 @@ pub fn contains(self: *Creep, pos: math.Vec2) bool {
 }
 
 pub fn calculatePath(self: *Creep, board: []const bool) void {
+    if (!self.alive) {
+        return;
+    }
+
     const cols = self.values.cols;
     assert(board.len % cols == 0, "the length is not a rectangle");
     assert(board.len == self.path.len, "the length of the board is different than what the creep was initialized with.");
+    assert(self.alive, "cannot calculate a path for a dead creep");
 
     for (0..self.scratch.len) |idx| {
         self.scratch[idx] = -1;
     }
 
-    const pos = self.pos.position().toIdx(cols);
+    const pos = self.aabb.min.position().toIdx(cols);
     const last = walk(pos, pos, cols, board, self.scratch);
 
     if (last == 0) {
-        unreachable;
+        a.never("unable to move creep forward");
     } else {
         self.pathLen = path(self.scratch, last, self.path);
         self.pathIdx = 0;
     }
 }
 
+pub fn kill(self: *Creep, gs: *GS) void {
+    assert(gs.fns != null, "must have functions defined");
+
+    self.alive = false;
+    gs.fns.?.creepKilled(gs, self);
+}
+
 pub fn completed(self: *Creep) bool {
     return self.pos.position().col == self.values.cols - 1;
 }

src/engine/game-state.zig

@@ -8,6 +8,8 @@ const towers = @import("tower.zig");
 const creeps = @import("creep.zig");
 const projectiles = @import("projectile.zig");
 
+const never = a.never;
+const Values = objects.Values;
 const AABB = math.AABB;
 const GS = objects.gamestate.GameState;
 const Message = objects.message.Message;
@@ -39,6 +41,13 @@ pub fn update(state: *GS, delta: i64) !void {
 
     for (state.creeps.items) |*c| {
         creeps.update(c, state);
+
+        if (creeps.completed(c) and c.alive) {
+            creeps.kill(c, state);
+            if (getRandomTower(state, c.team)) |tid| {
+                towers.killById(tid, state);
+            }
+        }
     }
 
     for (state.projectile.items) |*p| {
@@ -70,6 +79,36 @@ pub fn update(state: *GS, delta: i64) !void {
     });
 }
 
+fn getRandomTower(self: *GS, team: u8) ?usize {
+    switch (team) {
+        Values.TEAM_ONE => {
+            if (self.oneTowerCount == 0) {
+                return null;
+            }
+        },
+        Values.TEAM_TWO => {
+            if (self.twoTowerCount == 0) {
+                return null;
+            }
+        },
+        else => never("invalid team"),
+    }
+
+    // TODO: Such a bad way to do this
+    // i am sure there is a better way...
+    while (true) {
+        for (self.towers.items, 0..) |*t, idx| {
+            // 50% chance is not really random especially given the order...
+            if (t.alive and t.team == team and self.values.randBool()) {
+                return idx;
+            }
+        }
+    }
+
+    never("i should select a tower");
+    return null;
+}
+
 pub fn init(self: *GS) void {
     self.fns = &.{
         .placeProjectile = placeProjectile,
@@ -96,9 +135,12 @@ pub fn init(self: *GS) void {
 pub fn towerDied(self: *GS, t: *Tower) void {
     if (t.team == objects.Values.TEAM_ONE) {
         self.oneStats.towersLost += 1;
+        self.oneTowerCount -= 1;
     } else {
         self.twoStats.towersLost += 1;
+        self.twoTowerCount -= 1;
     }
+
     self.boardChanged += 1;
 }
 
@@ -125,6 +167,11 @@ pub fn strike(self: *GS, p: *Projectile) void {
     }
 }
 
+pub fn completed(self: *GS) bool {
+    return !self.noBuildZone and
+        (self.oneTowerCount == 0 or self.twoTowerCount == 0);
+}
+
 pub fn roundPlayed(state: *GS) bool {
     return !state.playing and state.round == state.one and state.round == state.two;
 }
@@ -173,9 +220,17 @@ pub fn message(state: *GS, msg: Message) !void {
                 a.never("haven't programmed this yet");
             }
 
-            if (try placeTower(state, aabb, c.team)) |id| {
-                std.debug.print("placed tower: {}\n", .{id});
+            if (try placeTower(state, aabb, c.team)) |_| {
             } else {
+                var count: usize = 0;
+                while (creepByAABB(state, aabb)) |id| : (count += 1) {
+                    creeps.kill(&state.creeps.items[id], state);
+                }
+
+                if (count > 0) {
+                    return;
+                }
+
                 std.debug.print("could not place tower: {s} {s}\n", .{try aabb.string(), try c.string()});
                 a.never("haven't programmed this yet also");
             }
@@ -218,7 +273,7 @@ pub fn clone(self: *GS) !GS {
 
 pub fn towerByAABB(self: *GS, aabb: AABB) ?usize {
     for (self.towers.items, 0..) |*t, i| {
-        if (t.aabb.overlaps(aabb)) {
+        if (t.alive and t.aabb.overlaps(aabb)) {
             return i;
         }
     }
@@ -227,7 +282,7 @@ pub fn towerByAABB(self: *GS, aabb: AABB) ?usize {
 
 pub fn creepByAABB(self: *GS, aabb: AABB) ?usize {
     for (self.creeps.items, 0..) |*c, i| {
-        if (c.aabb.overlaps(aabb)) {
+        if (c.alive and c.aabb.overlaps(aabb)) {
             return i;
         }
     }
@@ -335,14 +390,15 @@ fn canPlaceTower(self: *GS, aabb: math.AABB, team: u8) bool {
     }
 
     if (creepByAABB(self, aabb)) |_| {
-        std.debug.print("on creep", .{});
         return false;
     }
 
     return true;
 }
 
 pub fn placeTower(self: *GS, aabb: math.AABB, team: u8) !?usize {
+    Values.assertTeam(team);
+
     const pos = aabb.min;
     assert(aabb.min.closeEnough(pos, 0.0001), "you must place towers on natural numbers");
 
@@ -358,6 +414,11 @@ pub fn placeTower(self: *GS, aabb: math.AABB, team: u8) !?usize {
         .tower(self.values);
 
     try self.towers.append(t);
+    if (team == Values.TEAM_ONE) {
+        self.oneTowerCount += 1;
+    } else {
+        self.twoTowerCount += 1;
+    }
 
     updateBoard(self);
 
@@ -395,11 +456,35 @@ pub fn towerById(self: *GS, id: usize) *Tower {
 
 pub fn validateState(self: *GS) void {
     for (self.creeps.items) |*c| {
-        if (tower(self, c.pos)) |t| {
+        if (!c.alive) {
+            continue;
+        }
+
+        if (towerByAABB(self, c.aabb)) |t| {
             std.debug.print("tower: {s} collided with creep {s}\n", .{a.u(self.towers.items[t].pos.string()), a.u(c.string())});
             assert(false, "a creep is within a tower");
         }
     }
+
+    var one: usize = 0;
+    var tuwu: usize = 0;
+
+    for (self.towers.items) |*t| {
+        if (!t.alive) {
+            continue;
+        }
+
+        switch (t.team) {
+            Values.TEAM_ONE => one += 1,
+            Values.TEAM_TWO => tuwu += 1,
+            else => never("how tf did i get here?"),
+        }
+
+    }
+
+    std.debug.print("one = {} / {} two = {} / {}\n", .{one, self.oneTowerCount, tuwu, self.twoTowerCount});
+    assert(one == self.oneTowerCount, "one's tower count does not equal the alive towers");
+    assert(tuwu == self.twoTowerCount, "two's tower count does not equal the alive towers");
 }
 
 const testing = std.testing;

src/engine/tower.zig

@@ -127,9 +127,7 @@ pub fn update(self: *Tower, gs: *GS) !void {
     }
 
     if (self.ammo == 0) {
-        self.alive = false;
-        self.deadTimeUS = gs.time;
-        gs.fns.?.towerDied(gs, self);
+        kill(self, gs);
         return;
     }
 
@@ -220,6 +218,19 @@ pub fn creepWithinRange(self: *Tower, gs: *GS) ?*Creep {
     return out;
 }
 
+pub fn killById(tid: usize, gs: *GS) void {
+    kill(&gs.towers.items[tid], gs);
+}
+
+pub fn kill(t: *Tower, gs: *GS) void {
+    assert(gs.fns != null, "gs must have functions on it");
+
+    t.alive = false;
+    t.deadTimeUS = gs.time;
+
+    gs.fns.?.towerDied(gs, t);
+}
+
 fn createTestTower() Tower {
     return TowerBuilder.
         start().

src/engine/utils.zig

@@ -1 +1,3 @@
 
+
+

src/math/math.zig

@@ -322,3 +322,12 @@ test "aabb overlap" {
     try t.expect(!b_false_y.overlaps(a));
     try t.expect(b_true.overlaps(a));
 }
+
+test "aabb collision failure creep tower issue" {
+    const tower = AABB{.min = .{.x = 2.8e1, .y = 0e0}, .max = .{.x = 3.1e1, .y = 1e0}};
+    const creep = AABB{.min = .{.x = 3e1, .y = 1e0}, .max = .{.x = 3.1e1, .y = 2e0}};
+
+    try t.expect(!tower.overlaps(creep));
+    try t.expect(!creep.overlaps(tower));
+}
+

src/objects/creep.zig

@@ -42,15 +42,26 @@ pub const Creep = struct {
     pathLen: usize = 0,
     alloc: Allocator,
 
-    pub fn string(self: *Creep) ![]u8 {
-        const buf = scratchBuf(150);
+    pub fn string(self: *const Creep) ![]u8 {
+        const buf = scratchBuf(250);
         return std.fmt.bufPrint(buf, "creep({}, {}, {})\r\n  pos = {s} aabb = {s}\r\n  path = {}/{}, life = {}, speed = {}\r\n", .{
             self.alive, self.id, self.team,
             try self.pos.string(), try self.aabb.string(),
             self.pathIdx, self.pathLen, self.life, self.speed,
         });
     }
 
+    pub fn dumpScratch(self: *Creep) void {
+        std.debug.print("Creep({} {}): Scratch\n", .{self.alive, self.id});
+        for (0..self.scratch.len) |idx| {
+            if (idx > 0 and idx % self.values.cols == 0) {
+                std.debug.print("\n", .{});
+            }
+            std.debug.print("{} ", .{self.scratch[idx]});
+        }
+        std.debug.print("\n", .{});
+    }
+
     pub fn init(alloc: Allocator, values: *const Values) !Creep {
         return .{
             .values = values,

src/objects/game-state.zig

@@ -51,12 +51,14 @@ pub const GameState = struct {
     boardChanged: usize = 0,
 
     one: usize = 0,
+    oneTowerCount: usize = 0,
     oneCoords: [3]?Coord,
     oneStats: Stats = Stats{},
     oneCreepRange: Range = Range{},
     oneNoBuildTowerRange: Range = Range{},
 
     two: usize = 0,
+    twoTowerCount: usize = 0,
     twoCoords: [3]?Coord,
     twoStats: Stats = Stats{},
     twoCreepRange: Range = Range{},
@@ -158,6 +160,12 @@ pub const GameState = struct {
 
     pub fn debugBoard(self: *GameState) void {
         std.debug.print("\nBoard:\n", .{});
+
+        for (0..self.values.cols) |c| {
+                std.debug.print("{:0>3}", .{c});
+        }
+        std.debug.print("\n", .{});
+
         outer:
         for (self.board, 0..) |b, idx| {
             if (idx > 0 and idx % self.values.cols == 0) {
@@ -166,13 +174,13 @@ pub const GameState = struct {
 
             for (self.creeps.items) |*c| {
                 if (idx == c.pos.position().toIdx(self.values.cols)) {
-                    std.debug.print("c ", .{});
+                    std.debug.print("c  ", .{});
                     continue :outer;
                 }
             }
 
             const v: usize = if (b) 1 else 0;
-            std.debug.print("{} ", .{v});
+            std.debug.print("{}  ", .{v});
         }
         std.debug.print("\n", .{});
     }