Prototype scaled dungeon w anim background (#3)

* Prototype of scaled background, a dungeon twice as large. Additionally, working on background animation so the field doesn't fill like it's simply floating

* A nice looking starfield is rendering for the background layer.

* More comments, added a BoundedArrayQueue generic over a fixed size array and also added more code enhancements

Author: deckarep

README.md

@@ -20,14 +20,14 @@ This is a near exact **Zig port** of the [original DungeonRush `C-based`](https:
   * 8-bit style music and many sound sfx
 
 ## How to play
-* Each round starts with a random hero in the middle
-* Move the arrow keys: up, down, left, right to control your character
+* Each round starts with a random hero in the middle of the dungeon
+* Move the arrow keys: `up`, `down`, `left`, `right` to control your character
 * Make your party stronger by collecting more heroes
-* Collect weapon and loot drops to become more powerful and heal up
-* Don't run into walls, bad guys or yourself
-* Your heroes will intelligently attack nearby enemies
-* To advance to the next round, you must collect a certain amount of heros
-* Be careful of giant bosses, they are very strong
+* Collect weapon and loot drops to become more powerful and heal your party
+* Don't run into walls, bad guys or yourself or you will 💀
+* Your heroes will intelligently attack nearby enemies when they are near
+* To advance to the next round, you must collect a certain amount of heroes
+* Be careful of giant bosses, they can be very powerful
 
 ## Port Goals
 * To re-create a moderately complex game, fully in Zig and to get better at the language.
@@ -40,7 +40,7 @@ This is a near exact **Zig port** of the [original DungeonRush `C-based`](https:
   1. Phase 1: port the C code almost as-is to minimize bugs introduced
       * ✅ Deprecate usage of `c.malloc`/`c.free` in all cases
       * ✅ Deprecate use of `c.qsort` with a `callconv(.C)` callback in favor of Zig's sorting
-      * Deprecate all [*c] style pointers
+      * ✅ Deprecate all [*c] style pointers
       * ✅ Deprecate C-style multi-pointers
       * Find and improve `const` correctness where applicable
   2. Phase 2: Ziggify
@@ -50,23 +50,22 @@ This is a near exact **Zig port** of the [original DungeonRush `C-based`](https:
       * Utilize `defer`/`errdefer` for effective cleanup
       * Migrate to a Zig-based SDL wrapper, for a nicer SDL experience
       * Ensure all errors are accounted for, utilize `try`
-      * Use build.zig.zon
+      * Use `build.zig.zon` file for any dependencies
       * ✅ Setup Github to build the project regularly
   3. Phase 3: Code Clean-up/Refactor
       * ✅ Gamepad controller support added
       * Remove duplicate code
       * Make code even more idiomatic for Zig
       * Make the code more maintainable
       * Use less globals
-      * Fix namespace issues
       * Remove redundant naming like some enumerations have their container name as the prefix
       * ✅ Use some Zig based collections like the `generic` LinkList over the original C ADT style
-      * Bonus: Introduce unit-tests
       * Get building for other OSes (w/ community contributions)
       * Migrate hardcoded textures, music + sound sfx out of the source code and into config files
         * This will allow the game to be easily skinned, for a whole new experience.
   4. Phase 4: ???
       * I'd love to port this to Raylib.
+      * Bonus: Introduce unit-tests
 
 ## More baddies?
   * [pixel-sprite-mixer](https://kingbell.itch.io/pixel-sprite-mixer)
@@ -104,5 +103,7 @@ dumb shit like that.
   * This would make the game a little more interesting because you can pick up cerrtain heroes
   as part of the strategy to help you cope with the certain level.
 * Introduce themed levels, like a frost level where most or all baddies are cold-based.
-* Introduce upgrades along the way, pick up treason, loot upgrade your heroes.
-* Gamepad support, it might be fun to not always use the damn keyboard.
+* Introduce upgrades along the way, loot upgrade your heroes.
+* ✅ Gamepad support, it might be fun to not always use the damn keyboard.
+* Weather effects, snow, rain, wind, fog-of-war, etc.
+* Show temporary animated scores when certain events occur like picking up loot

build.zig

@@ -11,14 +11,41 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    //exe.linkSystemLibrary("objc");
+    // exe.linkFramework("Cocoa");
+    // exe.linkFramework("CoreAudio");
+    // exe.linkFramework("Carbon");
+    // exe.linkFramework("Metal");
+    // exe.linkFramework("QuartzCore");
+    // exe.linkFramework("AudioToolbox");
+    // exe.linkFramework("ForceFeedback");
+    // exe.linkFramework("GameController");
+    // exe.linkFramework("CoreHaptics");
+    // exe.linkFramework("IOKit");
+
+    // exe.linkSystemLibrary("iconv");
+
     // Link SDL2 and friends.
     exe.linkSystemLibrary("SDL2");
     exe.linkSystemLibrary("SDL2_mixer");
     exe.linkSystemLibrary("SDL2_image");
     exe.linkSystemLibrary("SDL2_ttf");
     exe.linkSystemLibrary("SDL2_net");
 
+    // exe.linkSystemLibrary2("SDL2", .{ .preferred_link_mode = .static });
+    // exe.linkSystemLibrary2("SDL2_mixer", .{ .preferred_link_mode = .static });
+    // exe.linkSystemLibrary2("SDL2_image", .{ .preferred_link_mode = .static });
+    // exe.linkSystemLibrary2("SDL2_ttf", .{ .preferred_link_mode = .static });
+    // exe.linkSystemLibrary2("SDL2_net", .{ .preferred_link_mode = .static });
+
+    // exe.linkSystemLibrary("freetype");
+    // exe.linkSystemLibrary("harfbuzz");
+    // exe.linkSystemLibrary("bz2");
+    // exe.linkSystemLibrary("zlib");
+    // exe.linkSystemLibrary("graphite2");
+
     // Link C
+    //exe.linkSystemLibrary2("c", .{ .preferred_link_mode = .static });
     exe.linkSystemLibrary("c");
 
     // This declares intent for the executable to be installed into the

res/drawable/starfield

@@ -0,0 +1 @@
+purple_staff 0 0 320 320 1 

res/drawable/starfield.png

@@ -74,7 +74,7 @@ pub fn getPowerfulPlayer() c_int {
     var id: c_int = -1;
 
     for (0..@intCast(gm.playersCount)) |i| {
-        const num = gm.spriteSnake[i].?.num;
+        const num = gm.spriteSnake[i].?.num();
         if (num > maxNum) {
             maxNum = num;
             mxCount = 1;
@@ -85,7 +85,7 @@ pub fn getPowerfulPlayer() c_int {
     }
 
     if (id != -1 and mxCount == 1) {
-        if (@as(f64, @floatFromInt(gm.spriteSnake[@intCast(id)].?.num)) >= AI_LOCK_LIMIT) {
+        if (@as(f64, @floatFromInt(gm.spriteSnake[@intCast(id)].?.num())) >= AI_LOCK_LIMIT) {
             return id;
         } else {
             return -1;

zsrc/ai.zig

@@ -30,7 +30,8 @@ const BGM_FADE_DURATION = 800;
 var nowBgmId: ?usize = null;
 
 pub fn playBgm(id: usize) void {
-    if (id == nowBgmId) {
+    // NOTE: temporary disabling music, as it's getting old.
+    if (true or id == nowBgmId) {
         return;
     }
 
@@ -48,6 +49,8 @@ pub fn stopBgm() void {
     nowBgmId = null;
 }
 
+/// randomBgm selects a random background music track from 1.. because track
+/// 0 is reserved for the game menu.
 pub fn randomBgm() void {
     const r: usize = @intCast(hlp.randInt(1, res.bgmsPath.len - 1));
     playBgm(r);

zsrc/audio.zig

@@ -0,0 +1,95 @@
+const std = @import("std");
+
+/// This is a generic queue built on top of a fixed size array.
+pub fn BoundedArrayQueue(comptime Child: type, comptime bufferSize: usize) type {
+    return struct {
+        const Self = @This();
+
+        buffer: [bufferSize]Child = undefined,
+        count: usize,
+
+        /// Creates and initializes an empty queue structure.
+        pub fn init() Self {
+            return .{ .count = 0 };
+        }
+
+        /// Only peeks at the top of the queue, but this doesn't do any
+        /// modification to the queue itself.
+        pub fn peek(self: *const Self) ?Child {
+            if (self.count > 0) {
+                return self.buffer[0];
+            }
+            return null;
+        }
+
+        /// This enqueues the value to be at the head of the queue.
+        pub fn enqueue(self: *Self, value: Child) void {
+            std.debug.assert(self.count < self.buffer.len);
+            self.buffer[self.count] = value;
+            self.count += 1;
+        }
+
+        /// Does the work of shifting over the elements
+        /// in the queue and returns what was at the top.
+        pub fn dequeue(self: *Self) ?Child {
+            if (self.count > 0) {
+                return self.popAndSlideOne();
+            }
+            return null;
+        }
+
+        /// Does the primary work of shifting everything over
+        /// and returning whatever was the first out.
+        fn popAndSlideOne(self: *Self) Child {
+            const item = self.buffer[0];
+            self.count -= 1;
+
+            for (0..self.count + 1) |idx| {
+                self.buffer[idx] = self.buffer[idx + 1];
+            }
+
+            return item;
+        }
+    };
+}
+
+fn testQ() void {
+    var q = BoundedArrayQueue(u8, 10).init();
+    q.enqueue(8);
+    q.enqueue(6);
+    q.enqueue(7);
+    q.enqueue(5);
+    q.enqueue(3);
+    q.enqueue(0);
+    q.enqueue(9);
+
+    std.debug.assert(q.count == 7);
+    std.debug.assert(q.peek() == 8);
+
+    var r = q.dequeue();
+    std.debug.assert(r == 8);
+
+    r = q.dequeue();
+    std.debug.assert(r == 6);
+
+    r = q.dequeue();
+    std.debug.assert(r == 7);
+
+    r = q.dequeue();
+    std.debug.assert(r == 5);
+
+    r = q.dequeue();
+    std.debug.assert(r == 3);
+
+    r = q.dequeue();
+    std.debug.assert(r == 0);
+
+    r = q.dequeue();
+    std.debug.assert(r == 9);
+
+    r = q.dequeue();
+    std.debug.assert(r == null);
+    std.debug.assert(q.count == 0);
+
+    std.process.exit(0);
+}

zsrc/boundedarrayqueue.zig

@@ -71,7 +71,7 @@ pub const Bullet = struct {
         self.ani.y = self.y;
     }
 
-    pub fn deinit(self: *Bullet) void {
+    pub fn deinit(self: *const Bullet) void {
         gAllocator.destroy(self);
     }
 };

zsrc/bullet.zig

@@ -173,7 +173,7 @@ pub fn appendSpriteToSnake(
     y: c_int,
     direction: tps.Direction,
 ) void {
-    snake.num += 1;
+    //snake.num += 1;
     snake.score.got += 1;
     var newX = x;
     var newY = y;
@@ -531,7 +531,7 @@ fn makeSnakeAttack(snake: *pl.Snake) void {
 
 fn isWin() bool {
     if (playersCount != 1) return false;
-    return spriteSnake[0].?.num >= GAME_WIN_NUM;
+    return spriteSnake[0].?.num() >= GAME_WIN_NUM;
 }
 
 const GameStatus = enum {
@@ -1175,7 +1175,8 @@ fn initGame(localPlayers: c_int, remotePlayers: c_int, localFirst: bool) !void {
     }
     try ren.initInfo();
     // create map
-    mp.initRandomMap(0.7, 7, GAME_TRAP_RATE);
+    //mp.initRandomMap(0.7, 7, GAME_TRAP_RATE); // Original
+    mp.initRandomMap(0.6, 3, GAME_TRAP_RATE);
 
     clearItemMap();
 
@@ -1489,7 +1490,6 @@ fn makeSnakeCross(snake: *pl.Snake) bool {
                 // So it goes from: {character-type}_run_anim -> {character-type}_hit_anim
                 // NOTE: Only some characters have the _hit_anim
                 var deathPtr: usize = @intFromPtr(sprite.ani.origin);
-
                 if (isPlayer(snake)) deathPtr += (@sizeOf(tps.Texture) * 1);
 
                 dropItem(sprite);
@@ -1543,7 +1543,7 @@ fn makeSnakeCross(snake: *pl.Snake) bool {
                 ren.clearBindInAnimationsList(sprite, ren.RENDER_LIST_SPRITE_ID);
                 tps.removeAnimationFromLinkList(&ren.animationsList[ren.RENDER_LIST_SPRITE_ID], sprite.ani);
                 //sprite.ani = null;
-                snake.num -= 1;
+                //snake.num -= 1;
             }
         }
     }
@@ -1567,7 +1567,8 @@ fn makeSnakeCross(snake: *pl.Snake) bool {
                     const currSprite: *spr.Sprite = @alignCast(@ptrCast(q.?.data));
                     currSprite.direction = prevSprite.direction;
                     currSprite.face = prevSprite.face;
-                    currSprite.posBuffer = prevSprite.posBuffer;
+                    //currSprite.posBuffer = prevSprite.posBuffer;
+                    currSprite.posQueue = prevSprite.posQueue;
                     currSprite.x = prevSprite.x;
                     currSprite.y = prevSprite.y;
                 }
@@ -1746,17 +1747,15 @@ fn moveSnake(snake: *pl.Snake) void {
         const sprite: *spr.Sprite = @ptrCast(@alignCast(node.data));
 
         for (0..@intCast(step)) |_| {
-            const b = &sprite.posBuffer;
-            var firstSlot = b.buffer[0];
-
-            while (b.size > 0 and sprite.x == firstSlot.x and sprite.y == firstSlot.y) {
-                tps.changeSpriteDirection(node, firstSlot.direction);
-                b.size -= 1;
-                for (0..@intCast(b.size)) |i| {
-                    b.buffer[i] = b.buffer[i + 1];
-                }
-                firstSlot = b.buffer[0];
+            const b = &sprite.posQueue;
+            var firstSlot = b.peek();
+
+            while (firstSlot != null and b.count > 0 and sprite.x == firstSlot.?.x and sprite.y == firstSlot.?.y) {
+                tps.changeSpriteDirection(node, firstSlot.?.direction);
+                _ = b.dequeue();
+                firstSlot = b.peek();
             }
+
             moveSprite(sprite, 1);
         }
     }
@@ -1890,7 +1889,7 @@ fn gameLoop() !GameStatus {
             // Cull snakes that have no more soldiers.
             var i: usize = @intCast(playersCount);
             while (i < spritesCount) : (i += 1) {
-                if (spriteSnake[i].?.num == 0) {
+                if (spriteSnake[i].?.num() == 0) {
                     destroySnake(spriteSnake[i].?);
                     spriteSnake[i] = null;
                     var j = i;

zsrc/game.zig

@@ -433,9 +433,11 @@ pub fn initRandomMap(floorPercent: f64, smoothTimes: c_int, trapRate: f64) void
 }
 
 pub fn pushMapToRender() void {
+    std.log.info("pushMapToRender()...", .{});
     // Aliases to cutdown on long names.
     const cpa = ren.createAndPushAnimation;
 
+    // This code figures out the map boundaries and lays down the map walls (edges) only.
     for (0..res.n) |i| {
         for (0..res.m) |j| {
             const i_cInt: c_int = @intCast(i);
@@ -699,13 +701,16 @@ pub fn pushMapToRender() void {
         }
     }
 
-    for (0..(res.SCREEN_WIDTH / res.UNIT)) |i| {
-        for (0..(res.SCREEN_HEIGHT / res.UNIT)) |j| {
+    // This code lays down the map ground basically, anything within wall boundaries that
+    // is not animated (like traps).
+    for (0..res.n) |i| {
+        for (0..res.m) |j| {
             if (!hasMap[i][j]) {
                 continue;
             }
             const node = tps.createLinkNode(gm.map[i][j].ani);
-            std.debug.assert(node.data != null);
+            // This line is not necessary, it's always guaranteed to have a populated data field.
+            // std.debug.assert(node.data != null);
             tps.pushLinkNode(&ren.animationsList[ren.RENDER_LIST_MAP_ID], node);
         }
     }