Added animation and color changing support, bouncing slime!!

build.zig

@@ -12,14 +12,6 @@ pub fn build(b: *Build) void {
         .target = target,
         .optimize = optimize,
     });
-    // Keeping this here just in case, but dynamic linking is working AFAICT
-    // if (target.query.isNativeOs() and target.result.os.tag == .linux) {
-    //     // The SDL package doesn't work for Linux yet, so we rely on system
-    //     // packages for now.
-    //     exe.linkSystemLibrary("SDL2");
-    //     exe.linkSystemLibrary("SDL2_ttf");
-    //     exe.linkSystemLibrary("SDL2_image");
-    // } else {
     const sdl_dep = b.dependency("SDL", .{
         .optimize = .ReleaseFast,
         .target = target,
@@ -37,7 +29,6 @@ pub fn build(b: *Build) void {
         .target = target,
     });
     exe.linkLibrary(sdl_image_dep.artifact("SDL2_image"));
-    // }
     b.installArtifact(exe);
 
     // Create Check step for zls
@@ -47,7 +38,8 @@ pub fn build(b: *Build) void {
         .target = target,
         .optimize = optimize,
     });
-    exe_check.linkLibrary(sdl_dep.artifact("SDL2"));
+    exe_check.root_module.addIncludePath(sdl_lib.getEmittedIncludeTree().path(b, "SDL2"));
+    exe_check.linkLibrary(sdl_lib);
     exe_check.linkLibrary(sdl_ttf_dep.artifact("SDL2_ttf"));
     exe_check.linkLibrary(sdl_image_dep.artifact("SDL2_image"));
     const check = b.step("check", "Check if project compiles, used by Zig Language Server");
@@ -57,93 +49,3 @@ pub fn build(b: *Build) void {
     const run_cmd = b.addRunArtifact(exe);
     run.dependOn(&run_cmd.step);
 }
-
-// // Although this function looks imperative, note that its job is to
-// // declaratively construct a build graph that will be executed by an external
-// // runner.
-// pub fn build(b: *std.Build) void {
-//     // Standard target options allows the person running `zig build` to choose
-//     // what target to build for. Here we do not override the defaults, which
-//     // means any target is allowed, and the default is native. Other options
-//     // for restricting supported target set are available.
-//     const target = b.standardTargetOptions(.{});
-
-//     // Standard optimization options allow the person running `zig build` to select
-//     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
-//     // set a preferred release mode, allowing the user to decide how to optimize.
-//     const optimize = b.standardOptimizeOption(.{});
-
-//     const lib = b.addStaticLibrary(.{
-//         .name = "zsdl",
-//         // In this case the main source file is merely a path, however, in more
-//         // complicated build scripts, this could be a generated file.
-//         .root_source_file = b.path("src/root.zig"),
-//         .target = target,
-//         .optimize = optimize,
-//     });
-
-//     // This declares intent for the library to be installed into the standard
-//     // location when the user invokes the "install" step (the default step when
-//     // running `zig build`).
-//     b.installArtifact(lib);
-
-//     const exe = b.addExecutable(.{
-//         .name = "zsdl",
-//         .root_source_file = b.path("src/main.zig"),
-//         .target = target,
-//         .optimize = optimize,
-//     });
-
-//     // This declares intent for the executable to be installed into the
-//     // standard location when the user invokes the "install" step (the default
-//     // step when running `zig build`).
-//     b.installArtifact(exe);
-
-//     // This *creates* a Run step in the build graph, to be executed when another
-//     // step is evaluated that depends on it. The next line below will establish
-//     // such a dependency.
-//     const run_cmd = b.addRunArtifact(exe);
-
-//     // By making the run step depend on the install step, it will be run from the
-//     // installation directory rather than directly from within the cache directory.
-//     // This is not necessary, however, if the application depends on other installed
-//     // files, this ensures they will be present and in the expected location.
-//     run_cmd.step.dependOn(b.getInstallStep());
-
-//     // This allows the user to pass arguments to the application in the build
-//     // command itself, like this: `zig build run -- arg1 arg2 etc`
-//     if (b.args) |args| {
-//         run_cmd.addArgs(args);
-//     }
-
-//     // This creates a build step. It will be visible in the `zig build --help` menu,
-//     // and can be selected like this: `zig build run`
-//     // This will evaluate the `run` step rather than the default, which is "install".
-//     const run_step = b.step("run", "Run the app");
-//     run_step.dependOn(&run_cmd.step);
-
-//     // Creates a step for unit testing. This only builds the test executable
-//     // but does not run it.
-//     const lib_unit_tests = b.addTest(.{
-//         .root_source_file = b.path("src/root.zig"),
-//         .target = target,
-//         .optimize = optimize,
-//     });
-
-//     const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
-
-//     const exe_unit_tests = b.addTest(.{
-//         .root_source_file = b.path("src/main.zig"),
-//         .target = target,
-//         .optimize = optimize,
-//     });
-
-//     const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
-
-//     // Similar to creating the run step earlier, this exposes a `test` step to
-//     // the `zig build --help` menu, providing a way for the user to request
-//     // running the unit tests.
-//     const test_step = b.step("test", "Run unit tests");
-//     test_step.dependOn(&run_lib_unit_tests.step);
-//     test_step.dependOn(&run_exe_unit_tests.step);
-// }

src/asset_utils.zig

@@ -0,0 +1,28 @@
+const sdl = @import("./sdl.zig").c;
+const log = sdl.SDL_Log;
+
+pub fn loadTexture(renderer: *sdl.struct_SDL_Renderer, path: [*c]const u8) !*sdl.struct_SDL_Texture {
+    const new_texture = sdl.IMG_LoadTexture(renderer, path) orelse {
+        log("Unable to load texture from surface %s\n", sdl.SDL_GetError());
+        return error.SDLLoadError;
+    };
+
+    return new_texture;
+}
+
+// fn loadSurface(path: [*c]const u8) !*sdl.struct_SDL_Surface {
+//     // TODO check file exists
+//     const loaded_surface: [*c]sdl.struct_SDL_Surface = sdl.IMG_Load(path);
+//     if (loaded_surface == null) {
+//         log("Unable to load media at path %s: %s\n", path, sdl.IMG_GetError());
+//         return error.SDLLoadError;
+//     }
+//     defer sdl.SDL_FreeSurface(loaded_surface);
+//     // Converting 24bit bmp to 32bit to match display
+//     const optimized_surface = sdl.SDL_ConvertSurface(loaded_surface, screen_surface.format, 0);
+//     if (optimized_surface == null) {
+//         log("Unable to optimize media at path %s: %s\n", path, sdl.SDL_GetError());
+//         return error.SDLLoadError;
+//     }
+//     return optimized_surface;
+// }

src/game_state.zig

@@ -0,0 +1,25 @@
+const sdl = @import("./sdl.zig").c;
+const std = @import("std");
+const sf = @import("./slime_factory.zig");
+
+pub const GameState = struct {
+    r: u8 = 0xff,
+    g: u8 = 0xff,
+    b: u8 = 0xff,
+    slime_factory: sf.SlimeFactory = undefined,
+    renderer: *sdl.struct_SDL_Renderer = undefined,
+
+    pub fn init(allocator: std.mem.Allocator, renderer: *sdl.struct_SDL_Renderer) !GameState {
+        var slime_factory = try sf.SlimeFactory.init(allocator, renderer);
+        try slime_factory.add(.{});
+        return .{ .slime_factory = slime_factory, .renderer = renderer };
+    }
+
+    pub fn deinit(self: *GameState) void {
+        self.slime_factory.deinit();
+    }
+
+    pub fn update_tick(self: *GameState) void {
+        self.slime_factory.render(self);
+    }
+};

src/main.zig

@@ -1,16 +1,16 @@
-const c = @cImport({
-    @cInclude("SDL2/SDL.h");
-    @cInclude("SDL2/SDL_image.h");
-});
-
 const std = @import("std");
+const sdl = @import("sdl.zig").c;
+const atils = @import("./asset_utils.zig");
+const gs = @import("./game_state.zig");
 const assert = std.debug.assert;
 const SCREEN_WIDTH = 640;
 const SCREEN_HEIGHT = 480;
-const log = c.SDL_Log;
+const log = sdl.SDL_Log;
+
+var window: *sdl.struct_SDL_Window = undefined;
+// var screen_surface: *sdl.struct_SDL_Surface = undefined;
+var renderer: *sdl.struct_SDL_Renderer = undefined;
 
-var window: *c.struct_SDL_Window = undefined;
-var screen_surface: *c.struct_SDL_Surface = undefined;
 const Offset = struct {
     x: i32,
     y: i32,
@@ -18,36 +18,65 @@ const Offset = struct {
 var img_pos: Offset = .{ .x = 0, .y = 0 };
 
 pub fn main() !void {
+    errdefer |err| if (err == error.SdlError) std.log.err("SDL error: {s}", .{sdl.SDL_GetError()});
     try init();
     defer close();
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
 
-    const zig_image = try loadSurface("assets/stretch.bmp");
+    const texture = try atils.loadTexture(renderer, "assets/png_test.png");
-    defer c.SDL_FreeSurface(zig_image);
+    defer sdl.SDL_DestroyTexture(texture);
 
-    var src_rect: c.struct_SDL_Rect = c.SDL_Rect{ .x = 0, .y = 0, .w = SCREEN_WIDTH / 2, .h = SCREEN_HEIGHT / 2 };
+    // var slime_factory = try sf.SlimeFactory.init(allocator, renderer);
+    // defer slime_factory.deinit();
+    // try slime_factory.add(.{});
+
+    var game_state = try gs.GameState.init(allocator, renderer);
+    defer game_state.deinit();
 
     var quit = false;
+    var shifted = false;
     while (!quit) {
-        var event: c.SDL_Event = undefined;
+        var event: sdl.SDL_Event = undefined;
-        while (c.SDL_PollEvent(&event) != 0) {
+        while (sdl.SDL_PollEvent(&event) != 0) {
             switch (event.type) {
-                c.SDL_QUIT => {
+                sdl.SDL_QUIT => {
                     quit = true;
                 },
-                c.SDL_KEYDOWN => {
+                sdl.SDL_KEYUP => {
                     switch (event.key.keysym.sym) {
-                        c.SDLK_UP => {
+                        sdl.SDLK_LSHIFT => {
-                            img_pos.y = img_pos.y - 5;
+                            shifted = false;
                         },
-                        c.SDLK_DOWN => {
+                        else => {},
-                            img_pos.y = img_pos.y + 5;
+                    }
+                },
+                sdl.SDL_KEYDOWN => {
+                    switch (event.key.keysym.sym) {
+                        sdl.SDLK_r => {
+                            game_state.r = if (shifted) game_state.r - 5 else game_state.r + 5;
                         },
-                        c.SDLK_LEFT => {
+                        sdl.SDLK_g => {
-                            img_pos.x = img_pos.x - 5;
+                            game_state.g = if (shifted) game_state.g - 5 else game_state.g + 5;
                         },
-                        c.SDLK_RIGHT => {
+                        sdl.SDLK_b => {
-                            img_pos.x = img_pos.x + 5;
+                            game_state.b = if (shifted) game_state.b - 5 else game_state.b + 5;
                         },
+                        sdl.SDLK_LSHIFT => {
+                            shifted = true;
+                        },
+                        // sdl.SDLK_UP => {
+                        //     img_pos.y = img_pos.y - 5;
+                        // },
+                        // sdl.SDLK_DOWN => {
+                        //     img_pos.y = img_pos.y + 5;
+                        // },
+                        // sdl.SDLK_LEFT => {
+                        //     img_pos.x = img_pos.x - 5;
+                        // },
+                        // sdl.SDLK_RIGHT => {
+                        //     img_pos.x = img_pos.x + 5;
+                        // },
                         else => {},
                     }
                     log("Got key event: %i\n", event.key.keysym.sym);
@@ -55,57 +84,65 @@ pub fn main() !void {
                 else => {},
             }
         }
-        _ = c.SDL_FillRect(screen_surface, null, c.SDL_MapRGB(screen_surface.format, 0xff, 0xff, 0xff));
+        _ = sdl.SDL_SetRenderDrawColor(renderer, 0xff, 0xff, 0xff, 0xff);
-        var dest_rect = c.SDL_Rect{ .x = src_rect.x + img_pos.x, .y = src_rect.y + img_pos.y, .w = SCREEN_WIDTH, .h = SCREEN_HEIGHT };
+        _ = sdl.SDL_RenderClear(renderer);
-        _ = c.SDL_BlitScaled(zig_image, &src_rect, screen_surface, &dest_rect);
+        std.debug.print("r:{x} g:{x} b:{x}\n", .{
+            game_state.r,
+            game_state.g,
+            game_state.b,
+        });
 
-        _ = c.SDL_UpdateWindowSurface(window);
+        game_state.update_tick();
-        c.SDL_Delay(17);
+
+        // Render red rect
+        // const fill_rect: sdl.struct_SDL_Rect = sdl.SDL_Rect{ .x = SCREEN_WIDTH / 4, .y = SCREEN_HEIGHT / 4, .w = SCREEN_WIDTH / 2 + img_pos.x, .h = SCREEN_HEIGHT / 2 + img_pos.y };
+        // _ = sdl.SDL_SetRenderDrawColor(renderer, 0xff, 0x00, 0x00, 0xff);
+        // _ = sdl.SDL_RenderFillRect(renderer, &fill_rect);
+        // _ = sdl.SDL_RenderSetViewport(renderer, &.{ .x = SCREEN_WIDTH / 2, .y = SCREEN_HEIGHT / 2, .w = SCREEN_WIDTH, .h = SCREEN_HEIGHT / 2 });
+        // _ = sdl.SDL_RenderCopy(renderer, texture, null, null);
+        _ = sdl.SDL_RenderPresent(renderer);
+        // var dest_rect = sdl.SDL_Rect{ .x = src_rect.x + img_pos.x, .y = src_rect.y + img_pos.y, .w = SCREEN_WIDTH, .h = SCREEN_HEIGHT };
+        // _ = sdl.SDL_BlitScaled(zig_image, &src_rect, screen_surface, &dest_rect);
+
+        // _ = sdl.SDL_UpdateWindowSurface(window);
+        sdl.SDL_Delay(117);
     }
     return;
 }
 
 fn init() !void {
     // Init SDL with video subsystem flag
-    if (c.SDL_Init(c.SDL_INIT_VIDEO) < 0) {
+    if (sdl.SDL_Init(sdl.SDL_INIT_VIDEO) < 0) {
-        log("Unable to initialize SDL: %s\n", c.SDL_GetError());
+        log("Unable to initialize SDL: %s\n", sdl.SDL_GetError());
         return error.SDLInitializationFailed;
     }
 
-    const opt_window = c.SDL_CreateWindow("Game Window", c.SDL_WINDOWPOS_UNDEFINED, c.SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, c.SDL_WINDOW_SHOWN);
+    const opt_window = sdl.SDL_CreateWindow("Game Window", sdl.SDL_WINDOWPOS_UNDEFINED, sdl.SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, sdl.SDL_WINDOW_SHOWN);
     if (opt_window == null) {
-        log("Unable to initialize SDL window: %s\n", c.SDL_GetError());
+        log("Unable to initialize SDL window: %s\n", sdl.SDL_GetError());
         return error.SDLInitializationFailed;
     }
     window = opt_window.?;
 
-    screen_surface = c.SDL_GetWindowSurface(window);
+    renderer = sdl.SDL_CreateRenderer(window, -1, sdl.SDL_RENDERER_ACCELERATED) orelse {
+        log("Unable to initialize SDL window: %s\n", sdl.SDL_GetError());
+        return error.SDLInitializationFailed;
+    };
+    _ = sdl.SDL_SetRenderDrawColor(renderer, 0xff, 0xff, 0xff, 0xff);
 
-    const img_flags = c.IMG_INIT_PNG;
+    // screen_surface = sdl.SDL_GetWindowSurface(window);
-    if (c.IMG_Init(img_flags) != img_flags) {
+
-        log("Unable to initialize SDL Image: %s\n", c.IMG_GetError());
+    const img_flags = sdl.IMG_INIT_PNG;
+    if (sdl.IMG_Init(img_flags) != img_flags) {
+        // NOTE remember that errors with SDL_Image will be in IMG_GetError() not SDL_GetError()
+        log("Unable to initialize SDL Image: %s\n", sdl.IMG_GetError());
         return error.SDLInitializationFailed;
     }
 }
 
-fn loadSurface(path: [*c]const u8) !*c.struct_SDL_Surface {
-    // TODO check file exists
-    const loaded_surface: [*c]c.struct_SDL_Surface = c.SDL_LoadBMP(path);
-    if (loaded_surface == null) {
-        log("Unable to load media at path %s: %s\n", path, c.SDL_GetError());
-        return error.SDLLoadError;
-    }
-    defer c.SDL_FreeSurface(loaded_surface);
-    // Converting 24bit bmp to 32bit to match display
-    const optimized_surface = c.SDL_ConvertSurface(loaded_surface, screen_surface.format, 0);
-    if (optimized_surface == null) {
-        log("Unable to optimize media at path %s: %s\n", path, c.SDL_GetError());
-        return error.SDLLoadError;
-    }
-    return optimized_surface;
-}
-
 fn close() void {
-    c.SDL_DestroyWindow(window);
+    sdl.SDL_DestroyRenderer(renderer);
-    c.SDL_Quit();
+    sdl.SDL_DestroyWindow(window);
+    sdl.IMG_Quit();
+    sdl.SDL_Quit();
 }

src/sdl.zig

@@ -0,0 +1,4 @@
+pub const c = @cImport({
+    @cInclude("SDL2/SDL.h");
+    @cInclude("SDL2/SDL_image.h");
+});

src/slime_factory.zig

@@ -0,0 +1,46 @@
+const std = @import("std");
+const sdl = @import("sdl.zig").c;
+const atils = @import("./asset_utils.zig");
+const GameState = @import("./game_state.zig").GameState;
+const slime_sprite_sheet_texture_path = "assets/slime_still.png";
+
+pub const Slime = struct {
+    total_frames: u8 = 6,
+    x: i32 = 64,
+    y: i32 = 64,
+    f: u16 = 0,
+};
+
+pub const SlimeFactory = struct {
+    slimes: std.ArrayList(Slime) = undefined,
+    slime_sprite_sheet_texture: *sdl.struct_SDL_Texture = undefined,
+
+    pub fn init(allocator: std.mem.Allocator, renderer: *sdl.struct_SDL_Renderer) !SlimeFactory {
+        const texture = try atils.loadTexture(renderer, slime_sprite_sheet_texture_path);
+        return .{
+            .slimes = std.ArrayList(Slime).init(allocator),
+            .slime_sprite_sheet_texture = texture,
+        };
+    }
+
+    pub fn deinit(sf: *SlimeFactory) void {
+        sdl.SDL_DestroyTexture(sf.slime_sprite_sheet_texture);
+        sf.slimes.deinit();
+    }
+
+    pub fn add(sf: *SlimeFactory, slime: Slime) !void {
+        try sf.slimes.append(slime);
+    }
+
+    pub fn render(sf: *SlimeFactory, game_state: *GameState) void {
+        _ = sdl.SDL_SetTextureColorMod(sf.slime_sprite_sheet_texture, game_state.r, game_state.g, game_state.b);
+        for (sf.slimes.items, 0..) |slime, s_idx| {
+            std.debug.print("Slime {d}:\t{}\n", .{ s_idx + 1, slime });
+            const sprite_frame_x_dim: u16 = slime.f * 64;
+            const sprite_frame_rect: sdl.struct_SDL_Rect = .{ .x = sprite_frame_x_dim, .y = 0, .w = 64, .h = 64 };
+            const dest_rect: sdl.struct_SDL_Rect = .{ .x = slime.x, .y = slime.y, .w = 128, .h = 128 };
+            _ = sdl.SDL_RenderCopy(game_state.renderer, sf.slime_sprite_sheet_texture, &sprite_frame_rect, &dest_rect);
+            sf.slimes.items[s_idx].f = (sf.slimes.items[s_idx].f + 1) % sf.slimes.items[s_idx].total_frames;
+        }
+    }
+};