From 052c3ad62474e5c733d796d87d552d13ae736415 Mon Sep 17 00:00:00 2001 From: Rokas Puzonas Date: Fri, 30 Jan 2026 23:28:18 +0200 Subject: [PATCH] Initial commit --- .gitignore | 3 + README.md | 28 + build.zig | 276 +++++++ build.zig.zon | 44 ++ libs/stb/build.zig | 53 ++ libs/stb/build.zig.zon | 17 + libs/stb/src/stb_image.zig | 31 + libs/stb/src/stb_image_impl.c | 3 + libs/stb/src/stb_rect_pack.zig | 52 ++ libs/stb/src/stb_rect_pack_impl.c | 2 + libs/stb/src/stb_vorbis.zig | 170 +++++ libs/stb/src/stb_vorbis_impl.c | 3 + libs/tiled/build.zig | 29 + libs/tiled/src/buffers.zig | 18 + libs/tiled/src/color.zig | 52 ++ libs/tiled/src/global_tile_id.zig | 15 + libs/tiled/src/layer.zig | 464 +++++++++++ libs/tiled/src/object.zig | 421 ++++++++++ libs/tiled/src/position.zig | 20 + libs/tiled/src/property.zig | 162 ++++ libs/tiled/src/root.zig | 16 + libs/tiled/src/tilemap.zig | 266 +++++++ libs/tiled/src/tileset.zig | 226 ++++++ libs/tiled/src/xml.zig | 687 +++++++++++++++++ src/assets.zig | 155 ++++ src/assets/game-2026-01-18.tiled-project | 14 + src/assets/icon.png | Bin 0 -> 795 bytes .../License.txt | 23 + .../PNG/Enemies/Tilesheet.txt | 9 + .../PNG/Enemies/tilemap_packed.png | Bin 0 -> 1222 bytes .../PNG/Interface/Tilesheet.txt | 9 + .../PNG/Interface/tilemap_packed.png | Bin 0 -> 2931 bytes .../PNG/Players/Tilesheet.txt | 9 + .../PNG/Players/tilemap_packed.png | Bin 0 -> 1147 bytes .../PNG/Tiles/Tilesheet.txt | 9 + .../PNG/Tiles/tilemap_packed.png | Bin 0 -> 6442 bytes .../PNG/Weapons/Tilesheet.txt | 9 + .../PNG/Weapons/tilemap_packed.png | Bin 0 -> 1554 bytes .../Sounds/coin-a.ogg | Bin 0 -> 5095 bytes .../Sounds/coin-b.ogg | Bin 0 -> 5274 bytes .../Sounds/coin-c.ogg | Bin 0 -> 6193 bytes .../Sounds/coin-d.ogg | Bin 0 -> 5705 bytes .../Sounds/error-a.ogg | Bin 0 -> 5297 bytes .../Sounds/error-b.ogg | Bin 0 -> 5570 bytes .../Sounds/error-c.ogg | Bin 0 -> 5309 bytes .../Sounds/explosion-a.ogg | Bin 0 -> 13019 bytes .../Sounds/explosion-b.ogg | Bin 0 -> 14422 bytes .../Sounds/explosion-c.ogg | Bin 0 -> 14572 bytes .../Sounds/fall-a.ogg | Bin 0 -> 16629 bytes .../Sounds/fall-b.ogg | Bin 0 -> 20092 bytes .../Sounds/hurt-a.ogg | Bin 0 -> 7511 bytes .../Sounds/hurt-b.ogg | Bin 0 -> 7538 bytes .../Sounds/hurt-c.ogg | Bin 0 -> 6175 bytes .../Sounds/hurt-d.ogg | Bin 0 -> 5888 bytes .../Sounds/hurt-e.ogg | Bin 0 -> 5883 bytes .../Sounds/jump-a.ogg | Bin 0 -> 6748 bytes .../Sounds/jump-b.ogg | Bin 0 -> 6736 bytes .../Sounds/jump-c.ogg | Bin 0 -> 6331 bytes .../Sounds/jump-d.ogg | Bin 0 -> 6317 bytes .../Sounds/jump-e.ogg | Bin 0 -> 4572 bytes .../Sounds/jump-f.ogg | Bin 0 -> 5508 bytes .../Sounds/lose-a.ogg | Bin 0 -> 21055 bytes .../Sounds/lose-b.ogg | Bin 0 -> 20739 bytes .../Sounds/lose-c.ogg | Bin 0 -> 14506 bytes .../Sounds/lose-d.ogg | Bin 0 -> 9826 bytes .../Sounds/move-a.ogg | Bin 0 -> 5296 bytes .../Sounds/move-b.ogg | Bin 0 -> 5156 bytes .../Sounds/move-c.ogg | Bin 0 -> 5665 bytes .../Sounds/move-d.ogg | Bin 0 -> 5311 bytes .../Sounds/select-a.ogg | Bin 0 -> 5157 bytes .../Sounds/shoot-a.ogg | Bin 0 -> 5753 bytes .../Sounds/shoot-b.ogg | Bin 0 -> 5840 bytes .../Sounds/shoot-c.ogg | Bin 0 -> 5764 bytes .../Sounds/shoot-d.ogg | Bin 0 -> 5259 bytes .../Sounds/shoot-e.ogg | Bin 0 -> 5691 bytes .../Sounds/shoot-f.ogg | Bin 0 -> 4741 bytes .../Sounds/shoot-g.ogg | Bin 0 -> 6682 bytes .../Sounds/shoot-h.ogg | Bin 0 -> 6895 bytes src/assets/map.tmx | 225 ++++++ src/assets/roboto-font/LICENSE.txt | 93 +++ src/assets/roboto-font/Roboto-Bold.ttf | Bin 0 -> 146768 bytes src/assets/roboto-font/Roboto-Italic.ttf | Bin 0 -> 152208 bytes src/assets/roboto-font/Roboto-Regular.ttf | Bin 0 -> 146004 bytes src/assets/tilemap.tsx | 4 + src/assets/tileset.tsx | 4 + src/assets/wood01.ogg | Bin 0 -> 8569 bytes src/assets/wood02.ogg | Bin 0 -> 8672 bytes src/assets/wood03.ogg | Bin 0 -> 9832 bytes src/engine/audio/data.zig | 74 ++ src/engine/audio/mixer.zig | 152 ++++ src/engine/audio/root.zig | 111 +++ src/engine/audio/store.zig | 106 +++ src/engine/fontstash/context.zig | 250 ++++++ src/engine/fontstash/font.zig | 33 + src/engine/fontstash/root.zig | 3 + src/engine/fontstash/sokol_fontstash_impl.c | 12 + src/engine/frame.zig | 291 +++++++ src/engine/graphics.zig | 380 +++++++++ src/engine/imgui.zig | 504 ++++++++++++ src/engine/input.zig | 124 +++ src/engine/math.zig | 469 ++++++++++++ src/engine/root.zig | 486 ++++++++++++ src/engine/screen_scaler.zig | 80 ++ src/engine/shell.html | 53 ++ src/game.zig | 130 ++++ src/game_original.zig | 719 ++++++++++++++++++ src/main.zig | 8 + src/raycast_tile_iterator.zig | 97 +++ tools/png-to-icon.zig | 56 ++ 109 files changed, 7759 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 build.zig create mode 100644 build.zig.zon create mode 100644 libs/stb/build.zig create mode 100644 libs/stb/build.zig.zon create mode 100644 libs/stb/src/stb_image.zig create mode 100644 libs/stb/src/stb_image_impl.c create mode 100644 libs/stb/src/stb_rect_pack.zig create mode 100644 libs/stb/src/stb_rect_pack_impl.c create mode 100644 libs/stb/src/stb_vorbis.zig create mode 100644 libs/stb/src/stb_vorbis_impl.c create mode 100644 libs/tiled/build.zig create mode 100644 libs/tiled/src/buffers.zig create mode 100644 libs/tiled/src/color.zig create mode 100644 libs/tiled/src/global_tile_id.zig create mode 100644 libs/tiled/src/layer.zig create mode 100644 libs/tiled/src/object.zig create mode 100644 libs/tiled/src/position.zig create mode 100644 libs/tiled/src/property.zig create mode 100644 libs/tiled/src/root.zig create mode 100644 libs/tiled/src/tilemap.zig create mode 100644 libs/tiled/src/tileset.zig create mode 100644 libs/tiled/src/xml.zig create mode 100644 src/assets.zig create mode 100644 src/assets/game-2026-01-18.tiled-project create mode 100644 src/assets/icon.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/License.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/Tilesheet.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/tilemap_packed.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Interface/Tilesheet.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Interface/tilemap_packed.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/Tilesheet.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/tilemap_packed.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Tiles/Tilesheet.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Tiles/tilemap_packed.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/Tilesheet.txt create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/tilemap_packed.png create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/fall-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/fall-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-e.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-e.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-f.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/select-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-a.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-b.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-c.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-d.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-e.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-f.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-g.ogg create mode 100644 src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-h.ogg create mode 100644 src/assets/map.tmx create mode 100644 src/assets/roboto-font/LICENSE.txt create mode 100644 src/assets/roboto-font/Roboto-Bold.ttf create mode 100644 src/assets/roboto-font/Roboto-Italic.ttf create mode 100644 src/assets/roboto-font/Roboto-Regular.ttf create mode 100644 src/assets/tilemap.tsx create mode 100644 src/assets/tileset.tsx create mode 100644 src/assets/wood01.ogg create mode 100644 src/assets/wood02.ogg create mode 100644 src/assets/wood03.ogg create mode 100644 src/engine/audio/data.zig create mode 100644 src/engine/audio/mixer.zig create mode 100644 src/engine/audio/root.zig create mode 100644 src/engine/audio/store.zig create mode 100644 src/engine/fontstash/context.zig create mode 100644 src/engine/fontstash/font.zig create mode 100644 src/engine/fontstash/root.zig create mode 100644 src/engine/fontstash/sokol_fontstash_impl.c create mode 100644 src/engine/frame.zig create mode 100644 src/engine/graphics.zig create mode 100644 src/engine/imgui.zig create mode 100644 src/engine/input.zig create mode 100644 src/engine/math.zig create mode 100644 src/engine/root.zig create mode 100644 src/engine/screen_scaler.zig create mode 100644 src/engine/shell.html create mode 100644 src/game.zig create mode 100644 src/game_original.zig create mode 100644 src/main.zig create mode 100644 src/raycast_tile_iterator.zig create mode 100644 tools/png-to-icon.zig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6c2ffbe --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +zig-out +.zig-cache +*.tiled-session diff --git a/README.md b/README.md new file mode 100644 index 0000000..d2e217c --- /dev/null +++ b/README.md @@ -0,0 +1,28 @@ +# Gaem + +Weapons: +* Laser mask +* Bomb mask +* Piston mask + +Enemies: +* Singular pawns that keep distance +* Cluster of many enemies +* Snake-like row of enemies + +## Run + +Linux and Windows: +```sh +zig build run +``` + +Web: +```sh +zig build -Dtarget=wasm32-emscripten run +``` + +Cross-compile for Windows from Linux: +```sh +zig build -Dtarget=x86_64-windows +``` diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..c5b1acf --- /dev/null +++ b/build.zig @@ -0,0 +1,276 @@ +const std = @import("std"); +const sokol = @import("sokol"); +const builtin = @import("builtin"); + +const project_name = "game-2026-01-18"; + +pub fn build(b: *std.Build) !void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const has_imgui = b.option(bool, "imgui", "ImGui integration") orelse (optimize == .Debug); + var has_tracy = b.option(bool, "tracy", "Tracy integration") orelse (optimize == .Debug); + const has_console = b.option(bool, "console", "Show console (Window only)") orelse (optimize == .Debug); + + const isWasm = target.result.cpu.arch.isWasm(); + + if (isWasm) { + has_tracy = false; + } + + const mod_main = b.createModule(.{ + .root_source_file = b.path("src/main.zig"), + .target = target, + .optimize = optimize, + .link_libc = true, + }); + + const dep_sokol = b.dependency("sokol", .{ .target = target, .optimize = optimize, .with_sokol_imgui = has_imgui, .vulkan = true }); + mod_main.linkLibrary(dep_sokol.artifact("sokol_clib")); + mod_main.addImport("sokol", dep_sokol.module("sokol")); + + if (has_imgui) { + if (b.lazyDependency("cimgui", .{ + .target = target, + .optimize = optimize, + })) |dep_cimgui| { + const cimgui = b.lazyImport(@This(), "cimgui").?; + const cimgui_conf = cimgui.getConfig(false); + mod_main.addImport("cimgui", dep_cimgui.module(cimgui_conf.module_name)); + dep_sokol.artifact("sokol_clib").addIncludePath(dep_cimgui.path(cimgui_conf.include_dir)); + } + } + + const dep_tracy = b.dependency("tracy", .{ .target = target, .optimize = optimize, .tracy_enable = has_tracy, .tracy_only_localhost = true }); + if (has_tracy) { + mod_main.linkLibrary(dep_tracy.artifact("tracy")); + } + mod_main.addImport("tracy", dep_tracy.module("tracy")); + + const dep_tiled = b.dependency("tiled", .{}); + mod_main.addImport("tiled", dep_tiled.module("tiled")); + + const dep_stb = b.dependency("stb", .{}); + mod_main.addImport("stb_image", dep_stb.module("stb_image")); + mod_main.addImport("stb_vorbis", dep_stb.module("stb_vorbis")); + mod_main.addImport("stb_rect_pack", dep_stb.module("stb_rect_pack")); + + const dep_fontstash_c = b.dependency("fontstash_c", .{}); + mod_main.addIncludePath(dep_fontstash_c.path("src")); + + const dep_sokol_c = b.dependency("sokol_c", .{}); + { + var cflags_buffer: [64][]const u8 = undefined; + var cflags = std.ArrayListUnmanaged([]const u8).initBuffer(&cflags_buffer); + switch (sokol.resolveSokolBackend(.vulkan, target.result)) { + .d3d11 => try cflags.appendBounded("-DSOKOL_D3D11"), + .metal => try cflags.appendBounded("-DSOKOL_METAL"), + .gl => try cflags.appendBounded("-DSOKOL_GLCORE"), + .gles3 => try cflags.appendBounded("-DSOKOL_GLES3"), + .wgpu => try cflags.appendBounded("-DSOKOL_WGPU"), + .vulkan => try cflags.appendBounded("-DSOKOL_VULKAN"), + else => @panic("unknown sokol backend"), + } + + mod_main.addIncludePath(dep_sokol_c.path("util")); + mod_main.addCSourceFile(.{ .file = b.path("src/engine/fontstash/sokol_fontstash_impl.c"), .flags = cflags.items }); + } + + // TODO: + // const sdl = b.dependency("sdl", .{ + // .optimize = optimize, + // .target = target, + // .linkage = .static, + // .default_target_config = !isWasm + // }); + // mod_main.linkLibrary(sdl.artifact("SDL3")); + // if (isWasm) { + // // TODO: Define buid config for wasm + // } + + var options = b.addOptions(); + options.addOption(bool, "has_imgui", has_imgui); + options.addOption(bool, "has_tracy", has_tracy); + mod_main.addOptions("build_options", options); + + // from here on different handling for native vs wasm builds + if (target.result.cpu.arch.isWasm()) { + try buildWasm(b, .{ + .name = project_name, + .mod_main = mod_main, + .dep_sokol = dep_sokol, + }); + } else { + try buildNative(b, project_name, mod_main, has_console); + } +} + +fn buildNative(b: *std.Build, name: []const u8, mod: *std.Build.Module, has_console: bool) !void { + const exe = b.addExecutable(.{ .name = name, .root_module = mod }); + const target = mod.resolved_target.?; + if (target.result.os.tag == .windows) { + exe.subsystem = if (has_console) .Console else .Windows; + + const png_to_icon_tool = b.addExecutable(.{ + .name = "png-to-icon", + .root_module = b.createModule(.{ + .target = b.graph.host, + .root_source_file = b.path("tools/png-to-icon.zig"), + }), + }); + const dep_stb_image = b.dependency("stb_image", .{}); + png_to_icon_tool.root_module.addImport("stb_image", dep_stb_image.module("stb_image")); + + const png_to_icon_step = b.addRunArtifact(png_to_icon_tool); + png_to_icon_step.addFileArg(b.path("src/assets/icon.png")); + const icon_file = png_to_icon_step.addOutputFileArg("icon.ico"); + + const add_icon_step = AddExecutableIcon.init(exe, icon_file); + exe.step.dependOn(&add_icon_step.step); + } + b.installArtifact(exe); + + { + const run_step = b.step("run", "Run game"); + + const run_cmd = b.addRunArtifact(exe); + run_step.dependOn(&run_cmd.step); + run_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + run_cmd.addArgs(args); + } + } + + { + const exe_tests = b.addTest(.{ + .root_module = exe.root_module, + }); + + const run_exe_tests = b.addRunArtifact(exe_tests); + + const test_step = b.step("test", "Run tests"); + test_step.dependOn(&run_exe_tests.step); + } +} + +const BuildWasmOptions = struct { + name: []const u8, + mod_main: *std.Build.Module, + dep_sokol: *std.Build.Dependency, +}; + +fn patchWasmIncludeDirs(module: *std.Build.Module, path: std.Build.LazyPath, depend_step: *std.Build.Step) void { + if (module.link_libc != null and module.link_libc.?) { + // need to inject the Emscripten system header include path into + // the cimgui C library otherwise the C/C++ code won't find + // C stdlib headers + module.addSystemIncludePath(path); + } + + for (module.import_table.values()) |imported_module| { + patchWasmIncludeDirs(imported_module, path, depend_step); + } + + for (module.link_objects.items) |link_object| { + if (link_object != .other_step) { + continue; + } + const lib = link_object.other_step; + if (&lib.step == depend_step) { + continue; + } + + if (lib.root_module.link_libc != null and lib.root_module.link_libc.?) { + // need to inject the Emscripten system header include path into + // the cimgui C library otherwise the C/C++ code won't find + // C stdlib headers + lib.root_module.addSystemIncludePath(path); + + // all C libraries need to depend on the sokol library, when building for + // WASM this makes sure that the Emscripten SDK has been setup before + // C compilation is attempted (since the sokol C library depends on the + // Emscripten SDK setup step) + lib.step.dependOn(depend_step); + } + patchWasmIncludeDirs(lib.root_module, path, depend_step); + } +} + +fn buildWasm(b: *std.Build, opts: BuildWasmOptions) !void { + opts.mod_main.sanitize_c = .off; + + // build the main file into a library, this is because the WASM 'exe' + // needs to be linked in a separate build step with the Emscripten linker + const main_lib = b.addLibrary(.{ + .name = "index", + .root_module = opts.mod_main, + }); + + const dep_emsdk = opts.dep_sokol.builder.dependency("emsdk", .{}); + + patchWasmIncludeDirs(opts.mod_main, dep_emsdk.path("upstream/emscripten/cache/sysroot/include"), &(opts.dep_sokol.artifact("sokol_clib").step)); + + // create a build step which invokes the Emscripten linker + const link_step = try sokol.emLinkStep(b, .{ + .lib_main = main_lib, + .target = opts.mod_main.resolved_target.?, + .optimize = opts.mod_main.optimize.?, + .emsdk = dep_emsdk, + .use_webgl2 = true, + .use_emmalloc = true, + .use_filesystem = false, + .shell_file_path = b.path("src/engine/shell.html"), + }); + // attach to default target + b.getInstallStep().dependOn(&link_step.step); + // ...and a special run step to start the web build output via 'emrun' + const run = sokol.emRunStep(b, .{ .name = "index", .emsdk = dep_emsdk }); + run.step.dependOn(&link_step.step); + b.step("run", "Run game").dependOn(&run.step); + + // TODO: Create a zip archive of all of the files. Would be useful for easier itch.io upload +} + +const AddExecutableIcon = struct { + obj: *std.Build.Step.Compile, + step: std.Build.Step, + icon_file: std.Build.LazyPath, + resource_file: std.Build.LazyPath, + + fn init(obj: *std.Build.Step.Compile, icon_file: std.Build.LazyPath) *AddExecutableIcon { + const b = obj.step.owner; + const self = b.allocator.create(AddExecutableIcon) catch @panic("OOM"); + + self.obj = obj; + self.step = std.Build.Step.init(.{ .id = .custom, .name = "add executable icon", .owner = b, .makeFn = make }); + + self.icon_file = icon_file; + icon_file.addStepDependencies(&self.step); + + const write_files = b.addWriteFiles(); + self.resource_file = write_files.add("resource-file.rc", ""); + self.step.dependOn(&write_files.step); + + self.obj.addWin32ResourceFile(.{ + .file = self.resource_file, + }); + + return self; + } + + fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) !void { + const b = step.owner; + const self: *AddExecutableIcon = @fieldParentPtr("step", step); + + const resource_file = try std.fs.cwd().createFile(self.resource_file.getPath(b), .{}); + defer resource_file.close(); + + const relative_icon_path = try std.fs.path.relative(b.allocator, self.resource_file.dirname().getPath(b), self.icon_file.getPath(b)); + std.mem.replaceScalar(u8, relative_icon_path, '\\', '/'); + + try resource_file.writeAll("IDI_ICON ICON \""); + try resource_file.writeAll(relative_icon_path); + try resource_file.writeAll("\""); + } +}; diff --git a/build.zig.zon b/build.zig.zon new file mode 100644 index 0000000..242addf --- /dev/null +++ b/build.zig.zon @@ -0,0 +1,44 @@ +.{ + .name = .sokol_template, + .version = "0.0.0", + .fingerprint = 0x60a8e079a691c8d9, // Changing this has security and trust implications. + .minimum_zig_version = "0.15.2", + .dependencies = .{ + .sokol = .{ + .url = "git+https://github.com/floooh/sokol-zig.git#3f893819d1469cf96ab4d18ec1a54311c9c1c9c8", + .hash = "sokol-0.1.0-pb1HK_qcNgDWA4dFM6Lr-aUxnequltCKH87jDcYsV7t5", + }, + .sokol_c = .{ + .url = "git+https://github.com/floooh/sokol.git#c66a1f04e6495d635c5e913335ab2308281e0492", + .hash = "N-V-__8AAC3eYABB1DVLb4dkcEzq_xVeEZZugVfQ6DoNQBDN", + }, + .fontstash_c = .{ + .url = "git+https://github.com/memononen/fontstash.git#b5ddc9741061343740d85d636d782ed3e07cf7be", + .hash = "N-V-__8AAA9xHgAxdLYPmlNTy6qzv9IYqiIePEHQUOPWYQ_6", + }, + .cimgui = .{ + .url = "git+https://github.com/floooh/dcimgui.git#33c99ef426b68030412b5a4b11487a23da9d4f13", + .hash = "cimgui-0.1.0-44ClkQRJlABdFMKRqIG8KDD6jy1eQbgPO335NziPYjmL", + .lazy = true, + }, + .tracy = .{ + .url = "git+https://github.com/sagehane/zig-tracy.git#80933723efe9bf840fe749b0bfc0d610f1db1669", + .hash = "zig_tracy-0.0.5-aOIqsX1tAACKaRRB-sraMLuNiMASXi_y-4FtRuw4cTpx", + }, + .tiled = .{ + .path = "./libs/tiled", + }, + .stb = .{ + .path = "./libs/stb", + }, + // .sdl = .{ + // .url = "git+https://github.com/allyourcodebase/SDL3.git#f85824b0db782b7d01c60aaad8bcb537892394e8", + // .hash = "sdl-0.0.0-i4QD0UuFqADRQysNyJ1OvCOZnq-clcVhq3BfPcBOf9zr", + // }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + "src", + }, +} diff --git a/libs/stb/build.zig b/libs/stb/build.zig new file mode 100644 index 0000000..54a79ed --- /dev/null +++ b/libs/stb/build.zig @@ -0,0 +1,53 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const stb_dependency = b.dependency("stb", .{}); + + { + const mod_stb_image = b.addModule("stb_image", .{ + .target = target, + .optimize = optimize, + .root_source_file = b.path("src/stb_image.zig"), + .link_libc = true, + }); + + mod_stb_image.addIncludePath(stb_dependency.path(".")); + mod_stb_image.addCSourceFile(.{ + .file = b.path("src/stb_image_impl.c"), + .flags = &.{} + }); + } + + { + const mod_stb_image = b.addModule("stb_vorbis", .{ + .target = target, + .optimize = optimize, + .root_source_file = b.path("src/stb_vorbis.zig"), + .link_libc = true, + }); + + mod_stb_image.addIncludePath(stb_dependency.path(".")); + mod_stb_image.addCSourceFile(.{ + .file = b.path("src/stb_vorbis_impl.c"), + .flags = &.{} + }); + } + + { + const mod_stb_rect_pack = b.addModule("stb_rect_pack", .{ + .target = target, + .optimize = optimize, + .root_source_file = b.path("src/stb_rect_pack.zig"), + .link_libc = true, + }); + + mod_stb_rect_pack.addIncludePath(stb_dependency.path(".")); + mod_stb_rect_pack.addCSourceFile(.{ + .file = b.path("src/stb_rect_pack_impl.c"), + .flags = &.{} + }); + } +} diff --git a/libs/stb/build.zig.zon b/libs/stb/build.zig.zon new file mode 100644 index 0000000..867deaa --- /dev/null +++ b/libs/stb/build.zig.zon @@ -0,0 +1,17 @@ +.{ + .name = .stb_image, + .version = "0.0.0", + .fingerprint = 0xe5d3607840482046, // Changing this has security and trust implications. + .minimum_zig_version = "0.15.2", + .dependencies = .{ + .stb = .{ + .url = "git+https://github.com/nothings/stb.git#f1c79c02822848a9bed4315b12c8c8f3761e1296", + .hash = "N-V-__8AABQ7TgCnPlp8MP4YA8znrjd6E-ZjpF1rvrS8J_2I", + }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + "src", + }, +} diff --git a/libs/stb/src/stb_image.zig b/libs/stb/src/stb_image.zig new file mode 100644 index 0000000..1c357a8 --- /dev/null +++ b/libs/stb/src/stb_image.zig @@ -0,0 +1,31 @@ +const std = @import("std"); + +const c = @cImport({ + @cDefine("STBI_NO_STDIO", {}); + @cInclude("stb_image.h"); +}); + +const STBImage = @This(); + +rgba8_pixels: [*c]u8, +width: u32, +height: u32, + +pub fn load(png_data: []const u8) !STBImage { + var width: c_int = undefined; + var height: c_int = undefined; + const pixels = c.stbi_load_from_memory(png_data.ptr, @intCast(png_data.len), &width, &height, null, 4); + if (pixels == null) { + return error.InvalidPng; + } + + return STBImage{ + .rgba8_pixels = pixels, + .width = @intCast(width), + .height = @intCast(height) + }; +} + +pub fn deinit(self: *const STBImage) void { + c.stbi_image_free(self.rgba8_pixels); +} diff --git a/libs/stb/src/stb_image_impl.c b/libs/stb/src/stb_image_impl.c new file mode 100644 index 0000000..eeee84a --- /dev/null +++ b/libs/stb/src/stb_image_impl.c @@ -0,0 +1,3 @@ +#define STB_IMAGE_IMPLEMENTATION +#define STBI_NO_STDIO +#include "stb_image.h" diff --git a/libs/stb/src/stb_rect_pack.zig b/libs/stb/src/stb_rect_pack.zig new file mode 100644 index 0000000..77de6d1 --- /dev/null +++ b/libs/stb/src/stb_rect_pack.zig @@ -0,0 +1,52 @@ + +const c = @cImport({ + @cInclude("stb_rect_pack.h"); +}); + +const STBRectPack = @This(); + +pub const Node = c.stbrp_node; +pub const Rect = c.stbrp_rect; + +pub const Options = struct { + const Heuristic = enum(i32) { + bl_sort_height = c.STBRP_HEURISTIC_Skyline_BL_sortHeight, + bf_sort_height = c.STBRP_HEURISTIC_Skyline_BF_sortHeight, + + pub const default: Heuristic = @enumFromInt(c.STBRP_HEURISTIC_Skyline_default); + }; + + width: u31, + height: u31, + nodes: []Node, + allow_out_of_memory: bool = false, + heuristic: Heuristic = .default, +}; + +ctx: c.stbrp_context, + +pub fn init(options: Options) STBRectPack { + var ctx: c.stbrp_context = undefined; + c.stbrp_init_target( + &ctx, + options.width, + options.height, + options.nodes.ptr, + options.nodes.len + ); + + if (options.allow_out_of_memory) { + c.stbrp_setup_allow_out_of_mem(&ctx, 1); + } + + if (options.heuristic != .default) { + c.stbrp_setup_heuristic(&ctx, options.heuristic); + } + + return STBRectPack{ .ctx = ctx }; +} + +pub fn packRects(self: *STBRectPack, rects: []Rect) bool { + const success = c.stbrp_pack_rects(&self.ctx, rects.ptr, rects.len); + return success != 0; +} diff --git a/libs/stb/src/stb_rect_pack_impl.c b/libs/stb/src/stb_rect_pack_impl.c new file mode 100644 index 0000000..31c4106 --- /dev/null +++ b/libs/stb/src/stb_rect_pack_impl.c @@ -0,0 +1,2 @@ +#define STB_RECT_PACK_IMPLEMENTATION +#include "stb_rect_pack.h" diff --git a/libs/stb/src/stb_vorbis.zig b/libs/stb/src/stb_vorbis.zig new file mode 100644 index 0000000..ea25583 --- /dev/null +++ b/libs/stb/src/stb_vorbis.zig @@ -0,0 +1,170 @@ +const std = @import("std"); +const assert = std.debug.assert; +const log = std.log.scoped(.stb_vorbis); + +const c = @cImport({ + @cDefine("STB_VORBIS_NO_INTEGER_CONVERSION", {}); + @cDefine("STB_VORBIS_NO_STDIO", {}); + @cDefine("STB_VORBIS_HEADER_ONLY", {}); + @cInclude("stb_vorbis.c"); +}); + +const STBVorbis = @This(); + +pub const Error = error { + NeedMoreData, + InvalidApiMixing, + OutOfMemory, + FeatureNotSupported, + TooManyChannels, + FileOpenFailure, + SeekWithoutLength, + UnexpectedEof, + SeekInvalid, + InvalidSetup, + InvalidStream, + MissingCapturePattern, + InvalidStreamStructureVersion, + ContinuedPacketFlagInvalid, + IncorrectStreamSerialNumber, + InvalidFirstPage, + BadPacketType, + CantFindLastPage, + SeekFailed, + OggSkeletonNotSupported, + + Unknown +}; + +fn errorFromInt(err: c_int) ?Error { + return switch (err) { + c.VORBIS__no_error => null, + c.VORBIS_need_more_data => Error.NeedMoreData, + c.VORBIS_invalid_api_mixing => Error.InvalidApiMixing, + c.VORBIS_outofmem => Error.OutOfMemory, + c.VORBIS_feature_not_supported => Error.FeatureNotSupported, + c.VORBIS_too_many_channels => Error.TooManyChannels, + c.VORBIS_file_open_failure => Error.FileOpenFailure, + c.VORBIS_seek_without_length => Error.SeekWithoutLength, + c.VORBIS_unexpected_eof => Error.UnexpectedEof, + c.VORBIS_seek_invalid => Error.SeekInvalid, + c.VORBIS_invalid_setup => Error.InvalidSetup, + c.VORBIS_invalid_stream => Error.InvalidStream, + c.VORBIS_missing_capture_pattern => Error.MissingCapturePattern, + c.VORBIS_invalid_stream_structure_version => Error.InvalidStreamStructureVersion, + c.VORBIS_continued_packet_flag_invalid => Error.ContinuedPacketFlagInvalid, + c.VORBIS_incorrect_stream_serial_number => Error.IncorrectStreamSerialNumber, + c.VORBIS_invalid_first_page => Error.InvalidFirstPage, + c.VORBIS_bad_packet_type => Error.BadPacketType, + c.VORBIS_cant_find_last_page => Error.CantFindLastPage, + c.VORBIS_seek_failed => Error.SeekFailed, + c.VORBIS_ogg_skeleton_not_supported => Error.OggSkeletonNotSupported, + else => Error.Unknown + }; +} + +handle: *c.stb_vorbis, + +pub fn init(data: []const u8, alloc_buffer: []u8) Error!STBVorbis { + const stb_vorbis_alloc: c.stb_vorbis_alloc = .{ + .alloc_buffer = alloc_buffer.ptr, + .alloc_buffer_length_in_bytes = @intCast(alloc_buffer.len) + }; + var error_code: c_int = -1; + const handle = c.stb_vorbis_open_memory( + data.ptr, + @intCast(data.len), + &error_code, + &stb_vorbis_alloc + ); + if (handle == null) { + return errorFromInt(error_code) orelse Error.Unknown; + } + + return STBVorbis{ + .handle = handle.? + }; +} + +pub fn getMinimumAllocBufferSize(self: STBVorbis) u32 { + const info = self.getInfo(); + return info.setup_memory_required + @max(info.setup_temp_memory_required, info.temp_memory_required); +} + +fn getLastError(self: STBVorbis) ?Error { + const error_code = c.stb_vorbis_get_error(self.handle); + return errorFromInt(error_code); +} + +pub fn seek(self: STBVorbis, sample_number: u32) !void { + const success = c.stb_vorbis_seek(self.handle, sample_number); + if (success != 1) { + return self.getLastError() orelse Error.Unknown; + } +} + +pub fn getStreamLengthInSamples(self: STBVorbis) u32 { + return c.stb_vorbis_stream_length_in_samples(self.handle); +} + +pub fn getStreamLengthInSeconds(self: STBVorbis) f32 { + return c.stb_vorbis_stream_length_in_seconds(self.handle); +} + +pub fn getSamples( + self: STBVorbis, + channels: []const [*]f32, + max_samples_per_channel: u32 +) u32 { + const samples_per_channel = c.stb_vorbis_get_samples_float( + self.handle, + @intCast(channels.len), + @constCast(@ptrCast(channels.ptr)), + @intCast(max_samples_per_channel) + ); + return @intCast(samples_per_channel); +} + +const Frame = struct { + channels: []const [*c]const f32, + samples_per_channel: u32 +}; + +pub fn getFrame(self: STBVorbis) Frame { + var output: [*c][*c]f32 = null; + var channels: c_int = undefined; + const samples_per_channel = c.stb_vorbis_get_frame_float( + self.handle, + &channels, + &output + ); + return Frame{ + .channels = output[0..@intCast(channels)], + .samples_per_channel = @intCast(samples_per_channel) + }; +} + +pub const Info = struct { + sample_rate: u32, + channels: u32, + + setup_memory_required: u32, + setup_temp_memory_required: u32, + temp_memory_required: u32, + + max_frame_size: u32 +}; + +pub fn getInfo(self: STBVorbis) Info { + const info = c.stb_vorbis_get_info(self.handle); + return Info{ + .sample_rate = info.sample_rate, + .channels = @intCast(info.channels), + + .setup_memory_required = info.setup_memory_required, + .setup_temp_memory_required = info.setup_temp_memory_required, + .temp_memory_required = info.temp_memory_required, + + .max_frame_size = @intCast(info.max_frame_size), + }; +} diff --git a/libs/stb/src/stb_vorbis_impl.c b/libs/stb/src/stb_vorbis_impl.c new file mode 100644 index 0000000..4a53456 --- /dev/null +++ b/libs/stb/src/stb_vorbis_impl.c @@ -0,0 +1,3 @@ +#define STB_VORBIS_NO_INTEGER_CONVERSION +#define STB_VORBIS_NO_STDIO +#include "stb_vorbis.c" diff --git a/libs/tiled/build.zig b/libs/tiled/build.zig new file mode 100644 index 0000000..e717649 --- /dev/null +++ b/libs/tiled/build.zig @@ -0,0 +1,29 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) !void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const mod = b.addModule("tiled", .{ + .target = target, + .optimize = optimize, + .root_source_file = b.path("src/root.zig") + }); + + const lib = b.addLibrary(.{ + .name = "tiled", + .root_module = mod + }); + b.installArtifact(lib); + + { + const tests = b.addTest(.{ + .root_module = mod + }); + + const run_tests = b.addRunArtifact(tests); + + const test_step = b.step("test", "Run tests"); + test_step.dependOn(&run_tests.step); + } +} diff --git a/libs/tiled/src/buffers.zig b/libs/tiled/src/buffers.zig new file mode 100644 index 0000000..b9ab166 --- /dev/null +++ b/libs/tiled/src/buffers.zig @@ -0,0 +1,18 @@ +const std = @import("std"); + +const Position = @import("./position.zig"); + +const Buffers = @This(); + +allocator: std.mem.Allocator, +points: std.ArrayList(Position) = .empty, + +pub fn init(gpa: std.mem.Allocator) Buffers { + return Buffers{ + .allocator = gpa + }; +} + +pub fn deinit(self: *Buffers) void { + self.points.deinit(self.allocator); +} diff --git a/libs/tiled/src/color.zig b/libs/tiled/src/color.zig new file mode 100644 index 0000000..d8cd764 --- /dev/null +++ b/libs/tiled/src/color.zig @@ -0,0 +1,52 @@ +const std = @import("std"); + +const Color = @This(); + +r: u8, +g: u8, +b: u8, +a: u8, + +pub const black = Color{ + .r = 0, + .g = 0, + .b = 0, + .a = 255, +}; + +pub fn parse(str: []const u8, hash_required: bool) !Color { + var color = Color{ + .r = undefined, + .g = undefined, + .b = undefined, + .a = 255, + }; + + if (str.len < 1) { + return error.InvalidColorFormat; + } + + const has_hash = str[0] == '#'; + if (hash_required and !has_hash) { + return error.InvalidColorFormat; + } + + const hex_str = if (has_hash) str[1..] else str; + + if (hex_str.len == 6) { + color.r = try std.fmt.parseInt(u8, hex_str[0..2], 16); + color.g = try std.fmt.parseInt(u8, hex_str[2..4], 16); + color.b = try std.fmt.parseInt(u8, hex_str[4..6], 16); + + } else if (hex_str.len == 8) { + color.a = try std.fmt.parseInt(u8, hex_str[0..2], 16); + color.r = try std.fmt.parseInt(u8, hex_str[2..4], 16); + color.g = try std.fmt.parseInt(u8, hex_str[4..6], 16); + color.b = try std.fmt.parseInt(u8, hex_str[6..8], 16); + + } else { + return error.InvalidColorFormat; + } + + return color; +} diff --git a/libs/tiled/src/global_tile_id.zig b/libs/tiled/src/global_tile_id.zig new file mode 100644 index 0000000..96d93ad --- /dev/null +++ b/libs/tiled/src/global_tile_id.zig @@ -0,0 +1,15 @@ + +pub const Flag = enum(u32) { + flipped_horizontally = 1 << 31, // bit 32 + flipped_vertically = 1 << 30, // bit 31 + flipped_diagonally = 1 << 29, // bit 30 + rotated_hexagonal_120 = 1 << 28, // bit 29 + _, + + pub const clear: u32 = ~( + @intFromEnum(Flag.flipped_horizontally) | + @intFromEnum(Flag.flipped_vertically) | + @intFromEnum(Flag.flipped_diagonally) | + @intFromEnum(Flag.rotated_hexagonal_120) + ); +}; diff --git a/libs/tiled/src/layer.zig b/libs/tiled/src/layer.zig new file mode 100644 index 0000000..184380a --- /dev/null +++ b/libs/tiled/src/layer.zig @@ -0,0 +1,464 @@ +const std = @import("std"); + +const Property = @import("./property.zig"); +const xml = @import("./xml.zig"); +const Color = @import("./color.zig"); +const Object = @import("./object.zig"); +const Position = @import("./position.zig"); + +const Layer = @This(); + +pub const Bounds = struct { + left: i32, + right: i32, + top: i32, + bottom: i32, + + pub const zero = Bounds{ + .left = 0, + .right = 0, + .top = 0, + .bottom = 0, + }; + + pub fn initFromRect(x: i32, y: i32, width: i32, height: i32) Bounds { + return Bounds{ + .left = x, + .right = x + width, + .top = y, + .bottom = y + height, + }; + } + + pub fn getWidth(self: Bounds) u32 { + return @intCast(self.right - self.left + 1); + } + + pub fn getHeight(self: Bounds) u32 { + return @intCast(self.bottom - self.top + 1); + } + + pub fn combine(lhs: Bounds, rhs: Bounds) Bounds { + return Bounds{ + .left = @min(lhs.left, rhs.left), + .right = @max(lhs.right, rhs.right), + .top = @min(lhs.top, rhs.top), + .bottom = @max(lhs.bottom, rhs.bottom) + }; + } +}; + +pub const TileVariant = struct { + pub const Chunk = struct { + x: i32, + y: i32, + width: u32, + height: u32, + data: []u32, + + pub fn getBounds(self: Chunk) Bounds { + return Bounds.initFromRect(self.x, self.y, @intCast(self.width), @intCast(self.height)); + } + }; + + pub const Data = union(enum) { + fixed: []u32, + chunks: []Chunk + }; + + const Encoding = enum { + csv, + + const map: std.StaticStringMap(Encoding) = .initComptime(.{ + .{ "csv", .csv }, + }); + }; + + width: u32, + height: u32, + data: Data, + + fn initChunkDataFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, + encoding: Encoding + ) !Chunk { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("chunk"); + + const x = try attrs.getNumber(i32, "x") orelse return error.MissingAttribute; + const y = try attrs.getNumber(i32, "y") orelse return error.MissingAttribute; + const width = try attrs.getNumber(u32, "width") orelse return error.MissingAttribute; + const height = try attrs.getNumber(u32, "height") orelse return error.MissingAttribute; + + var temp_tiles: std.ArrayList(u32) = .empty; + + while (try iter.next()) |node| { + if (node == .text) { + const encoded_tiles = try lexer.nextExpectText(); + const tiles = try parseEncoding(encoding, scratch.allocator(), encoded_tiles); + try temp_tiles.appendSlice(scratch.allocator(), tiles.items); + + continue; + } + + try iter.skip(); + } + + try iter.finish("chunk"); + + return Chunk{ + .x = x, + .y = y, + .width = width, + .height = height, + .data = try arena.dupe(u32, temp_tiles.items) + }; + } + + fn initDataFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, + ) !Data { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("data"); + + const encoding = try attrs.getEnum(Encoding, "encoding", Encoding.map) orelse .csv; + // TODO: compression + + var temp_chunks: std.ArrayList(Chunk) = .empty; + var temp_tiles: std.ArrayList(u32) = .empty; + + while (try iter.next()) |node| { + if (node == .text) { + const encoded_tiles = try lexer.nextExpectText(); + const tiles = try parseEncoding(encoding, scratch.allocator(), encoded_tiles); + try temp_tiles.appendSlice(scratch.allocator(), tiles.items); + + } else if (node.isTag("chunk")) { + const chunk = try initChunkDataFromXml(arena, scratch, lexer, encoding); + try temp_chunks.append(scratch.allocator(), chunk); + + continue; + } + + try iter.skip(); + } + + try iter.finish("data"); + + if (temp_chunks.items.len > 0) { + return .{ + .chunks = try arena.dupe(Chunk, temp_chunks.items) + }; + } else { + return .{ + .fixed = try arena.dupe(u32, temp_tiles.items) + }; + } + + } + + fn parseEncoding( + encoding: Encoding, + allocator: std.mem.Allocator, + text: []const u8 + ) !std.ArrayList(u32) { + return switch (encoding) { + .csv => try parseCSVEncoding(allocator, text) + }; + } + + fn parseCSVEncoding( + allocator: std.mem.Allocator, + text: []const u8 + ) !std.ArrayList(u32) { + var result: std.ArrayList(u32) = .empty; + + var split_iter = std.mem.splitScalar(u8, text, ','); + while (split_iter.next()) |raw_tile_id| { + const tile_id_str = std.mem.trim(u8, raw_tile_id, &std.ascii.whitespace); + const tile_id = try std.fmt.parseInt(u32, tile_id_str, 10); + try result.append(allocator, tile_id); + } + + return result; + } + + pub fn getBounds(self: TileVariant) Bounds { + if (self.data == .fixed) { + return Bounds.initFromRect(0, 0, @intCast(self.width), @intCast(self.height)); + + } else if (self.data == .chunks) { + const chunks = self.data.chunks; + + var result: Bounds = .zero; + if (chunks.len > 0) { + result = chunks[0].getBounds(); + for (chunks[1..]) |chunk| { + result = result.combine(chunk.getBounds()); + } + } + + return result; + } else { + unreachable; + } + } + + pub fn get(self: TileVariant, x: i32, y: i32) ?u32 { + if (self.data == .fixed) { + if ((0 <= x and x < self.width) and (0 <= y and y < self.height)) { + const x_u32: u32 = @intCast(x); + const y_u32: u32 = @intCast(y); + return self.data.fixed[y_u32 * self.width + x_u32]; + } + } else if (self.data == .chunks) { + for (self.data.chunks) |chunk| { + const ox = x - chunk.x; + const oy = y - chunk.y; + if ((0 <= ox and ox < chunk.width) and (0 <= oy and oy < chunk.height)) { + const ox_u32: u32 = @intCast(ox); + const oy_u32: u32 = @intCast(oy); + return chunk.data[oy_u32 * chunk.width + ox_u32]; + } + } + } else { + unreachable; + } + return null; + } +}; + +pub const ImageVariant = struct { + pub const Image = struct { + // TODO: format + source: []const u8, + transparent_color: ?Color, + width: ?u32, + height: ?u32, + + fn initFromXml(arena: std.mem.Allocator, lexer: *xml.Lexer) !Image { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("image"); + + // TODO: format + const source = try attrs.getDupe(arena, "source") orelse return error.MissingSource; + const width = try attrs.getNumber(u32, "width") orelse null; + const height = try attrs.getNumber(u32, "height") orelse null; + const transparent_color = try attrs.getColor("trans", false); + + try iter.finish("image"); + + return Image{ + .source = source, + .transparent_color = transparent_color, + .width = width, + .height = height + }; + } + }; + + repeat_x: bool, + repeat_y: bool, + image: ?Image +}; + +pub const ObjectVariant = struct { + pub const DrawOrder = enum { + top_down, + index, + + const map: std.StaticStringMap(DrawOrder) = .initComptime(.{ + .{ "topdown", .top_down }, + .{ "index", .index }, + }); + }; + + color: ?Color, + draw_order: DrawOrder, + items: []Object +}; + +pub const GroupVariant = struct { + layers: []Layer +}; + +pub const Type = enum { + tile, + object, + image, + group, + + const name_map: std.StaticStringMap(Type) = .initComptime(.{ + .{ "layer", .tile }, + .{ "objectgroup", .object }, + .{ "imagelayer", .image }, + .{ "group", .group } + }); + + fn toXmlName(self: Type) []const u8 { + return switch (self) { + .tile => "layer", + .object => "objectgroup", + .image => "imagelayer", + .group => "group", + }; + } +}; + +pub const Variant = union(Type) { + tile: TileVariant, + object: ObjectVariant, + image: ImageVariant, + group: GroupVariant +}; + +id: u32, +name: []const u8, +class: []const u8, +opacity: f32, +visible: bool, +tint_color: ?Color, +offset_x: f32, +offset_y: f32, +parallax_x: f32, +parallax_y: f32, +properties: Property.List, +variant: Variant, + +pub fn initFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, +) !Layer { + const value = try lexer.peek() orelse return error.MissingStartTag; + if (value != .start_tag) return error.MissingStartTag; + + var layer_type = Type.name_map.get(value.start_tag.name) orelse return error.UnknownLayerType; + + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin(layer_type.toXmlName()); + + const id = try attrs.getNumber(u32, "id") orelse return error.MissingId; + const name = try attrs.getDupe(arena, "name") orelse ""; + const class = try attrs.getDupe(arena, "class") orelse ""; + const opacity = try attrs.getNumber(f32, "opacity") orelse 1; + const visible = try attrs.getBool("visible", "1", "0") orelse true; + const offset_x = try attrs.getNumber(f32, "offsetx") orelse 0; + const offset_y = try attrs.getNumber(f32, "offsety") orelse 0; + const parallax_x = try attrs.getNumber(f32, "parallaxx") orelse 1; + const parallax_y = try attrs.getNumber(f32, "parallaxy") orelse 1; + const tint_color = try attrs.getColor("tintcolor", true); + + var variant: Variant = undefined; + switch (layer_type) { + .tile => { + const width = try attrs.getNumber(u32, "width") orelse return error.MissingWidth; + const height = try attrs.getNumber(u32, "height") orelse return error.MissingHeight; + variant = .{ + .tile = TileVariant{ + .width = width, + .height = height, + .data = .{ .fixed = &[0]u32{} } + } + }; + }, + .image => { + const repeat_x = try attrs.getBool("repeatx", "1", "0") orelse false; + const repeat_y = try attrs.getBool("repeaty", "1", "0") orelse false; + variant = .{ + .image = ImageVariant{ + .repeat_x = repeat_x, + .repeat_y = repeat_y, + .image = null + } + }; + }, + .object => { + const draw_order = try attrs.getEnum(ObjectVariant.DrawOrder, "draworder", ObjectVariant.DrawOrder.map) orelse .top_down; + const color = try attrs.getColor("color", true); + + variant = .{ + .object = ObjectVariant{ + .color = color, + .draw_order = draw_order, + .items = &.{} + } + }; + }, + .group => { + variant = .{ + .group = .{ + .layers = &.{} + } + }; + }, + } + + var properties: Property.List = .empty; + var objects: std.ArrayList(Object) = .empty; + var layers: std.ArrayList(Layer) = .empty; + + while (try iter.next()) |node| { + if (node.isTag("properties")) { + properties = try Property.List.initFromXml(arena, scratch, lexer); + continue; + } + + if (variant == .tile and node.isTag("data")) { + variant.tile.data = try TileVariant.initDataFromXml(arena, scratch, lexer); + continue; + } + + if (variant == .image and node.isTag("image")) { + variant.image.image = try ImageVariant.Image.initFromXml(arena, lexer); + continue; + } + + if (variant == .object and node.isTag("object")) { + const object = try Object.initFromXml(arena, scratch, lexer); + try objects.append(scratch.allocator(), object); + continue; + } + + if (variant == .group and isLayerNode(node)) { + const layer = try initFromXml(arena, scratch, lexer); + try layers.append(scratch.allocator(), layer); + continue; + } + + try iter.skip(); + } + + try iter.finish(layer_type.toXmlName()); + + if (variant == .object) { + variant.object.items = try arena.dupe(Object, objects.items); + } + + if (variant == .group) { + variant.group.layers = try arena.dupe(Layer, layers.items); + } + + return Layer{ + .id = id, + .name = name, + .class = class, + .opacity = opacity, + .visible = visible, + .tint_color = tint_color, + .offset_x = offset_x, + .offset_y = offset_y, + .parallax_x = parallax_x, + .parallax_y = parallax_y, + .properties = properties, + .variant = variant, + }; +} + +pub fn isLayerNode(node: xml.TagParser.Node) bool { + return node.isTag("layer") or node.isTag("objectgroup") or node.isTag("imagelayer") or node.isTag("group"); +} diff --git a/libs/tiled/src/object.zig b/libs/tiled/src/object.zig new file mode 100644 index 0000000..e52ba05 --- /dev/null +++ b/libs/tiled/src/object.zig @@ -0,0 +1,421 @@ +const std = @import("std"); + +const xml = @import("./xml.zig"); +const Position = @import("./position.zig"); +const Color = @import("./color.zig"); + +const Object = @This(); + +pub const Shape = union (Type) { + pub const Type = enum { + rectangle, + point, + ellipse, + polygon, + tile, + // TODO: template + text + }; + + pub const Rectangle = struct { + x: f32, + y: f32, + width: f32, + height: f32, + }; + + pub const Tile = struct { + x: f32, + y: f32, + width: f32, + height: f32, + gid: u32 + }; + + pub const Ellipse = struct { + x: f32, + y: f32, + width: f32, + height: f32, + }; + + pub const Polygon = struct { + x: f32, + y: f32, + points: []const Position + }; + + pub const Text = struct { + pub const Font = struct { + family: []const u8, + pixel_size: f32, + bold: bool, + italic: bool, + underline: bool, + strikeout: bool, + kerning: bool + }; + + pub const HorizontalAlign = enum { + left, + center, + right, + justify, + + const map: std.StaticStringMap(HorizontalAlign) = .initComptime(.{ + .{ "left", .left }, + .{ "center", .center }, + .{ "right", .right }, + .{ "justify", .justify }, + }); + }; + + pub const VerticalAlign = enum { + top, + center, + bottom, + + const map: std.StaticStringMap(VerticalAlign) = .initComptime(.{ + .{ "top", .top }, + .{ "center", .center }, + .{ "bottom", .bottom }, + }); + }; + + x: f32, + y: f32, + width: f32, + height: f32, + word_wrap: bool, + color: Color, + font: Font, + horizontal_align: HorizontalAlign, + vertical_align: VerticalAlign, + content: []const u8 + }; + + pub const Point = struct { + x: f32, + y: f32, + }; + + rectangle: Rectangle, + point: Point, + ellipse: Ellipse, + polygon: Polygon, + tile: Tile, + text: Text +}; + +id: u32, +name: []const u8, +class: []const u8, +rotation: f32, // TODO: maybe this field should be moved to Shape struct +visible: bool, +shape: Shape, + +pub fn initFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, +) !Object { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("object"); + + const id = try attrs.getNumber(u32, "id") orelse return error.MissingId; + const name = try attrs.getDupe(arena, "name") orelse ""; + const class = try attrs.getDupe(arena, "type") orelse ""; + const x = try attrs.getNumber(f32, "x") orelse 0; + const y = try attrs.getNumber(f32, "y") orelse 0; + const width = try attrs.getNumber(f32, "width") orelse 0; + const height = try attrs.getNumber(f32, "height") orelse 0; + const rotation = try attrs.getNumber(f32, "rotation") orelse 0; + const visible = try attrs.getBool("visible", "1", "0") orelse true; + + var shape: ?Shape = null; + + while (try iter.next()) |node| { + if (shape == null) { + if (node.isTag("point")) { + shape = .{ + .point = Shape.Point{ + .x = x, + .y = y, + } + }; + + } else if (node.isTag("ellipse")) { + shape = .{ + .ellipse = Shape.Ellipse{ + .x = x, + .y = y, + .width = width, + .height = height + } + }; + + } else if (node.isTag("text")) { + const HorizontalShape = Shape.Text.HorizontalAlign; + const VerticalAlign = Shape.Text.VerticalAlign; + + const text_attrs = node.tag.attributes; + const word_wrap = try text_attrs.getBool("wrap", "1", "0") orelse false; + const color = try text_attrs.getColor("color", true) orelse Color.black; + const horizontal_align = try text_attrs.getEnum(HorizontalShape, "halign", HorizontalShape.map) orelse .left; + const vertical_align = try text_attrs.getEnum(VerticalAlign, "valign", VerticalAlign.map) orelse .top; + const bold = try text_attrs.getBool("bold", "1", "0") orelse false; + const italic = try text_attrs.getBool("italic", "1", "0") orelse false; + const strikeout = try text_attrs.getBool("strikeout", "1", "0") orelse false; + const underline = try text_attrs.getBool("underline", "1", "0") orelse false; + const kerning = try text_attrs.getBool("kerning", "1", "0") orelse true; + const pixel_size = try text_attrs.getNumber(f32, "pixelsize") orelse 16; + const font_family = try text_attrs.getDupe(arena, "fontfamily") orelse "sans-serif"; + + _ = try lexer.nextExpectStartTag("text"); + var content: []const u8 = ""; + const content_value = try lexer.peek(); + if (content_value != null and content_value.? == .text) { + content = try arena.dupe(u8, content_value.?.text); + } + try lexer.skipUntilMatchingEndTag("text"); + + shape = .{ + .text = Shape.Text{ + .x = x, + .y = y, + .width = width, + .height = height, + .word_wrap = word_wrap, + .color = color, + .horizontal_align = horizontal_align, + .vertical_align = vertical_align, + .content = try arena.dupe(u8, content), + .font = .{ + .bold = bold, + .italic = italic, + .strikeout = strikeout, + .underline = underline, + .pixel_size = pixel_size, + .kerning = kerning, + .family = font_family, + } + } + }; + continue; + + } else if (node.isTag("polygon")) { + const points_str = node.tag.attributes.get("points") orelse ""; + + var points: std.ArrayList(Position) = .empty; + var point_iter = std.mem.splitScalar(u8, points_str, ' '); + while (point_iter.next()) |point_str| { + const point = try Position.parseCommaDelimited(point_str); + try points.append(scratch.allocator(), point); + } + + shape = .{ + .polygon = Shape.Polygon{ + .x = x, + .y = y, + .points = try arena.dupe(Position, points.items) + } + }; + } + } + + try iter.skip(); + } + + if (shape == null) { + if (try attrs.getNumber(u32, "gid")) |gid| { + shape = .{ + .tile = Shape.Tile{ + .x = x, + .y = y, + .width = width, + .height = height, + .gid = gid + } + }; + } else { + shape = .{ + .rectangle = Shape.Rectangle{ + .x = x, + .y = y, + .width = width, + .height = height + } + }; + } + } + + try iter.finish("object"); + + return Object{ + .id = id, + .name = name, + .class = class, + .rotation = rotation, + .visible = visible, + .shape = shape orelse return error.UnknownShapeType + }; +} + +fn expectParsedEquals(expected: Object, body: []const u8) !void { + const allocator = std.testing.allocator; + var ctx: xml.Lexer.TestingContext = undefined; + ctx.init(allocator, body); + defer ctx.deinit(); + + var scratch = std.heap.ArenaAllocator.init(allocator); + defer scratch.deinit(); + + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); + + const parsed = try initFromXml(arena.allocator(), &scratch, &ctx.lexer); + try std.testing.expectEqualDeep(expected, parsed); +} + +test Object { + try expectParsedEquals( + Object{ + .id = 10, + .name = "rectangle", + .class = "object class", + .rotation = 0, + .visible = true, + .shape = .{ + .rectangle = .{ + .x = 12.34, + .y = 56.78, + .width = 31.5, + .height = 20.25, + } + } + }, + \\ + ); + + try expectParsedEquals( + Object{ + .id = 3, + .name = "point", + .class = "foo", + .rotation = 0, + .visible = true, + .shape = .{ + .point = .{ + .x = 77.125, + .y = 99.875 + } + } + }, + \\ + \\ + \\ + ); + + try expectParsedEquals( + Object{ + .id = 4, + .name = "ellipse", + .class = "", + .rotation = 0, + .visible = true, + .shape = .{ + .ellipse = .{ + .x = 64.25, + .y = 108.25, + .width = 22.375, + .height = 15.375 + } + } + }, + \\ + \\ + \\ + ); + + try expectParsedEquals( + Object{ + .id = 5, + .name = "", + .class = "", + .rotation = 0, + .visible = true, + .shape = .{ + .polygon = .{ + .x = 40.125, + .y = 96.25, + .points = &[_]Position{ + .{ .x = 0, .y = 0 }, + .{ .x = 13.25, .y = -4.25 }, + .{ .x = 10.125, .y = 18.625 }, + .{ .x = 2.25, .y = 17.375 }, + .{ .x = -0.125, .y = 25.75 }, + .{ .x = -3.875, .y = 20.75 }, + } + } + } + }, + \\ + \\ + \\ + ); + + try expectParsedEquals( + Object{ + .id = 2, + .name = "tile", + .class = "", + .rotation = 0, + .visible = true, + .shape = .{ + .tile = .{ + .x = 60.125, + .y = 103.5, + .width = 8, + .height = 8, + .gid = 35 + } + } + }, + \\ + ); + + try expectParsedEquals( + Object{ + .id = 6, + .name = "text", + .class = "", + .rotation = 0, + .visible = true, + .shape = .{ + .text = .{ + .x = 64.3906, + .y = 92.8594, + .width = 87.7188, + .height = 21.7813, + .content = "Hello World", + .word_wrap = true, + .color = .black, + .horizontal_align = .center, + .vertical_align = .top, + .font = .{ + .family = "sans-serif", + .pixel_size = 16, + .bold = false, + .italic = false, + .underline = false, + .strikeout = false, + .kerning = true + }, + } + } + }, + \\ + \\ Hello World + \\ + ); +} diff --git a/libs/tiled/src/position.zig b/libs/tiled/src/position.zig new file mode 100644 index 0000000..79179d4 --- /dev/null +++ b/libs/tiled/src/position.zig @@ -0,0 +1,20 @@ +const std = @import("std"); + +const Position = @This(); + +x: f32, +y: f32, + +pub fn parseCommaDelimited(str: []const u8) !Position { + const comma_index = std.mem.indexOfScalar(u8, str, ',') orelse return error.MissingComma; + const x_str = str[0..comma_index]; + const y_str = str[(comma_index+1)..]; + + const x = try std.fmt.parseFloat(f32, x_str); + const y = try std.fmt.parseFloat(f32, y_str); + + return Position{ + .x = x, + .y = y + }; +} diff --git a/libs/tiled/src/property.zig b/libs/tiled/src/property.zig new file mode 100644 index 0000000..19af15b --- /dev/null +++ b/libs/tiled/src/property.zig @@ -0,0 +1,162 @@ +const std = @import("std"); +const xml = @import("./xml.zig"); + +const Property = @This(); + +pub const Type = enum { + string, + int, + bool, + + const map: std.StaticStringMap(Type) = .initComptime(.{ + .{ "string", .string }, + .{ "int", .int }, + .{ "bool", .bool }, + }); +}; + +pub const Value = union(Type) { + string: []const u8, + int: i32, + bool: bool +}; + +name: []const u8, +value: Value, + +pub const List = struct { + items: []Property, + + pub const empty = List{ + .items = &[0]Property{} + }; + + pub fn initFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer + ) !Property.List { + var iter = xml.TagParser.init(lexer); + _ = try iter.begin("properties"); + + var temp_properties: std.ArrayList(Property) = .empty; + + while (try iter.next()) |node| { + if (node.isTag("property")) { + const property = try Property.initFromXml(arena, lexer); + try temp_properties.append(scratch.allocator(), property); + continue; + } + + try iter.skip(); + } + try iter.finish("properties"); + + const properties = try arena.dupe(Property, temp_properties.items); + + return List{ + .items = properties + }; + } + + pub fn get(self: List, name: []const u8) ?Value { + for (self.items) |item| { + if (std.mem.eql(u8, item.name, name)) { + return item.value; + } + } + return null; + } + + pub fn getString(self: List, name: []const u8) ?[]const u8 { + if (self.get(name)) |value| { + return value.string; + } + return null; + } + + pub fn getBool(self: List, name: []const u8) ?bool { + if (self.get(name)) |value| { + if (value == .bool) { + return value.bool; + } + } + return null; + } +}; + +pub fn init(name: []const u8, value: Value) Property { + return Property{ + .name = name, + .value = value + }; +} + +pub fn initFromXml(arena: std.mem.Allocator, lexer: *xml.Lexer) !Property { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("property"); + + const name = try attrs.getDupe(arena, "name") orelse return error.MissingName; + const prop_type_str = attrs.get("type") orelse "string"; + const value_str = attrs.get("value") orelse ""; + + const prop_type = Type.map.get(prop_type_str) orelse return error.UnknownPropertyType; + const value = switch(prop_type) { + .string => Value{ + .string = try arena.dupe(u8, value_str) + }, + .int => Value{ + .int = try std.fmt.parseInt(i32, value_str, 10) + }, + .bool => Value{ + .bool = std.mem.eql(u8, value_str, "true") + } + }; + + try iter.finish("property"); + + return Property{ + .name = name, + .value = value + }; +} + +fn expectParsedEquals(expected: Property, body: []const u8) !void { + const allocator = std.testing.allocator; + var ctx: xml.Lexer.TestingContext = undefined; + ctx.init(allocator, body); + defer ctx.deinit(); + + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); + + const parsed = try initFromXml(arena.allocator(), &ctx.lexer); + try std.testing.expectEqualDeep(expected, parsed); +} + +test Property { + try expectParsedEquals( + Property.init("solid", .{ .string = "hello" }), + \\ + ); + + try expectParsedEquals( + Property.init("solid", .{ .string = "hello" }), + \\ + ); + + try expectParsedEquals( + Property.init("integer", .{ .int = 123 }), + \\ + ); + + try expectParsedEquals( + Property.init("boolean", .{ .bool = true }), + \\ + ); + + try expectParsedEquals( + Property.init("boolean", .{ .bool = false }), + \\ + ); +} diff --git a/libs/tiled/src/root.zig b/libs/tiled/src/root.zig new file mode 100644 index 0000000..50a97ee --- /dev/null +++ b/libs/tiled/src/root.zig @@ -0,0 +1,16 @@ +const std = @import("std"); + +// Warning: +// This library is not complete, it does not cover all features that the specification provides. +// But there are enough features implemented so that I could use this for my games. + +// Map format specification: +// https://doc.mapeditor.org/en/stable/reference/tmx-map-format/# + +pub const xml = @import("./xml.zig"); +pub const Tileset = @import("./tileset.zig"); +pub const Tilemap = @import("./tilemap.zig"); + +test { + _ = std.testing.refAllDeclsRecursive(@This()); +} diff --git a/libs/tiled/src/tilemap.zig b/libs/tiled/src/tilemap.zig new file mode 100644 index 0000000..3bf4e47 --- /dev/null +++ b/libs/tiled/src/tilemap.zig @@ -0,0 +1,266 @@ +const std = @import("std"); +const xml = @import("./xml.zig"); +const Io = std.Io; +const assert = std.debug.assert; + +const Property = @import("./property.zig"); +const Layer = @import("./layer.zig"); +const Object = @import("./object.zig"); +const Position = @import("./position.zig"); +const Tileset = @import("./tileset.zig"); +const GlobalTileId = @import("./global_tile_id.zig"); + +const Tilemap = @This(); + +pub const Orientation = enum { + orthogonal, + staggered, + hexagonal, + isometric, + + const map: std.StaticStringMap(Orientation) = .initComptime(.{ + .{ "orthogonal", .orthogonal }, + .{ "staggered", .staggered }, + .{ "hexagonal", .hexagonal }, + .{ "isometric", .isometric } + }); +}; + +pub const RenderOrder = enum { + right_down, + right_up, + left_down, + left_up, + + const map: std.StaticStringMap(RenderOrder) = .initComptime(.{ + .{ "right-down", .right_down }, + .{ "right-up", .right_up }, + .{ "left-down", .left_down }, + .{ "left-up", .left_up }, + }); +}; + +pub const StaggerAxis = enum { + x, + y, + + const map: std.StaticStringMap(StaggerAxis) = .initComptime(.{ + .{ "x", .x }, + .{ "y", .y } + }); +}; + +pub const TilesetReference = struct { + source: []const u8, + first_gid: u32, + + pub fn initFromXml(arena: std.mem.Allocator, lexer: *xml.Lexer) !TilesetReference { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("tileset"); + + const source = try attrs.getDupe(arena, "source") orelse return error.MissingFirstGid; + const first_gid = try attrs.getNumber(u32, "firstgid") orelse return error.MissingFirstGid; + + try iter.finish("tileset"); + + return TilesetReference{ + .source = source, + .first_gid = first_gid + }; + } +}; + +pub const Tile = struct { + tileset: *const Tileset, + id: u32, + + pub fn getProperties(self: Tile) Property.List { + return self.tileset.getTileProperties(self.id) orelse .empty; + } +}; + +arena: std.heap.ArenaAllocator, + +version: []const u8, +tiled_version: ?[]const u8, +orientation: Orientation, +render_order: RenderOrder, +width: u32, +height: u32, +tile_width: u32, +tile_height: u32, +infinite: bool, + +stagger_axis: ?StaggerAxis, +next_layer_id: u32, +next_object_id: u32, + +tilesets: []TilesetReference, +layers: []Layer, + +pub fn initFromBuffer( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + xml_buffers: *xml.Lexer.Buffers, + buffer: []const u8 +) !Tilemap { + var reader = Io.Reader.fixed(buffer); + return initFromReader(gpa, scratch, xml_buffers, &reader); +} + +pub fn initFromReader( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + xml_buffers: *xml.Lexer.Buffers, + reader: *Io.Reader, +) !Tilemap { + var lexer = xml.Lexer.init(reader, xml_buffers); + return initFromXml(gpa, scratch, &lexer); +} + +// Map specification: +// https://doc.mapeditor.org/en/stable/reference/tmx-map-format/#map +pub fn initFromXml( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, +) !Tilemap { + var arena_allocator = std.heap.ArenaAllocator.init(gpa); + errdefer arena_allocator.deinit(); + + const arena = arena_allocator.allocator(); + + var iter = xml.TagParser.init(lexer); + const map_attrs = try iter.begin("map"); + + const version = try map_attrs.getDupe(arena, "version") orelse return error.MissingVersion; + const tiled_version = try map_attrs.getDupe(arena, "tiledversion"); + const orientation = try map_attrs.getEnum(Orientation, "orientation", Orientation.map) orelse return error.MissingOrientation; + const render_order = try map_attrs.getEnum(RenderOrder, "renderorder", RenderOrder.map) orelse return error.MissingRenderOrder; + // TODO: compressionlevel + const width = try map_attrs.getNumber(u32, "width") orelse return error.MissingWidth; + const height = try map_attrs.getNumber(u32, "height") orelse return error.MissingHeight; + const tile_width = try map_attrs.getNumber(u32, "tilewidth") orelse return error.MissingTileWidth; + const tile_height = try map_attrs.getNumber(u32, "tileheight") orelse return error.MissingTileHeight; + // TODO: hexidelength + const infinite_int = try map_attrs.getNumber(u32, "infinite") orelse 0; + const infinite = infinite_int != 0; + const next_layer_id = try map_attrs.getNumber(u32, "nextlayerid") orelse return error.MissingLayerId; + const next_object_id = try map_attrs.getNumber(u32, "nextobjectid") orelse return error.MissingObjectId; + // TODO: parallaxoriginx + // TODO: parallaxoriginy + // TODO: backgroundcolor + + var stagger_axis: ?StaggerAxis = null; + if (orientation == .hexagonal or orientation == .staggered) { + stagger_axis = try map_attrs.getEnum(StaggerAxis, "staggeraxis", StaggerAxis.map) orelse return error.MissingRenderOrder; + // TODO: staggerindex + } + + var tileset_list: std.ArrayList(TilesetReference) = .empty; + var layer_list: std.ArrayList(Layer) = .empty; + + while (try iter.next()) |node| { + if (node.isTag("tileset")) { + try tileset_list.append(scratch.allocator(), try TilesetReference.initFromXml(arena, lexer)); + continue; + } else if (Layer.isLayerNode(node)) { + const layer = try Layer.initFromXml( + arena, + scratch, + lexer, + ); + try layer_list.append(scratch.allocator(), layer); + continue; + } + + try iter.skip(); + } + try iter.finish("map"); + + const tilesets = try arena.dupe(TilesetReference, tileset_list.items); + const layers = try arena.dupe(Layer, layer_list.items); + + return Tilemap{ + .arena = arena_allocator, + .version = version, + .tiled_version = tiled_version, + .orientation = orientation, + .render_order = render_order, + .width = width, + .height = height, + .tile_width = tile_width, + .tile_height = tile_height, + .infinite = infinite, + .stagger_axis = stagger_axis, + .next_object_id = next_object_id, + .next_layer_id = next_layer_id, + .tilesets = tilesets, + .layers = layers, + }; +} + +fn getTilesetByGid(self: *const Tilemap, gid: u32) ?TilesetReference { + var result: ?TilesetReference = null; + for (self.tilesets) |tileset| { + if (gid < tileset.first_gid) { + continue; + } + if (result != null and result.?.first_gid < tileset.first_gid) { + continue; + } + result = tileset; + } + + return result; +} + +pub fn getTile(self: *const Tilemap, tilesets: Tileset.List, gid: u32) ?Tile { + const tileset_ref = self.getTilesetByGid(gid & GlobalTileId.Flag.clear) orelse return null; + const tileset = tilesets.get(tileset_ref.source) orelse return null; + const id = gid - tileset_ref.first_gid; + + return Tile{ + .tileset = tileset, + .id = id + }; +} + +pub fn getTileByPosition(self: *const Tilemap, layer: *const Layer, tilesets: Tileset.List, x: usize, y: usize) ?Tile { + assert(layer.variant == .tile); + const tile_variant = layer.variant.tile; + + const gid = tile_variant.get(x, y) orelse return null; + const tileset_ref = self.getTilesetByGid(gid & GlobalTileId.Flag.clear) orelse return null; + const tileset = tilesets.get(tileset_ref.source) orelse return null; + const id = gid - tileset_ref.first_gid; + + return Tile{ + .tileset = tileset, + .id = id + }; +} + +pub fn getTileBounds(self: *const Tilemap) Layer.Bounds { + var result: ?Layer.Bounds = null; + + for (self.layers) |layer| { + if (layer.variant != .tile) { + continue; + } + + const layer_bounds = layer.variant.tile.getBounds(); + if (result == null) { + result = layer_bounds; + } else { + result = layer_bounds.combine(result.?); + } + } + + + return result orelse .zero; +} + +pub fn deinit(self: *const Tilemap) void { + self.arena.deinit(); +} diff --git a/libs/tiled/src/tileset.zig b/libs/tiled/src/tileset.zig new file mode 100644 index 0000000..04b9305 --- /dev/null +++ b/libs/tiled/src/tileset.zig @@ -0,0 +1,226 @@ +const std = @import("std"); +const Io = std.Io; +const Allocator = std.mem.Allocator; + +const xml = @import("./xml.zig"); +const Property = @import("./property.zig"); +const Position = @import("./position.zig"); + +const Tileset = @This(); + +pub const Image = struct { + source: []const u8, + width: u32, + height: u32, + + pub fn intFromXml(arena: std.mem.Allocator, lexer: *xml.Lexer) !Image { + var iter = xml.TagParser.init(lexer); + const attrs = try iter.begin("image"); + + const source = try attrs.getDupe(arena, "width") orelse return error.MissingSource; + const width = try attrs.getNumber(u32, "width") orelse return error.MissingWidth; + const height = try attrs.getNumber(u32, "height") orelse return error.MissingHeight; + + try iter.finish("image"); + + return Image{ + .source = source, + .width = width, + .height = height + }; + } +}; + +pub const Tile = struct { + id: u32, + properties: Property.List, + + pub fn initFromXml( + arena: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer, + ) !Tile { + var iter = xml.TagParser.init(lexer); + const tile_attrs = try iter.begin("tile"); + + const id = try tile_attrs.getNumber(u32, "id") orelse return error.MissingId; + + var properties: Property.List = .empty; + + while (try iter.next()) |node| { + if (node.isTag("properties")) { + properties = try Property.List.initFromXml(arena, scratch, lexer); + continue; + } + + try iter.skip(); + } + + try iter.finish("tile"); + + return Tile{ + .id = id, + .properties = properties + }; + } +}; + +pub const List = struct { + const Entry = struct { + name: []const u8, + tileset: Tileset + }; + + list: std.ArrayList(Entry), + + pub const empty = List{ + .list = .empty + }; + + pub fn add(self: *List, gpa: Allocator, name: []const u8, tileset: Tileset) !void { + if (self.get(name) != null) { + return error.DuplicateName; + } + + const name_dupe = try gpa.dupe(u8, name); + errdefer gpa.free(name_dupe); + + try self.list.append(gpa, .{ + .name = name_dupe, + .tileset = tileset + }); + } + + pub fn get(self: *const List, name: []const u8) ?*const Tileset { + for (self.list.items) |*entry| { + if (std.mem.eql(u8, entry.name, name)) { + return &entry.tileset; + } + } + return null; + } + + pub fn deinit(self: *List, gpa: Allocator) void { + for (self.list.items) |entry| { + gpa.free(entry.name); + entry.tileset.deinit(); + } + self.list.deinit(gpa); + } +}; + +arena: std.heap.ArenaAllocator, + +version: []const u8, +tiled_version: []const u8, +name: []const u8, +tile_width: u32, +tile_height: u32, +tile_count: u32, +columns: u32, + +image: Image, + +tiles: []Tile, + +pub fn initFromBuffer( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + xml_buffers: *xml.Lexer.Buffers, + buffer: []const u8 +) !Tileset { + var reader = Io.Reader.fixed(buffer); + return initFromReader(gpa, scratch, xml_buffers, &reader); +} + +pub fn initFromReader( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + xml_buffers: *xml.Lexer.Buffers, + reader: *Io.Reader, +) !Tileset { + var lexer = xml.Lexer.init(reader, xml_buffers); + return initFromXml(gpa, scratch, &lexer); +} + +pub fn initFromXml( + gpa: std.mem.Allocator, + scratch: *std.heap.ArenaAllocator, + lexer: *xml.Lexer +) !Tileset { + var arena_state = std.heap.ArenaAllocator.init(gpa); + const arena = arena_state.allocator(); + + var iter = xml.TagParser.init(lexer); + const tileset_attrs = try iter.begin("tileset"); + + const version = try tileset_attrs.getDupe(arena, "version") orelse return error.MissingTilesetTag; + const tiled_version = try tileset_attrs.getDupe(arena, "tiledversion") orelse return error.MissingTilesetTag; + const name = try tileset_attrs.getDupe(arena, "name") orelse return error.MissingTilesetTag; + const tile_width = try tileset_attrs.getNumber(u32, "tilewidth") orelse return error.MissingTilesetTag; + const tile_height = try tileset_attrs.getNumber(u32, "tileheight") orelse return error.MissingTilesetTag; + const tile_count = try tileset_attrs.getNumber(u32, "tilecount") orelse return error.MissingTilesetTag; + const columns = try tileset_attrs.getNumber(u32, "columns") orelse return error.MissingTilesetTag; + + var image: ?Image = null; + var tiles_list: std.ArrayList(Tile) = .empty; + + while (try iter.next()) |node| { + if (node.isTag("image")) { + image = try Image.intFromXml(arena, lexer); + continue; + } else if (node.isTag("tile")) { + const tile = try Tile.initFromXml(arena, scratch, lexer); + try tiles_list.append(scratch.allocator(), tile); + continue; + } + + try iter.skip(); + } + try iter.finish("tileset"); + + const tiles = try arena.dupe(Tile, tiles_list.items); + + return Tileset{ + .arena = arena_state, + .version = version, + .tiled_version = tiled_version, + .name = name, + .tile_width = tile_width, + .tile_height = tile_height, + .tile_count = tile_count, + .columns = columns, + .image = image orelse return error.MissingImageTag, + .tiles = tiles + }; +} + +pub fn getTileProperties(self: *const Tileset, id: u32) ?Property.List { + for (self.tiles) |tile| { + if (tile.id == id) { + return tile.properties; + } + } + return null; +} + +pub fn getTilePositionInImage(self: *const Tileset, id: u32) ?Position { + if (id >= self.tile_count) { + return null; + } + + const tileset_width = @divExact(self.image.width, self.tile_width); + + const tile_x = @mod(id, tileset_width); + const tile_y = @divFloor(id, tileset_width); + + return Position{ + .x = @floatFromInt(tile_x * self.tile_width), + .y = @floatFromInt(tile_y * self.tile_height), + }; + +} + +pub fn deinit(self: *const Tileset) void { + self.arena.deinit(); +} diff --git a/libs/tiled/src/xml.zig b/libs/tiled/src/xml.zig new file mode 100644 index 0000000..661c065 --- /dev/null +++ b/libs/tiled/src/xml.zig @@ -0,0 +1,687 @@ +const std = @import("std"); +const Io = std.Io; +const assert = std.debug.assert; + +const Color = @import("./color.zig"); + +pub const Attribute = struct { + name: []const u8, + value: []const u8, + + pub const List = struct { + items: []const Attribute, + + pub fn get(self: List, name: []const u8) ?[]const u8 { + for (self.items) |attr| { + if (std.mem.eql(u8, attr.name, name)) { + return attr.value; + } + } + return null; + } + + pub fn getDupe(self: List, gpa: std.mem.Allocator, name: []const u8) !?[]u8 { + if (self.get(name)) |value| { + return try gpa.dupe(u8, value); + } + return null; + } + + pub fn getNumber(self: List, T: type, name: []const u8) !?T { + if (self.get(name)) |value| { + if (@typeInfo(T) == .int) { + return try std.fmt.parseInt(T, value, 10); + } else if (@typeInfo(T) == .float) { + return try std.fmt.parseFloat(T, value); + } + } + return null; + } + + pub fn getBool(self: List, name: []const u8, true_value: []const u8, false_value: []const u8) !?bool { + if (self.get(name)) |value| { + if (std.mem.eql(u8, value, true_value)) { + return true; + } else if (std.mem.eql(u8, value, false_value)) { + return false; + } else { + return error.InvalidBoolean; + } + } + return null; + } + + pub fn getEnum(self: List, T: type, name: []const u8, map: std.StaticStringMap(T)) !?T { + if (self.get(name)) |value| { + return map.get(value) orelse return error.InvalidEnumValue; + } + return null; + } + + pub fn getColor(self: List, name: []const u8, hash_required: bool) !?Color { + if (self.get(name)) |value| { + return try Color.parse(value, hash_required); + } + return null; + } + + pub fn format(self: List, writer: *Io.Writer) Io.Writer.Error!void { + if (self.items.len > 0) { + try writer.writeAll("{ "); + for (self.items, 0..) |attribute, i| { + if (i > 0) { + try writer.writeAll(", "); + } + try writer.print("{f}", .{attribute}); + } + try writer.writeAll(" }"); + } else { + try writer.writeAll("{ }"); + } + } + }; + + pub fn format(self: *const Attribute, writer: *Io.Writer) Io.Writer.Error!void { + try writer.print("{s}{{ .name='{s}', .value='{s}' }}", .{ @typeName(Attribute), self.name, self.value }); + } + + pub fn formatSlice(data: []const Attribute, writer: *Io.Writer) Io.Writer.Error!void { + if (data.len > 0) { + try writer.writeAll("{ "); + for (data, 0..) |attribute, i| { + if (i > 0) { + try writer.writeAll(", "); + } + try writer.print("{f}", .{attribute}); + } + try writer.writeAll(" }"); + } else { + try writer.writeAll("{ }"); + } + } + + fn altSlice(data: []const Attribute) std.fmt.Alt(Attribute.List, Attribute.List.format) { + return .{ .data = data }; + } +}; + +pub const Tag = struct { + name: []const u8, + attributes: Attribute.List +}; + +pub const Lexer = struct { + pub const Buffers = struct { + scratch: std.heap.ArenaAllocator, + text: std.ArrayList(u8), + + pub fn init(allocator: std.mem.Allocator) Buffers { + return Buffers{ + .scratch = std.heap.ArenaAllocator.init(allocator), + .text = .empty + }; + } + + pub fn clear(self: *Buffers) void { + self.text.clearRetainingCapacity(); + _ = self.scratch.reset(.retain_capacity); + } + + pub fn deinit(self: *Buffers) void { + const allocator = self.scratch.child_allocator; + self.scratch.deinit(); + self.text.deinit(allocator); + } + }; + + pub const Token = union(enum) { + start_tag: Tag, + end_tag: []const u8, + text: []const u8, + + pub fn isStartTag(self: Token, name: []const u8) bool { + if (self == .start_tag) { + return std.mem.eql(u8, self.start_tag.name, name); + } + return false; + } + + pub fn isEndTag(self: Token, name: []const u8) bool { + if (self == .end_tag) { + return std.mem.eql(u8, self.end_tag, name); + } + return false; + } + }; + + pub const StepResult = struct { + token: ?Token, + self_closing: bool = false, + }; + + pub const TestingContext = struct { + io_reader: Io.Reader, + buffers: Buffers, + lexer: Lexer, + + pub fn init(self: *TestingContext, allocator: std.mem.Allocator, body: []const u8) void { + self.* = TestingContext{ + .lexer = undefined, + .io_reader = Io.Reader.fixed(body), + .buffers = Buffers.init(allocator) + }; + self.lexer = Lexer.init(&self.io_reader, &self.buffers); + } + + pub fn deinit(self: *TestingContext) void { + self.buffers.deinit(); + } + }; + + io_reader: *Io.Reader, + buffers: *Buffers, + + peeked_value: ?Token, + cursor: usize, + queued_end_tag: ?[]const u8, + + pub fn init(reader: *Io.Reader, buffers: *Buffers) Lexer { + buffers.clear(); + + return Lexer{ + .io_reader = reader, + .buffers = buffers, + .cursor = 0, + .queued_end_tag = null, + .peeked_value = null + }; + } + + fn step(self: *Lexer) !StepResult { + _ = self.buffers.scratch.reset(.retain_capacity); + + if (try self.peekByte() == '<') { + self.tossByte(); + + if (try self.peekByte() == '/') { + // End tag + self.tossByte(); + + const name = try self.parseName(); + try self.skipWhiteSpace(); + + if (!std.mem.eql(u8, try self.takeBytes(1), ">")) { + return error.InvalidEndTag; + } + + const token = Token{ .end_tag = name }; + return .{ .token = token }; + + } else if (try self.peekByte() == '?') { + // Prolog tag + self.tossByte(); + if (!std.mem.eql(u8, try self.takeBytes(4), "xml ")) { + return error.InvalidPrologTag; + } + + const attributes = try self.parseAttributes(); + try self.skipWhiteSpace(); + + if (!std.mem.eql(u8, try self.takeBytes(2), "?>")) { + return error.MissingPrologEnd; + } + + const version = attributes.get("version") orelse return error.InvalidProlog; + if (!std.mem.eql(u8, version, "1.0")) { + return error.InvalidPrologVersion; + } + const encoding = attributes.get("encoding") orelse return error.InvalidProlog; + if (!std.mem.eql(u8, encoding, "UTF-8")) { + return error.InvalidPrologEncoding; + } + + return .{ .token = null }; + + } else { + // Start tag + const name = try self.parseName(); + const attributes = try self.parseAttributes(); + try self.skipWhiteSpace(); + + const token = Token{ + .start_tag = .{ + .name = name, + .attributes = attributes + } + }; + + var self_closing = false; + if (std.mem.eql(u8, try self.peekBytes(1), ">")) { + self.tossBytes(1); + + } else if (std.mem.eql(u8, try self.peekBytes(2), "/>")) { + self.tossBytes(2); + + self_closing = true; + + } else { + return error.UnfinishedStartTag; + } + + return .{ + .token = token, + .self_closing = self_closing + }; + } + + } else { + try self.skipWhiteSpace(); + + const text_start = self.cursor; + while (try self.peekByte() != '<') { + self.tossByte(); + } + var text: []const u8 = self.buffers.text.items[text_start..self.cursor]; + text = std.mem.trimEnd(u8, text, &std.ascii.whitespace); + + var token: ?Token = null; + if (text.len > 0) { + token = Token{ .text = text }; + } + return .{ .token = token }; + } + } + + pub fn next(self: *Lexer) !?Token { + if (self.peeked_value) |value| { + self.peeked_value = null; + return value; + } + + if (self.queued_end_tag) |name| { + self.queued_end_tag = null; + return Token{ + .end_tag = name + }; + } + + while (true) { + if (self.buffers.text.items.len == 0) { + self.readIntoTextBuffer() catch |e| switch (e) { + error.EndOfStream => break, + else => return e + }; + } + + const saved_cursor = self.cursor; + const result = self.step() catch |e| switch(e) { + error.EndOfTextBuffer => { + self.cursor = saved_cursor; + + const unused_capacity = self.buffers.text.capacity - self.buffers.text.items.len; + if (unused_capacity == 0 and self.cursor > 0) { + self.rebaseBuffer(); + } else { + self.readIntoTextBuffer() catch |read_err| switch (read_err) { + error.EndOfStream => break, + else => return read_err + }; + } + + continue; + }, + else => return e + }; + + if (result.token) |token| { + if (token == .start_tag and result.self_closing) { + self.queued_end_tag = token.start_tag.name; + } + return token; + } + } + + return null; + } + + pub fn nextExpectEndTag(self: *Lexer, name: []const u8) !void { + const value = try self.next() orelse return error.MissingEndTag; + if (!value.isEndTag(name)) return error.MissingEndTag; + } + + pub fn nextExpectStartTag(self: *Lexer, name: []const u8) !Attribute.List { + const value = try self.next() orelse return error.MissingStartTag; + if (!value.isStartTag(name)) return error.MissingStartTag; + return value.start_tag.attributes; + } + + pub fn nextExpectText(self: *Lexer) ![]const u8 { + const value = try self.next() orelse return error.MissingTextTag; + if (value != .text) return error.MissingTextTag; + return value.text; + } + + pub fn skipUntilMatchingEndTag(self: *Lexer, name: ?[]const u8) !void { + var depth: usize = 0; + while (true) { + const value = try self.next() orelse return error.MissingEndTag; + + if (depth == 0 and value == .end_tag) { + if (name != null and !std.mem.eql(u8, value.end_tag, name.?)) { + return error.MismatchedEndTag; + } + break; + } + + if (value == .start_tag) { + depth += 1; + } else if (value == .end_tag) { + depth -= 1; + } + } + } + + pub fn peek(self: *Lexer) !?Token { + if (try self.next()) |value| { + self.peeked_value = value; + return value; + } + + return null; + } + + fn readIntoTextBuffer(self: *Lexer) !void { + const gpa = self.buffers.scratch.child_allocator; + const text = &self.buffers.text; + try text.ensureUnusedCapacity(gpa, 1); + + var writer = Io.Writer.fixed(text.allocatedSlice()); + writer.end = text.items.len; + + _ = self.io_reader.stream(&writer, .limited(text.capacity - text.items.len)) catch |e| switch (e) { + error.WriteFailed => unreachable, + else => |ee| return ee + }; + text.items.len = writer.end; + } + + fn rebaseBuffer(self: *Lexer) void { + if (self.cursor == 0) { + return; + } + + const text = &self.buffers.text; + @memmove( + text.items[0..(text.items.len - self.cursor)], + text.items[self.cursor..] + ); + + text.items.len -= self.cursor; + self.cursor = 0; + } + + fn isNameStartChar(c: u8) bool { + return c == ':' or c == '_' or std.ascii.isAlphabetic(c); + } + + fn isNameChar(c: u8) bool { + return isNameStartChar(c) or c == '-' or c == '.' or ('0' <= c and c <= '9'); + } + + fn hasBytes(self: *Lexer, n: usize) bool { + const text = self.buffers.text.items; + return self.cursor + n <= text.len; + } + + fn peekBytes(self: *Lexer, n: usize) ![]const u8 { + if (self.hasBytes(n)) { + const text = self.buffers.text.items; + return text[self.cursor..][0..n]; + } + return error.EndOfTextBuffer; + } + + fn tossBytes(self: *Lexer, n: usize) void { + assert(self.hasBytes(n)); + self.cursor += n; + } + + fn takeBytes(self: *Lexer, n: usize) ![]const u8 { + const result = try self.peekBytes(n); + self.tossBytes(n); + return result; + } + + fn peekByte(self: *Lexer) !u8 { + return (try self.peekBytes(1))[0]; + } + + fn tossByte(self: *Lexer) void { + self.tossBytes(1); + } + + fn takeByte(self: *Lexer) !u8 { + return (try self.takeBytes(1))[0]; + } + + fn parseName(self: *Lexer) ![]const u8 { + const name_start = self.cursor; + + if (isNameStartChar(try self.peekByte())) { + self.tossByte(); + + while (isNameChar(try self.peekByte())) { + self.tossByte(); + } + } + + return self.buffers.text.items[name_start..self.cursor]; + } + + fn skipWhiteSpace(self: *Lexer) !void { + while (std.ascii.isWhitespace(try self.peekByte())) { + self.tossByte(); + } + } + + fn parseAttributeValue(self: *Lexer) ![]const u8 { + const quote = try self.takeByte(); + if (quote != '"' and quote != '\'') { + return error.InvalidAttributeValue; + } + + const value_start: usize = self.cursor; + var value_len: usize = 0; + + while (true) { + const c = try self.takeByte(); + if (c == '<' or c == '&') { + return error.InvalidAttributeValue; + } + if (c == quote) { + break; + } + value_len += 1; + } + + return self.buffers.text.items[value_start..][0..value_len]; + } + + fn parseAttributes(self: *Lexer) !Attribute.List { + const arena = self.buffers.scratch.allocator(); + var attributes: std.ArrayList(Attribute) = .empty; + + while (true) { + try self.skipWhiteSpace(); + const name = try self.parseName(); + if (name.len == 0) { + break; + } + + try self.skipWhiteSpace(); + if (try self.takeByte() != '=') { + return error.MissingAttributeEquals; + } + try self.skipWhiteSpace(); + const value = try self.parseAttributeValue(); + + const list = Attribute.List{ .items = attributes.items }; + if (list.get(name) != null) { + return error.DuplicateAttribute; + } + + try attributes.append(arena, Attribute{ + .name = name, + .value = value + }); + } + + return Attribute.List{ + .items = attributes.items + }; + } + + test "self closing tag" { + const allocator = std.testing.allocator; + var ctx: TestingContext = undefined; + ctx.init(allocator, + \\ + ); + defer ctx.deinit(); + + try std.testing.expect((try ctx.lexer.next()).?.isStartTag("hello")); + try std.testing.expect((try ctx.lexer.next()).?.isEndTag("hello")); + try std.testing.expect((try ctx.lexer.next()) == null); + } + + test "tag" { + const allocator = std.testing.allocator; + var ctx: TestingContext = undefined; + ctx.init(allocator, + \\ + ); + defer ctx.deinit(); + + try std.testing.expect((try ctx.lexer.next()).?.isStartTag("hello")); + try std.testing.expect((try ctx.lexer.next()).?.isEndTag("hello")); + try std.testing.expect((try ctx.lexer.next()) == null); + } + + test "tag with prolog" { + const allocator = std.testing.allocator; + var ctx: TestingContext = undefined; + ctx.init(allocator, + \\ + \\ + ); + defer ctx.deinit(); + + try std.testing.expect((try ctx.lexer.next()).?.isStartTag("hello")); + try std.testing.expect((try ctx.lexer.next()).?.isEndTag("hello")); + try std.testing.expect((try ctx.lexer.next()) == null); + } + + test "text content" { + const allocator = std.testing.allocator; + var ctx: TestingContext = undefined; + ctx.init(allocator, + \\ Hello World + ); + defer ctx.deinit(); + + try std.testing.expect((try ctx.lexer.next()).?.isStartTag("hello")); + try std.testing.expectEqualStrings("Hello World", (try ctx.lexer.next()).?.text); + try std.testing.expect((try ctx.lexer.next()).?.isEndTag("hello")); + try std.testing.expect((try ctx.lexer.next()) == null); + } + + test "attributes" { + const allocator = std.testing.allocator; + var ctx: TestingContext = undefined; + ctx.init(allocator, + \\ + ); + defer ctx.deinit(); + + const token = try ctx.lexer.next(); + const attrs = token.?.start_tag.attributes; + try std.testing.expectEqualStrings("1", attrs.get("a").?); + try std.testing.expectEqualStrings("2", attrs.get("b").?); + } +}; + +// TODO: The API for this is easy to misuse. +// Design a better API for using Reader +// As a compromise `assert` was used to guard against some of the ways this can be misused +pub const TagParser = struct { + lexer: *Lexer, + + begin_called: bool = false, + finish_called: bool = false, + + pub const Node = union(enum) { + tag: Tag, + text: []const u8, + + pub fn isTag(self: Node, name: []const u8) bool { + if (self == .tag) { + return std.mem.eql(u8, self.tag.name, name); + } + return false; + } + }; + + pub fn init(lexer: *Lexer) TagParser { + return TagParser{ + .lexer = lexer, + }; + } + + pub fn begin(self: *TagParser, name: []const u8) !Attribute.List { + assert(!self.begin_called); + self.begin_called = true; + + return try self.lexer.nextExpectStartTag(name); + } + + pub fn finish(self: *TagParser, name: []const u8) !void { + assert(self.begin_called); + assert(!self.finish_called); + self.finish_called = true; + + try self.lexer.skipUntilMatchingEndTag(name); + } + + pub fn next(self: *TagParser) !?Node { + assert(self.begin_called); + assert(!self.finish_called); + + const value = try self.lexer.peek() orelse return error.MissingEndTag; + if (value == .end_tag) { + return null; + } + + return switch (value) { + .text => |text| Node{ .text = text }, + .start_tag => |start_tag| Node{ .tag = start_tag }, + .end_tag => unreachable, + }; + } + + pub fn skip(self: *TagParser) !void { + assert(self.begin_called); + assert(!self.finish_called); + + const value = try self.lexer.next() orelse return error.MissingNode; + if (value == .end_tag) { + return error.UnexpectedEndTag; + } else if (value == .start_tag) { + // TODO: Make this configurable + var name_buffer: [64]u8 = undefined; + var name: std.ArrayList(u8) = .initBuffer(&name_buffer); + try name.appendSliceBounded(value.start_tag.name); + + try self.lexer.skipUntilMatchingEndTag(name.items); + } + } +}; diff --git a/src/assets.zig b/src/assets.zig new file mode 100644 index 0000000..119f1f0 --- /dev/null +++ b/src/assets.zig @@ -0,0 +1,155 @@ +const std = @import("std"); + +const tiled = @import("tiled"); + +const Math = @import("./engine/math.zig"); +const Engine = @import("./engine/root.zig"); +const STBImage = @import("stb_image"); +const Gfx = Engine.Graphics; +const Audio = Engine.Audio; +const Vec2 = Engine.Vec2; +const Rect = Engine.Math.Rect; + +const Assets = @This(); + +const FontName = enum { + regular, + bold, + italic, + + const EnumArray = std.EnumArray(FontName, Gfx.Font.Id); +}; + +pub const Tilemap = struct { + texture: Gfx.TextureId, + tile_size: Engine.Vec2, + + + pub fn getTileUV(self: Tilemap, tile_x: f32, tile_y: f32) Rect { + const texture_info = Engine.Graphics.getTextureInfo(self.texture); + const tilemap_size = Vec2.initFromInt(u32, texture_info.width, texture_info.height); + + return .{ + .pos = Vec2.init(tile_x, tile_y).multiply(self.tile_size).divide(tilemap_size), + .size = self.tile_size.divide(tilemap_size), + }; + } +}; + +arena: std.heap.ArenaAllocator, + +font_id: FontName.EnumArray, +wood01: Audio.Data.Id, +map: tiled.Tilemap, +tilesets: tiled.Tileset.List, +move_sound: []Audio.Data.Id, + +terrain_tilemap: Tilemap, +players_tilemap: Tilemap, +weapons_tilemap: Tilemap, + +pub fn init(gpa: std.mem.Allocator) !Assets { + var arena = std.heap.ArenaAllocator.init(gpa); + errdefer arena.deinit(); + + const font_id_array: FontName.EnumArray = .init(.{ + .regular = try Gfx.addFont("regular", @embedFile("assets/roboto-font/Roboto-Regular.ttf")), + .bold = try Gfx.addFont("bold", @embedFile("assets/roboto-font/Roboto-Bold.ttf")), + .italic = try Gfx.addFont("italic", @embedFile("assets/roboto-font/Roboto-Italic.ttf")), + }); + + const wood01 = try Audio.load(.{ + .format = .vorbis, + .data = @embedFile("assets/wood01.ogg"), + }); + + var scratch = std.heap.ArenaAllocator.init(gpa); + defer scratch.deinit(); + + var xml_buffers = tiled.xml.Lexer.Buffers.init(gpa); + defer xml_buffers.deinit(); + + const map = try tiled.Tilemap.initFromBuffer( + gpa, + &scratch, + &xml_buffers, + @embedFile("assets/map.tmx") + ); + + const tileset = try tiled.Tileset.initFromBuffer( + gpa, + &scratch, + &xml_buffers, + @embedFile("assets/tileset.tsx") + ); + + var tilesets: tiled.Tileset.List = .empty; + try tilesets.add(gpa, "tilemap.tsx", tileset); + + const players_image = try STBImage.load(@embedFile("assets/kenney_desert-shooter-pack_1.0/PNG/Players/tilemap_packed.png")); + defer players_image.deinit(); + const players_texture = try Gfx.addTexture(&.{ + .{ + .width = players_image.width, + .height = players_image.height, + .rgba = players_image.rgba8_pixels + } + }); + + const tileset_image = try STBImage.load(@embedFile("assets/kenney_desert-shooter-pack_1.0/PNG/Tiles/tilemap_packed.png")); + defer tileset_image.deinit(); + const tileset_texture = try Gfx.addTexture(&.{ + .{ + .width = tileset_image.width, + .height = tileset_image.height, + .rgba = tileset_image.rgba8_pixels + } + }); + + const weapons_tileset = try STBImage.load(@embedFile("assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/tilemap_packed.png")); + defer weapons_tileset.deinit(); + const weapons_texture = try Gfx.addTexture(&.{ + .{ + .width = weapons_tileset.width, + .height = weapons_tileset.height, + .rgba = weapons_tileset.rgba8_pixels + } + }); + + const move_c = try Audio.load(.{ + .data = @embedFile("assets/kenney_desert-shooter-pack_1.0/Sounds/move-c.ogg"), + .format = .vorbis, + }); + const move_d = try Audio.load(.{ + .data = @embedFile("assets/kenney_desert-shooter-pack_1.0/Sounds/move-d.ogg"), + .format = .vorbis, + }); + const move_sound = try arena.allocator().dupe(Audio.Data.Id, &.{ move_c, move_d }); + + return Assets{ + .arena = arena, + .font_id = font_id_array, + .wood01 = wood01, + .map = map, + .tilesets = tilesets, + .move_sound = move_sound, + .terrain_tilemap = .{ + .texture = tileset_texture, + .tile_size = .initFromInt(u32, tileset.tile_width, tileset.tile_height) + }, + .players_tilemap = .{ + .texture = players_texture, + .tile_size = .init(24, 24) + }, + .weapons_tilemap = .{ + .texture = weapons_texture, + .tile_size = .init(24, 24) + }, + }; +} + +pub fn deinit(self: *Assets, gpa: std.mem.Allocator) void { + self.map.deinit(); + self.tilesets.deinit(gpa); + self.arena.deinit(); +} diff --git a/src/assets/game-2026-01-18.tiled-project b/src/assets/game-2026-01-18.tiled-project new file mode 100644 index 0000000..d0eb592 --- /dev/null +++ b/src/assets/game-2026-01-18.tiled-project @@ -0,0 +1,14 @@ +{ + "automappingRulesFile": "", + "commands": [ + ], + "compatibilityVersion": 1100, + "extensionsPath": "extensions", + "folders": [ + "." + ], + "properties": [ + ], + "propertyTypes": [ + ] +} diff --git a/src/assets/icon.png b/src/assets/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..12eecccdab48eeccb48e6c9d1ffcbae38509be41 GIT binary patch literal 795 zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G!U;i$lZzY=1HA;AcrO0(btiI zVPik{pF~z5Um@8e$d`ekN{xY`p@o6r7f`6-1p`B=0RzLU1O^7H84L{K1#@-<+5jau z3p^r=85s1GL71^(seKtxkiEpy*OmPxk30jvwzT2;wG0eQg`O^sAr-gYUOUL!V8FxT z*b{VUs_V`#&r1$)A31C+`$TDNjOQ-~H!EKTCI$`$1%?Ko9_lbiGUd1U)B{>I;I*77BH)SQ9o Ok-^i|&t;ucLK6VjNNExP literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/License.txt b/src/assets/kenney_desert-shooter-pack_1.0/License.txt new file mode 100644 index 0000000..8355bd0 --- /dev/null +++ b/src/assets/kenney_desert-shooter-pack_1.0/License.txt @@ -0,0 +1,23 @@ + + + Desert Shooter Pack (1.0) + + Created/distributed by Kenney (www.kenney.nl) + Sponsored by: GameMaker (www.gamemaker.io) + Creation date: 24-04-2024 + + ------------------------------ + + License: (Creative Commons Zero, CC0) + http://creativecommons.org/publicdomain/zero/1.0/ + + This content is free to use in personal, educational and commercial projects. + Support us by crediting Kenney or www.kenney.nl (this is not mandatory) + + ------------------------------ + + Donate: http://support.kenney.nl + Patreon: http://patreon.com/kenney/ + + Follow on Twitter for updates: + http://twitter.com/KenneyNL \ No newline at end of file diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/Tilesheet.txt b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/Tilesheet.txt new file mode 100644 index 0000000..964fd76 --- /dev/null +++ b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/Tilesheet.txt @@ -0,0 +1,9 @@ +Tilesheet information: + +Tile size • 24px × 24px +Space between tiles • 1px × 1px +--- +Total tiles (horizontal) • 4 tiles +Total tiles (vertical) • 4 tiles +--- +Total tiles in sheet • 16 tiles \ No newline at end of file diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/tilemap_packed.png b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Enemies/tilemap_packed.png new file mode 100644 index 0000000000000000000000000000000000000000..d3e1177f3c35c61cc215d439abb921c41a145237 GIT binary patch literal 1222 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/Tilesheet.txt b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/Tilesheet.txt new file mode 100644 index 0000000..964fd76 --- /dev/null +++ b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/Tilesheet.txt @@ -0,0 +1,9 @@ +Tilesheet information: + +Tile size • 24px × 24px +Space between tiles • 1px × 1px +--- +Total tiles (horizontal) • 4 tiles +Total tiles (vertical) • 4 tiles +--- +Total tiles in sheet • 16 tiles \ No newline at end of file diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/tilemap_packed.png b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Players/tilemap_packed.png new file mode 100644 index 0000000000000000000000000000000000000000..ec1003f7cb464be7fd8e850c4464c77ac24459ce GIT binary patch literal 1147 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

rnT<^;JoHyY(8ik!4%4YM*jFe-?&W!uq4ZI4mx z;G@nRX6T~!(P__oDK;-#rmm_KUAw4mP|b;E0yEFXEHr`c=lh=>JUz4C&Vgb|Tfxk0 zEc+YtFLP6`4diQ20n%r*%J^|N77qfYvx|(tcL-D011cVMB(dvD(Lg4%)~j&tzh<40 z8bMH`?KOEqKC`QgQmKuZcB`trd@}Z#vTh*2-N62kUpo?&ju1t`zkbeaTeX}5*9ISB(@KgJA6=F)FSkpy*mX0`)b%*w8Z3T2;>M_T=mEjmoTot!P`L zhp*#yDN#bf_y2mB-*OO&=u@< z8_Hh8(kDiTuvPoAtz6&z&WGX57SY%BZMQqWoZ;{FsXFrgPsY1O*LLz zB6_Rj>f4OZshQT3)s0~Hv)lXL5@n&GLOWyFR+8{}sc=PMY#`(kjcu!7saASdo1I>hq$ z@FDH~?AyBM_8fF8tY<~r-b}<(l)kDV!d3Mt1I|{Mn#!SeqXR4K{Q0zi;BueIn801}oNct>YAamlzVxHK0Y^$JFqsPd!Qh_aIG{)%x0L25C&!PZ^k0;Dfnc=2(6lfB$y@aqVO0$o-Lg>ds7~XjlZ^4~ajuEcvY2|Ae!+ z+msVWxE2twIRvQO6}W3_HWwa#O}sHQP1fo@`SPNHS^&4V4=FdX1xH!K445YDQ|o6W v2K>?kWF?cy_9adgZ#9I|a>Pn~54FEJMOlBm{Yv8KV*)VNx6rH7agP2UozSwd literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/Tilesheet.txt b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/Tilesheet.txt new file mode 100644 index 0000000..d2636d2 --- /dev/null +++ b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/Tilesheet.txt @@ -0,0 +1,9 @@ +Tilesheet information: + +Tile size • 24px × 24px +Space between tiles • 1px × 1px +--- +Total tiles (horizontal) • 10 tiles +Total tiles (vertical) • 4 tiles +--- +Total tiles in sheet • 40 tiles \ No newline at end of file diff --git a/src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/tilemap_packed.png b/src/assets/kenney_desert-shooter-pack_1.0/PNG/Weapons/tilemap_packed.png new file mode 100644 index 0000000000000000000000000000000000000000..a38ac73523da212ffe6f8a246b0829d020edc1a4 GIT binary patch literal 1554 zcmV+t2JQKYP)oI$tL}I^%fVXkEoyD!!~tr zE7-bhzJVFeII#OSygh8`d}Q!=BJS-3i3Ez)OP1p{vC(1ALJXa{!1r;gOvvLHAFyUA zqxRrV&PT}adUPiMA{u>`FAfjCu^UNXt;XQK|85XTV1(@V`$C+7-ZWlBmsXT9wN?{g z@yAC39DCqcdT9dm0|F}@Y0T-Vu@4Avr-#6IQ4f@HdH<)wcUF{RSOOe)yd1<{6v6<* zB8npIBM5vg#BD6|EfS(9v<(sNB8;2tF}nCAx^QBrV}VIJL3qX&Ln`_NSq{$?@FEh2 zQDlG-=L7T&@X6!JsW}{+=-n9`P+W96HjaSy6JTOSNLvaCwUS}it{SwGwH8P{3**&jlyyDn z@$T(B*nLAMX63yzXqmeJzs8_pe_PWxTpQIHSD!78Iq8m8F^w-{Zt!xW!|nQQ9`bXJbkBxDPcSVMM1~dHleyenm?a z@B<%BTdg86W_31pXGVY-TzO!3#w_Ea%@O1`37qlq5%dl4@x$?HW|c-$6Ka${XRTH- zxv-A2v8!X2^_@y~Ji#q*=1Z~0jBY7REfP()sxI-;A$X^~g6Kij?swA&?(MXe|y^w~HY$yBp$ zhE?E>M#jOGcN%mA?&%1$3$xuWElY6bDO768omnE4zNkEC*Gtzg0oP#( zn3hw!a$DH}tmYN{*#ak;$0bnENaiV9B?@Mx<++rfZ{&jKn{-2XnFdbRiK1F=fhDAV zhQJgo0G>$iCndl>4DeTXHSc~8>qka`R~mQ@mUr8`A5F#uD-BF!iK)A{0+yjJ1qT09faD6?06arsB2WrL*Pwq!Lvu{vy7HRt zuItMW`QHP>vB`2og_|wFG%UdnFHZ_QGYOMR7fBg&V3mBLvR=vQO`dOb&S9?3SMyaN zV`XaKY*}JL>EXR8aBZQkFS%+fr}`R5T`jY&OQN=Gu|6VD8}-?b{n(GS(VT5jNP>@G z2A4MV`=*xFUI*9y`2t|KFiHF~TuHzJ;E8-rHUl@4<}8_Q1lB&4C~1?6Plc(`D>p?) z5IFH~{fq~mRRpFIINYcLSSptSR}881@`R$m<#|)RRAGM+gPh*v;M(L|lFXX3W-((o zB<8{Omje7B3;VxGuG-3}z6MfP%dG8^sP9_bkFR_D4Xz!KKwBBSGynhq07*qoM6N<$ Ef+$Dp0{{R3 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-a.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-a.ogg new file mode 100644 index 0000000000000000000000000000000000000000..1e6e4a319a8cd864661c7cf4ec5ff3a134b2ab00 GIT binary patch literal 5095 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Ξ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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/coin-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..214a9b902fa86bace5545d8a67696b60c0323ffd GIT binary patch literal 6193 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 b3lQTIzNoR+7_Hjm@!+?@yGawXAdmkqNqhBU literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-a.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-a.ogg new file mode 100644 index 0000000000000000000000000000000000000000..98f03ddf62a279941f3a75a1d0e97e1a42c620e9 GIT binary patch literal 5297 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-b.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-b.ogg new file mode 100644 index 0000000000000000000000000000000000000000..a6ad06ba963a72697cce4662781886317ec3f53b GIT binary patch literal 5570 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/error-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..1dc55bc413adfc4bdfdb8895e459b511b329e29d GIT binary patch literal 5309 zcmai130zah*1us**bERbXw(EjxPhp_pai84P=s7SAP`n@34|?x?AE9Br4lG0AVNeo zl`T;sK}A8KpDQLtKtPmD^od#l#j34U>sH^~#I}C@zF*({&7I%eIWywS} z8whDYpPx5D>VZY>#9PclOxCtEZhSgAg<03~dC7K+YH$|ghwl92L3g5*zWU)n{OV8t z>$#?>W@HEGq46nkOa0Pf$%*mYU=@2Zi|nwR?y%fp`3kbFUs7^>N*XVnmz)8kyfND9 zt+4yrU<`x>Gjt!aTrgP5fgn5tZLxxl%41ltSX6Jjqf+FBj^xV=Dn$iyVpI`b@q0&R zM4Lg779_C6l{8MV68f33M4OVdI%fO^rz2$D!hlI8?((Z8QOT0i5`J<&Y>hPx(}sXu zT)il{1UA}n^C@{m(0xZrQ&Nu9rs+|S*6r4FP?B?e93D57Z*YEmw6VnbiS6k@cYWIF zA;gD1930hpPA76#dOvfz_H&0*=|Ki(ao4ek#=B!t_W7`+G7Yd&t3`$cKuySVAAxm} z(0h_}{f3p_&-MYPjyG0#1P1wXz>^snlEoX%${fwg4y(+KIGY`IHaB7{H}XyHR$|`g z_G|XNH)vC-PR2lWiym4JaBl2^m*r370jpBryrC@iiTB$2yXF z+w6PW3{*>iPqom~Ky~relK<0U!YX+Gy}8CIsgNtM<<(Tu)l@4Fw$;@%dtH@cNi^Q{UmKoQEpn2H1ec17t{m01LUEwLWE)<7)@EXc3_fm}UU{qj1~sQOV|Goj|@ zrGlUuo6hFS8kGkV`z;;hyk=LA6*t+F??oD{CGCa~9LJMhc6qU|sxB zwQloxDA*e|SUq*LlK@5qq8gj_&LB0v&#-9TRNH@vc^~X3xLw2V#6^P9+vwV7*Kz3F zU*Y2l{I+$Bs5rQroL!>BB~T=k@`V|DjmqojO1NoZamjk5Ime%EVI$7it#l`JYhtgY_UVL%;NVuI? z#71DTI--D6$cu?Fpi11)fc3nz#Z zl9d#8AamkOZsb_zz0vG@qs5!&=KU2|e?$%hf<~x{NfEb*ezi7dgF8;`;NK%Bm2h<* z>DoRk?=~ynA^Yn;GyGmMZkT!mFnj~eB5#;w-ZbY0u8h3t$h*nm4QKJjJ9rUivcoz) z2aGyw?u}-C5jkjxSTai_21!+$U3Vf1Ya54H*P28` z@4|ykCQ$`4unE!yuYUbtsTszV06|;>wjP`-V)w&SrR*O1BN7{79;prNXJQu!d+0g` zbMUa36xa`6B?~vZBJ2Zmuyy%I@`5;mjv#W9DCB$+|`vl+m+hakwj{g zJ~>bAy?mml?fGoiveTKA08ZvzQRKrAphwc??S~@XIB

    +QikEi(*y>awj;#hKmC9fcz@XSL?QyNA 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-a.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-a.ogg new file mode 100644 index 0000000000000000000000000000000000000000..bc374c0ff101c06b7f256cccbb3a774d895ec434 GIT binary patch literal 13019 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-b.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-b.ogg new file mode 100644 index 0000000000000000000000000000000000000000..cfd7318bb673e0099b4e6a33d269bc8829017ecf GIT binary patch literal 14422 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

    s_F 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/explosion-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..9ae8fe655a8c9dbb350a60f2d591ae94ef80bfbb GIT binary patch literal 14572 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 PZ~|oSi-hL7DDeLQ#tu0K literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/fall-b.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/fall-b.ogg new file mode 100644 index 0000000000000000000000000000000000000000..f6eee211d90599e63f9ce812b70f821a6f53fec2 GIT binary patch literal 20092 zcmagG1ymi)(l$C9clQ8+0Ks+R9)fNxc<==G1P>0u0>Og2yF0-l!QBZKJUE2leuup0 zeCOQn-u3^pdiUz-ny$90ny0IKwz9do8UP3U>$+3_C(-r1(7WM z*CVcwzlpC9<;Rl$b3K-Pr1V&j-{J^8{J*Y#_TgbA%+uhIEq{hjI4&JEGz?Ap`&fz?T6vBIlQ!)rf#O34Me^ zrhugqe*qP8sLF}}>bJA!#&-F&`POzLjC3fN+K2!+F5J0^k7S~~$#;GEVpE^kHB_jDW)*h>9Z zg!;E1RA5^qkVs8%Bv2mNe`3r}bO2fX(=95%7wje=^MydJieRvce0ZEz`45WH* zN=;o+1H7E|wOmYRU7TlKytESob-#LPe+|_A5vYF=_?9H-U*Xbg`QkDB?K%|%$fOa7 zUuVpIMwY!MkPROYR0;=}JPrvJYVR2=@WtoQkWmbUSd%ICA$o z3WGt$NwPmyVfa)5``?rBIPCx+&Pm>FPu>rXhAQi%1CN%Y$gHE{EI1U8Bl3T~{Qk-d z*b(Y9vv@0C6lm1jzr*4SvL(qvd5Q5)P2dBcvNoua$C6Km1+bDgGm8jPCObpaQ|KFu z5>x)ppv?&BIyje%14-SPNn^>5BXStYdH5!|c%j`I?O6O>{W9#D$I>wcv>mJ7&Q=he;V zFz3ap!Wi@Z(I{|IsZ63?Ad&u6lAuI~0mcGQEB<@pe$$TPQjGss7(FIe!J`AiI2WrL zR768vL(9chJHdIOAyEH^^YX0M@@%*vanS!3tpCv*092ZQzd9Lf6vo+`>aQe$`p*Ra zTXXCQdcTnOf1#DHrd6C^8UDkqe8N4BFQvk*s79ziPUt*IWU9uiKgnY{sbMnI`A2P*XPy5`a~@UXnLxz4Y&61uG$)fGVvRq7MlPCGJNmg>ym?4+QBwL& zQ8wED(j1G>g2d2*PoZ0%A{avAEklxv8?$W&%J-W7ui<|*N5+8`44~#nIne%>=5%n9 zzXY|Znnm&CpFWC=g9GX$Mf~3r0013P81jGZh>9xfv?|ZEDyxRN$p2YmKiM&SP{6&kHC4iLGMG{be1H}-)eC8DOf?ninw7_?alND74 zLP-Vxa5}ySD$H;BdUBimD4^Lx08{|Lm$Q$vi^O3>u0K<9gcCI_woiaQFJ?lHku{zK z%1D=wXS|-8Ga=WX8%rV|nwE=a98v}r0+7KUde&GJAw--20E{qH(HH|`RYw?qMX3&O zZj!6Q1PW5sMg&kO0tPsd()@84^T^dk7<6p=;5Ly0aOi=R z_q3xi-0}o;^7vAt1g5k2inDRt!`wV7>KcRi8q?|;3q*<<^>m8(ii)S|8u(Hggc_6a ziW+scqui!*>KaQ#8q@Wr3q;;p@y^RoMQ!kQ2BbRA#(Npg*y<<#ivG;L!(|}?#xyr-fPuKLto2u?m|PG$XjD!Z^anW4D2sJPy?xV%g^d%HNhc%a(6xV&_rx}v1q zW)Gy67Zz8u6c@9URF~cqv+UIu7B`g*R9B{ym+aLap?_!DYkFT?US3kY|43~r+v~C4 zYvSpFvLC9qCC@3|ZDShzRyk08wAaL5>rAbp;k*>9zpe%L!`9F> zUH2le+E%E&>}CLDFmWj``i{I2ELLOp1kCF>VHSJKACYIC47RkmETy<)uiB3Jd+DBp ziiVedoar*3zBaMlGGB!5YVp zV}B#Ke(s!8fq~i^3CafKQ8w@g#IvZG;e7ca021{Uff^1|HMm8TIwumfqY|u} zJoXjLiaK_RsfS8ELar}01`lSz7(1bgoR#+qW}Ou~qiS81KV@`4l}iM(WR0EBu`24B z(h0*g#^Kt^H5rjZ&8vMRfULGMbFm~~dAS7gFjmbWP>^#bUdR^Z;;G3M)q$+?a*5<& zob?2{cAPWhV2NBjT{*@c0ySIKo@AOHDv(wGW95JA*i4KCSta>L!(e4`(W*nKF^{bL zBVclj_0cc|uvIWvRiLVl4d+a%stpg=Dv(t)%!ai`M^~ZF8Ak{GZ>!4cG_9@5dcex* z@<`-iRdqzxcAUS+V3uW%l^1mr=|+H+t6B5p&saSYbZtduk{w}XGgGSJAi>zSbvoJO z=-)jzvSRI-F)DkkoT(}<8m#=+yiS-v?1T}>Dq1xRETL=Dm>+Ki5|ULv*ZrDzwBb3Q z(kXqcLmqrXI7T*}X@XYA7akDzMK#TQG$D^_`{I-8h@2&k!;kF~0eUXEL1S6xy z&0I*uotW#?)a;=NQxod5Hw6}R6r8c;vOo{?jVuo zk@%01q42%JZ59wHy)&3AiDGQw8lBWYj!K|z+ zQ3ph@`(T6i|Jo5cAPN}}C&>Zp6)?v!8WPwh=LRh!c>oquPpUtb1PUS84DekwBmhP@ z5+DJ@ds+TqlovbkNKl3CP=R@jc}|anSXDFtV0sTCqDmDL$B$n!L7NE&xINlTm;iEC ztTbZ}Rcy2>SRL4wX zp$GVqeZ(JOAOXDX0SN+I^P!>E)qcS04^PZHx&P=R!;!KPcYGSb#NW|=To|Z=bCLNdE!2`Q zP^unfggOA6hJW$`qW&ijM{w&O(E!0UhUrGEGEtD)UkC6ftGKRk?IxvO$4}kkC zi~)Ecl#2y9|C1Ms2iEZy-o>guN+dWmkA%OX`ZtA2{Wx5IAEy4N>?0NgMHK$g3e#-U z<_tWu;a>d)|H`5d2KZtCfc+1vJ;s?ns_xW)c=>=R2OJ|dT-8tknJQCR(r%LJSk62G zHC5~FRHHBz2%>!b@$EjWVJd&^L=}|E!}@0d3;`$sAR3eE*|TJU2&_o#D4Z|2(ReZV zv7q<@zzW0{8}Ow?{PgLQSwznFb$D7ylYrc=4FtNsBg1+gAJc^Rp$aQ|bgY$bQRb)izv|{n3C*PKiMw})HbuvTEcn^wv zEKs>`#dMEHmCH$G@kkz0!towT>+9z!)et_Uob-cECLq`G0)pQ=m z2)Tks**wB0p~dNLm-?=7iQ8o5Og}8*MI^11A2w&)-@v~8G4)0XhTAyK^A};;o#)7? zwO(GWuwuIeZjBg`Q{h&Wkr~#<3wlm$iOtd-=Jk9G)=sRCV;3J>oXzRBL^+-7yqB(B zXd_E#+F}~nAxcRH}4+-gud%rL*6X@ep>SO@uug zjaj5YI3BhuN_$I3s79G%7rrJ@InzKr(Vf8AcNaei7xcGBzAXixb#flhl{(K z!qAg*>CD_3XgOv}oMoX$*A?)8F{Um!8j%zfvQC1iJBTJRG9y7r{`F!76K1@XI z_Fn4?i;lxVyC_up%audm;Dt}wvn$GcyjV8uDR*HOa(kC0)XW^eDTJigRmK~eKW9U5 zu=>;s+w1*KN=}z;#_7j7M5q>j@#2}S`Mhz&I@M7@CIAv;d>vX=>3n!Mr(*DRcMg&Z z%AU{_6by7fpQguN(@_p76=Ip+oI7{ooxkc0Yv22p9LMr?!H*nArrP?2&GrtnT}ML+nEa6aD?wyMK8acQ3qm!pads63sF$E> zVzjnn)jzF2kzN+KE7aSCxpc){7#&1N$zjxr^39X-;`^bEbl!NtF))*PWG6`vJKfH? z#&otGt#WyR>^wyeXJv5d`2U0Q9aE)K}G;rz&}l+)FsO zkTLbVq?XlGSw%C4cmoCK@J6C5Y^BF&4>zO(L~n)+x2r~^})hy`G;))6O$k4Ge;t*sp} z^EC6Iv-96Pmqz!!kv^Ov^|5#{O%yB^*WQ{QQxZWio)LECdzZ_JoYhX9%OEa+YE|y?(VRqL%7EhN&7Vzg0^{529ZS5vcnpV&1b^0X_`Dj%{-m2 zlw*O4Jc+)z>i=`n#ov~y`$u0q@tWs1?Y1Tv%8;Yz!O={B2Xd(rCugjRa};%F1zaVP z&q>R4LDl4$vgKs9;iS)l%zT3z&Z`^Ycej^TdpAp59%tF@5AGFH=Z1n)MwZM2>f!;v zo8edNwz(U4HA<2W65_^=s|+rSM$3LjM%xJ`lV$A>`2+s?iPb(gzK|)`~ZY z0BI|JW5C^qB85?=wwPce=_$$5Y7p9 zMuHN8IOhgm$##Kg!!Mz>SFfq5`Mj9*OfF-pb!y?1oyZjpY4NmV^YC8aob}=U;US|R zaY|FA=ryi+|J=wS3+Zl#=b?e)*~4?OwK%y}kGj`T+AQ zJeHy|gf2|ZY@6s5rue)If=_GR9@f&%n1s*=hpsbRt%HZps)v!?hrQbN%8H62h3pMT z&)Gcz6EZ_zw9N09LJ-;hkA9kpoP#@_i|KzzY`J(BMg*x;WaZ&SAYG~|Z~$rFDAQKx-dzz_oFju zLQ~*2*NQcA+%d~}H8;IlMRRl>1Va~};{Og!uK8mg8!PN@W=9zF1Y3`Y*!ZwiRJI$P zYC!o)1maX_#6hpK-;Ym9(JtGW*FLJh^TRHPtmSGV*_PVGo|jtQ!ycraa}rCiZMJdH=bZ}0^P z0CYj4JT<&p6O8pVJ-y33R`@mKLU()Q0%=Xx`iv+~#^>&A9KFKjbo}!ucx~VkqJ`#x zBByY*&>$Twfvi6-r2m5;nl2+|d$)U!g-w@D1lB|J{I2#}ACp9nY>HMf37R?{yX10s z6KCk?(5+HCzPNe?=BDK5G-~;yYyY)osi^xEC8~B3gZr`7hu;-52!fueFFi5d-OB>G zFizfF6-NtZgvh;XJu5)PjAYMIoqTToCKd`E0GedhvHvIRgi!U}Xj_M{wBfr%obG zF@XD8Gc(^PNt>|ujkMd^GQN0xA7ALNslBXAQ872KblUm{O>=TXiz6M!g<7O#RumUv zVDh6N>Pw(Yi4J)HC6M3kjI2;HxA)fxM>(U5*j~Xpch|ULvXbY)C_WUc4auUCDu-`; z+RFPZoD~?-v@`|xV4kzQV$-E0UTds1N2_GEgel(I^7x6S<-V+ zZhc-sPRqnf@ zsA2r(*xM=GHH=l18-3##6wkNGQ8FVjb4%FAxdo~w=$q}3UY zw0-_u2h_s&Bu%$AO8170=AD%Re0`eY(_~4md8bsih1b2Ul9?34hGd6`0p~tuIe|** z*f>PDxP|SZXs*D94kJ7{u>F$m(BY;YneE^mt?JX8d{fqoW%obj4T2*?sb#yNtbvGk z3wg#`iBH>T!tW#j1wqyrS81&A>mN9d-mZSqG~)?=q7q(YNiaa*8ctwTBs?l!Vw{OSM++LF@|~cQWNJ#CvI*+6<%Z4HYUAe*V+YJ@VLk z&5Kq11M0(P*zgx`MIssa#VaEqlP)lz(9&*MI@Z`D={tReiBj}JMGo(Bu-=XF+qPKW zrQkvbbvnA0n|96dsaS{!C4HfMNy&Lr4fWz(I?(hHm+5DrBENI-cOTU^A0#hk`wxla zDusA5p%9Jy^WACY5@PpCNUbykvh|0^$^2oGmTdENVwMtMZa!zO|8%q0LI*{pKB04{OjH`uz%r23A5x!XY z6O-*-1@CW-GQVYfjrx1f4|9yW)4e_1YDIu^ErBfrpseEH~#< zqs{MFmPfnfH@NL(f-;nj%fC1yulL<7APS;d;``eTIqdD=SAbyrPDBXO>JOt$j=CY142 zd`2Bh_0`l;yyI?_diFOBk>i6NocxX2cn5KKLjMyDJ4hH4d+Z6fpdevIKfyE5=3=1P z?t~D{UP~tUA2Xw$d7B`oP@?=EO`(2h7m4=6$6McmRC@L6Q!hgHHE}_mymSO+E*;61 zCVL6YoA;iHjb`24_v-%gc5$JPz&BsqZcsI=;4A%rp1&{6jMW1Bf)MK@AMMTO=inCQ z$W1(Ic7QxA?@c&N9pN1ISudk3c&j{nO~$f+R)yQpzZ8=TX$X_18!JVMAk^9nWw{L# z7aP{hC)R!HRQ-FjChmB9kA?UCb#KA&Pn7#B7|_#kIgR!S(?=a)34#0C%+6M#XT01# zAEM+!UUyn+wbLM5EX(dB3tF#%r_f)M1zMD#RYAF* zS8NPLd>yLxhX&;m8JlI&Ta-jnSqzpYwB%-Hlm&|E+TI^s^=75DIu+$WrgRwp!O#<% ze{AdQ4zE}Itz5L)##TieF55)ZSD(y=?ZK^6NA6+wDSPtVnAb*P{L2lY_#Za}JeW+J z)m>HM<>2SzgF*$Nd_1hYoI;#}P!4_$s0cS72fr{6F9+ysc+BGx;N}H=4^SR{9w;A| z02ik)FE1~YLy!$B!Y9DX0s1ERxH$#5cocYP^2FrcHvPydW!HWa4zr(`HO9_<^_@+5 zt&_;@!I0<|p=-;v$+#lw*3yS#<4n(oJ&j^ej=0uE3+oeb9Ws>s6zr;ORVg?xFP}Cp zX~vN->yO{#e&_OePp2S3bjMR)i1!)G^BM6kZ;Wweuwb;KsJO~0^FhcGr2m{CMA@GAc{N}*>T>;rz zWR0`J$?ZP2N~m4y{Rfufj*Y?1yU_K($onUuo`^7}QuD``x2U~_B%JF~8iaxPcrk33 zj3zuoO@u9G`(SpX#Yd_ya@tq$t*&08J`8(1JuwRn;aW4lMiMVnA?n5hjf&!Pc)00Q zvb3(+!`P=CUE%dZJS3Dq96uVH&gFjx-J7BMg-Zvs1NwQl` z_*prLw*9;F_b{uH!E5=LHYI(BCO+hE6qez`-0bwFu3SPIa4o7*W?c~92Ma3wpc^E+ z5eCc+XKX1~MpE*eTyH@ZMZ)r{^XS=R*DzS9WQ~%~+4Fgb4U8f`g-1%=|Jy=4##lJR z@yY!6gI}6*{R=Lz`=Q9%f@3YBxWPZ zFwdo+HaPvl?IQXOE8Oi=NhOM>dx;^>2#aTbG<4Vz0JW;NJSl{lRIu>36_nyqaV~;e z{e_%|o^i3C&rzJe-)zv%&RLdW;mL5VF8Ao!Ba#n`m9jp*=g|QmKh=->SH;%ziLo=k z>51M}DTB^GJW^ayzU)#oNOuACc1^ z6c*KI*A~b81+S&Tc%wp#W@??G(g%lr(eFlv^n{(+mmOb^=%~;jH|)8F0+R8EN7T&_ zmsRjZt$slATbaOEMz1T{&w1iQ$hA3~TPpOu2K?0=q&~`)l-Ls(l4wMThP`gd#)@Jy z90}GJi52;LIW-4wS5U6_qU}3_V3QAn`?$oCr%T@5#u2xgYiWPyl1Lv@+Zr}yfmB{k(#ph>tTDJ5uZ0H zg`R|ImYdJL@fmSSXwDnXz-GF{$FHA8`_LVrcXYb*;({d`&)5yW6jB1G8jHgD-w7wJ_`9-L& zjl%l{PPMhQJC9Bd`3c4P*EJVT4x9vAmBY(?s!(K&9V1%bKjXpg0?`6=N{1Sm_a}$= zsVg!Sg^w`ljBS~wu1{U>;ozo2W9j_tQ}mk6xGBVjK;pSuQng!m1I#Nt7B2i}V#|SS zr*0N)hirg;@A$BASsEIimrptS!RYJSlNX#l{$*B?$<0r+Z>^7C7}!{f{lWuEA@ox6 zG@m3oEX+LP7{|n;D~3M`?V;FqAYsT~kbYh?R(Zlt900=!F5G{+^P&X7iIQ(1jzufF z6g}`!(O(J>?If8?dvfBJo1C}(+;_iD%C1}gY%Nk$!}Ele()EJR5~g2tj|`Y7p_lTm z&3A^Jy1_H>-N1`J6%vpUWM&>*z5C_5u*dJ!-{aEoTKEHwg<|u=-NW*JOcALTBP3<; zK@fgO2{ZeWp(#4#xEVgm^4G;eV|3Z{Oyuld;*80lhwDX3n`KA$T`3wCdy!*Ia0Lu4xv^erqcqgOUNa4MH{iEctjCmy z>p?rd0#J)+jvC6K-NEhCP4MFR=Y?zjfmqp19}S~`i3TVkr$k(U#!^w-$CWQ*ft`2@ ziKsSY*aM8a(Y0%QHF#=1%7A`nm8^1rTzKr4?F{aZ%il-+QF9ED1I8=-tg?FL_0$97 zInPjlRB6OK6^O5v8hl^^^MjB;IllIAxvQf?1Coo z;Fk|j$dD>0jf4_R6np^Tk&@97W1LO7$8p&h2`C?o~AE_3TIWrP@rQtFb3i zBakNV!%&5pkV_+wD{w1Tbqrx=UV&@Xo^*=n28B} z&A&@6YFhgcHvoE+*j=Q#j2>DoX1_#UgUf;sXm&;($^Ep+W{VF)c)J>RRDI{7?_}Pm z(Oin@AyyGjjL5e4Ke-Kt3cI+)F=^v%=^+ABilh?WN<-~9U4BJ=Lc*Xzw1mmw;*xc3rz9cm+`kSCJTFTsD-U{WX9w| zKGM&v+b?G|=UG@V^{Y+mAb9R;qC#T@C}GC9u<(64K*rD+DZ|B#s2S&zOn2GZd{1>} z_o79AY&%n6-X5!V6pLT!cBc@&RQe)Q)WlL#DoQ{gb{X_O)pT{rcX{*bJjL2Cc(EH7 zx4dMwJk3G-V94vq9@K^;&B)^*g#8?!5L{XLL11XUne8*;joJbahhg&?WXnfy$wTyI zr6v`h8b5Jf*wWdCyTJ*`rqNoDWn&h>Yh^W&rf^E#Pg(BbW1F|`hCoZfP1ODX500ojl*YW6yNeA-=1L=R?iNrpv!85pwxjy`ibqRwu<9j zqs2iDROC(}?cnlTP*Fy*v-F6-rv2W}2B#ee5Wq{kEsQ$-)yPjV>kfSJ$a2p1hFU9B ziKbphLB4bUF$`H3%d@vGm<}JSwe(8B)LovcGYI5BT2%Felc0k52;jvI3f+YrU~GIH zHK-9fd!}4)c-RT2Z=HYiQFyHh)84Z=o!c09G1Mv~v`R?fhkLG^k-Ab-|Ob;K*;u(UTkd~Jm5q#k-C zoMSZwJBTS$cs|)bU$W=Fs0F=nql2)ki}13O>XRH?3A}*hA~t8w^i^w`7wX>m;yk}V7|V*i z)b(^-d`&Dbmg{F)b4Sm2MKy*z>2cPRA3i~80k>y%I;Z`!)*r}K%7XyN2Qes_s)^@H zsyR&)Em|KpD)?ru==xkVI;9_iEL@N$b=gnizkb17q?r)_TBH#z5r8*L<{kP*H=12HgAU~KkiokGM>Im**5V36CZAPnr6@2W7=j679LzsTVPcP5)9;* zO9+d7CvnGm;knwPH?L#L0(`2xt`kymrmw;bCw#aSDY-X&@=Yx9X(^$3V()(HonhA` zT6k4;NY2XUJ=Bp4@x)c}k*Y+O?0oHOhIAeUcR1FOI33wAc2v55(A;epeh=hAi2E97 z6XcyPGlUVVsWLM9N~_}J*iv|p1314HqA(NwPC5L(| z1Ex4JZPKyB+#wZKGBFo+#fNBblU)I4Rhde&8`0vGK^X6Al@gu@>zY+w#Uq)6geE#dm^-67PKA5DGoz7j-%hpR8P9 zjA*wZS_!sXVZcQfX}j`b*DjlpnRZL@=G<#9RC=>GJiJcXdZ=w?Cv|C$4!rMf&tA+q zlub!qbHG}>GqVft+$bG=5(IjcCbWssy3>U%Y^zYf9iZtp&mE4l99^iN4b{CXdpl)m zJvHF;Ou4Jo$KlI#vQY;J97D>#tbOp`Gm|g>bvw|_u+@0@M?iV?opFvMH@bw?OObKb zek)S>G;}7QMKlYJ4G-gs)|5D@+f9lVWiS_hR~oC!%|1(|u=6ZqpE6yoXm{{|k?HwY z6QZ5!6vQDIBRYaIK%MahY18gc+tM?Sn)8>O?518_^|2ZoeD|;SI5t9C;pktTu5i8+ zB$DcHY?~JTmvh4DKhBBAvlD+*EJl`5@6yN;RD?i47_}x!-9pL2TThIGCvm*hjQ?;J!eu7r0?>K zHyM`d=4rsQc&J9yv5G?D(HZ@LZy3m=n-_JY;OW^B&@HpLU;oVqA?&9);GKt1pP0M~ z#2yp8O)q6>GU9~NTD#ucDYqv_|Wly>-&>+26qh&Q`YxlpE<|gb!-I-bG z!Q4Q_E|o7CC}G30v8gx%_ejmVXm#+9@HcO65!!VT`an1Q4|tyUsnAzt=gdl_)(s&Q z@HR}u76+dVH_9&+dlFrj@Bw;C0{030aTerM@{y!J?(uXR={8!I7YJ?2800v=Tc1|S zplpbHFI9v43sn#$n9OTg0~Pokqs^Ag4~Odlr<+~w<4VJn+cvgeLVOlu`AJ;JJquhk z6}Ia(aB`IpEs=o^dQ@4yiUp<;1v`P7`tftodF-Z1 zqZ#Pxf@St1rqcsW;z^z7hSlPHjGR8^lGs*VD;feD%CDYJ%!;a@& zmL8Gw^^6Bk30C7xY9zg z>kj|>WevRZ8$&b=uBOlD%8IRrgy1@}*@=#MRwLUYUBaiB*q27)>bYbq%B{h5#ZGHV zmu^VH^=-qulCv?0I+j)!A5q-Tvk{IW5boe8cXqEyGbjD-Rv@`IRyTZ?PWj3@Lxg6q z7g88@pR!S8z1Yy1mmmQbCjG?a9LD4HyykcPp$srKuGaEPs!KOKaqcD}i!Ir!tie|B zdt*M2CjCach0Sc2tsQ+;IW<%YSXBK25CE6f?6SSh@g-+uTKGRH90Nn`1lgWG-|#JBE*zyGse%zDhSia#9j1L`xa{prQAJWwHDQE`O2`+Wp-!sP!$616PUF z*eIoGmM!y~RCOO~;h-h37!gSH-%&mOpBPm5E40C^j$!@pd>`<*DhJ=aVaC>>=Au1E4)8TJu(C)AvKs4cI$+#Er@Bmv&86 zO0Y-V=;-~W-_=hv@n;ENA}`DX2PZRS)vLP2QU=b6m+wuuM+WY0XQ%cB>Kj3QeRhEc zwFL5)DxRL7BoCEiezaK`80%o(l$oqm@IbaOEq8%>=S8_oZ1`Gf#2g$rAme$Ibo%Yk z2rqa9X7Xfee-RqO#0UO;z4QY-Pq)0Ntsp$=;~-E7?P$bi-m|x;@^D$gol?b z`1yvf=bMzvW(h0e7J4T$RE(Gq&$|qs?nSdnTp?n|D-*Vq1Hx=VuQD*P47M|djOx!! zf$e1dENBMlqN(YJn$~bu11|ORdek##g3B_A0*$_|1XH-kpbnI@uM_aGX9QF(h4x+8 z1425p801Z4jI>-XRuS9w9y;^-)0Ow`F&v^Ka0}~jY|QC1DD3FpYmN`33A+#*a$Up& zg}{BGuz*%vvEF&3XT^0{=Pj(kbV=u#KE?8%$6grq=3sz<}+h^f5tf!Cj0w)$Wj0jDyw4mz%h;g^JnO1j914{Yb9Y|t&I?yKS@R*JjG>7Dw~C*q=bK%Zw-v!NUWbIO){Uxzy(RB9C9(&~;B46F zcYY!fE}V_vAm00A0D>cRlYY`S1H?Sko^kk>>69;ek1O!(t;@{KLia|{PV6Pl_aC0q z;R2UOJkR@wd8+u<7ml3Q;pSVO}tmAyLUt+YWN2DXG z2J+}n_7S00)iqXy$i00{%_uGw1hBbuyySLXF(ug;fOt}IQz2dHlq`AND;Z8{1E1}a%1p&ukibi;a<5C z&A{^uEE`_)HJkTYq3{^1wo8!!7OQ{yt2NJ0%rjwf$7_*9_|5Hj|(HsiHZ@Ieb zZHhKsM;s3qrOQsMpC}8Efi7wI?ARU#6zanZ@VLptesGN?TbWgzj+Tf)#h&W?-TA)r zeW^lCcPIYc1d2v8wN)jk$8yz5yoNlr#4hUHsu7O z8n>%}-^M?StdVX-X;$q0A_|oj-ZtFWm!eKxJyXxfl@D#&FbPbqelYU;Kvs0B7FD(0 z$Zru`@AuQ|e30jXz(Kern9FAbxUGfbr`GJD|Ex!B0};yS)=!nr8u7jb1jz^Cw%d)F z0}U}=Ac!o-z@@z9-Hb6O=bA$D18DCxr_M}n)naeb>eO99KjJYh-LCcc##a^BJ|FSc zmeOA@4T+t)e!_RwW%x$;2_Ip^p@Kw|Ybi;RMywKic=Ls<6H5^z> z^d8Jl!e&=BCAt)r(Ecc+bvxrdA$6K54vr;KHZ-OgkhYAoH#q6HSy7*lTNC zp61agtB)w3t<#Smy~m*wTNWExi#%%zi$<0=TmL+ut=129;@X6IT2>(B*P8na*b&8-xRVt^kW#8> zBRiUTN?wnq3$E2wZY06G1>!_+rIfwdCZuMXQ@Wa~cV^hs5Ir{Yfkm-KniAx|!KSB> zeQ<-896Ml*HT12IcyJby+UnAaS}EeSI-U?R zU#I=wA{Gjcdir9d)|iabJ+sp`xUch@><8M>j-uzn_nwYa>4z!|X{w;7B6h?+p$cCl zPkwiiz*D3wrK!vjd{dr4?zL-9P<%6X-vO|CUraGK%B26|158ApIE7Gdq=+w6K0m(0T=>>NHu0;WsJc06S?8OQx&~UCsXF8q7t=A_g$>`G zLh^UJiQjud!D-`-{7>p_A4?N_Z`c7?)=w9fsI+h726k{JS6>llIyIny%K{4+UjtkW z_0D!*`Jmng-hIgSpKkErJ}LV4nrv|&@-(&)GeSh;n2dG42n52I{JP))%@FF$rFL1| z_`z9?fNAsIc)pl}{a%JF{-4w?HT(z)l;$hKsNeL>dFPhteamCkp!m46+(u?g%hBg*IlKcpVUgPVIqix!ACnXxKhU}6;k5?NJk3jaX`X88z7BD(BYx&j>b}iL+$o0O<&E7qw2P&kuoiKCVaNi7x%60Y8=flrlf*qeBSU-Co3ASsjPK|4-yS0QK}i0b3R zFA`;oE*zB*p4prI)?9Oh>7`T zt{T_fmPd+jvq+(|%LO_MxQ5#sd24sIo#DSv8sKfHHHZ3?EeZi)s*E($>cBf>*#uKa zZDWPkc3J#RrkFCt@KnTGwJ4D#TbG?knRdD8%g!2~yTRhrNJxvcC3t$sSGkfZ9M?R9 zSTA|{g1>&#tK9g6@aI#l@!I$HTZT3HLKn*ue~#BoT(R{;pRBoCNxT&KQOYj=Cb%az z_9y$=%wpfRh4pGVX^B@Q4cqJnGRwx(iAI7a0!D0$Ka7^_kr2=b*B)5hvea*p9KSut z6Ukz3<{`eGCan6zm;6%sn$hG(^q)Lmjno(+)<2SPHdo|Pq-W`bPdMDwOwlax27W}8 zaiY=dwaBP!DVi$}_(YCkTp z!lBdi6-IEXP~T0o_erxkwcEg5I=m|XVmis5?b^#y;T0KaZ=Z<^JJ%zu?;IFl;E?S2 z3RgSv15p;PdF7W2WC*emV$v}ox?WN6c$F5j{fKFA4}KUuWq&GqyRyG+&qYD_TrQB; zr}NU2o7A|D_hD_dgcAIWOgeBTU}k=|d%sPn``U;u1R&rg%>ZtjmxfWAjJBr6%1`G@zOb=#QFC%oy0=hjhwr{l!f0|;oW=gV~R zuNY##{5}AJ-}}cC`)<0uB6Vzfr>_{=Lz+ZX47sg3M6pL}qk4v)_6|uAgGivNeoed` zhx%Isyi*sv{|rV)MFR0v-6d=Gfy-WmJ=4tu!w6N5#ftF#NU4pJy)3*sQ&lXN_=~Gt z-`YRk=GGnYlQn6(-4a?yPFBr`^Y^z8bnM3!9wN^T=qWh%Tu~t+&k#*0QR!W!UvuD{ zhu{}-i=-8I4kvE5S}o5UuUFq_Y?WTiHv90CoPA_X7`e30l$?#-ioNq(MUH0h)JKWp zNh*;Ug%{yyJ(_D)27~M2)EmaiP%<{FGZwX z-;A<_-xyMe2pi)S3_rK^_I6%P)Eh;^v3vywEZ%QzJ0T2R%^G%VX#CcbNm3}e+RP?s z?A6fNGxRxIAI}p?f2Av&EG%tz=-b%bd~>JuwGQbOvq>2gT7qMc8FUu55Z;1Fl+0vg z*1a`&e#ycHw+P|)Pu?pjwz}IZY!>o$_tzb!oYJ47Ep)JG9}h zf_tOiW-uBy__h%)_KdutC;RhuLMjkwB_z%tfe-g#k)UXZ!JoTMyR9*)8}@OjD#na} zFf#-dXxU+LI`83R5Y72A)rp0pV&n$=KLOzg9`~QNjiDM;+RY)ROy6_D3GWO&8}3U z7wiQ&bnTj3Qr9yQt{vbJu7uVMVEiPdqa}2nR_Q$*B8lvx0KSwy#3U*uClwne1STWY zAEOu5Kg`2#djJzH4Jc73fMrUD{l*X#bFHFZjD-y9UM?F{8C|D}aRtF%$$B#8ZT=)uDern1Z%F~&H3@ZX1e6Tp)-|LNaN+16TH z%{KvPtD5R$6wb_FiLJVKodZ%r@!1A zRBJV$;n&?$~t2y0C201*i_ z0_dcvySS-1SX!M)`e@wV9niY6L@yU~2s%=P`5LkIdv6XEOfkM4075D#51_x^8=A*m zW0j&REiuuNK=epF4VW(o*+>DT^$c^3#T3!2ZwQ5U0EkP$usi_yL{&FE_%ER69c-x* zJxUbySDUKw3&yNUV*|YD9JZdR40W*?EQomrhzA;4BY+V0Eg*KwCn~LxgkZlJ?HwY- zek(zya4Vx(B8&ml0VQ#U=0Kr;0Lm-v0O88engMjuK3=M-M6#`5%fFVbeG+q1DR+z8 ziwEQgD0vd>4J|ZxyG)b4zF`@j+5tKm4Ha55fG|k4mIS(fADxiT(Y87~kVfF9V%>QV z6nuG_Q~(Sf5d)ME4nb)LK$N330?64K>&|Rx_<^^&sYy|3)*oi$$bQ124@0|bnIBkX z>=M>kxY;n0CuI*T9D)WA1 z)qYBPZ^|~(N8DZo*4xg!#LNSGWaQT~{qJ^n7=~dOhGAfyV+U9PR)8RBe1Igd3vO-~ zz#KqBBqb;n><6>i&4;Ic3|NVWO-OAl?IB%=Z`LKC31`Db&l0%s3jZ$fKLVuT0)EdOlDHd<=}Y_6|F1jW1r z0Pa=b89Jcv^Zv)^{W5fS_YeSpGBw3FjEwE1!`vwyVZdv-v7SFL`k{pn0Bb-cYyax2 zCg2ybjW4{<8eAuL}SG0B8Lo1lI+}CID0&@0%Vh5sYyMkQnR^ z;9YZERux#OOY5)pRG@ra>ZFbWL=A0JvnBjM-Piz(fEoexYonS|Sm}@umm@lc!uPz|cc6et>WlYXp$rI1-Vl=(8&pKX?E zzfi{DwgYs;(@@450r=J4gglLXAK-T9wiW%T9vKZ872pxy3P1DO0IcOK^gf!U6#ATj znA!m*!ZoyJ0q6rxEmmBu8BwiA;m4m2;6Eo`OYDu~8KF}k0L=Xyv7YT*N>|?)gW3Tg z9xgCz1RxI~?UbZ(AP@MdI=;&9i3JgWqYC-n02e4v4L!^a6I7o@w-JgLHig^v0C@2f zUuc~Gk}u=9ybYV|1yR*o<*6giH|*$W<2a#j0ZhNg}$oLSM8BT5S)!2KrXKo(y^X$L|(A zXxK=+hxe|#<6#(vVHk$A^Sq6KaRG*iP{C%^D?$Bn4-@lbh|&>bCkC^3TJA zllSwx=`&3{Nld0^R?VxmY-_EpF3kPifEeTC;H&p~gC^Aks3r*b>FX==S@^tsc$~#m zReKqlbXZ<@VF8#0{bMaMH6;VUYy4_u>F&-60Kk?>!N+#Pi0Idi;g|pt;Lm?nGk14) zX8>TSisLvO!2GKfcLq>_0C)g+@Jkk-pWOfe_!?_pJpe$h02TlMNXsuNDY*e)0zOyV zY5<-_oaYp#fRbPoV1CsD2*;rgivp|wD?lKFI!LKp&N4H_!qb2|ZB8C{tF5hU>+aOo z|HM1T<>h5_Z?Lh>b)QPq#>>=)jP-_w5USJFLlFAsc8Db&wTxtxYT&kcjAzXnr( zjWO9&peKfhsC>urXv&O+{Rgj8in=KUcTC&|iCxcIuRmQ1T`w4=fMoypRvpA&5B>lg z!rb5g-w^=aDS%iq1RWrHKi>erC-uWH+}4JA87xgCyW%c=E@4>(YPUf=QFz8U3CXAwqaS;T1R6j@Zw;a-^SlB%s&s>{C#2j=j(iTzfL`SC3A8( zb-A?3r<1u}lkxsIwq=;>LdhhpZ67*Ful97Bi#fFj)Bfw| zybQN>nR6DI|CLX@$o~qMmVfv3u8NAcd$PMHySrps%x7$rHC`?9bCF*o{?~~AxyApC zVRsL=Hg#)L%RTjQPaf_m`365v3@Avxtp4Xl0KKDHLoO{lBpYxpiFtE2bg7!dvUB8WY2i1{$ z7wH7){M@~49KC5%bY~0ydgMCY&fpcD0d3{KF4{^Oh2j9);#AxI|E?zbT}D!XZtCda zAZy@d4|j32G1*}c*M%#{BNgNo6?ox!-8525)3Ctk% z;PoM$aaaiAgrKXU2#)w`x`-TNhQ!Sz;(6MrUOp;`7*)@28;zv=-NBXYcp+#n6e7VK zn>DTL)Q+;}7mxKyM>$?p&4V-EGaN-R*R3D3b;~Wyb#`kUC5>@%?~ zdd*-N=-rN*A^p`c@8|&sd(mPLu;bKXqOp%e7eWnQ#5j>{|D#s)M8Fwt)2mzmJV5IB4 zlytn68obp()A2dmMAU2hrnmoZC(zsuK^jO{y(g>*SOX)|r9@0TFC=OQN$GSvP$D!et*Ft--^`!4mAc=M14weu4J|ZqfI-~QX4aE?myw9 z0sLnDk)M)!2Obp5V8bJvD;zKA^ME5h9odM;7L18Kht3bZgb@(W@wv03IUIt*ICoI| zceexOT@+^%?nyRFl(Z_eNYlE)_w6SZUcBc#!-fPXmR1HRjwzc?^DaW2cg`uJ;-qqj z7&IbhH==-3;dXJF3<5hr5|QN9jK~8~@lVHn740~1r0XB8V+Cf&B?elTf{c;kNvtvU zvY)HjBj3S_aLbRrBmF@m{V`V#M*JtR{uMb82%4~+m?YXnBO6Ge7qyso9sGCXc=9wn zgf%@By-+Nw-!0v?s${UH)WxlBsHAViYuUx?+rx)9I&RscjPJqX`~2_&<#_XoAhYtn z0%kXCM*4mK5jnIFIf{y%I8WI7@5o7)h#gmr711S#nh}oOOtg(ERR!>4aI)cCr(rRU4%>`zal~`m&9w~r(hT~DvxB;j$%3z z){JCG4dq1Sz>L}v4Y06Q%_&l7r=|o1!Qaw>pO%D@oi@ZN4vl(K9mlJ(Q6!p!(Efr9G`xAq%P+cvP{$i!iv%~5*w!d82&uRjVccY6c9tf1oLCX*uWSM{;QL!{T=r*DfYu+D| zSukHE+42SmLJm>fVb$_5%faJ-kXlS;4YF1G4b6u>p2^9!vlZ~IvO^( zn>8|orS^oV(m@QuGdxC|lJ#&OPRu+!+Zf3p?0pek4sW6jm*RIQ)Q%WNMRx|0@ z99rm{Y@Q2f8Ix83nQK)|$;;%TfxW6`>ZaspZp>A zV4}eabC=58L?=K<#@sKP{^aeV{Jj@fNRx2^ydk_FRIZzVtP?^HX@oH2(`hM$7Pgv^ zn08%9POny!B(qj4N<807PYZ#-wrVnom9?V~hFgDw&nNc(2^9eZP%1Qgk3^Q zBEmV*x?(w?z-57fdd{VjXbJ-x+RY*4Fnx-Qs2PpL3 zCxIO^90`j+%w~rH_hg(wqa?%tN)QMD9}v+*9Qv_01|un!lSoS)y*RWC;LRwOL&Z1& zDJPh6N_%OdK5CvvF!e`L{ zRWytUhXFV2&V|MOYmW28%r3M5pk{WTBVN+lffiE+m_r-^Ad}b`iGdOGZUMIg#xO2W z$`JwQ-8mu`kg-$V5ivAG0@Kh4J5b#jF$>eowezs>?pj(c2p~#N%fceFqFK#HU6jV^ z=r1`mqM;Br2=e^sw1A*C!s|(4i5J4+yf|%S4`A-0bY9}m3)J)X5s^7OMi}Q=l1;Rs zL8>hp`M!{7f|huAr`xNr%&!%kDB((zO`z(ii;bHK-!jbiK zJaHkR+-^6<*$rO3V?Lps!?Ak+rh^0_h`~)B7iRhjnake zheAa6MMg$mi_LmJK`(mNE-d@Q{cU;c@dmN+IZeoRTO?U=lhq6$(OsfbjTRg_misw&MD+OWo7D=A~V zJF7!ys$#zX0eukaackz2*bce8p6wso-x^*Ad>z%?*6LZ>{=JPd*P4&FJId<^&fgu2 zUc&N8w>{p;|DLB5C|&Dm!YWjKS`L8ScOdDXOWdd!TpYrgz+xx~O^c6O6z4)}zm7)v z?-_FQMc3h38H39#i7jcfS8XT4qDD-NbtJ5o9V^Tw%(W-RJx~+F%=Bf36SkYWTmBqI zY$q&@eS#ftPr&YAleXu%7InMz7 zyyPKLTeUhG|GH-JoAdnm)bS?!RoVS>p`=@ldbB@sseh7w#V!T3X7Me1LZv1ro589- zy&)GW2e;mwNML_8@8+pDSR>>$^?8Y19p|X?e5HTogWK|mp8eU{YY)Wz)DArzigbON z0YSkb&@4OuGxWtwT5>U4YY&7bkK42lzpH+)+oS%%Grz1}saGZFgxjnLM zUD@khoUAIXR-G49n=W;7?C#a<&->-v`+N_$<4%te6IU2KUx_ZRF9v;URAm`aGjP9q zpn&mn#H*QO*c;}!{dPG&xmE=56p70>p1Wpc3j32J%5cf<57|FauGEwXr)0dXGc-ux zPrTmyvZ#==zCzRSgTGN-gvz0@OS$nYd73}0hhWF3dT)|i?;ZjG&p7>>o5>->@X?hi z^}I5_JFFy^7!GZpn26si+p4Y|zXQH?@U;Z~QCc3^-ycxi%X_NlX#yK#VZhUmnUV6| zq~l_#hW*z`Kg&%z$QVNrd`o@<&pKKXd7L-5*{G+#UrnT*sbBqB0wwt1(emqin_ip>sYM90Y6oMEmGV#s%EZkuN3*4gLq`0L3RTzREl-p9S4 zP$07;hEq{&((DlQ)g!nLSwg2_jxElgb!+6>b~#F+Kf%I)ay$Jg>7M~Q#^C*pPiIw*@nc<_ItugRG#dGGeN&l zKpP4f^i)_0DlGqLOFFr+I(Vf*t!nOjOdmld!1k3&yz3h3YiKv|qgyA-z-MlApV5-Z zNaf%9Qw1m2_7AtdT*bUBEuLR?2<$cy&8~J4a+fQ1?d@z`t~Rl~bI_~2LdW$^!5m}J z5d+)a)f5+HS=}F&7L08lEgVaHfTZyFG4V%hZ^~~`N z8p)sed?Ob%HX~63Pks5ZGCEi7_1EDC4inad3dTJggRGZoAF{6auT(qw4~Lh8u4#}S z>?bT+n*K`MQu;mmNhR`ljU+N-;@*g%RiFFSpmTH8I&)?ztUtf~Vh%DDt;*ayk=hh5 zHEVrfVeF{D$INf8b`J~dSPHc!RrYmR<3o#_Om5pf`9|*-C3>5V2^!tRZhHPyE&B3h zppcJ_B3X%!1&L{$AX~IVat?R8q-OrHx-EEM+pM8$a{IV_nb%9{quTmt~ZJI zDCwdxV@pGotPELMA_o%j19Xgq{d0>SkF&LtP%XuaPJ^e?q+6Ozj~DpNsdrfNM?Bnu zHLTOVq6DNFY!?(z0KYRl+Joh;gXP2hccohf25280dL+Pi1^q0ERegf!L-3Wyb?|uF z%*`~6zCeU#wqyX}+tgF=5b`$pmN_XUro&CP+|8oIhsLLD6) zZp3`VX^+#@o_j>ma?d&+#T>MMLpLi*V!83>aU!~kP;_42`HF%0@2X?g9z6|xud}%q z4=leE<@xfVev3{++5x92sO+FI^v8)79qT zQFv$1!BaOgWEyin20G2Cz)ghtDM#MI>pG!vlZ6uSLDqkLzE4V7xi9g=*p^GBf%9KOBs6PwLVp9-z`w~zPcg4KES))7xIEi%cDWZ&3`yB}OmbRakR8;ZbJrZPR~zbOmROMFRa z`y~U3q#qA?lxsXEB6Y2M`K-@I1Ep4(O>lG-USz;?v6e3`!JFHyl0G{bQr_c{p6Gtd zFA!^jHSz7y)DbLD&$%&ST{HFWv5v?ef4qj>F>O2}^j4ku)kE!T&z$s>>KjgF1zooD zaof0}{%$}@aM0bm#h-WjG1>jgt&7tx3+BIscvx;LD23eVuAm!ge9keGLf!1LSV)jb zo3bk5ekEM;`Frr6n#9#qWa~MrsDQN73qwA|xL1stU(N5Q6E{{To45zdzx?@4C(RH~9|CP;oga-I7Hs&2wcx0} z5i#E*vH7LpdbRJmoC&Uyw`e~}UG~26rxf8JZZ;P|L&v>Px&V{P>P88pK~(Q%SB87H zuTb%)?Zwwmnn0Nq(#QMD^S8guDFZ^+=L!4lWhA50pTd0*qhb~`RF9ri@1ssE`E|VN zK77hMr(z*@zu)`m8KJwCa!vlj31;o(&&Vo}9^XDtuwQK!@DMq?TJ(dR+1&d#D(Jk4 z;OZ;-QIAGEa6dKPrc;9w{YjvQ7?**JmkHDL7vDO~Kl-7>%Xs&_ zTU<-6CAR9eqN)d;*X&8H<-&;U(v$W>#$1Mu;CL>?bbWLFLA7(sH_5Zqtot+ifl&*m zvd;+BTdhg-~ZKPagqP}Q2l3_<5i_@ zHczV^4yKdDe~Jwga0+)asJ(RREQW6M(CBmJQH+$6KG|TEswqYMOFF7;5eHUC4Qr%gRT;(Fub!Da1nYH5X)Yh1CD_iO9%e{e`S%4@(kLGnWokJUxBu;WLBGpL0?^O9U35KW z=<9;?aI-hvVUN^7N}s?;pO8KwgA_CL^m4oC>*VL;<&UQEhV9v1iq<%73WJ!z3`P%0 z4IYRC;y5A57KLU{bk;$WNx5QIQb^jg5%ol53MrBbcZkAt{M8|49eE*$0SXpliFq)q zvE+BgKp+%VYneTysUDULN!g=tt&OSou zHXL+!5Wby4g&DrA;tz8|Sfx9Wp?cEu`H2P!^A8`yC@hFo4`}R_svg4WVMa|I%APP< zU-#?7&Sm`BvFzx91bfk7_fA)#QPCZrY5qf^P#U5V%&L>aC~ z8ga`F%4iy!=o7#dU~LxYG#(f*9vEbv5^h-^WL_U``7+#kBis&t`_J|xXljGjc2q~g zpd4Xr@(eof$ick#*gX2M+og1nBh4g8mV_hdga9wvUwVvHolHFBoJC6XL zGSGGd<+!C4{IBM0p6vAhH#OHzaYzl=^0^Ph{c&IlnnnKmb!!JN zKoOx#=VbR_W|=s<9kT=jw(wl$(`>tvzylGvACPGSX{)_h_Oy>VMLg-l&mv9IMH`Az z(sw-Q(Z@dne2MN#rRJm#r1|yfu%(fAM_0JgnJ7g=V2*z-gS~^_4m{^Jl*UvvaUQHS zA4r>h*uVouk)(9dng)|yet*KE$R?xj8Fm`1hk+HQ+b9 zm++3v5M)pcqdkvMfl#8Le=K`q4yF^GFBlzj7FQH{4$m)2_7B<790@^ToI5D~tJ{I{ zE{gLL?uvJbJ?fF}mZWv1ZG8%h6>XfS*)Rabl5zmW(KWMKeq~r~BDrSFLV`@fY zhyqSUI>xCp^6v!6?G)cGbRmd}e>(0fs(=5X!GE;=ZwMnU5zq#urHo~i2_^)yKu`1g z0k7-AtzQOAjR#GQM_)K_`#*v8ugHNw(1h*8B*{Js^E@NeK!au1!GA@L56|;>#EW>8 zZWT&@NV0cD)^JsJkXzG8R^OP{dXP6@n9s>r-g;QhX_(+N8t61p>ttCMWM2Dc!0d+2 z)Of%@B8L_tN3bz7+6fGQM^27d%==R@!a4~k^Ms>Ul3gOxic+)Yi}G0iBXV5t7N*=S zjJP`&5hE6v>=v0;+>qzdRkqmp|F(Zcj+QS9G!QwOzNmjh&QlEHG>E1uN&VGb9hC=x zLH#uk{L=vt^fZo5cPEb+;iX3La-(=Df{F5fj~GB5mDL}X1%^$6AbtoE22Kv+yz3jM z;iY_@88eI8lZ$1{ZHI>ya>}q__Z{(%Qx{dPPr$aZt-iyH@t)BOjTSi>gWT6zV5Rf% z6f;PB43H571!Fof?Qq{dofkQ0`YPlD^- z&CKU=h@^l;5EJS7Rtdb4T3q}4a@QH>Ghy#IF0l8XaJzvjXBxX1x$&#rMbE1 zJuFTWD=sc7uJtS~qgdvBD$XnJs&XkVEA6T(FDdg_1k|#J#Z{8U#gZjerJKc)i?t7n z8!25?73pOqi?v_&wn;8FUMwyvE2&zdQ5z|X9X^YVC$1Nuy9-Jd8jBhmy%rmNdTKop z4~iF>#k*T8x~je`HXg4I5HcbJydhc7m;pUJFI>v9+z7AoRBWMab^!)MKd}AYhz79i zk(U6N>sXagwL29F!Nwk$NY8VlMtdpFkPFkBE@R~XqV>uq3SG>?D z-rWoYVJ17g5ltr$*01FOA+w6IH^`xLgQcJNy2EEvVP-wxK{*@C^H_il7!4cTU23^P z5_G|*U=X9w9FH-lI2Gy7iC;kGn_w7){0wkZ1nC^kU5GRy-hniU(do=c_F_$!kCsr1W*e@gV`EYJhq#+CUqK*-ZsQnI{(sTKaeL5`UY8nBsn#;*&*T9kU zd3147rab`24~EpWi}JaQb&6^LD{?-cE)G-6W9fw%Lx2_eT$VcM4jyAqsg5+^4kTdp zf+l=N#>W&AV3iu0fWuLe67W44i8NNBF*qG`Z30dY>v{ zL#o5VQm-a}(_-(=t|&F8M0ZLD5H3Q7>*6YF_=sMZ*@HMY3Qc$smCrH;2sb9m6^yyl z2$r78V`+Xk%Gd}#8W0>jpNytm`|_9O_U=+0WA+r9aPi8d1R#9&l|>YmG-MB0CE%mL z3QLcMf@F6ep%R-8qn2P<0StEYiR6MEE{MQZx6Xf$;U%Pd0X(-oJZniA1ypoJ8uJ9fgBQ9qIj zW8G)Y0-XU-+<^pnhmoHQ4;_H#^EhxGA;W=R$UF|fws1do4RL;lK6Np4*g2dyI-C=y zBSHoRE-M1ma~=bv^9Zn^-8^E;X3vJXjr2E>7T+JHhZ8Nj1uRMl08k)Pdo0{3)i2eU zDdA(%x*`Ay&Xo2P3sAu>fekI~f^a7glqHq>*S;rkEf|0W?Tu0Jj~0fSp6ox(vUVzYCMUM=bw`5=EfS+HVTp)*WyG=H06NEZ5Gh zgU6pmddlwYKWg^BtM~slvLsRf^AySei(31?r9uWOa!0=jRx=m5lyndrTXFV;v(c^TIv|Fz)1n#Od{klygQJhz)Y?l zp^18_u8k&-S=^HXA%_FE_EB=T@!%2aOZ!qx{tzC-C)}YF1ds(0Y@H~Dt{JnBssZ)~ z8Dh--p4^zlUg(|IMJQOi!sm8U{-f5xcRRio0>!q*jiy^ z0XOW43wu zm6A+xV(}qEzNIyRJ>W!%WQI;~3d!73gYm#SfuJx3G?Y{EbO2+;!0>@fnw5?9d6?gj z8$HAs*2xwhah{EfyZBa~y#jRJ%C?g!m@PWG`rh78(ogqTPX-{vkPJc*R2WZOa45Ie z<@fsx>z}bGXp-4?55O=;5P}l+A&(qM!^W`3a>Q}Q?@!=LQ_aAKv25ya>=h|4N$L)-K} z|Bw)uK#PmZ%E-#fEs2VWphP8Qj~|zkk(QT{mX?wK@#UvYb>J56^ey^7;x00`)U+Py{RaO06Kl&z>9~Dx*!T`rZ?dzjmJ)eCZ zdp3`L=kip_N^N@V-DettO$opM_CRH0`?_b#uaAOsbzbyt3Jx7qswU@Emp6`W42RA= zm5A(|=lg22uyxrt>rO_SeP&K^vAtVirue9xhwhXGYHq(dA|bbO zy~5_jSJ<avIHMH8;tRC@n-W3SJ?bVvAyguOR)@)_6Rvp3%rjwfG^ zE02+2p&pECg|Bf}myTv}tdA>Z3S-WOEjkWTp$?9RbnBK&xzdV-m z{K?n7t*zf*C6qmi?n}+Tw-sv6|I&Ie`N4g= z#q*{LKXQ|aW2)}A3@1bItaM+G-r)@Se(6HP!+2ZrD{d^-BBXP2{eX+v#&?(URfoEp zQ(aFx8*SvEbBRmnKDpl4{#K(5P|9^L*6h5uX$s#iaM+@3`_3kGdzgJ`UpN-1CsYz7 zn3U{=8LbOtMC~aw6%bUNo7x9s6A_G+eYKtLE1HEdFb$| zCiv$JlUb2N4q~P^2tSbc^;FD90WvRf?BrPYM%B;XO${=x-nuF+3Tq3qBgp~=`&4^t z8-~;jg;ausLz<^Det2E@IaeCY08755VsOYQt55k_ydkgK?DQ;gXj%>C?qkbst~cj~n>3e!g${?$USr%ksl*SASFT zmb2$e3DmH(V@aG8;cnBq6)6fDXF$5PMA@1ivC!=fx*Q;xw&$gr&y8G_BAGmsVNbmV zg~j7G3XN`${t&F7aGzF8h1t1wdfKjU)yP-SuWL2h`YN&7Qi!Irlm5sEU05vi9><|X zjDRy#Qlgea)VGdmv90hY*6nX7(6@mbB>+yAoX$UD@w-ZXT+Ny z&mSTe1&S|TQ?JN7C~MQLa}9#hl&!kvEN4|GM~dvN>yKJKrw`wPPs6!y@TR-=-{*31 z+H+b_$)+1E072i-4E1ML$A-0QO{lIs(J_JApKf9zyb9M;#;=J~=PiFetY^{9Pj3L( zl7e+pH+lEBpE4|Wc@R}-eAz|sv3jTKz4~fbNrTgskBSaTT3iyp76v_4TB8#l{P^C2 z>r?wiw6iE$A?9k(dd2IKqmMmXNgk^YzV945L{^S{l1f75mNTJWrPHb*q!iHy#7mmp#yT%Zts7S(m`$9WIq5f+~zQxGH?(u<@B_kLcb%zKxu%`0<%v(P;*C!6NFpVsuEc zN8)wylgE?enaCd&r5@gJQr!w+d=q+J=zRDk<{|sn5lQTs;fKrzcm(1z^f3_!qVdJP zVhofN-fmKVrCEj6xgO{i?~j&?;S^~$9mj7b}ldnNJS5}isd zdf_jjs4!!gPOXckDJf=b?ZR*OhD|NpfJdGZN9qJL!gAr@({o8f4r7x|!Gim}uKlr) z8h8HA89#h%r(}Wao&5zr$I}d6pwH|v{xA{TmBl;d&*;x3jU}#KMlXMxDcKrKu`=9D z(u0@3-p7%@XB^3gY&+3>jqU`OHkW(R_cPTm*Nv{RR(Btt8XMT+wb!CU9c)SXe72e; zXu;1AI`+;Z$6O$Ri}!2~;?nAEyw+3=MQBQNIFODO&{7`e<5 znCb18Id!8+6-B9Qsc8wgsZ9GrUss8whnN&M=q9PuUmCB^Vdh;Xx8{wvf4Ob1e0K;? zP|q}dBwkZIS?rs5l!$<;dHX%oI_=dZ`o8o93v|FYcxD2eQGEx7VsB_Vu4Q8y$K|%3 zDsCFI%4dFA(SQ(K*@~S?d|%Gp`~nS4>kCj=vT9%X7NUEa4tZ;1nc)PA_gA1-c77Y8Jbu~W?QHb6VW$r6cnLv zFkV0ARtAFxJUEUyrOi`ja-RhZrWvk;${n7%)K|9>7=wEI+u~Z#)$+QYtmT`cTjf>| z;$TqM?L@U_Q%v>oYoA}UX?-l%lo+#PSkxPH>l;<|-I{5rTRoq=daoe)+Cre=j|N7Q zV^2D0Nd_d0DSc7);}emo=0Nkq#98K&x$pNU`?JUKH=e?sh0EKOy{|;A{F3rB5m)X4 zAK)K}Pj-&4Za>DR_lO<}I?}SW++xSOZqzXPq0FWwgna0U!*idlcCRl}ucG=QZopn? zPLkAFSfF6Dh?Kee*>{_K9IJYnI`V(vx=w*}Qml93{cz(w8(w%T4%XUzhgF(yDpq{- zU9emANRa81BJvNtDQ$a2hme(Z!N`p*Pusn*@|>(RsFZq5ndMn~)2}ff9>gmZ(MEr; z@yXfGRymbRJry1y!;-D9-xapg4V55I^VW>qYN(7|;OOHQX&%&ace=20WlNzlF zHQwKVEV%d6dgGDC^$*h1Yt|;`B+Q0x9QksW?lxx5By#ohkqgrDpCzKUEyC=U-y7hF z%kmM9EOoZ~AD@*tvQ^8+@Dmow9}NYWOE)%&GiN1yy%rR>*DoLe2Ybsq$zWN>gCm zwk8?VAu{s*ZL#7_C%u-ucf5=J(BrQ)6)cDH1EJ1StC@SBJo_dfdZ!nfs1EY0Ek?>@#JgVZ== za+Z^!2Nw)z=kCYk`1pHvHj2{2AGp>xJYobo-(G(Ou@Eo?*^dOE>ZK3AN{B8+{70cP zX@>oi*;_+VNBqtY;mZn95Y$<(BDifB1`g*3er~m0)PjtCYX7icUx{97-@Fx;kif)r zj(+dG3)!w~Y!FX&@4*;``m7QghNsrQ${$}$eJ|}Kc)q{CUp6~OPhbDZS*3S3yi!*j zbM%xaTeMExIyqtacujBdO2tQMIXMy4d%r*|svi^V8o7F`_HegyypL=7^_z?bvfiuT zn6~M^%*%fs%YHI2uWMhk)8wy*-c~SyhsB-XyA}9P-0TWuL?`Cx-LBz5jj!& MmXYg12c7@_00>7cfB*mh literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..1101d205dff3a4d463ef0ee56ca39c7ebfd22558 GIT binary patch literal 6175 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 cHCW7_{r&8bpCHNF?P_RSAZi5!*-b(^b literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-e.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/hurt-e.ogg new file mode 100644 index 0000000000000000000000000000000000000000..8de52c2d249516c2793f5eff552eecc7a72fe0c6 GIT binary patch literal 5883 zcmai12|SeR_kSm{4h@DziLu3qGPW9VNhyX&h7l&oFtTSam76k(k{CnQvdoBKlnF_D z82dK%Hd-vD(xpY)?f=Z^-rN8F|DWIQ{XFx0&ikC_Ip;a&e9xKlI_=-@0xg4nKBA;0 zLR!O76Q&A_JrGF=j1nxtwpIPyau6mY8emR>lYc*glLF4u4EuM8%|HIv(=M_kXdU3Y z2Zjf%cZ%GP4hf{V3B{xB(MEwT59-0~N9m+R7U2SSZn}gPKkYn$lf3_7t#4RaZCP+w4@O%;#$!1I{98{4|L5=h{Q@!B0r9f^$@iH-NjNg_AIdo(1GN0YohCHbIE{v3<(KygAyc+(|v?)NdRI|#S&ZLOPaujI9*=Q`hOX{f2cUiYlG2mWZ+_KNpdCajt%uV zAM@~9lGkX=_(=Tt$XV}|C;ttszcU8{NkbFnB!iNQZ7oRLX(PE5;J-2_0@<3O(w?E^ zz||t~^}FXyoEA*_6>ObN2ri0V{faRIN>mp!uK`o)0Es#jOC77HlCQ;k)c;JFrL-9z ziTNdS1Sz6{OM7ld7yT!5igeSSZA#O$r)zo8*T!YB$CbW^eeQ}Wo?OF}xTXB+?P_&alUL~4NnGRHPj>zB;Ai&fbQvWcrtSXi>rvL84! z+IHoy0f3;p>2L>O9dRZa3=vI-hz2BA%m17)fIDPD7%%~j&4M6h2+{;WrXfy8rrU&B zx=UcEw3Zj+#EP3yv`YwMI8H_*I(>_dWdj}81YejS>MCw?OgyW-F%2zqzif~Fa__91j2h)l7cNsku;D^Ak~HTno!4FNspCCL-o{$O26;Uju|&5 zc!1Yoz>OKnj`to8^~(7vihvY~G9!)Dn>t66oJmvewfehtlulk))>|T@k-TsJT;FsP)Qou|uY zSFr0t+0`6!$qc)M-ND_@uCD6fUaqVTnFZYHayD0=&DO8vR()mb&(@c-8#x`^EBV!x zv-NY*P5QHq;q2<_O73d`w~;f;i)8=Mjkm^!hY4L*LfQ#!am|1 zP`P2K;`PuBFbcUG>3H9^Pm;aC4|x$^&7XgaDZLDrY&{3C0TWnJVXtFq&ri_1H_YY6T1+YPyIiYlCMokq&qRw=MwW zQvMdZ3Z}e^eMKD*#bPQs;IZ{cau{}41)N~YlkG7)q)Vs)FHe()2BO*p%7r>6a~MEW zZXz9z=VZ}|T?Lr}QHg1IdrUnY?+9*%$JZngJwvd=1;h|ja4R5+jt?>5d6FILVi2Cv z!dr3b+=7ERJfK{gg>t~x)F}mrVW(E%133ca6)j5SG@#ri*tBdoNWdV6S`Oz$;W@*D z#Iu0m8+vOf@5tO=mQ#WZc*7KqK)GH`79A*`df=IgWAG_J6rGp~PLM;cmt_Y5Mjr7@ z-PD7q5Yvx?o>c-J4&Wam>fH4YZlLNUh(Oi}lGGwW2@$02mSkd&eIO#T3#TV((}mNi zh;+2UU`SnCB(&>#a2QO>Fit|7rR1Pz(Bc-1!2l}^K;I!uTQNdP3rtGJLlW8svY3Yk zbw^B@g-Yy0F_FFq4HgQ-g@yD5zC}gJ+UP0!_H5C`(01YVFi8l!y*3LpxKb*hp9|?@ zxT}B*E!B~Ia0(oI5*_Voq$fvn#OqWX2Oj0b04T6px;%q8wWHP&oTOnR2W)uE{Rm1IZbrofR7Mq=tRAl*QPxI65nKcOS9RgQgs=e& z(C-x|f{Df83m8QFOEg%+u%ZPF22l!v^uj?$bj8^(>O@8nsF};4I6=+CvP0I=eDZpCw2+=HvtS;Len(-8pTx~aTiJYWQO zUx%Pa%f+E9BCBo9bWoCdCVoOA641bnso0Z9%4zI$!Bz=OOAhF9%20yV1N_Mf`j1q= z0Ixj2z)h}lYaVK~#8OwjU0(R=8}hSB&slo?rDy-A zd;d=qIhX?=_v-{%-;olBeu%Gj+p!6=N?KoFBSIE5dQCat#$sz|CowZj8VFDERy5YS>S!Kxh;s2bg3hhYtSo-qI^ zhX=2eRMV40u%%^`QiWymi6B2wzEvQBJcGg2gAFis!<5uI;D1mdhAC%EhdrgCiLh`e z!R|`L$t>p8`~4HbSgV6(+eYYZ!G{46#G*)m7WHj-fGPn-)M+3LOKY_Bzt<4v(@W3- zfSO*~$Jk{fgqB1xSi`IVAk!66+JKT=YT$%mq{)L;jsYYutuf?*4q;#)dlVnZdPA9E9eCQL`4KuSaU|Jv_m7r)))C;<*Z5u-t~nBg{bO93t0 zftDVLpsbf8p2qE{q1q|8poSP&7Se?nJX1hPb#^NB#bcYQ7;bpoj1&CGs=C-N@I{H1 zfD94p#>cH;NK_k8L=(k8MOW_jVfToNzK}PPf=jj1qWFO#5Q5eQ&q#KM%PX*tmr%?h z_dWaC#1r6W&(@xio-w++-0M*cnuZotPi}!B(-RUE!VW!?aca0HX>QAsUHSlqL8=f$ zmqBZ24jM=6iupeR{-syo#`Pz z{G?7l0LE-LBlho;T+{oUoaR(D)i<#1i1SzT&dRtolN;|B)o!qTphInZkgFm7rM&Kx z>)V44YEMg6STqt&w06GlwwSZ{@qWiK?0pf3gnD*KK>(+2LhisWZ|$+ddoS-LRrY|TGaeE3EX0HwO>>sbpuns5c`qk_HkuC2C2Wwn9mmSG zwzh64o|@5=_;6tPy%TB>gxoX;y%UGh{m*e#3i~`Im5Nq;doAniR`z*uVep{(<+u^U zm>KE(V^;n!YlV!2Ac+ZazQvu-;RI3Wu1Nf?n(HgXtvug^{AeFZARb#ckdjC}>>GCR z@L`I^c-^CAm*B$3U+*!kZpBf8teZ#zorH57S`rHyiezKo@##)YPKi$O2 z>U+)3cj-6$KGH4}He)xY!k61CZsOoEQPpeDY*e-IIy=bv;1dih=sEr2@KOGjDh4`N z)mSb2Sp7W`BkZDtg#L{72Ibf_i5qvqz9>8D`L=$#hdWfVOYu)t+?AOd1py_PbW(=) z6Zgk$MJL7f9$Q(P-oQ9{KB2K;GrZ_Ho6XiTzf?zzYqJ}F5_dDd`cB~_x#O_A_q5uj z7te;U`Q~@55=y$~-h5azuC^eD|9E*wsh*K+c0SG1`C+7wPxuith1rN!^ERiqW8608 zR+?|%)0&TG)?7OHm|XPw_L1wYw~Urg-)Vx4JlJ{mRYul{6#ka=PNzJmU*HZ+1!1Nb)=E;hM?V@b(ZSyOCqr5@B0@Y*7`2~esve#c}UGNFk22ad_huG`}LdU zW~8vqYrR%Id1qYyhPQV#;96C3htg!#ROth>9z#UAjrGBH%xMSu6MYw=}PzxkE7SH_+1MsVhzFz301 zmkJ51liz-6I=!>i*m-8V)z{VLd=cg`v6`x?N#)A#Haj{{YO03vejjF*5$^}#KgOq<|xT)K1P=E*#&;; z{=8*PG*|cadb4Va0dbwll5?-6ucBg!a$W0ozu%bxJArIN9`h*Lvv;y*K_+ldWwQT> z3!dX9KC$<*L-Ah6^*3ss&lP;@MyW*=vfqyVNon3GCn-9o{O*W2+9mQ%p3Yb2mz!DK z&GjRBWu22ofj*k;dsk+CyhX#PTyBsLv zeU5atp7-idlgqqy_iVn+{7Fh*;2ypv*YlA4!K(9O-U~6eg|Y8$U)N1Mns+1*R6u(X ziXkkK%W_@H7oUGvHT%7uc(G&G)uT@&Rw`OdNYycNIOb-EF?t;ADIM zT4`$CAC`0Fsh+*n6sc%M{6H(|{*JXZ@bWva0$O>u5`BJau-l_5vORC|+sE5kYLfw) zq2GzQrZFMIk7^B#!Vzr%Oxv!&3-sjFwYHZ7bLtWnO-&DJKsxmR{i5L0wju=eJ(MHrhd=+<~ zHRJgA@NrjZ7lN%3a$S_gwYJQPkz1aAaVJ*4Zl_Ge(KI&9-}Eb2WybwkF@H#I^zt}m zI{fXCeAlB5LwTtY7QyT*b`AB9Ur6pfb9&F7-kw48%`jE}kU$wE6y8DK>sA@MOqUa5 z3z{F~A?}-3vv;oDKKx;5JaO+0)9K
    6cKyBbeDe=X4Jd|Y^FZfvvoWskL1O&>-g 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 Bn4|yz literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..2156626d467d79806cf7af6aca04c75471495246 GIT binary patch literal 6331 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-d.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-d.ogg new file mode 100644 index 0000000000000000000000000000000000000000..1438aea1e917804244e03af88e35a7e83159c3e3 GIT binary patch literal 6317 zcmai22|SeD_kSj`H8e38S>72-j3{HP(S{NRVHh%#l6{Y{M5U(J5{1_?NvLc?mZ7|s zv~OcKqRc3=l&D7O4XKF#ozc7e-~a#f`#qmK_j8|n?mg$8bH3+1=Z?LfpA)nS`uPZx zRt9TSZPj2Zu;?RH&wvR26l_oR&m~7;g24@#J%8t44}T}0GL~um39)VYe?9F&D~vV* z`u>10|4sH(KXh<_r;C6++8V8|htt>7*E2wC*@uJ%gi(DWd_p6!eBQ9tD_gPVyIo+A z7?{D?qFJ;j89*EYf;`l*QrW)NSO&dFD>j#I#UHWsQgZ1jERQw#9{`?i*&MbA2p;>91%ZSV>$t1k-*Wn(qOB;8g+z%Hg%m_#Iz z-+3lul2D*KqeN}PlowDXw67NaDxu$oj5xKcZ?22uAZ)yOqs2RFiw3rxYc$bWuL z3-AII!Cdmq38aY`WE>Wlg$CH7io|xqS0sT2$wlMnyeD}x-FT_IH-#0*{HG66obxrC zD{}J%9t>tHyav9+c3fl?UVM@l!M29yF;+&g()psyias!>Fj*kgqHq|j3+T%et$4m4 z>~(vRH*vKY2}UXOe9eYt=M{cGVNr3gfc*eJ26m*p$Pa23cL$?y-UT1K#rbpphL0)m z+u;FJ%cWn@ap@wSNK6?fTP5;0sq8{r8@5y>EqyPcBHn?hpvj2*RiHT38bzyXr@56W+B)h~01;K(USyKyg~b#N~(@yj2jRfkWQNpc4sL z#!5s1r=q-j^;QCb7EUVU9BgB>Jil52E` z+l8pXrbPFFs1a`52siDJeA2&x^;hITAZQW(lA}Y-m4Y*ehe)tCH^;FKs$=Lm=k0>1x(l>TX#ZVsrdb@+vM~epgW}@vq47KUeBsr3N+?+{n(LQeTBv($H4WK&N zJ(nes8cEORLP$ArW053xSD)weBsaN}6mH_!m$)$$pEI{V3Q!Mod=587jc5hr1q2pf zt<2M^tgNVP45_SPQi|VJ7FTxE`Bm0bchuEZ)dceZwdQJNola$?PE}p?LZuF`@oMEw zW=Gw%{F*9WacTtm^&Eikmk>c{jtm8bg#y zD&ODL?tFNyqi&jab8~$Z#*q~DlJ5T673dLi=;&q2d}3Y5wtLKl4#1%AE57H5QZv~0 zd#ECqYnj=&>+sfehF=~yX(cnivWiz1y75sp&)ks|=YHO2WQ)6-eCWuQbP6}Exbpo? z?asSE5N@dDh|(=RCHFyNK)6)LTodQjHZR^2G}scpVDkD)R7ovdy!AJL4HzFAG99Kx zn2oDwTVaq0W)kUy&}N|{5ybcCQfHh9CSo6fr9^ii1Y+pVv|G^5>DFxp+0q1mEWM8? zTEuW51QpRa#GvbC&pbb%OXUawy7WGBU`5L_a_TxSg#KiyH``jAQO_p;R+ELLQsx9k zDbj|Z>(T{)T+(M|RZ%MKWL?n!STRcFYzVkUBqbEbQ35+kr770f7Nk>%ZcCn83mUL$ z=L;9ec#}&9tS-i95eUrlS;Ve_Y(A^_bb>XuF^gaePDLPGPb89qahw8Tun{;FV3kD( z)@>nEY#X8w(}V;bwo&kLhn&7II)OwLK60E zX##Lh(QX1>O9P+;iv{oj5ltr(E=CZE+8T@;e(HEeCg=j*q8bbiF%U>G5o6Rp$xx#sq0l%FzMml{vaJkRd4V z=tMpufob>z0aOJeaSY#Fg2kAXz5H4bKvamIh1K4wmvpEG8;(5`a`0~>Kr}c6g%1Ss zu$(qDs~{oACLx20@Z7YHcouJY-N#CSh3co{7)U2#(AxsfR7d+uUIg5uYPt(SEA!Vr zYIQ?&7r0TP#UMQd#^AIm42fz3f)a$WP~o-vPjCl>g~z4!CEyaR2@!n(LJ%UM4W602 zA1*CZdAius1loVVqfL|sPfM#mx8|+>{nhS6QRoD;FeaG=LuSz8WkO?KN!s6dAZ}v8 zkXpF_!ypw1%92E@s^;O-rG8tRfyi8!C7mrp2k?cUQ5bD4L{nd#oSf{NUh?R*koq3) zgwn_3!WsfHzY`N%xvB^Y#)1p7uoM5*3m*OjnJ*^XLzN@7dDG~F2VIYv?vA`>va#@Z z?k&r}+U@$GFPknHdU$MT`am1w9iLLBY`=E>(w4=l1LLcHxSR}5>4-7iC<`I4EM)7? zZah-_IF0pU-pn*GOfmY+^)oK)(8o=@kh-!m*9+S|UdlG^x?7R(LfGV+^7=(&W=+-N zvEyZOUoa_3L-uQrP7mKXeiW57OB_d-I2>;7;F=_%XaylXMqOQt@QSNE15I{+n%-%%DG5l?a?;xXnYIXzsD3|)w$o-W5%`g;W5VagKL>Gxe+=` z>05K26(z^mOf6gxF)0*n_e;5F{3c4tu&=negz}erED657XhEknp_sr^Zk0-MQo(O&e~ywTmr8^FXhgY^GIfY-0!u zLFh*BiANVyPJCJVHuw7Z$L~J*z#ksAH4}=?YYb`^UnuI>JPeGO<8na`gZ!6eJ!Z|; z;_r_fIzX4pjLB}DnTe1cGPvAiDpKC5w#p%t>we$>+<7#?rRQCsbGG8uL1`$AarsKX zd#SGat8j(ld&~ie`>-1_M|Sqbbk9~x(b9y?>;j%eZ`~tYc<~mN(a2s68P|&pzt#0x zXO`hQIisydp4;`AmUjE)rnYUSRlM&PMW8HN$esefDx+MXHV9$iq6SWO+iu@NkMGpo zyF2cAQokJ~fT<_9&LCDXQWkl4Lh8at-<>&K?ldS2y;bp6mf^j8zVv#u)~_{~dh%5J z;@3~9tDsNuG%IqGZK<&h3s${+ad}y2{^az+Ed4Guu8D$)k?rNpsP<0L4v_$;>fWL)uV6xa+PBV; z%JslDdN;oC$Uk|i_gNkF=wo=3F{`Ia_jVq#y6&31|5E1S9WTOMOp ziCHok1Wuj;WD}gNHvQp?3TkQjQ~#~lBnjRH$`PLf!`tk;bn@$>?&heuS2urH3>|BH zx_@tu3cF|vxjER@?SipQXY0(#le*T%^E1qf_8rFvcRm*9wb}2f}l@CA&2wo)cg1i04c6A zF455GuF!+*0^?&mUJ(-36{~o3&0KW;``a#;i5q9vZZSwoc%{inVDGF~rUX`EeYldbY0m4I+ncj%x8Jq5=dO;8 z9d{w_dQW><@k2d-@cWSO?6G}Tsl>5bcb^K$uKct{#;<{2s;73go*U9v^XX89U6z+L zeq;04kSo-kj@oyI@`GOG4AVZK(V8JG2VEU_^*roW_C&`^o8_ScFTZYEK1Ho;`t~jM zqU~n;VfW#F#jPb-zY}AGFly^LGMvhVsr{})4XyJpDx$b6!Vm z&q2xdOBo^rzaS+lmm=G|{$tG!x7yRY|1jU!<*$0ny>s1g3%r>$?(t@3CcIkx?5>^n z4}0Vd)(cgRU$xoBG+GVebcMb|52`FiO+Gyx&)u{*GdKFW=gZ`lwW9XQ$Iz_q@1`+> zxBU7~brUxp#b4RXTiLA>B5Q$9AQ@ zEN^Xg+2|8n<6mNhA=4|5^WOlhRH_ z_EJ>H_U$EhhJP&F(>|V`uuge zmH>^zoMAeWN*Ql8CBiz8P*~5fSbX2I?=J;Wkqh3NFYHWL|Kl^2*Z3*78)Rb$B5dfU z&cp^QTGmj&Tk?<8i;)|1f5ZAb8f=ZDJE;!l^vja0zs$!Dr`59~Umx*e1lre{n=p(P)k+NIw^s!nt+ z-%|~88M|`$9c(WY5iH}($)g68TS;t9?in(+H}?IqRC~Pn$Rp~`_NLgt^Z8`^y0Xme zgMB;WE;>L^nBCmy^Wo$3O3kKqrF#Q1#S9x>#|)RZoq4r%IQil2@%2dV?Fxg=;JG6w z{}?=R!qL$@f4qD8Eh^L;nLan8SGh literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-e.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/jump-e.ogg new file mode 100644 index 0000000000000000000000000000000000000000..fc5c600d46c3b4720be3924bfea68bf65f95e9a2 GIT binary patch literal 4572 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 CL^?_U literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/lose-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..5fc7ae434c2d7ebf6504a128ffd619351d99ed99 GIT binary patch literal 14506 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-b.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-b.ogg new file mode 100644 index 0000000000000000000000000000000000000000..fdc8375d5497d60a91ef42c9a52bbe4b0b2ec803 GIT binary patch literal 5156 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 DIZS*c literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-c.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/move-c.ogg new file mode 100644 index 0000000000000000000000000000000000000000..a6f0da0c2c2c2a4445ec7f1c60b1b43a4eba61ec GIT binary patch literal 5665 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 literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/select-a.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/select-a.ogg new file mode 100644 index 0000000000000000000000000000000000000000..9bc26ecc6ae242827484df3116f186835804a9a9 GIT binary patch literal 5157 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 L_F0{GtkM4fEGOf_ literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-a.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-a.ogg new file mode 100644 index 0000000000000000000000000000000000000000..4f603aa5b4c1d1b5b742ad5af955207a6c92478d GIT binary patch literal 5753 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 E1JV<~F6lB%axLT1+EU68xva}%#VEHS zlTn1Qk*%ExxnwX@N~uWNtthtD<$vDM?)KmR|MUC3pEKuk-t(OEJm-0y@AJIR8Ta5| zPiPtR`B_0<8l+bS?n3FJ;tsGFA<@VbYD>-MC5KSbK{Lu7+4=W_>_jO07Y!oN>p%Uk zr%PsukqMytgdE)ejXNtCA0EQ+ma@k?;VsNb7UmY_mUx1DL}bW87BiX|83QA{QOlRM z!uFfJQIGu>TxyF*KxOr0S($L3a|z>eQ>^vXqGDOHL?RbmEg-ET${++-#=LmuJ~LCp6r)S2k-9 zQ(Z{I-hs7kasfx8`zTY~&z+)F4?H-Fy_|Ls+Fk)+p9)tNumGziweV0PP!rmggK?_E z+^WO%4j8)6ntEth4OlvOdb!fU6C1E2jyVz+I}(@RTafJEoZ#D>>_3_uu#mhLoASB+ zkubi1G^y%%6jWkB$$t!&>8~!Epp?n5Q)-q$L5NB4in;o5Zn;zCzR=o`qNe>9nj&u1 zo8GEdkuCu~l|@bim4p;l{-3tbH=p_6o8A6SB4h__c{2)kGs@6`W_XijDlfHgCj@+I zM>7?&$lIdHH={Rzwk>8$7ssXdjmyfvoPf9;g6v2*VHBh0%RZDuukIQM`JQyr5bP=Cr4{sv_;ZU|oo~ zP`>((57_H_yKwS+3kHnRI7P;dEnZ9fKEtAV7q{;h$|JBN?QT(6i(&v6y$j<0-m8er z{Tn`Zz;Am;v7+J=_=GGu21c(^FHbk-N7cL%QYT!Yo0+whTAj3=rftlNIU&^?4?%3S z6vcmaQYbH>xFYuyv72zY$KsYL($(DPvzfVc1HD;=1W;^h1yG#XIC(a@mf{%3Yn1qz z@HjLo%v*{m;8c82_9i)PX^^B8u)5(Y5EWlK?v-J`+M0ncTK{XDhq@7H0~ThUmbP>+ z`i{5=-=AXdT}ciYjU69J7$3>py(;D3!1_CKAP_WcX-sk$8Kj%sBsY7-B?tc%IZ>FK zIk>JIL+5%!SFvgDEZKdIJfPv=L3Z`j3>eUi9n@laS_ceTF$d|);W*}Le`N3(0)o0F5SC=XMD{}Uq zswy~Dm3nF_HH(mzACgwcZz&7!uAOQ9ukG*1*~T&i4MdIu%kYcH=^)`YgJ`NZb)8$% z(RKhBG{#}omkxlSj%*cYX&&*QnGMsdhG}MWFWdhdF@QQub{!-G!=8p9Z3r>|PG+M| zv9j$WZG99-lZMMnDRQO1V%b$_OBKor{g~`c#~4}= zaS|Hl;XM1`n>cpQrl;Jb+nWdwgzrFspFM#b5uYr9mI|qTkbUr8gP5YPh<-@uF)u&^76U`L6WFh<-Bjju-vD7Jayhc~9%; zj{MkhOIKg;Dgo5kk^F?+l8AtU&#YWAQdZXVktQpT7`g|Y>FY)Jjbr*Q(051@oB`F- z^^PW;-bBCiHiDj?@F<2Ju!DJLf$pny)PE%T(R{)qEW&wYI2KU%N|<}E#Eug}3PVE6 z&hrZie10{*DS}@s@GpDDFXMOD2lH!dy6Z1qs12V1)Y|j>dQ(2%^g?~jBHwhT={&zx z&|QD2sP@84(@W(WrZcSv`L(qd>R%w#R>6!YYNplvNF{u$^1}1h>eklCnbxSDrU+a) z|9Ly{*7Zx>^)F{yzio)s^PtDx=L9_70rZI2edw(JLUMh?`fGy4ZookN2c`c2t_5tn z9H|55L~|w^_pZz01s8&o@&!fw3p4eRCO2wk>^c~3itt`pPMzF5b?SbYBc{oh z^0rgMN;wi*SY721<2QVT7B$3-BlZie77h7js0E@erYeH^oD_Kt2m!E~DydMlr}8Q= z&Qvq+9suNW@g~RW3UyDX>PEndSE1!hB{gCEBS{h**ioVG?*xl5o)KoELIV*Vuu2Cm6Szwf}3)wF5pyDYF#qTFPtRd(!#C4sQ{~7YPgxm z&)=mn7VW1jJ(Zx*J1kTn0>X`WSZ8WoqgGfXX>v6+M1Tmd7Haut0pXruR+W-agy0`x zD=Cbo3M50cOh5>XXd5m({PHi&8KGt(2}6JgC)SX~ zRJ8A*7+14g>|vPRvq{0Iv5x}7LJ38|h^OUDG!uG_$oqM zKopDcAn(X&^RP*`u@#s=v_20D{KCTo0^4GvRqct|fqk0@Fnc?d2q&YdPDVUX;40xj zJr{nPvk`#8 zKEbaAexQPV0S@#+nn#SFYg3*i~$}=1pWJVlYl_=sSsoE=Of@6ShRSyMp zXnQ~a^VxCRwBR6RDsYZtX7XFVboZS01!7$7KTv) zA*{Crg2tB1LziT99ITD8ibQgdREb19Fk=QO1;aQ+n&NI&fQ1F1#;L?2r3d)PBK1cG zAb?j9AW)`oNXL!N`lm4YXQcT5C{YdSEH!WNwH9G@6qc&;t?JU(!0^vSdco4`7d87o z)%$-M`G*MrZwCBc6m73Z&R5@EV2?QKOq2VV=Y<-3){r z6}&PstWs!TiExxrL#hzdKzw2YYd`?`g@L1onZb<`Mn)sBKgbXgM!J>6PZ@d`c@Ro; zycCsky5jQnfrnCG>w#k1UTSURVn74FC_&Jow}lE&g5j3Is)shR(o}PP~xI&Ua>K zv(Suh)M%$D+v=E(+CuCwhs48p(!!o`85th##er1PjT(+Om5_5n%&KXO>j5`PyaHs7 z*0Vfrhr(bxfgrXl43%8!xJ}wAEBi#ohmu0J}T-O{NrT|8^~wp zo=*8hmCVeBbmeCj9m@m8V)1OetX`@Rg~?7#(un+iVugG2FN!t}Jk_NOFbdLzpxhOB zef>g8mg>pWC#aD7Tqyn9x>E-(@>5;K=*=M(JF8==|-1)5a-?6PGZS zv}{iuccu{^@a}HN_YK6y&1ehTA~(M^ZkZ3>ymuLAube0=I@C;A!?&^hQ|+Q4Xi$H< zPB`lp><&SuJRdvW$=>)X6Ccm{K~b`iN^j@+V7bbjZi}9&S`S`0ZrTt{82b5uzwTAq zrw1h*2R9>|L~+sVrW{}*wzi+GOp?0?!{j9 zH^#j-7iZ?KxtTwxS~_usXF4!~S1s!KCg{3#K-{B8dmA(_Zr@rt(RA%jJwff63yRB1 zKdlDK?7=8jaCYx~&{Izkzpzre{O)4TK*D^ULATD_I{P8Q;Z=GEpc)o%JqjZG-{3hO zp;|6%SWnzRTyJu2jU57ng6i>enW6grHu@L4zy(qho8QZoD}+ zV&iSR&5z!mQfFnSqTF^kzu0w`#YizcMu4o6G6Vd%M1PgE4jbT}I!P zW$3-nt~mL}eE-t9Aa<3u!v2=@k6v0WAD1%@K4N-fjwX0=S|1#=k>9*^+Wy-uFUf>0 z2fNjZbc36szu7cLa-RynT-|jfw5^&Q9iQIZBV)LBkW7jAz9Hru-a0huZi@Y`>J`!3Qh2f%IxanA72B-K8rRzN`HB{N#5p+M3@# zJ$dVvaQ@x%b-LEN34iSHm>Ir4W-MtZZVu*N)#6~Hc6Q)st6L;WFKUFO-{5>=yRc#0 zE9%@EOu5#Mo%>?q@70u7e;pd~zEbn@SHG{~9E`hTH6zdHPH9p&8pzpZz*-h}0oC=2 zy&+Oj!*p!_6NQO*&BKJ539Vha&PTE}2bT|Ajpba)wkiDK+Xta)in6;}W~aj1sLw3( zHdN_+xSlAxcKVKyX!!ZglT_S;yUxexMvWn5ll-yNnxfiV=&WLpoy-Sl?Zfan{ykYc z`sw@&M51JM@f>OH`MH*J?GNT(&$I-83fFnrUmINX*=d-(fDg}?1=e${s|y?k+%`<#yuK< zy)LMVHw}G0Z1GlH85vPOmiHlEf8)y8xztaTJ%05@U)`Avmhx&fzPc^C@n_fF!Gfb} z&Ufq{o!v-(lX2$M*@1u$gNr+kU1`6zPw;vq(dwf*{kSIBa_Z~@x`*JSaN>P@_HKux zr{RmtBcWY4C(5se{#0HZ;a>NLk0~{BVd!_=QQKE@50CYISo`ikVQXXceOvPf%=bU9 zxrR?v#L29UXljw&li^1KCesx@ZX(J)sp>BoqT@fI7icDH+wEn309hy6_v Yi{L-NoGl*YruueO85x;of=C4Y4+8?J*8l(j literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-d.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-d.ogg new file mode 100644 index 0000000000000000000000000000000000000000..6599afe88cbd6954746fa8fb5bf23ffc6210d139 GIT binary patch literal 5259 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 D$NYcJ literal 0 HcmV?d00001 diff --git a/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-h.ogg b/src/assets/kenney_desert-shooter-pack_1.0/Sounds/shoot-h.ogg new file mode 100644 index 0000000000000000000000000000000000000000..dc676affbeda852cb7391ff14a975c1947d8f695 GIT binary patch literal 6895 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 z + + + + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,91, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,109, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,109 + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,65,65,0,0,0,0,0,0, +92,92,92,92,92,92,92,93,65,65,0,0,0,0,0,0, +110,20,110,110,110,110,110,112,110,65,0,0,0,0,0,0, +110,110,110,110,20,110,110,110,110,65,65,0,0,0,0,0 + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,109, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,109, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + +110,110,20,110,110,110,110,94,110,65,65,0,0,0,65,0, +110,20,110,110,110,110,20,111,65,65,65,0,0,0,65,0, +128,128,128,128,128,128,128,129,65,65,65,0,65,65,65,0, +0,0,0,65,65,65,65,65,65,65,65,65,195,65,65,0, +0,0,0,65,65,65,65,65,65,65,65,65,65,65,65,0, +0,0,65,65,65,65,65,65,65,65,65,65,66,65,65,65, +0,0,65,65,65,65,66,65,65,66,65,65,65,65,65,65, +0,0,0,65,65,65,65,65,65,65,66,65,65,65,65,65, +0,0,0,65,65,195,65,65,65,65,65,65,65,65,65,65, +0,0,0,65,65,65,65,66,65,65,65,65,65,65,65,65, +0,0,0,65,65,65,65,65,65,66,65,65,195,65,65,65, +0,0,0,65,65,65,65,65,65,65,65,65,65,65,66,65, +0,65,65,65,65,65,66,65,65,65,65,65,65,65,65,65, +0,0,65,65,65,65,65,65,65,65,65,65,65,65,65,65, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,65,0,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,65,0,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,65,65,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,65,65,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,65,0,0,0,0,0,0,0,0,0,0, +65,65,65,65,65,0,0,0,0,0,0,0,0,0,0,0, +65,65,65,0,0,0,0,0,0,0,0,0,0,0,0,0, +65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + + + + + + + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,2,2,2,2,3,0,0, +0,0,0,0,0,0,0,0,19,110,20,110,20,21,0,0, +0,0,0,0,0,0,0,0,19,110,110,20,20,21,0,0, +0,0,0,0,0,0,0,0,37,38,38,38,38,39,0,0, +0,0,0,0,0,0,0,0,73,56,174,174,174,57,0,0, +0,0,0,0,0,0,0,0,73,174,174,56,174,57,0,0, +0,0,0,0,0,0,0,0,73,174,174,174,174,57,0,0 + + +0,0,0,0,0,0,0,0,73,174,56,56,174,57,0,0, +0,0,0,0,0,0,0,0,73,174,174,174,56,57,0,0, +0,0,0,0,0,0,0,0,73,74,74,74,74,75,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + + + + + + + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2, +0,0,0,0,0,0,0,0,0,0,0,0,0,37,38,38 + + +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,2,2,3,0,0,0,0,0,0,0,0,0,0,0,0, +38,38,38,39,0,0,0,0,0,0,0,0,0,0,0,0 + + +0,0,0,0,0,0,0,0,0,0,0,0,0,73,174,174, +0,0,0,0,0,0,0,0,0,0,0,0,0,73,174,174, +0,0,0,0,0,0,0,0,0,0,0,0,0,73,56,174, +0,0,0,0,0,0,0,0,0,0,0,0,0,73,56,56, +0,0,0,0,0,0,0,0,0,0,0,0,0,73,74,74, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + +56,56,174,75,0,0,0,0,0,0,0,0,0,0,0,0, +174,174,174,75,0,0,0,0,0,0,0,0,0,0,0,0, +174,174,56,75,0,0,0,0,0,0,0,0,0,0,0,0, +174,56,56,75,0,0,0,0,0,0,0,0,0,0,0,0, +74,74,74,75,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + + + + + + + + + diff --git a/src/assets/roboto-font/LICENSE.txt b/src/assets/roboto-font/LICENSE.txt new file mode 100644 index 0000000..9c48e05 --- /dev/null +++ b/src/assets/roboto-font/LICENSE.txt @@ -0,0 +1,93 @@ +Copyright 2011 The Roboto Project Authors (https://github.com/googlefonts/roboto-classic) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://openfontlicense.org + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/src/assets/roboto-font/Roboto-Bold.ttf b/src/assets/roboto-font/Roboto-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..9d7cf220f98402e6908795046cd3c124886fc54a GIT binary patch literal 146768 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]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 pSMMfWC3h031oSW{sOP-O*@UYa+3X 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�egE!tu*v~K}gWeK5h%eT<6pQ9}X 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�PJ}HG?Q&#wR5zLv9qnRi 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 + + + diff --git a/src/assets/tileset.tsx b/src/assets/tileset.tsx new file mode 100644 index 0000000..b66a44d --- /dev/null +++ b/src/assets/tileset.tsx @@ -0,0 +1,4 @@ + + + + diff --git a/src/assets/wood01.ogg b/src/assets/wood01.ogg new file mode 100644 index 0000000000000000000000000000000000000000..be5a4094b6800ca7aa26754fa8a6148cf2ea587c GIT binary patch literal 8569 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∾vaN&U{{sM*MR@@yYem=1=aQwte#YME}J2#QGHQ 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 |opts| { + if (opts.sample_rate == sample_rate) { + assert(channel_index < opts.channels.len); // TODO: + const channel = opts.channels[channel_index]; + + var memcpy_len: usize = 0; + if (cursor + buffer.len <= opts.sample_count) { + memcpy_len = buffer.len; + } else if (cursor < opts.sample_count) { + memcpy_len = opts.sample_count - cursor; + } + + @memcpy(buffer[0..memcpy_len], channel[cursor..][0..memcpy_len]); + return buffer[0..memcpy_len]; + } else { + // const in_sample_rate: f32 = @floatFromInt(opts.sample_rate); + // const out_sample_rate: f32 = @floatFromInt(sample_rate); + // const increment = in_sample_rate / out_sample_rate; + // _ = increment; // autofix + unreachable; + } + }, + .vorbis => |opts| { + _ = opts; // autofix + unreachable; + }, + } + // return result.items; + } + + pub fn getSampleCount(self: Data) u32 { + return switch (self) { + .raw => |opts| opts.sample_count, + .vorbis => |opts| opts.stb_vorbis.getStreamLengthInSamples() + }; + } + + pub fn getSampleRate(self: Data) u32 { + return switch (self) { + .raw => |opts| opts.sample_rate, + .vorbis => |opts| blk: { + const info = opts.stb_vorbis.getInfo(); + break :blk info.sample_rate; + } + }; + } + + pub const Id = enum (u16) { _ }; +}; diff --git a/src/engine/audio/mixer.zig b/src/engine/audio/mixer.zig new file mode 100644 index 0000000..2cc6daf --- /dev/null +++ b/src/engine/audio/mixer.zig @@ -0,0 +1,152 @@ +const std = @import("std"); +const log = std.log.scoped(.audio); +const assert = std.debug.assert; +const Allocator = std.mem.Allocator; + +const sokol = @import("sokol"); +const saudio = sokol.audio; + +const AudioData = @import("./data.zig").Data; +pub const Store = @import("./store.zig"); + +const Mixer = @This(); + +pub const Instance = struct { + data_id: AudioData.Id, + volume: f32 = 0, + cursor: u32 = 0, +}; + +pub const Command = union(enum) { + pub const Play = struct { + id: AudioData.Id, + volume: f32 = 1 + }; + + play: Play, + + pub const RingBuffer = struct { + // TODO: This ring buffer will work in a single producer single consumer configuration + // For my game this will be good enough + + items: []Command, + head: std.atomic.Value(usize) = .init(0), + tail: std.atomic.Value(usize) = .init(0), + + pub fn push(self: *RingBuffer, command: Command) error{OutOfMemory}!void { + const head = self.head.load(.monotonic); + const tail = self.tail.load(.monotonic); + const next_head = @mod(head + 1, self.items.len); + + // A single slot in the .items array will always not be used. + if (next_head == tail) { + return error.OutOfMemory; + } + + self.items[head] = command; + self.head.store(next_head, .monotonic); + } + + pub fn pop(self: *RingBuffer) ?Command { + const head = self.head.load(.monotonic); + const tail = self.tail.load(.monotonic); + + if (head == tail) { + return null; + } + + const result = self.items[tail]; + self.tail.store(@mod(tail + 1, self.items.len), .monotonic); + return result; + } + }; +}; + +// TODO: Tracks + +instances: std.ArrayList(Instance), +commands: Command.RingBuffer, +working_buffer: []f32, + +pub fn init( + gpa: Allocator, + max_instances: u32, + max_commands: u32, + working_buffer_size: u32 +) !Mixer { + var instances = try std.ArrayList(Instance).initCapacity(gpa, max_instances); + errdefer instances.deinit(gpa); + + const commands = try gpa.alloc(Command, max_commands); + errdefer gpa.free(commands); + + const working_buffer = try gpa.alloc(f32, working_buffer_size); + errdefer gpa.free(working_buffer); + + return Mixer{ + .working_buffer = working_buffer, + .instances = instances, + .commands = .{ + .items = commands + } + }; +} + +pub fn deinit(self: *Mixer, gpa: Allocator) void { + self.instances.deinit(gpa); + gpa.free(self.commands.items); + gpa.free(self.working_buffer); +} + +pub fn queue(self: *Mixer, command: Command) void { + self.commands.push(command) catch log.warn("Maximum number of audio commands reached!", .{}); +} + +pub fn stream(self: *Mixer, store: Store, buffer: []f32, num_frames: u32, num_channels: u32) !void { + while (self.commands.pop()) |command| { + switch (command) { + .play => |opts| { + const volume = @max(opts.volume, 0); + if (volume == 0) { + log.warn("Attempt to play audio with 0 volume", .{}); + continue; + } + + self.instances.appendBounded(.{ + .data_id = opts.id, + .volume = volume, + }) catch log.warn("Maximum number of audio instances reached!", .{}); + } + } + } + + assert(num_channels == 1); // TODO: + const sample_rate: u32 = @intCast(saudio.sampleRate()); + + @memset(buffer, 0); + assert(self.working_buffer.len >= num_frames); + + for (self.instances.items) |*instance| { + const audio_data = store.get(instance.data_id); + const samples = audio_data.streamChannel(self.working_buffer[0..num_frames], instance.cursor, 0, sample_rate); + for (0.., samples) |i, sample| { + buffer[i] += sample * instance.volume; + } + instance.cursor += @intCast(samples.len); + } + + { + var i: usize = 0; + while (i < self.instances.items.len) { + const instance = self.instances.items[i]; + const audio_data = store.get(instance.data_id); + const is_complete = instance.cursor == audio_data.getSampleCount(); + + if (is_complete) { + _ = self.instances.swapRemove(i); + } else { + i += 1; + } + } + } +} diff --git a/src/engine/audio/root.zig b/src/engine/audio/root.zig new file mode 100644 index 0000000..a1d9365 --- /dev/null +++ b/src/engine/audio/root.zig @@ -0,0 +1,111 @@ +const std = @import("std"); +const log = std.log.scoped(.audio); +const assert = std.debug.assert; + +const tracy = @import("tracy"); + +const Math = @import("../math.zig"); +const STBVorbis = @import("stb_vorbis"); + +pub const Data = @import("./data.zig").Data; +pub const Store = @import("./store.zig"); +pub const Mixer = @import("./mixer.zig"); + +pub const Command = Mixer.Command; + +const Nanoseconds = @import("../root.zig").Nanoseconds; +const sokol = @import("sokol"); +const saudio = sokol.audio; + +var stopped: bool = true; +var gpa: std.mem.Allocator = undefined; +var store: Store = undefined; +pub var mixer: Mixer = undefined; + +const Options = struct { + allocator: std.mem.Allocator, + logger: saudio.Logger = .{}, + channels: u32 = 1, + max_vorbis_alloc_buffer_size: u32 = 1 * Math.bytes_per_mib, + buffer_frames: u32 = 2048, + max_instances: u32 = 64 +}; + +pub fn init(opts: Options) !void { + gpa = opts.allocator; + + store = try Store.init(.{ + .allocator = opts.allocator, + .max_vorbis_alloc_buffer_size = opts.max_vorbis_alloc_buffer_size, + }); + + mixer = try Mixer.init(gpa, + opts.max_instances, + opts.max_instances, + opts.buffer_frames + ); + + saudio.setup(.{ + .logger = opts.logger, + .stream_cb = sokolStreamCallback, + .num_channels = @intCast(opts.channels), + .buffer_frames = @intCast(opts.buffer_frames) + }); + stopped = false; + + const sample_rate: f32 = @floatFromInt(saudio.sampleRate()); + const audio_latency: f32 = @as(f32, @floatFromInt(opts.buffer_frames)) / sample_rate; + log.debug("Audio latency = {D}", .{@as(u64, @intFromFloat(audio_latency * std.time.ns_per_s))}); +} + +pub fn deinit() void { + stopped = true; + saudio.shutdown(); + mixer.deinit(gpa); + store.deinit(); +} + +pub fn load(opts: Store.LoadOptions) !Data.Id { + return try store.load(opts); +} + +const Info = struct { + sample_count: u32, + sample_rate: u32, + + pub fn getDuration(self: Info) Nanoseconds { + return @as(Nanoseconds, self.sample_count) * std.time.ns_per_s / self.sample_rate; + } +}; + +pub fn getInfo(id: Data.Id) Info { + const data = store.get(id); + return Info{ + .sample_count = data.getSampleCount(), + .sample_rate = data.getSampleRate(), + }; +} + +fn sokolStreamCallback(buffer: [*c]f32, num_frames: i32, num_channels: i32) callconv(.c) void { + if (stopped) { + return; + } + + const zone = tracy.initZone(@src(), .{ }); + defer zone.deinit(); + + const num_frames_u32: u32 = @intCast(num_frames); + const num_channels_u32: u32 = @intCast(num_channels); + + mixer.stream( + store, + buffer[0..(num_frames_u32 * num_channels_u32)], + num_frames_u32, + num_channels_u32 + ) catch |e| { + log.err("mixer.stream() failed: {}", .{e}); + if (@errorReturnTrace()) |trace| { + std.debug.dumpStackTrace(trace.*); + } + }; +} diff --git a/src/engine/audio/store.zig b/src/engine/audio/store.zig new file mode 100644 index 0000000..10e3b13 --- /dev/null +++ b/src/engine/audio/store.zig @@ -0,0 +1,106 @@ +const std = @import("std"); +const assert = std.debug.assert; + +const Math = @import("../math.zig"); +const STBVorbis = @import("stb_vorbis"); + +const AudioData = @import("./data.zig").Data; + +const Store = @This(); + +arena: std.heap.ArenaAllocator, +list: std.ArrayList(AudioData), +temp_vorbis_alloc_buffer: []u8, + +const Options = struct { + allocator: std.mem.Allocator, + max_vorbis_alloc_buffer_size: u32, +}; + +pub fn init(opts: Options) !Store { + const gpa = opts.allocator; + + const temp_vorbis_alloc_buffer = try gpa.alloc(u8, opts.max_vorbis_alloc_buffer_size); + errdefer gpa.free(temp_vorbis_alloc_buffer); + + return Store{ + .arena = std.heap.ArenaAllocator.init(gpa), + .list = .empty, + .temp_vorbis_alloc_buffer = temp_vorbis_alloc_buffer + }; +} + +pub fn deinit(self: *Store) void { + const gpa = self.arena.child_allocator; + gpa.free(self.temp_vorbis_alloc_buffer); + self.list.deinit(gpa); + self.arena.deinit(); +} + +pub const LoadOptions = struct { + const PlaybackStyle = enum { + stream, + decode_once, + + // If the decoded size is less than `stream_threshold`, then .decode_once will by default be used. + const stream_threshold = 10 * Math.bytes_per_mib; + }; + + const Format = enum { + vorbis + }; + + format: Format, + data: []const u8, + playback_style: ?PlaybackStyle = null, +}; + +pub fn load(self: *Store, opts: LoadOptions) !AudioData.Id { + const gpa = self.arena.child_allocator; + + const id = self.list.items.len; + try self.list.ensureUnusedCapacity(gpa, 1); + + const PlaybackStyle = LoadOptions.PlaybackStyle; + const temp_stb_vorbis = try STBVorbis.init(opts.data, self.temp_vorbis_alloc_buffer); + const info = temp_stb_vorbis.getInfo(); + const duration_in_samples = temp_stb_vorbis.getStreamLengthInSamples(); + const decoded_size = info.channels * duration_in_samples * @sizeOf(f32); + const stream_threshold = PlaybackStyle.stream_threshold; + const default_playback_style: PlaybackStyle = if (decoded_size < stream_threshold) .decode_once else .stream; + + const arena_allocator = self.arena.allocator(); + const playback_style = opts.playback_style orelse default_playback_style; + if (playback_style == .decode_once) { + const channels = try arena_allocator.alloc([*]f32, info.channels); + for (channels) |*channel| { + channel.* = (try arena_allocator.alloc(f32, duration_in_samples)).ptr; + } + const samples_decoded = temp_stb_vorbis.getSamples(channels, duration_in_samples); + assert(samples_decoded == duration_in_samples); + + self.list.appendAssumeCapacity(AudioData{ + .raw = .{ + .channels = channels, + .sample_count = duration_in_samples, + .sample_rate = info.sample_rate + } + }); + } else { + const alloc_buffer = try arena_allocator.alloc(u8, temp_stb_vorbis.getMinimumAllocBufferSize()); + const stb_vorbis = STBVorbis.init(opts.data, alloc_buffer) catch unreachable; + + self.list.appendAssumeCapacity(AudioData{ + .vorbis = .{ + .alloc_buffer = alloc_buffer, + .stb_vorbis = stb_vorbis + } + }); + } + + return @enumFromInt(id); +} + +pub fn get(self: Store, id: AudioData.Id) AudioData { + return self.list.items[@intFromEnum(id)]; +} diff --git a/src/engine/fontstash/context.zig b/src/engine/fontstash/context.zig new file mode 100644 index 0000000..d360b31 --- /dev/null +++ b/src/engine/fontstash/context.zig @@ -0,0 +1,250 @@ +const std = @import("std"); + +const Font = @import("./font.zig"); +const Align = Font.Align; + +const Context = @This(); + +const c = @cImport({ + @cInclude("fontstash.h"); + + @cInclude("sokol/sokol_gfx.h"); + @cInclude("sokol/sokol_gl.h"); + @cInclude("sokol_fontstash.h"); +}); + +pub const FONScontext = c.FONScontext; + +pub const Size = struct { + width: u32, + height: u32, +}; + +pub const TextBounds = struct { + advance: f32, + min_x: f32, + max_x: f32, + min_y: f32, + max_y: f32, +}; + +pub const LineBounds = struct { + min_y: f32, + max_y: f32, +}; + +pub const VertMetrics = struct { + ascender: f32, + descender: f32, + lineh: f32 +}; + +pub const Quad = struct { + x0: f32, + y0: f32, + s0: f32, + t0: f32, + + x1: f32, + y1: f32, + s1: f32, + t1: f32, +}; + +pub const TextIterator = struct { + context: Context, + iter: c.FONStextIter, + + pub fn init(ctx: Context, x: f32, y: f32, text: []const u8) TextIterator { + var self = TextIterator{ + .context = ctx, + .iter = undefined + }; + + const success = c.fonsTextIterInit( + self.context.ctx, + &self.iter, + x, + y, + text.ptr, + text.ptr + text.len + ); + if (success != 1) { + return error.fonsTextIterInit; + } + + return self; + } + + pub fn next(self: TextIterator) ?Quad { + var quad: c.FONSquad = undefined; + const success = c.fonsTextIterNext(self.context, &self.iter, &quad); + if (success != 1) { + return null; + } + + return Quad{ + .x0 = quad.x0, + .y0 = quad.y0, + .s0 = quad.s0, + .t0 = quad.t0, + + .x1 = quad.x0, + .y1 = quad.y0, + .s1 = quad.s0, + .t1 = quad.t0, + }; + } +}; + +ctx: *FONScontext, + +pub fn init(desc: c.sfons_desc_t) !Context { + const ctx = c.sfons_create(&desc); + if (ctx == null) { + return error.sfons_create; + } + + return Context{ + .ctx = ctx.? + }; +} + +pub fn deinit(self: Context) void { + c.sfons_destroy(self.ctx); +} + +pub fn flush(self: Context) void { + c.sfons_flush(self.ctx); +} + +pub fn addFont(self: Context, name: [*c]const u8, data: []const u8) !Font.Id { + const font_id = c.fonsAddFontMem( + self.ctx, + name, + @constCast(data.ptr), + @intCast(data.len), + 0 + ); + if (font_id == c.FONS_INVALID) { + return error.fonsAddFontMem; + } + return @enumFromInt(font_id); +} + +pub fn addFallbackFont(self: Context, base: Font.Id, fallback: Font.Id) void { + const success = c.fonsAddFallbackFont(self.ctx, @intFromEnum(base), @intFromEnum(fallback)); + if (success != 1) { + return error.fonsAddFallbackFont; + } +} + +pub fn getFontByName(self: Context, name: [*c]const u8) ?Font.Id { + const font_id = c.fonsGetFontByName(self.ctx, name); + if (font_id == c.FONS_INVALID) { + return null; + } + return @enumFromInt(font_id); +} + +// TODO: fonsSetErrorCallback + +pub fn getAtlasSize(self: Context) Size { + var result: Size = .{ + .width = 0, + .height = 0 + }; + c.fonsGetAtlasSize(self.ctx, &result.width, &result.height); + return result; +} + +pub fn expandAtlas(self: Context, width: u32, height: u32) !void { + const success = c.fonsExpandAtlas(self.ctx, @bitCast(width), @bitCast(height)); + if (success != 1) { + return error.fonsExpandAtlas; + } +} + +pub fn resetAtlas(self: Context) !void { + const success = c.fonsResetAtlas(self.ctx); + if (success != 1) { + return error.fonsResetAtlas; + } +} + +pub fn pushState(self: Context) void { + c.fonsPushState(self.ctx); +} + +pub fn popState(self: Context) void { + c.fonsPopState(self.ctx); +} + +pub fn clearState(self: Context) void { + c.fonsClearState(self.ctx); +} + +pub fn setSize(self: Context, size: f32) void { + c.fonsSetSize(self.ctx, size); +} + +pub fn setColor(self: Context, color: u32) void { + c.fonsSetColor(self.ctx, color); +} + +pub fn setSpacing(self: Context, spacing: f32) void { + c.fonsSetSpacing(self.ctx, spacing); +} + +pub fn setBlur(self: Context, blur: f32) void { + c.fonsSetSpacing(self.ctx, blur); +} + +pub fn setAlign(self: Context, alignment: Align) void { + c.fonsSetAlign(self.ctx, @intFromEnum(alignment.x) | @intFromEnum(alignment.y)); +} + +pub fn setFont(self: Context, id: Font.Id) void { + c.fonsSetFont(self.ctx, @intFromEnum(id)); +} + +pub fn drawText(self: Context, x: f32, y: f32, text: []const u8) void { + const advance = c.fonsDrawText(self.ctx, x, y, text.ptr, text.ptr + text.len); + _ = advance; +} + +pub fn textBounds(self: Context, x: f32, y: f32, text: []const u8) TextBounds { + var bounds: f32[4] = undefined; + const advance = c.fonsTextBounds(self.ctx, x, y, text.ptr, text.ptr + text.len, &bounds); + + return TextBounds{ + .advance = advance, + .min_x = bounds[0], + .max_x = bounds[1], + .min_y = bounds[2], + .max_y = bounds[3] + }; +} + +pub fn lineBounds(self: Context, y: f32) LineBounds { + var result: LineBounds = .{ + .max_y = 0, + .min_y = 0 + }; + c.fonsLineBounds(self.ctx, y, &result.min_y, &result.max_y); + return result; +} + +pub fn vertMetrics(self: Context) void { + var result: VertMetrics = .{ + .ascender = 0, + .descender = 0, + .lineh = 0 + }; + c.fonsVertMetrics(self.ctx, &result.ascender, &result.descender, &result.lineh); + return result; +} + +pub fn drawDebug(self: Context, x: f32, y: f32) void { + c.fonsDrawDebug(self.ctx, x, y); +} diff --git a/src/engine/fontstash/font.zig b/src/engine/fontstash/font.zig new file mode 100644 index 0000000..3b2032c --- /dev/null +++ b/src/engine/fontstash/font.zig @@ -0,0 +1,33 @@ +const std = @import("std"); + +const c = @cImport({ + @cInclude("fontstash.h"); +}); + +const Font = @This(); + +pub const Id = enum(c_int) { + _, + + pub const invalid: Id = @enumFromInt(c.FONS_INVALID); +}; + +pub const AlignX = enum(c_int) { + left = c.FONS_ALIGN_LEFT, + right = c.FONS_ALIGN_RIGHT, + center = c.FONS_ALIGN_CENTER, + _, +}; + +pub const AlignY = enum(c_int) { + top = c.FONS_ALIGN_TOP, + middle = c.FONS_ALIGN_MIDDLE, + bottom = c.FONS_ALIGN_BOTTOM, + baseline = c.FONS_ALIGN_BASELINE, + _, +}; + +pub const Align = struct { + x: AlignX, + y: AlignY, +}; diff --git a/src/engine/fontstash/root.zig b/src/engine/fontstash/root.zig new file mode 100644 index 0000000..2620597 --- /dev/null +++ b/src/engine/fontstash/root.zig @@ -0,0 +1,3 @@ + +pub const Font = @import("./font.zig"); +pub const Context = @import("./context.zig"); diff --git a/src/engine/fontstash/sokol_fontstash_impl.c b/src/engine/fontstash/sokol_fontstash_impl.c new file mode 100644 index 0000000..26aeca8 --- /dev/null +++ b/src/engine/fontstash/sokol_fontstash_impl.c @@ -0,0 +1,12 @@ +#include +#include +#ifdef _WIN32 +#include +#endif +#define FONTSTASH_IMPLEMENTATION +#include "fontstash.h" + +#include "sokol/sokol_gfx.h" +#include "sokol/sokol_gl.h" +#define SOKOL_FONTSTASH_IMPL +#include "sokol_fontstash.h" diff --git a/src/engine/frame.zig b/src/engine/frame.zig new file mode 100644 index 0000000..4b4f2bf --- /dev/null +++ b/src/engine/frame.zig @@ -0,0 +1,291 @@ +const std = @import("std"); +const build_options = @import("build_options"); +const log = std.log.scoped(.engine); + +const InputSystem = @import("./input.zig"); +const KeyCode = InputSystem.KeyCode; +const MouseButton = InputSystem.MouseButton; + +const AudioSystem = @import("./audio/root.zig"); +const AudioData = AudioSystem.Data; +const AudioCommand = AudioSystem.Command; + +const GraphicsSystem = @import("./graphics.zig"); +const TextureId = GraphicsSystem.TextureId; +const GraphicsCommand = GraphicsSystem.Command; +const Font = GraphicsSystem.Font; +const Sprite = GraphicsSystem.Sprite; + +const Math = @import("./math.zig"); +const Rect = Math.Rect; +const Vec4 = Math.Vec4; +const Vec2 = Math.Vec2; +const rgb = Math.rgb; + +pub const Nanoseconds = u64; + +const Frame = @This(); + +pub const Input = struct { + keyboard: InputSystem.ButtonStateSet(KeyCode), + mouse_button: InputSystem.ButtonStateSet(MouseButton), + mouse_position: ?Vec2, + + pub const empty = Input{ + .keyboard = .empty, + .mouse_button = .empty, + .mouse_position = null, + }; +}; + +pub const KeyState = struct { + down: bool, + pressed: bool, + released: bool, + down_duration: ?f64, + + pub const RepeatOptions = struct { + first_at: f64 = 0, + period: f64 + }; + + pub fn repeat(self: KeyState, last_repeat_at: *?f64, opts: RepeatOptions) bool { + if (!self.down) { + last_repeat_at.* = null; + return false; + } + + const down_duration = self.down_duration.?; + if (last_repeat_at.* != null) { + if (down_duration >= last_repeat_at.*.? + opts.period) { + last_repeat_at.* = last_repeat_at.*.? + opts.period; + return true; + } + } else { + if (down_duration >= opts.first_at) { + last_repeat_at.* = opts.first_at; + return true; + } + } + + return false; + } +}; + +pub const Audio = struct { + commands: std.ArrayList(AudioCommand), + + pub const empty = Audio{ + .commands = .empty + }; +}; + +pub const Graphics = struct { + clear_color: Vec4, + screen_size: Vec2, + canvas_size: ?Vec2, + + scissor_stack: std.ArrayList(Rect), + commands: std.ArrayList(GraphicsCommand), + + pub const empty = Graphics{ + .clear_color = rgb(0, 0, 0), + .screen_size = .init(0, 0), + .canvas_size = null, + .scissor_stack = .empty, + .commands = .empty + }; +}; + +arena: std.heap.ArenaAllocator, + +time_ns: Nanoseconds, +dt_ns: Nanoseconds, +input: Input, +audio: Audio, +graphics: Graphics, + +show_debug: bool, +hide_cursor: bool, + +pub fn init(self: *Frame, gpa: std.mem.Allocator) void { + self.* = Frame{ + .arena = std.heap.ArenaAllocator.init(gpa), + .time_ns = 0, + .dt_ns = 0, + .input = .empty, + .audio = .empty, + .graphics = .empty, + .show_debug = false, + .hide_cursor = false + }; +} + +pub fn deinit(self: *Frame) void { + self.arena.deinit(); +} + +pub fn deltaTime(self: Frame) f32 { + return @as(f32, @floatFromInt(self.dt_ns)) / std.time.ns_per_s; +} + +pub fn time(self: Frame) f64 { + return @as(f64, @floatFromInt(self.time_ns)) / std.time.ns_per_s; +} + +pub fn isKeyDown(self: Frame, key_code: KeyCode) bool { + const keyboard = &self.input.keyboard; + return keyboard.down.contains(key_code); +} + +pub fn getKeyDownDuration(self: Frame, key_code: KeyCode) ?f32 { + if (!self.isKeyDown(key_code)) { + return null; + } + + const keyboard = &self.input.keyboard; + const pressed_at_ns = keyboard.pressed_at.get(key_code).?; + const duration_ns = self.time_ns - pressed_at_ns; + + return @as(f32, @floatFromInt(duration_ns)) / std.time.ns_per_s; +} + +pub fn isKeyPressed(self: Frame, key_code: KeyCode) bool { + const keyboard = &self.input.keyboard; + return keyboard.pressed.contains(key_code); +} + +pub fn isKeyReleased(self: Frame, key_code: KeyCode) bool { + const keyboard = &self.input.keyboard; + return keyboard.released.contains(key_code); +} + +pub fn getKeyState(self: Frame, key_code: KeyCode) KeyState { + return KeyState{ + .down = self.isKeyDown(key_code), + .released = self.isKeyReleased(key_code), + .pressed = self.isKeyPressed(key_code), + .down_duration = self.getKeyDownDuration(key_code) + }; +} + +pub fn isMousePressed(self: Frame, button: MouseButton) bool { + return self.input.mouse_button.pressed.contains(button); +} + +pub fn isMouseDown(self: Frame, button: MouseButton) bool { + return self.input.mouse_button.down.contains(button); +} + +fn pushAudioCommand(self: *Frame, command: AudioCommand) void { + const arena = self.arena.allocator(); + + self.audio.commands.append(arena, command) catch |e| { + log.warn("Failed to play audio: {}", .{e}); + }; +} + +pub fn pushGraphicsCommand(self: *Frame, command: GraphicsCommand) void { + const arena = self.arena.allocator(); + + self.graphics.commands.append(arena, command) catch |e|{ + log.warn("Failed to push graphics command: {}", .{e}); + }; +} + +pub fn prependGraphicsCommand(self: *Frame, command: GraphicsCommand) void { + const arena = self.arena.allocator(); + + self.graphics.commands.insert(arena, 0, command) catch |e|{ + log.warn("Failed to push graphics command: {}", .{e}); + }; +} + +pub fn playAudio(self: *Frame, options: AudioCommand.Play) void { + self.pushAudioCommand(.{ + .play = options, + }); +} + +pub fn pushScissor(self: *Frame, rect: Rect) void { + const arena = self.arena.allocator(); + self.graphics.scissor_stack.append(arena, rect) catch |e| { + log.warn("Failed to push scissor region: {}", .{e}); + return; + }; + + self.pushGraphicsCommand(.{ + .set_scissor = rect + }); +} + +pub fn popScissor(self: *Frame) void { + _ = self.graphics.scissor_stack.pop().?; + const rect = self.graphics.scissor_stack.getLast(); + + self.pushGraphicsCommand(.{ + .set_scissor = rect + }); +} + +pub fn drawRectangle(self: *Frame, opts: GraphicsCommand.DrawRectangle) void { + self.pushGraphicsCommand(.{ .draw_rectangle = opts }); +} + +pub fn drawLine(self: *Frame, pos1: Vec2, pos2: Vec2, color: Vec4, width: f32) void { + self.pushGraphicsCommand(.{ + .draw_line = .{ + .pos1 = pos1, + .pos2 = pos2, + .width = width, + .color = color + } + }); +} + +pub fn drawRectanglOutline(self: *Frame, pos: Vec2, size: Vec2, color: Vec4, width: f32) void { + // TODO: Don't use line segments + self.drawLine(pos, pos.add(.{ .x = size.x, .y = 0 }), color, width); + self.drawLine(pos, pos.add(.{ .x = 0, .y = size.y }), color, width); + self.drawLine(pos.add(.{ .x = 0, .y = size.y }), pos.add(size), color, width); + self.drawLine(pos.add(.{ .x = size.x, .y = 0 }), pos.add(size), color, width); +} + +pub const DrawTextOptions = struct { + font: Font.Id, + size: f32 = 16, + color: Vec4 = rgb(255, 255, 255), +}; + +pub fn drawText(self: *Frame, position: Vec2, text: []const u8, opts: DrawTextOptions) void { + const arena = self.arena.allocator(); + const text_dupe = arena.dupe(u8, text) catch |e| { + log.warn("Failed to draw text: {}", .{e}); + return; + }; + + self.pushGraphicsCommand(.{ + .draw_text = .{ + .pos = position, + .text = text_dupe, + .size = opts.size, + .font = opts.font, + .color = opts.color, + } + }); +} + +pub fn pushTransform(self: *Frame, translation: Vec2, scale: Vec2) void { + self.pushGraphicsCommand(.{ + .push_transformation = .{ + .translation = translation, + .scale = scale + } + }); +} + +pub fn popTransform(self: *Frame) void { + self.pushGraphicsCommand(.{ + .pop_transformation = {} + }); +} diff --git a/src/engine/graphics.zig b/src/engine/graphics.zig new file mode 100644 index 0000000..59de1ba --- /dev/null +++ b/src/engine/graphics.zig @@ -0,0 +1,380 @@ +const sokol = @import("sokol"); +const sg = sokol.gfx; +const sglue = sokol.glue; +const slog = sokol.log; +const sapp = sokol.app; +const simgui = sokol.imgui; +const sgl = sokol.gl; + +const Math = @import("./math.zig"); +const Vec2 = Math.Vec2; +const Vec4 = Math.Vec4; +const rgb = Math.rgb; +const Rect = Math.Rect; + +const std = @import("std"); +const log = std.log.scoped(.graphics); +const assert = std.debug.assert; + +const imgui = @import("imgui.zig"); +const tracy = @import("tracy"); +const fontstash = @import("./fontstash/root.zig"); +pub const Font = fontstash.Font; + +const GraphicsFrame = @import("./frame.zig").Graphics; + +// TODO: Seems that there is a vertical jitter bug when resizing a window in OpenGL. Seems like a driver bug. +// From other peoples research it seems that disabling vsync when a resize event occurs fixes it. +// Maybe a patch for sokol could be made? +// More info: +// * https://github.com/libsdl-org/SDL/issues/11618 +// * https://github.com/nimgl/nimgl/issues/59 + +const Options = struct { + const ImguiFont = struct { ttf_data: []const u8, size: f32 = 16 }; + + allocator: std.mem.Allocator, + logger: sg.Logger = .{}, + imgui_font: ?ImguiFont = null, +}; + +pub const Command = union(enum) { + pub const DrawRectangle = struct { + rect: Rect, + color: Vec4, + sprite: ?Sprite = null, + rotation: f32 = 0, + origin: Vec2 = .init(0, 0), + }; + + set_scissor: Rect, + draw_rectangle: DrawRectangle, + draw_line: struct { pos1: Vec2, pos2: Vec2, color: Vec4, width: f32 }, + draw_text: struct { + pos: Vec2, + text: []const u8, + font: Font.Id, + size: f32, + color: Vec4, + }, + push_transformation: struct { translation: Vec2, scale: Vec2 }, + pop_transformation: void, +}; + +const Texture = struct { + image: sg.Image, + view: sg.View, + info: Info, + + const Info = struct { + width: u32, + height: u32, + }; + + const Id = enum(u32) { _ }; + const Data = struct { width: u32, height: u32, rgba: [*]u8 }; +}; +pub const TextureId = Texture.Id; +pub const TextureInfo = Texture.Info; + +pub const Sprite = struct { + texture: TextureId, + uv: Rect, +}; + +var gpa: std.mem.Allocator = undefined; + +var main_pipeline: sgl.Pipeline = .{}; +var linear_sampler: sg.Sampler = .{}; +var nearest_sampler: sg.Sampler = .{}; +var font_context: fontstash.Context = undefined; +var textures: std.ArrayList(Texture) = .empty; + +var scale_stack_buffer: [32]Vec2 = undefined; +var scale_stack: std.ArrayList(Vec2) = .empty; + +pub fn init(options: Options) !void { + gpa = options.allocator; + + sg.setup(.{ + .logger = options.logger, + .environment = sglue.environment(), + }); + + sgl.setup(.{ .logger = .{ .func = options.logger.func, .user_data = options.logger.user_data } }); + + main_pipeline = sgl.makePipeline(.{ + .colors = init: { + var colors: [8]sg.ColorTargetState = @splat(.{}); + colors[0] = .{ + .blend = .{ + .enabled = true, + .src_factor_rgb = .SRC_ALPHA, + .dst_factor_rgb = .ONE_MINUS_SRC_ALPHA, + .op_rgb = .ADD, + .src_factor_alpha = .ONE, + .dst_factor_alpha = .ONE_MINUS_SRC_ALPHA, + .op_alpha = .ADD, + }, + }; + break :init colors; + }, + }); + + imgui.setup(options.allocator, .{ + .logger = .{ .func = options.logger.func, .user_data = options.logger.user_data }, + .no_default_font = options.imgui_font != null, + + // TODO: Figure out a way to make imgui play nicely with UI + // Ideally when mouse is inside a Imgui window, then the imgui cursor should be used. + // Otherwise our own cursor should be used. + .disable_set_mouse_cursor = true, + }); + + if (options.imgui_font) |imgui_font| { + imgui.addFont(imgui_font.ttf_data, imgui_font.size); + } + + linear_sampler = sg.makeSampler(.{ + .min_filter = .LINEAR, + .mag_filter = .LINEAR, + .mipmap_filter = .LINEAR, + .label = "linear-sampler", + }); + + nearest_sampler = sg.makeSampler(.{ + .min_filter = .NEAREST, + .mag_filter = .NEAREST, + .mipmap_filter = .NEAREST, + .label = "nearest-sampler", + }); + + const dpi_scale = sapp.dpiScale(); + const atlas_size = 512; + const atlas_dim = std.math.ceilPowerOfTwoAssert(u32, @intFromFloat(atlas_size * dpi_scale)); + font_context = try fontstash.Context.init(.{ + .width = @intCast(atlas_dim), + .height = @intCast(atlas_dim), + }); +} + +pub fn deinit() void { + textures.deinit(gpa); + imgui.shutdown(); + font_context.deinit(); + sgl.shutdown(); + sg.shutdown(); +} + +pub fn drawCommand(command: Command) void { + switch (command) { + .push_transformation => |opts| { + pushTransform(opts.translation, opts.scale); + // font_resolution_scale = font_resolution_scale.multiply(opts.scale); + }, + .pop_transformation => { + popTransform(); + }, + .draw_rectangle => |opts| { + drawRectangle(opts); + }, + .set_scissor => |opts| { + sgl.scissorRectf(opts.pos.x, opts.pos.y, opts.size.x, opts.size.y, true); + }, + .draw_line => |opts| { + drawLine(opts.pos1, opts.pos2, opts.color, opts.width); + }, + .draw_text => |opts| { + const font_resolution_scale = scale_stack.getLast(); + + sgl.pushMatrix(); + defer sgl.popMatrix(); + + sgl.scale(1 / font_resolution_scale.x, 1 / font_resolution_scale.y, 1); + + font_context.setFont(opts.font); + font_context.setSize(opts.size * font_resolution_scale.y); + font_context.setAlign(.{ .x = .left, .y = .top }); + font_context.setSpacing(0); + + const r: u8 = @intFromFloat(opts.color.x * 255); + const g: u8 = @intFromFloat(opts.color.y * 255); + const b: u8 = @intFromFloat(opts.color.z * 255); + const a: u8 = @intFromFloat(opts.color.w * 255); + const color: u32 = r | (@as(u32, g) << 8) | (@as(u32, b) << 16) | (@as(u32, a) << 24); + font_context.setColor(color); + font_context.drawText(opts.pos.x * font_resolution_scale.x, opts.pos.y * font_resolution_scale.y, opts.text); + }, + } +} + +pub fn drawCommands(commands: []const Command) void { + for (commands) |command| { + drawCommand(command); + } +} + +pub fn beginFrame() void { + const zone = tracy.initZone(@src(), .{}); + defer zone.deinit(); + + imgui.newFrame(.{ .width = sapp.width(), .height = sapp.height(), .delta_time = sapp.frameDuration(), .dpi_scale = sapp.dpiScale() }); + + scale_stack = .initBuffer(&scale_stack_buffer); + scale_stack.appendAssumeCapacity(.init(1, 1)); + + font_context.clearState(); + sgl.defaults(); + sgl.matrixModeProjection(); + sgl.ortho(0, sapp.widthf(), sapp.heightf(), 0, -1, 1); + sgl.loadPipeline(main_pipeline); +} + +pub fn endFrame(clear_color: Vec4) void { + const zone = tracy.initZone(@src(), .{}); + defer zone.deinit(); + + var pass_action: sg.PassAction = .{}; + + pass_action.colors[0] = sg.ColorAttachmentAction{ .load_action = .CLEAR, .clear_value = .{ .r = clear_color.x, .g = clear_color.y, .b = clear_color.z, .a = clear_color.w } }; + + font_context.flush(); + + { + sg.beginPass(.{ .action = pass_action, .swapchain = sglue.swapchain() }); + defer sg.endPass(); + + sgl.draw(); + + imgui.render(); + } + sg.commit(); +} + +fn pushTransform(translation: Vec2, scale: Vec2) void { + sgl.pushMatrix(); + sgl.translate(translation.x, translation.y, 0); + sgl.scale(scale.x, scale.y, 1); + + scale_stack.appendAssumeCapacity(scale_stack.getLast().multiply(scale)); +} + +fn popTransform() void { + sgl.popMatrix(); + _ = scale_stack.pop().?; +} + +const Vertex = struct { pos: Vec2, uv: Vec2 }; + +fn drawQuad(quad: [4]Vertex, color: Vec4, texture_id: TextureId) void { + sgl.enableTexture(); + defer sgl.disableTexture(); + + const view = textures.items[@intFromEnum(texture_id)].view; + // TODO: Make sampler configurable + sgl.texture(view, nearest_sampler); + + sgl.beginQuads(); + defer sgl.end(); + + sgl.c4f(color.x, color.y, color.z, color.w); + for (quad) |vertex| { + const pos = vertex.pos; + const uv = vertex.uv; + sgl.v2fT2f(pos.x, pos.y, uv.x, uv.y); + } +} + +fn drawQuadNoUVs(quad: [4]Vec2, color: Vec4) void { + sgl.beginQuads(); + defer sgl.end(); + + sgl.c4f(color.x, color.y, color.z, color.w); + for (quad) |pos| { + sgl.v2f(pos.x, pos.y); + } +} + +fn drawRectangle(opts: Command.DrawRectangle) void { + const pos = opts.rect.pos; + const size = opts.rect.size; + + const top_left = Vec2.init(0, 0).rotateAround(opts.rotation, opts.origin); + const top_right = Vec2.init(size.x, 0).rotateAround(opts.rotation, opts.origin); + const bottom_right = size.rotateAround(opts.rotation, opts.origin); + const bottom_left = Vec2.init(0, size.y).rotateAround(opts.rotation, opts.origin); + + if (opts.sprite) |sprite| { + const uv = sprite.uv; + const quad = [4]Vertex{ .{ .pos = pos.add(top_left), .uv = .init(uv.left(), uv.top()) }, .{ .pos = pos.add(top_right), .uv = .init(uv.right(), uv.top()) }, .{ .pos = pos.add(bottom_right), .uv = .init(uv.right(), uv.bottom()) }, .{ .pos = pos.add(bottom_left), .uv = .init(uv.left(), uv.bottom()) } }; + drawQuad(quad, opts.color, sprite.texture); + } else { + const quad = .{ pos.add(top_left), pos.add(top_right), pos.add(bottom_right), pos.add(bottom_left) }; + drawQuadNoUVs(quad, opts.color); + } +} + +fn drawLine(from: Vec2, to: Vec2, color: Vec4, width: f32) void { + const step = to.sub(from).normalized().multiplyScalar(width / 2); + + const top_left = from.add(step.rotateLeft90()); + const bottom_left = from.add(step.rotateRight90()); + const top_right = to.add(step.rotateLeft90()); + const bottom_right = to.add(step.rotateRight90()); + + drawQuadNoUVs(.{ top_right, top_left, bottom_left, bottom_right }, color); +} + +pub fn addFont(name: [*c]const u8, data: []const u8) !Font.Id { + return try font_context.addFont(name, data); +} + +fn makeView(image: sg.Image) !sg.View { + const image_view = sg.makeView(.{ .texture = .{ .image = image } }); + if (image_view.id == sg.invalid_id) { + return error.InvalidView; + } + return image_view; +} + +fn makeImageWithMipMaps(mipmaps: []const Texture.Data) !sg.Image { + if (mipmaps.len == 0) { + return error.NoMipMaps; + } + + var data: sg.ImageData = .{}; + var mip_levels: std.ArrayListUnmanaged(sg.Range) = .initBuffer(&data.mip_levels); + + for (mipmaps) |mipmap| { + try mip_levels.appendBounded(.{ .ptr = mipmap.rgba, .size = mipmap.width * mipmap.height * 4 }); + } + + const image = sg.makeImage(.{ .width = @intCast(mipmaps[0].width), .height = @intCast(mipmaps[0].height), .pixel_format = .RGBA8, .usage = .{ .immutable = true }, .num_mipmaps = @intCast(mip_levels.items.len), .data = data }); + if (image.id == sg.invalid_id) { + return error.InvalidImage; + } + + return image; +} + +pub fn addTexture(mipmaps: []const Texture.Data) !TextureId { + const image = try makeImageWithMipMaps(mipmaps); + errdefer sg.deallocImage(image); + + const view = try makeView(image); + errdefer sg.deallocView(view); + + assert(mipmaps.len > 0); + const index = textures.items.len; + try textures.append(gpa, .{ .image = image, .view = view, .info = .{ + .width = mipmaps[0].width, + .height = mipmaps[0].height, + } }); + + return @enumFromInt(index); +} + +pub fn getTextureInfo(id: TextureId) TextureInfo { + const texture = textures.items[@intFromEnum(id)]; + return texture.info; +} diff --git a/src/engine/imgui.zig b/src/engine/imgui.zig new file mode 100644 index 0000000..e92f419 --- /dev/null +++ b/src/engine/imgui.zig @@ -0,0 +1,504 @@ +const std = @import("std"); +const Math = @import("./math.zig"); +const build_options = @import("build_options"); +pub const ig = @import("cimgui"); +const Vec2 = Math.Vec2; +const Vec3 = Math.Vec3; +const Vec4 = Math.Vec4; + +const sokol = @import("sokol"); +const sapp = sokol.app; +const simgui = sokol.imgui; + +const enabled = build_options.has_imgui; + +var global_allocator: ?std.mem.Allocator = null; + +pub const WindowOptions = struct { + name: [*c]const u8, + pos: ?Vec2 = null, + size: ?Vec2 = null, + collapsed: ?bool = null, + open: ?*bool = null +}; + +pub const SliderOptions = struct { + label: [*c]const u8, + value: *f32, + min: f32, + max: f32, +}; + +fn toImVec2(vec2: Vec2) ig.ImVec2 { + return ig.ImVec2{ + .x = vec2.x, + .y = vec2.y, + }; +} + +inline fn structCast(T: type, value: anytype) T { + return @as(*T, @ptrFromInt(@intFromPtr(&value))).*; +} + +pub fn setup(gpa: std.mem.Allocator, desc: simgui.Desc) void { + if (!enabled) { + return; + } + + global_allocator = gpa; + simgui.setup(desc); +} + +pub fn addFont(ttf_data: []const u8, font_size: f32) void { + if (!enabled) { + return; + } + + var font_config: ig.ImFontConfig = .{}; + font_config.FontDataOwnedByAtlas = false; + font_config.OversampleH = 2; + font_config.OversampleV = 2; + font_config.GlyphMaxAdvanceX = std.math.floatMax(f32); + font_config.RasterizerMultiply = 1.0; + font_config.RasterizerDensity = 1.0; + font_config.EllipsisChar = 0; + + const io = ig.igGetIO(); + _ = ig.ImFontAtlas_AddFontFromMemoryTTF( + io.*.Fonts, + @constCast(@ptrCast(ttf_data.ptr)), + @intCast(ttf_data.len), + font_size, + &font_config, + null + ); +} + +pub fn shutdown() void { + if (!enabled) { + return; + } + + simgui.shutdown(); +} + +pub fn handleEvent(ev: sapp.Event) bool { + if (enabled) { + return simgui.handleEvent(ev); + } else { + return false; + } +} + +pub fn newFrame(desc: simgui.FrameDesc) void { + if (!enabled) { + return; + } + + simgui.newFrame(desc); +} + +pub fn render() void { + if (!enabled) { + return; + } + + simgui.render(); +} + +pub fn beginWindow(opts: WindowOptions) bool { + if (!enabled) { + return false; + } + + if (opts.pos) |pos| { + ig.igSetNextWindowPos(toImVec2(pos), ig.ImGuiCond_Once); + } + if (opts.size) |size| { + ig.igSetNextWindowSize(toImVec2(size), ig.ImGuiCond_Once); + } + if (opts.collapsed) |collapsed| { + ig.igSetNextWindowCollapsed(collapsed, ig.ImGuiCond_Once); + } + + ig.igSetNextWindowBgAlpha(1); + + var open = ig.igBegin(opts.name, opts.open, ig.ImGuiWindowFlags_None); + if (opts.open) |opts_open| { + if (opts_open.* == false) { + open = false; + } + } + if (!open) { + endWindow(); + } + + return open; +} + +pub fn endWindow() void { + if (!enabled) { + return; + } + + ig.igEnd(); +} + +pub fn textFmt(comptime fmt: []const u8, args: anytype) void { + if (!enabled) { + return; + } + + const gpa = global_allocator orelse return; + + const formatted = std.fmt.allocPrintSentinel(gpa, fmt, args, 0) catch return; + defer gpa.free(formatted); + + text(formatted); +} + +pub fn text(text_z: [*c]const u8) void { + if (!enabled) { + return; + } + + ig.igText("%s", text_z); +} + +pub fn beginDisabled(disabled: bool) void { + if (!enabled) { + return; + } + + ig.igBeginDisabled(disabled); +} + +pub fn endDisabled() void { + if (!enabled) { + return; + } + + ig.igEndDisabled(); +} + +pub fn button(label: [*c]const u8) bool { + if (!enabled) { + return false; + } + + return ig.igButton(label); +} + +pub fn slider(opts: SliderOptions) bool { + if (!enabled) { + return false; + } + + return ig.igSliderFloat(opts.label, opts.value, opts.min, opts.max); +} + +pub fn checkbox(label: [*c]const u8, value: *bool) bool { + if (!enabled) { + return false; + } + + return ig.igCheckbox(label, value); +} + +pub fn beginTabBar(id: [*c]const u8) bool { + if (!enabled) { + return false; + } + + return ig.igBeginTabBar(id, ig.ImGuiTabBarFlags_None); +} + +pub fn endTabBar() void { + if (!enabled) { + return; + } + + ig.igEndTabBar(); +} + +pub fn beginTabItem(label: [*c]const u8) bool { + if (!enabled) { + return false; + } + + return ig.igBeginTabItem(label, null, ig.ImGuiTabItemFlags_None); +} + +pub fn endTabItem() void { + if (!enabled) { + return; + } + + return ig.igEndTabItem(); +} + +pub fn beginGroup() void { + if (!enabled) { + return; + } + + ig.igBeginGroup(); +} + +pub fn endGroup() void { + if (!enabled) { + return; + } + + ig.igEndGroup(); +} + +pub fn sameLine() void { + if (!enabled) { + return; + } + + ig.igSameLine(); +} + +pub fn beginTable(id: [*c]const u8, columns: u32, flags: ig.ImGuiTableFlags) bool { + if (!enabled) { + return false; + } + + return ig.igBeginTable(id, @intCast(columns), flags); +} + +pub fn endTable() void { + if (!enabled) { + return; + } + + ig.igEndTable(); +} + +pub fn tableNextColumn() void { + if (!enabled) { + return; + } + + _ = ig.igTableNextColumn(); +} + +pub fn tableNextRow() void { + if (!enabled) { + return; + } + + _ = ig.igTableNextRow(); +} + +pub fn tableSetColumnIndex(index: usize) void { + if (!enabled) { + return; + } + + _ = ig.igTableSetColumnIndex(@intCast(index)); +} + +pub fn tableSetupColumn(label: [*c]const u8, flags: ig.ImGuiTableColumnFlags) void { + if (!enabled) { + return; + } + + ig.igTableSetupColumn(label, flags); +} + +pub fn tableHeadersRow() void { + if (!enabled) { + return; + } + + ig.igTableHeadersRow(); +} + +pub const ID = union(enum) { + string: []const u8, + int: i32 +}; + +pub fn pushID(id: ID) void { + if (!enabled) { + return; + } + + switch (id) { + .string => |str| ig.igPushIDStr(str.ptr, str.ptr + str.len), + .int => |int| ig.igPushIDInt(int) + } +} + +pub fn popID() void { + if (!enabled) { + return; + } + + ig.igPopID(); +} + +pub const TreeNodeFlags = packed struct { + selected: bool = false, + framed: bool = false, + allow_overlap: bool = false, + no_tree_pushOnOpen: bool = false, + no_auto_open_on_log: bool = false, + default_open: bool = false, + open_on_double_click: bool = false, + open_on_arrow: bool = false, + leaf: bool = false, + bullet: bool = false, + frame_padding: bool = false, + span_avail_width: bool = false, + span_full_width: bool = false, + span_label_width: bool = false, + span_all_columns: bool = false, + label_span_all_columns: bool = false, + nav_left_jumps_back_here: bool = false, + collapsing_header: bool = false, + + fn toInt(self: TreeNodeFlags) u32 { + // TODO: Try using comptime to reduce this duplication. + // Would be great if `toInt()` could be replaced with just a @bitCast + // + // If the underlying C enum is exhaustive, maybe a bitcast could be performed? + // If the order of enums is correct + const flags = .{ + .{ self.selected, ig.ImGuiTreeNodeFlags_Selected }, + .{ self.framed, ig.ImGuiTreeNodeFlags_Framed }, + .{ self.allow_overlap, ig.ImGuiTreeNodeFlags_AllowOverlap }, + .{ self.no_tree_pushOnOpen, ig.ImGuiTreeNodeFlags_NoTreePushOnOpen }, + .{ self.no_auto_open_on_log, ig.ImGuiTreeNodeFlags_NoAutoOpenOnLog }, + .{ self.default_open, ig.ImGuiTreeNodeFlags_DefaultOpen }, + .{ self.open_on_double_click, ig.ImGuiTreeNodeFlags_OpenOnDoubleClick }, + .{ self.open_on_arrow, ig.ImGuiTreeNodeFlags_OpenOnArrow }, + .{ self.leaf, ig.ImGuiTreeNodeFlags_Leaf }, + .{ self.bullet, ig.ImGuiTreeNodeFlags_Bullet }, + .{ self.frame_padding, ig.ImGuiTreeNodeFlags_FramePadding }, + .{ self.span_avail_width, ig.ImGuiTreeNodeFlags_SpanAvailWidth }, + .{ self.span_full_width, ig.ImGuiTreeNodeFlags_SpanFullWidth }, + .{ self.span_label_width, ig.ImGuiTreeNodeFlags_SpanLabelWidth }, + .{ self.span_all_columns, ig.ImGuiTreeNodeFlags_SpanAllColumns }, + .{ self.label_span_all_columns, ig.ImGuiTreeNodeFlags_LabelSpanAllColumns }, + .{ self.nav_left_jumps_back_here, ig.ImGuiTreeNodeFlags_NavLeftJumpsBackHere }, + .{ self.collapsing_header, ig.ImGuiTreeNodeFlags_CollapsingHeader }, + }; + + var sum: u32 = 0; + inline for (flags) |flag_pair| { + if (flag_pair[0]) { + sum += flag_pair[1]; + } + } + return sum; + } +}; + +pub fn treeNode(label: [*c]const u8, flags: TreeNodeFlags) bool { + if (!enabled) { + return false; + } + + return ig.igTreeNodeEx(label, @intCast(flags.toInt())); +} + +pub fn treePop() void { + if (!enabled) { + return; + } + + ig.igTreePop(); +} + +pub fn isItemClicked() bool { + if (!enabled) { + return false; + } + + return ig.igIsItemClicked(); +} + +pub fn isItemToggledOpen() bool { + if (!enabled) { + return false; + } + + return ig.igIsItemToggledOpen(); +} + +pub fn colorPicker4(label: [*c]const u8, color: *Vec4) bool { + if (!enabled) { + return false; + } + + return ig.igColorPicker4(label, color.asArray().ptr, 0, null); +} + +pub fn colorEdit4(label: [*c]const u8, color: *Vec4) bool { + if (!enabled) { + return false; + } + + return ig.igColorEdit4(label, color.asArray().ptr, 0); +} + +pub fn beginCombo(label: [*c]const u8, preview_value: [*c]const u8) bool { + if (!enabled) { + return false; + } + + return ig.igBeginCombo(label, preview_value, 0); +} + +pub fn endCombo() void { + if (!enabled) { + return; + } + + ig.igEndCombo(); +} + +pub fn selectable(label: [*c]const u8, selected: bool) bool { + if (!enabled) { + return false; + } + + return ig.igSelectableEx(label, selected, 0, .{ }); +} + +pub fn setItemDefaultFocus() void { + if (!enabled) { + return; + } + + ig.igSetItemDefaultFocus(); +} + +pub fn combo(label: [*c]const u8, items: []const [*c]const u8, selected: *usize) void { + if (beginCombo(label, items[selected.*])) { + defer endCombo(); + + for (0.., items) |i, item| { + const is_selected = selected.* == i; + if (selectable(item, is_selected)) { + selected.* = i; + } + + if (is_selected) { + setItemDefaultFocus(); + } + } + } +} + +pub fn separator() void { + if (!enabled) { + return; + } + + ig.igSeparator(); +} diff --git a/src/engine/input.zig b/src/engine/input.zig new file mode 100644 index 0000000..ee7ed33 --- /dev/null +++ b/src/engine/input.zig @@ -0,0 +1,124 @@ +const std = @import("std"); +const sokol = @import("sokol"); + +const Frame = @import("./frame.zig"); +const Nanoseconds = Frame.Nanoseconds; + +const Math = @import("./math.zig"); +const Vec2 = Math.Vec2; + +const Input = @This(); + +const SokolKeyCodeInfo = @typeInfo(sokol.app.Keycode); +pub const KeyCode = @Type(.{ + .@"enum" = .{ + .tag_type = std.math.IntFittingRange(0, sokol.app.max_keycodes-1), + .decls = SokolKeyCodeInfo.@"enum".decls, + .fields = SokolKeyCodeInfo.@"enum".fields, + .is_exhaustive = false + } +}); + +pub const MouseButton = enum(i3) { + left = @intFromEnum(sokol.app.Mousebutton.LEFT), + right = @intFromEnum(sokol.app.Mousebutton.RIGHT), + middle = @intFromEnum(sokol.app.Mousebutton.MIDDLE), + _ +}; + +pub fn ButtonStateSet(E: type) type { + return struct { + const Self = @This(); + + down: std.EnumSet(E), + pressed: std.EnumSet(E), + released: std.EnumSet(E), + pressed_at: std.EnumMap(E, Nanoseconds), + + pub const empty = Self{ + .down = .initEmpty(), + .pressed = .initEmpty(), + .released = .initEmpty(), + .pressed_at = .init(.{}), + }; + + fn press(self: *Self, button: E, now: Nanoseconds) void { + self.pressed_at.put(button, now); + self.pressed.insert(button); + self.down.insert(button); + } + + fn release(self: *Self, button: E) void { + self.down.remove(button); + self.released.insert(button); + self.pressed_at.remove(button); + } + + fn releaseAll(self: *Self) void { + var iter = self.down.iterator(); + while (iter.next()) |key_code| { + self.released.insert(key_code); + } + self.down = .initEmpty(); + self.pressed_at = .init(.{}); + } + }; +} + +pub const Event = union(enum) { + mouse_pressed: struct { + button: MouseButton, + position: Vec2, + }, + mouse_released: struct { + button: MouseButton, + position: Vec2, + }, + mouse_move: Vec2, + mouse_enter: Vec2, + mouse_leave, + mouse_scroll: Vec2, + key_pressed: struct { + code: KeyCode, + repeat: bool + }, + key_released: Input.KeyCode, + window_resize, + char: u21, +}; + +pub fn processEvent(frame: *Frame, event: Event) void { + const input = &frame.input; + + switch (event) { + .key_pressed => |opts| { + if (!opts.repeat) { + input.keyboard.press(opts.code, frame.time_ns); + } + }, + .key_released => |key_code| { + input.keyboard.release(key_code); + }, + .mouse_leave => { + input.keyboard.releaseAll(); + + input.mouse_position = null; + input.mouse_button = .empty; + }, + .mouse_enter => |pos| { + input.mouse_position = pos; + }, + .mouse_move => |pos| { + input.mouse_position = pos; + }, + .mouse_pressed => |opts| { + input.mouse_position = opts.position; + input.mouse_button.press(opts.button, frame.time_ns); + }, + .mouse_released => |opts| { + input.mouse_position = opts.position; + input.mouse_button.release(opts.button); + }, + else => {} + } +} diff --git a/src/engine/math.zig b/src/engine/math.zig new file mode 100644 index 0000000..95d0178 --- /dev/null +++ b/src/engine/math.zig @@ -0,0 +1,469 @@ +const std = @import("std"); +const assert = std.debug.assert; + +pub const bytes_per_kib = 1024; +pub const bytes_per_mib = bytes_per_kib * 1024; +pub const bytes_per_gib = bytes_per_mib * 1024; + +pub const bytes_per_kb = 1000; +pub const bytes_per_mb = bytes_per_kb * 1000; +pub const bytes_per_gb = bytes_per_mb * 1000; + +pub const Range = struct { + from: f32, + to: f32, + + pub const zero = init(0, 0); + + pub fn init(from: f32, to: f32) Range { + return Range{ + .from = from, + .to = to + }; + } + + pub fn getSize(self: Range) f32 { + return @abs(self.from - self.to); + } + + pub fn random(self: Range, rng: std.Random) f32 { + return self.from + rng.float(f32) * (self.to - self.from); + } +}; + +pub const Vec2 = extern struct { + x: f32, + y: f32, + + pub const zero = init(0, 0); + + pub fn init(x: f32, y: f32) Vec2 { + return Vec2{ + .x = x, + .y = y, + }; + } + + pub fn initFromInt(T: type, x: T, y: T) Vec2 { + return .init(@floatFromInt(x), @floatFromInt(y)); + } + + pub fn initAngle(angle: f32) Vec2 { + return Vec2{ + .x = @cos(angle), + .y = @sin(angle), + }; + } + + pub fn rotateLeft90(self: Vec2) Vec2 { + return Vec2.init(self.y, -self.x); + } + + pub fn rotateRight90(self: Vec2) Vec2 { + return Vec2.init(-self.y, self.x); + } + + pub fn rotate(self: Vec2, angle: f32) Vec2 { + return init( + @cos(angle) * self.x - @sin(angle) * self.y, + @sin(angle) * self.x + @cos(angle) * self.y, + ); + } + + pub fn rotateAround(self: Vec2, angle: f32, origin: Vec2) Vec2 { + return self.sub(origin).rotate(angle).add(origin); + } + + pub fn getAngle(self: Vec2) f32 { + return std.math.atan2(self.y, self.x); + } + + pub fn flip(self: Vec2) Vec2 { + return Vec2.init(-self.x, -self.y); + } + + pub fn add(self: Vec2, other: Vec2) Vec2 { + return Vec2.init( + self.x + other.x, + self.y + other.y, + ); + } + + pub fn sub(self: Vec2, other: Vec2) Vec2 { + return Vec2.init( + self.x - other.x, + self.y - other.y, + ); + } + + pub fn multiplyScalar(self: Vec2, value: f32) Vec2 { + return Vec2.init( + self.x * value, + self.y * value, + ); + } + + pub fn multiply(self: Vec2, other: Vec2) Vec2 { + return Vec2.init( + self.x * other.x, + self.y * other.y, + ); + } + + pub fn divide(self: Vec2, other: Vec2) Vec2 { + return Vec2.init( + self.x / other.x, + self.y / other.y, + ); + } + + pub fn divideScalar(self: Vec2, value: f32) Vec2 { + return Vec2.init( + self.x / value, + self.y / value, + ); + } + + pub fn lengthSqr(self: Vec2) f32 { + return self.x*self.x + self.y*self.y; + } + + pub fn length(self: Vec2) f32 { + return @sqrt(self.lengthSqr()); + } + + pub fn distance(self: Vec2, other: Vec2) f32 { + return self.sub(other).length(); + } + + pub fn distanceSqr(self: Vec2, other: Vec2) f32 { + return self.sub(other).lengthSqr(); + } + + pub fn limitLength(self: Vec2, max_length: f32) Vec2 { + const self_length = self.length(); + if (self_length > max_length) { + if (self_length == 0) { + return Vec2.init(0, 0); + } + return self.divideScalar(self_length / max_length); + } else { + return self; + } + } + + pub fn normalized(self: Vec2) Vec2 { + const self_length = self.length(); + if (self_length == 0) { + return Vec2.init(0, 0); + } + return self.divideScalar(self_length); + } + + pub fn initScalar(value: f32) Vec2 { + return Vec2.init(value, value); + } + + pub fn eql(self: Vec2, other: Vec2) bool { + return self.x == other.x and self.y == other.y; + } + + pub fn format(self: Vec2, writer: *std.io.Writer) std.io.Writer.Error!void { + try writer.print("Vec2{{ {d}, {d} }}", .{ self.x, self.y }); + } +}; + +pub const Vec3 = extern struct { + x: f32, y: f32, z: f32, + + pub const zero = init(0, 0, 0); + + pub fn init(x: f32, y: f32, z: f32) Vec3 { + return Vec3{ + .x = x, + .y = y, + .z = z, + }; + } + + pub fn initScalar(value: f32) Vec3 { + return Vec3.init(value, value, value); + } + + pub fn asArray(self: *Vec3) []f32 { + const ptr: [*]f32 = @alignCast(@ptrCast(@as(*anyopaque, @ptrCast(self)))); + return ptr[0..3]; + } + + pub fn lerp(a: Vec3, b: Vec3, t: f32) Vec3 { + return Vec3.init( + std.math.lerp(a.x, b.x, t), + std.math.lerp(a.y, b.y, t), + std.math.lerp(a.z, b.z, t), + ); + } + + pub fn clamp(self: Vec3, min_value: f32, max_value: f32) Vec3 { + return Vec3.init( + std.math.clamp(self.x, min_value, max_value), + std.math.clamp(self.y, min_value, max_value), + std.math.clamp(self.z, min_value, max_value), + ); + } +}; + +pub const Vec4 = extern struct { + x: f32, y: f32, z: f32, w: f32, + + pub const zero = init(0, 0, 0, 0); + + pub fn init(x: f32, y: f32, z: f32, w: f32) Vec4 { + return Vec4{ + .x = x, + .y = y, + .z = z, + .w = w + }; + } + + pub fn initVec3XYZ(vec3: Vec3, w: f32) Vec4 { + return init(vec3.x, vec3.y, vec3.z, w); + } + + pub fn initScalar(value: f32) Vec4 { + return Vec4.init(value, value, value, value); + } + + pub fn multiplyMat4(left: Vec4, right: Mat4) Vec4 { + var result: Vec4 = undefined; + + // TODO: SIMD + + result.x = left.x * right.columns[0][0]; + result.y = left.x * right.columns[0][1]; + result.z = left.x * right.columns[0][2]; + result.w = left.x * right.columns[0][3]; + + result.x += left.y * right.columns[1][0]; + result.y += left.y * right.columns[1][1]; + result.z += left.y * right.columns[1][2]; + result.w += left.y * right.columns[1][3]; + + result.x += left.z * right.columns[2][0]; + result.y += left.z * right.columns[2][1]; + result.z += left.z * right.columns[2][2]; + result.w += left.z * right.columns[2][3]; + + result.x += left.w * right.columns[3][0]; + result.y += left.w * right.columns[3][1]; + result.z += left.w * right.columns[3][2]; + result.w += left.w * right.columns[3][3]; + + return result; + } + + pub fn multiply(left: Vec4, right: Vec4) Vec4 { + return init( + left.x * right.x, + left.y * right.y, + left.z * right.z, + left.w * right.w + ); + } + + pub fn asArray(self: *Vec4) []f32 { + const ptr: [*]f32 = @alignCast(@ptrCast(@as(*anyopaque, @ptrCast(self)))); + return ptr[0..4]; + } + + pub fn initArray(array: []const f32) Vec4 { + return Vec4.init(array[0], array[1], array[2], array[3]); + } + + pub fn lerp(a: Vec4, b: Vec4, t: f32) Vec4 { + return Vec4.init( + std.math.lerp(a.x, b.x, t), + std.math.lerp(a.y, b.y, t), + std.math.lerp(a.z, b.z, t), + std.math.lerp(a.w, b.w, t), + ); + } + + pub fn clamp(self: Vec4, min_value: f32, max_value: f32) Vec4 { + return Vec4.init( + std.math.clamp(self.x, min_value, max_value), + std.math.clamp(self.y, min_value, max_value), + std.math.clamp(self.z, min_value, max_value), + std.math.clamp(self.w, min_value, max_value), + ); + } + + pub fn toVec3XYZ(self: Vec4) Vec3 { + return Vec3.init(self.x, self.y, self.z); + } +}; + +pub const Mat4 = extern struct { + columns: [4][4]f32, + + pub fn initZero() Mat4 { + var self: Mat4 = undefined; + @memset(self.asArray(), 0); + return self; + } + + pub fn initIdentity() Mat4 { + return Mat4.initDiagonal(1); + } + + pub fn initDiagonal(value: f32) Mat4 { + var self = Mat4.initZero(); + self.columns[0][0] = value; + self.columns[1][1] = value; + self.columns[2][2] = value; + self.columns[3][3] = value; + return self; + } + + pub fn multiply(left: Mat4, right: Mat4) Mat4 { + var self: Mat4 = undefined; + + inline for (.{ 0, 1, 2, 3 }) |i| { + var column = Vec4.initArray(&right.columns[i]).multiplyMat4(left); + @memcpy(&self.columns[i], column.asArray()); + } + + return self; + } + + pub fn initScale(scale: Vec3) Mat4 { + var self = Mat4.initIdentity(); + self.columns[0][0] = scale.x; + self.columns[1][1] = scale.y; + self.columns[2][2] = scale.z; + return self; + } + + pub fn initTranslate(offset: Vec3) Mat4 { + var self = Mat4.initIdentity(); + self.columns[3][0] = offset.x; + self.columns[3][1] = offset.y; + self.columns[3][2] = offset.z; + return self; + } + + pub fn asArray(self: *Mat4) []f32 { + const ptr: [*]f32 = @alignCast(@ptrCast(@as(*anyopaque, @ptrCast(&self.columns)))); + return ptr[0..16]; + } +}; + +pub const Rect = struct { + pos: Vec2, + size: Vec2, + + pub const zero = Rect{ + .pos = Vec2.zero, + .size = Vec2.zero + }; + + pub fn init(x: f32, y: f32, width: f32, height: f32) Rect { + return Rect{ + .pos = Vec2.init(x, y), + .size = Vec2.init(width, height) + }; + } + + pub fn clip(self: Rect, other: Rect) Rect { + const left_edge = @max(self.left(), other.left()); + const right_edge = @min(self.right(), other.right()); + const top_edge = @max(self.top(), other.top()); + const bottom_edge = @min(self.bottom(), other.bottom()); + return Rect.init( + left_edge, + top_edge, + right_edge - left_edge, + bottom_edge - top_edge + ); + } + + pub fn left(self: Rect) f32 { + return self.pos.x; + } + + pub fn right(self: Rect) f32 { + return self.pos.x + self.size.x; + } + + pub fn top(self: Rect) f32 { + return self.pos.y; + } + + pub fn bottom(self: Rect) f32 { + return self.pos.y + self.size.y; + } + + pub fn center(self: Rect) Vec2 { + return self.pos.add(self.size.multiplyScalar(0.5)); + } + + pub fn multiply(self: Rect, xy: Vec2) Rect { + return Rect{ + .pos = self.pos.multiply(xy), + .size = self.size.multiply(xy), + }; + } + + pub fn divide(self: Rect, xy: Vec2) Rect { + return Rect{ + .pos = self.pos.divide(xy), + .size = self.size.divide(xy), + }; + } + + pub fn isInside(self: Rect, pos: Vec2) bool { + const x_overlap = self.pos.x <= pos.x and pos.x < self.pos.x + self.size.x; + const y_overlap = self.pos.y <= pos.y and pos.y < self.pos.y + self.size.y; + return x_overlap and y_overlap; + } +}; + +pub const Line = struct { + p0: Vec2, + p1: Vec2 +}; + +pub fn isInsideRect(rect_pos: Vec2, rect_size: Vec2, pos: Vec2) bool { + const rect = Rect{ + .pos = rect_pos, + .size = rect_size + }; + return rect.isInside(pos); +} + +pub fn rgba(r: u8, g: u8, b: u8, a: f32) Vec4 { + assert(0 <= a and a <= 1); + return Vec4.init( + @as(f32, @floatFromInt(r)) / 255, + @as(f32, @floatFromInt(g)) / 255, + @as(f32, @floatFromInt(b)) / 255, + a, + ); +} + +pub fn rgb(r: u8, g: u8, b: u8) Vec4 { + return rgba(r, g, b, 1); +} + +pub fn rgb_hex(text: []const u8) ?Vec4 { + if (text.len != 7) { + return null; + } + if (text[0] != '#') { + return null; + } + const r = std.fmt.parseInt(u8, text[1..3], 16) catch return null; + const g = std.fmt.parseInt(u8, text[3..5], 16) catch return null; + const b = std.fmt.parseInt(u8, text[5..7], 16) catch return null; + return rgb(r, g, b); +} diff --git a/src/engine/root.zig b/src/engine/root.zig new file mode 100644 index 0000000..3ae7a79 --- /dev/null +++ b/src/engine/root.zig @@ -0,0 +1,486 @@ +const std = @import("std"); +const log = std.log.scoped(.engine); +const assert = std.debug.assert; + +const sokol = @import("sokol"); +const sapp = sokol.app; + +pub const Math = @import("./math.zig"); +pub const Vec2 = Math.Vec2; +const rgb = Math.rgb; + +pub const Input = @import("./input.zig"); + +pub const Frame = @import("./frame.zig"); + +const ScreenScalar = @import("./screen_scaler.zig"); +pub const imgui = @import("./imgui.zig"); +pub const Graphics = @import("./graphics.zig"); +pub const Audio = @import("./audio/root.zig"); +const tracy = @import("tracy"); +const builtin = @import("builtin"); +const STBImage = @import("stb_image"); + +const Gfx = Graphics; + +const Game = @import("../game.zig"); +const Assets = @import("../assets.zig"); + +const Engine = @This(); + +pub const Nanoseconds = u64; + +allocator: std.mem.Allocator, +started_at: std.time.Instant, +mouse_inside: bool, +last_frame_at: Nanoseconds, + +game: Game, +assets: Assets, +frame: Frame, + +canvas_size: ?Vec2 = null, + +const RunOptions = struct { + window_title: [*:0]const u8 = "Game", + window_width: u31 = 640, + window_height: u31 = 480, +}; + +pub fn run(self: *Engine, opts: RunOptions) !void { + self.* = Engine{ + .allocator = undefined, + .started_at = std.time.Instant.now() catch @panic("Instant.now() unsupported"), + .mouse_inside = false, + .last_frame_at = 0, + .assets = undefined, + .game = undefined, + .frame = undefined + }; + + var debug_allocator: std.heap.DebugAllocator(.{}) = .init; + defer _ = debug_allocator.deinit(); + + // TODO: Use tracy TracingAllocator + if (builtin.cpu.arch.isWasm()) { + self.allocator = std.heap.wasm_allocator; + } else if (builtin.mode == .Debug) { + self.allocator = debug_allocator.allocator(); + } else { + self.allocator = std.heap.smp_allocator; + } + + self.frame.init(self.allocator); + + tracy.setThreadName("Main"); + + if (builtin.os.tag == .linux) { + var sa: std.posix.Sigaction = .{ + .handler = .{ .handler = posixSignalHandler }, + .mask = std.posix.sigemptyset(), + .flags = std.posix.SA.RESTART, + }; + std.posix.sigaction(std.posix.SIG.INT, &sa, null); + } + + // TODO: Don't hard code icon path, allow changing through options + var icon_data = try STBImage.load(@embedFile("../assets/icon.png")); + defer icon_data.deinit(); + + var icon: sapp.IconDesc = .{}; + icon.sokol_default = false; + icon.images[0] = .{ + .width = @intCast(icon_data.width), + .height = @intCast(icon_data.height), + .pixels = .{ + .ptr = icon_data.rgba8_pixels, + .size = icon_data.width * icon_data.height * 4 + } + }; + + sapp.run(.{ + .init_userdata_cb = sokolInitCallback, + .frame_userdata_cb = sokolFrameCallback, + .cleanup_userdata_cb = sokolCleanupCallback, + .event_userdata_cb = sokolEventCallback, + .user_data = self, + .width = opts.window_width, + .height = opts.window_height, + .icon = icon, + .gl = .{ + .major_version = 3, + .minor_version = 3 + }, + .window_title = opts.window_title, + .logger = .{ .func = sokolLogCallback }, + .win32 = .{ + .console_utf8 = true + } + }); +} + +fn sokolInit(self: *Engine) !void { + const zone = tracy.initZone(@src(), .{ }); + defer zone.deinit(); + + try Gfx.init(.{ + .allocator = self.allocator, + .logger = .{ .func = sokolLogCallback }, + .imgui_font = .{ + .ttf_data = @embedFile("../assets/roboto-font/Roboto-Regular.ttf"), + } + }); + + try Audio.init(.{ + .allocator = self.allocator, + .logger = .{ .func = sokolLogCallback }, + }); + + const seed: u64 = @bitCast(std.time.milliTimestamp()); + + self.assets = try Assets.init(self.allocator); + self.game = try Game.init(self.allocator, seed, &self.assets); +} + +fn sokolCleanup(self: *Engine) void { + const zone = tracy.initZone(@src(), .{ }); + defer zone.deinit(); + + self.frame.deinit(); + Audio.deinit(); + self.game.deinit(); + self.assets.deinit(self.allocator); + Gfx.deinit(); +} + +fn sokolFrame(self: *Engine) !void { + tracy.frameMark(); + + const zone = tracy.initZone(@src(), .{ }); + defer zone.deinit(); + + const now = std.time.Instant.now() catch @panic("Instant.now() unsupported"); + const time_passed = now.since(self.started_at); + defer self.last_frame_at = time_passed; + + const frame = &self.frame; + + const screen_size = Vec2.init(sapp.widthf(), sapp.heightf()); + + var revert_mouse_position: ?Vec2 = null; + if (self.canvas_size) |canvas_size| { + if (self.frame.input.mouse_position) |mouse| { + const transform = ScreenScalar.init(screen_size, canvas_size); + + revert_mouse_position = mouse; + self.frame.input.mouse_position = mouse.sub(transform.translation).divideScalar(transform.scale); + } + } + + { + _ = frame.arena.reset(.retain_capacity); + const arena = frame.arena.allocator(); + + const audio_commands_capacity = frame.audio.commands.capacity; + frame.audio = .empty; + try frame.audio.commands.ensureTotalCapacity(arena, audio_commands_capacity); + + const graphics_commands_capacity = frame.graphics.commands.capacity; + const scissor_stack_capacity = frame.graphics.scissor_stack.capacity; + frame.graphics = .empty; + frame.graphics.screen_size = screen_size; + try frame.graphics.commands.ensureTotalCapacity(arena, graphics_commands_capacity); + try frame.graphics.scissor_stack.ensureTotalCapacity(arena, scissor_stack_capacity); + frame.pushScissor(.init(0, 0, sapp.widthf(), sapp.heightf())); + + frame.time_ns = time_passed; + frame.dt_ns = time_passed - self.last_frame_at; + frame.hide_cursor = false; + + try self.game.tick(&self.frame); + + frame.input.keyboard.pressed = .initEmpty(); + frame.input.keyboard.released = .initEmpty(); + frame.input.mouse_button.pressed = .initEmpty(); + frame.input.mouse_button.released = .initEmpty(); + } + + if (self.canvas_size) |canvas_size| { + const transform = ScreenScalar.init( + screen_size, + canvas_size + ); + transform.apply( + screen_size, + &self.frame, + rgb(0, 0, 0) + ); + } + + sapp.showMouse(!self.frame.hide_cursor); + + // Canvas size modification must always be applied a frame later. + // So that mouse coordinate transformations are consistent. + self.canvas_size = self.frame.graphics.canvas_size; + + { + Gfx.beginFrame(); + defer Gfx.endFrame(frame.graphics.clear_color); + + Gfx.drawCommands(frame.graphics.commands.items); + + if (frame.show_debug) { + try self.game.debug(); + try showDebugWindow(&self.frame); + } + } + + for (frame.audio.commands.items) |command| { + try Audio.mixer.commands.push(command); + } + + if (revert_mouse_position) |pos| { + self.frame.input.mouse_position = pos; + } +} + +fn showDebugWindow(frame: *Frame) !void { + if (!imgui.beginWindow(.{ + .name = "Engine", + .pos = Vec2.init(240, 20), + .size = Vec2.init(200, 200), + })) { + return; + } + defer imgui.endWindow(); + + imgui.textFmt("Draw commands: {}\n", .{ + frame.graphics.commands.items.len, + }); + imgui.textFmt("Audio instances: {}/{}\n", .{ + Audio.mixer.instances.items.len, + Audio.mixer.instances.capacity + }); +} + +fn sokolEvent(self: *Engine, e_ptr: [*c]const sapp.Event) !bool { + const zone = tracy.initZone(@src(), .{ }); + defer zone.deinit(); + + const e = e_ptr.*; + + if (imgui.handleEvent(e)) { + if (self.mouse_inside) { + Input.processEvent(&self.frame, .{ + .mouse_leave = {} + }); + } + self.mouse_inside = false; + return true; + } + + switch (e.type) { + .MOUSE_DOWN => { + Input.processEvent(&self.frame, .{ + .mouse_pressed = .{ + .button = @enumFromInt(@intFromEnum(e.mouse_button)), + .position = Vec2.init(e.mouse_x, e.mouse_y) + } + }); + + return true; + }, + .MOUSE_UP => { + Input.processEvent(&self.frame, .{ + .mouse_released = .{ + .button = @enumFromInt(@intFromEnum(e.mouse_button)), + .position = Vec2.init(e.mouse_x, e.mouse_y) + } + }); + + return true; + }, + .MOUSE_MOVE => { + if (!self.mouse_inside) { + Input.processEvent(&self.frame, .{ + .mouse_enter = Vec2.init(e.mouse_x, e.mouse_y) + }); + } else { + Input.processEvent(&self.frame, .{ + .mouse_move = Vec2.init(e.mouse_x, e.mouse_y) + }); + } + + self.mouse_inside = true; + return true; + }, + .MOUSE_ENTER => { + if (!self.mouse_inside) { + Input.processEvent(&self.frame, .{ + .mouse_enter = Vec2.init(e.mouse_x, e.mouse_y) + }); + } + + self.mouse_inside = true; + return true; + }, + .RESIZED => { + if (self.mouse_inside) { + Input.processEvent(&self.frame, .{ + .mouse_leave = {} + }); + } + + Input.processEvent(&self.frame, .{ + .window_resize = {} + }); + + self.mouse_inside = false; + return true; + }, + .MOUSE_LEAVE => { + if (self.mouse_inside) { + Input.processEvent(&self.frame, .{ + .mouse_leave = {} + }); + } + + self.mouse_inside = false; + return true; + }, + .MOUSE_SCROLL => { + Input.processEvent(&self.frame, .{ + .mouse_scroll = Vec2.init(e.scroll_x, e.scroll_y) + }); + + return true; + }, + .KEY_DOWN => { + Input.processEvent(&self.frame, .{ + .key_pressed = .{ + .code = @enumFromInt(@intFromEnum(e.key_code)), + .repeat = e.key_repeat + } + }); + + return true; + }, + .KEY_UP => { + Input.processEvent(&self.frame, .{ + .key_released = @enumFromInt(@intFromEnum(e.key_code)) + }); + + return true; + }, + .CHAR => { + Input.processEvent(&self.frame, .{ + .char = @intCast(e.char_code) + }); + + return true; + }, + .QUIT_REQUESTED => { + // TODO: handle quit request. Maybe show confirmation window in certain cases. + }, + else => {} + } + + return false; +} + +fn sokolEventCallback(e_ptr: [*c]const sapp.Event, userdata: ?*anyopaque) callconv(.c) void { + const engine: *Engine = @alignCast(@ptrCast(userdata)); + + const consume_event = engine.sokolEvent(e_ptr) catch |e| blk: { + log.err("sokolEvent() failed: {}", .{e}); + if (@errorReturnTrace()) |trace| { + std.debug.dumpStackTrace(trace.*); + } + break :blk false; + }; + + if (consume_event) { + sapp.consumeEvent(); + } +} + +fn sokolCleanupCallback(userdata: ?*anyopaque) callconv(.c) void { + const engine: *Engine = @alignCast(@ptrCast(userdata)); + + engine.sokolCleanup(); +} + +fn sokolInitCallback(userdata: ?*anyopaque) callconv(.c) void { + const engine: *Engine = @alignCast(@ptrCast(userdata)); + + engine.sokolInit() catch |e| { + log.err("sokolInit() failed: {}", .{e}); + if (@errorReturnTrace()) |trace| { + std.debug.dumpStackTrace(trace.*); + } + sapp.requestQuit(); + }; +} + +fn sokolFrameCallback(userdata: ?*anyopaque) callconv(.c) void { + const engine: *Engine = @alignCast(@ptrCast(userdata)); + + engine.sokolFrame() catch |e| { + log.err("sokolFrame() failed: {}", .{e}); + if (@errorReturnTrace()) |trace| { + std.debug.dumpStackTrace(trace.*); + } + sapp.requestQuit(); + }; +} + +fn sokolLogFmt(log_level: u32, comptime format: []const u8, args: anytype) void { + const log_sokol = std.log.scoped(.sokol); + + if (log_level == 0) { + log_sokol.err(format, args); + } else if (log_level == 1) { + log_sokol.err(format, args); + } else if (log_level == 2) { + log_sokol.warn(format, args); + } else { + log_sokol.info(format, args); + } +} + +fn cStrToZig(c_str: [*c]const u8) [:0]const u8 { + return std.mem.span(c_str); +} + +fn sokolLogCallback(tag: [*c]const u8, log_level: u32, log_item: u32, message: [*c]const u8, line_nr: u32, filename: [*c]const u8, user_data: ?*anyopaque) callconv(.c) void { + _ = user_data; + + if (filename != null) { + sokolLogFmt( + log_level, + "[{s}][id:{}] {s}:{}: {s}", + .{ + cStrToZig(tag orelse "-"), + log_item, + std.fs.path.basename(cStrToZig(filename orelse "-")), + line_nr, + cStrToZig(message orelse "") + } + ); + } else { + sokolLogFmt( + log_level, + "[{s}][id:{}] {s}", + .{ + cStrToZig(tag orelse "-"), + log_item, + cStrToZig(message orelse "") + } + ); + } +} + +fn posixSignalHandler(sig: i32) callconv(.c) void { + _ = sig; + sapp.requestQuit(); +} diff --git a/src/engine/screen_scaler.zig b/src/engine/screen_scaler.zig new file mode 100644 index 0000000..08a57ea --- /dev/null +++ b/src/engine/screen_scaler.zig @@ -0,0 +1,80 @@ +const Gfx = @import("./graphics.zig"); + +const Math = @import("./math.zig"); +const Vec2 = Math.Vec2; +const Vec4 = Math.Vec4; +const rgb = Math.rgb; + +const Frame = @import("./frame.zig"); + +const ScreenScalar = @This(); + +// TODO: Implement a fractional pixel perfect scalar +// Based on this video: https://www.youtube.com/watch?v=d6tp43wZqps +// And this blog: https://colececil.dev/blog/2017/scaling-pixel-art-without-destroying-it/ + +translation: Vec2, +scale: f32, + +pub fn init(window_size: Vec2, canvas_size: Vec2) ScreenScalar { + // TODO: Render to a lower resolution instead of scaling. + // To avoid pixel bleeding in spritesheet artifacts + const scale = @floor(@min( + window_size.x / canvas_size.x, + window_size.y / canvas_size.y, + )); + + var translation: Vec2 = Vec2.sub(window_size, canvas_size.multiplyScalar(scale)).multiplyScalar(0.5); + translation.x = @round(translation.x); + translation.y = @round(translation.y); + + return ScreenScalar{ + .translation = translation, + .scale = scale + }; +} + +pub fn apply(self: ScreenScalar, window_size: Vec2, frame: *Frame, color: Vec4) void { + const scale = self.scale; + const translation = self.translation; + + frame.prependGraphicsCommand(.{ + .push_transformation = .{ + .translation = translation, + .scale = .init(scale, scale) + } + }); + frame.popTransform(); + + frame.drawRectangle(.{ + .rect = .{ + .pos = .init(0, 0), + .size = .init(window_size.x, translation.y), + }, + .color = color + }); + + frame.drawRectangle(.{ + .rect = .{ + .pos = .init(0, window_size.y - translation.y), + .size = .init(window_size.x, translation.y), + }, + .color = color + }); + + frame.drawRectangle(.{ + .rect = .{ + .pos = .init(0, 0), + .size = .init(translation.x, window_size.y), + }, + .color = color + }); + + frame.drawRectangle(.{ + .rect = .{ + .pos = .init(window_size.x - translation.x, 0), + .size = .init(translation.x, window_size.y), + }, + .color = color + }); +} diff --git a/src/engine/shell.html b/src/engine/shell.html new file mode 100644 index 0000000..5b3aae6 --- /dev/null +++ b/src/engine/shell.html @@ -0,0 +1,53 @@ + + + + + + Sokol + + + + + + {{{ SCRIPT }}} + + diff --git a/src/game.zig b/src/game.zig new file mode 100644 index 0000000..b4eecb8 --- /dev/null +++ b/src/game.zig @@ -0,0 +1,130 @@ +const std = @import("std"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const clamp = std.math.clamp; +const log = std.log.scoped(.game); + +const sokol = @import("sokol"); +const sapp = sokol.app; + +const Assets = @import("./assets.zig"); +const Tilemap = Assets.Tilemap; + +const Engine = @import("./engine/root.zig"); +const Nanoseconds = Engine.Nanoseconds; +const imgui = Engine.imgui; +const Vec2 = Engine.Vec2; +const Vec4 = Engine.Math.Vec4; +const Rect = Engine.Math.Rect; +const rgb = Engine.Math.rgb; +const rgba = Engine.Math.rgba; +const Range = Engine.Math.Range; +const TextureId = Engine.Graphics.TextureId; +const AudioId = Engine.Audio.Data.Id; +const Sprite = Engine.Graphics.Sprite; + +const RaycastTileIterator = @import("./raycast_tile_iterator.zig"); + +const Game = @This(); + +const RNGState = std.Random.DefaultPrng; + +const Player = struct { + pos: Vec2 = .zero, + vel: Vec2 = .zero, + acc: Vec2 = .zero, +}; + +arena: std.heap.ArenaAllocator, +gpa: Allocator, +rng: RNGState, +assets: *Assets, + +player: Player = .{}, + +pub fn init(gpa: Allocator, seed: u64, assets: *Assets) !Game { + var arena = std.heap.ArenaAllocator.init(gpa); + errdefer arena.deinit(); + + return Game{ + .arena = arena, + .gpa = gpa, + .assets = assets, + .player = .{ + .pos = .init(50, 50), + }, + .rng = RNGState.init(seed), + }; +} + +pub fn deinit(self: *Game) void { + self.arena.deinit(); +} + +pub fn tick(self: *Game, frame: *Engine.Frame) !void { + const dt = frame.deltaTime(); + + const canvas_size = Vec2.init(20 * 16, 15 * 16); + frame.graphics.canvas_size = canvas_size; + + if (frame.isKeyPressed(.F3)) { + frame.show_debug = !frame.show_debug; + } + + if (frame.isKeyPressed(.ESCAPE)) { + sapp.requestQuit(); + } + + frame.drawRectangle(.{ + .rect = .init(0, 0, canvas_size.x, canvas_size.y), + .color = rgb(20, 20, 20) + }); + + var dir = Vec2.init(0, 0); + if (frame.isKeyDown(.W)) { + dir.y -= 1; + } + if (frame.isKeyDown(.S)) { + dir.y += 1; + } + if (frame.isKeyDown(.A)) { + dir.x -= 1; + } + if (frame.isKeyDown(.D)) { + dir.x += 1; + } + dir = dir.normalized(); + + const max_speed = 400; + const acceleration = 1500; + const friction_coef = 0.99988; + + self.player.acc = dir.multiplyScalar(acceleration); + self.player.vel = self.player.vel.add(self.player.acc.multiplyScalar(dt)); + self.player.vel = self.player.vel.limitLength(max_speed); + const friction_force = std.math.pow(f32, 1 - friction_coef, dt); + self.player.vel = self.player.vel.multiplyScalar(friction_force); + self.player.pos = self.player.pos.add(self.player.vel.multiplyScalar(dt)); + + var size = self.assets.players_tilemap.tile_size; + frame.drawRectangle(.{ + .rect = .{ + .pos = self.player.pos.sub(size.divideScalar(2)), + .size = size, + }, + .color = rgb(255, 255, 255) + }); +} + +pub fn debug(self: *Game) !void { + if (!imgui.beginWindow(.{ + .name = "Game", + .pos = Vec2.init(20, 20), + .size = Vec2.init(200, 200), + })) { + return; + } + defer imgui.endWindow(); + + _ = self; +} diff --git a/src/game_original.zig b/src/game_original.zig new file mode 100644 index 0000000..12e0628 --- /dev/null +++ b/src/game_original.zig @@ -0,0 +1,719 @@ +const std = @import("std"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const clamp = std.math.clamp; +const log = std.log.scoped(.game); + +const Assets = @import("./assets.zig"); +const Tilemap = Assets.Tilemap; + +const Engine = @import("./engine/root.zig"); +const Nanoseconds = Engine.Nanoseconds; +const imgui = Engine.imgui; +const Vec2 = Engine.Vec2; +const Vec4 = Engine.Math.Vec4; +const Rect = Engine.Math.Rect; +const rgb = Engine.Math.rgb; +const rgba = Engine.Math.rgba; +const Range = Engine.Math.Range; +const TextureId = Engine.Graphics.TextureId; +const AudioId = Engine.Audio.Data.Id; +const Sprite = Engine.Graphics.Sprite; + +const RaycastTileIterator = @import("./raycast_tile_iterator.zig"); + +const Game = @This(); + +const RNGState = std.Random.DefaultPrng; + +const Animation = struct { + texture: TextureId, + frames: []Frame, + + const Frame = struct { + uv: Rect, + duration: f32, + }; + + const State = struct { + frame_index: usize, + timer: f32, + + const default = State{ + .frame_index = 0, + .timer = 0 + }; + + pub fn update(self: *State, animation: Animation, dt: f32) void { + self.timer += dt; + while (true) { + self.frame_index = @mod(self.frame_index, animation.frames.len); + const frame = animation.frames[self.frame_index]; + if (self.timer < frame.duration) { + break; + } + self.timer -= frame.duration; + self.frame_index += 1; + } + } + }; +}; + +const AudioBundle = struct { + cooldown_until: ?Engine.Nanoseconds, + + const empty = AudioBundle{ + .cooldown_until = null, + }; + + const PlayOptions = struct { + sounds: []const AudioId, + volume: Range = .init(1, 1), + fixed_delay: Range = .zero, + rng: std.Random + }; + + pub fn play(self: *AudioBundle, frame: *Engine.Frame, opts: PlayOptions) void { + if (opts.sounds.len == 0) { + return; + } + if (self.cooldown_until) |cooldown_until| { + if (cooldown_until > frame.time_ns) { + return; + } + } + + const sound_index = opts.rng.uintLessThan(usize, opts.sounds.len); + const sound = opts.sounds[sound_index]; + + frame.playAudio(.{ + .id = sound, + .volume = opts.volume.random(opts.rng) + }); + + const sound_info = Engine.Audio.getInfo(sound); + var duration = sound_info.getDuration(); + duration += @intFromFloat(opts.fixed_delay.random(opts.rng) * std.time.ns_per_s); + self.cooldown_until = frame.time_ns + duration; + } +}; + +const Bullet = struct { + position: Vec2, + velocity: Vec2 +}; + +const Tile = struct { + sprites_buffer: [4]Sprite, + sprites_len: usize, + + solid: bool, + + const empty = Tile{ + .sprites_buffer = undefined, + .sprites_len = 0, + .solid = false + }; + + fn sprites(self: *Tile) []Sprite { + return self.sprites_buffer[0..self.sprites_len]; + } + + fn appendSprite(self: *Tile, sprite: Sprite) void { + var list: std.ArrayList(Sprite) = .{ + .items = self.sprites(), + .capacity = self.sprites_buffer.len + }; + + if (list.items.len == list.capacity) { + _ = list.orderedRemove(0); + log.warn("Too many sprites on a single tile", .{}); + } + list.appendAssumeCapacity(sprite); + + self.sprites_len = list.items.len; + } +}; + +const TileGrid = struct { + origin: Vec2, + width: usize, + height: usize, + tile_size: Vec2, + tiles: []Tile, + + pub fn get(self: TileGrid, x: usize, y: usize) *Tile { + assert(0 <= x and x < self.width); + assert(0 <= y and y < self.height); + return &self.tiles[y * self.width + x]; + } + + pub fn isInBounds(self: TileGrid, x: i32, y: i32) bool { + return (0 <= x and x < @as(i32, @intCast(self.width))) and (0 <= y and y < @as(i32, @intCast(self.height))); + } + + pub fn toTileSpace(self: TileGrid, pos: Vec2) Vec2 { + return pos.sub(self.origin).divide(self.tile_size); + } + + pub fn fromTileSpace(self: TileGrid, pos: Vec2) Vec2 { + return pos.multiply(self.tile_size).add(self.origin); + } +}; + +arena: std.heap.ArenaAllocator, +gpa: Allocator, +rng: RNGState, +assets: *Assets, + +player: Vec2, +player_anim_state: Animation.State = .default, +last_faced_left: bool = false, +player_walk_sound: AudioBundle = .empty, +hand_offset: Vec2 = .zero, + +bullets: std.ArrayList(Bullet) = .empty, +tilegrid: TileGrid, + +player_anim: Animation, + +pub fn init(gpa: Allocator, seed: u64, assets: *Assets) !Game { + var arena = std.heap.ArenaAllocator.init(gpa); + errdefer arena.deinit(); + + const player_anim = Animation{ + .texture = assets.players_tilemap.texture, + .frames = try arena.allocator().dupe(Animation.Frame, &.{ + .{ + .uv = assets.players_tilemap.getTileUV(0, 0), + .duration = 0.1, + }, + .{ + .uv = assets.players_tilemap.getTileUV(1, 0), + .duration = 0.2, + } + }), + }; + + const tilemap = assets.terrain_tilemap; + const map_bounds = assets.map.getTileBounds(); + + const map_width = map_bounds.getWidth(); + const map_height = map_bounds.getHeight(); + const tilegrid = TileGrid{ + .origin = Vec2.initFromInt(i32, map_bounds.left, map_bounds.top).multiply(tilemap.tile_size), + .width = map_width, + .height = map_height, + .tile_size = tilemap.tile_size, + .tiles = try arena.allocator().alloc(Tile, map_width * map_height), + }; + + @memset(tilegrid.tiles, .empty); + + { + const texture_info = Engine.Graphics.getTextureInfo(tilemap.texture); + const tilemap_size = Vec2.initFromInt(u32, texture_info.width, texture_info.height); + + for (assets.map.layers) |layer| { + if (layer.variant != .tile) { + continue; + } + + const is_layer_solid = layer.properties.getBool("solid") orelse false; + + const tile_layer = layer.variant.tile; + const layer_bounds = tile_layer.getBounds(); + for (0..layer_bounds.getHeight()) |oy| { + const y = layer_bounds.top + @as(i32, @intCast(oy)); + + for (0..layer_bounds.getWidth()) |ox| { + const x = layer_bounds.left + @as(i32, @intCast(ox)); + const tile_gid = tile_layer.get(x, y) orelse continue; + if (tile_gid == 0) continue; + const tile = assets.map.getTile(assets.tilesets, tile_gid) orelse continue; + + const tile_id_f32: f32 = @floatFromInt(tile.id); + const width_in_tiles = tilemap_size.x / tilemap.tile_size.x; + const tile_x = @rem(tile_id_f32, width_in_tiles); + const tile_y =@divFloor(tile_id_f32, width_in_tiles); + + const tilegrid_tile = tilegrid.get( + @intCast(x - map_bounds.left), + @intCast(y - map_bounds.top) + ); + tilegrid_tile.solid |= is_layer_solid; + tilegrid_tile.appendSprite(.{ + .texture = tilemap.texture, + .uv = tilemap.getTileUV(tile_x, tile_y) + }); + } + } + } + } + + return Game{ + .arena = arena, + .gpa = gpa, + .assets = assets, + .player = findSpawnpoint(assets) orelse .init(0, 0), + .player_anim = player_anim, + .rng = RNGState.init(seed), + .tilegrid = tilegrid + }; +} + +pub fn deinit(self: *Game) void { + self.arena.deinit(); + self.bullets.deinit(self.gpa); +} + +fn findSpawnpoint(assets: *Assets) ?Vec2 { + const map = assets.map; + for (map.layers) |layer| { + if (layer.variant != .object) { + continue; + } + const object_layer = layer.variant.object; + for (object_layer.items) |object| { + if (object.shape != .point) { + continue; + } + const point = object.shape.point; + if (std.mem.eql(u8, object.name, "spawnpoint")) { + return .init(point.x, point.y); + } + } + } + return null; +} + +const DrawTileOptions = struct { + pos: Vec2, + scale: Vec2 = .init(1, 1), + color: Vec4 = rgb(255, 255, 255), + rotation: f32 = 0, + origin: Vec2 = .init(0, 0), + + tilemap: Tilemap, + tile: Vec2 +}; + +fn drawTile(frame: *Engine.Frame, opts: DrawTileOptions) void { + frame.drawRectangle(.{ + .rect = .{ + .pos = opts.pos, + .size = opts.tilemap.tile_size.multiply(opts.scale) + }, + .color = opts.color, + .rotation = opts.rotation, + .origin = opts.origin, + .sprite = .{ + .texture = opts.tilemap.texture, + .uv = opts.tilemap.getTileUV(opts.tile.x, opts.tile.y) + } + }); +} + +fn drawTilemap(self: *Game, frame: *Engine.Frame) void { + for (0..self.tilegrid.height) |y| { + for (0..self.tilegrid.width) |x| { + const tile = self.tilegrid.get(x, y); + if (tile.sprites_len == 0) continue; + + const tile_pos = Vec2.initFromInt(usize, x, y).multiply(self.tilegrid.tile_size); + const tile_rect = Rect{ + .pos = self.tilegrid.origin.add(tile_pos), + .size = self.tilegrid.tile_size + }; + + const color = rgb(255, 255, 255); + for (tile.sprites()) |sprite| { + frame.drawRectangle(.{ + .rect = tile_rect, + .color = color, + .sprite = sprite + }); + } + } + } +} + +const CollisionResult = struct { + time: f32, + normal: Vec2, +}; + +fn sweptAABB(b1: Rect, v1: Vec2, b2: Rect) ?CollisionResult { + var entry_x: f32 = undefined; + var exit_x: f32 = undefined; + if (v1.x > 0) { + entry_x = b2.left() - b1.right(); + exit_x = b2.right() - b1.left(); + } else { + entry_x = b2.right() - b1.left(); + exit_x = b2.left() - b1.right(); + } + + var entry_y: f32 = undefined; + var exit_y: f32 = undefined; + if (v1.y > 0) { + entry_y = b2.top() - b1.bottom(); + exit_y = b2.bottom() - b1.top(); + } else { + entry_y = b2.bottom() - b1.top(); + exit_y = b2.top() - b1.bottom(); + } + + const inf = std.math.inf(f32); + + var entry_x_time: f32 = undefined; + var exit_x_time: f32 = undefined; + if (v1.x == 0) { + entry_x_time = -inf; + exit_x_time = inf; + } else { + entry_x_time = entry_x / v1.x; + exit_x_time = exit_x / v1.x; + } + + var entry_y_time: f32 = undefined; + var exit_y_time: f32 = undefined; + if (v1.y == 0) { + entry_y_time = -inf; + exit_y_time = inf; + } else { + entry_y_time = entry_y / v1.y; + exit_y_time = exit_y / v1.y; + } + + const entry_time = @max(entry_x_time, entry_y_time); + const exit_time = @min(exit_x_time, exit_y_time); + + if (entry_time > exit_time or + (entry_x_time < 0 and entry_y_time < 0) or + entry_x_time > 1.0 or + entry_y_time > 1.0 + ) { + return null; + } + + var result = CollisionResult{ + .time = entry_time, + .normal = .zero + }; + + if (entry_x_time > entry_y_time) { + result.normal.x = if ((exit_x - entry_x) < 0.0) 1 else -1; + } else { + result.normal.y = if ((exit_y - entry_y) < 0.0) 1 else -1; + } + + return result; +} + +fn getStepBounds(rect: Rect, step: Vec2) Rect { + var result = rect; + + if (step.x >= 0) { + result.size.x += step.x; + } else { + result.pos.x += step.x; + result.size.x -= step.x; + } + + if (step.y >= 0) { + result.size.y += step.y; + } else { + result.pos.y += step.y; + result.size.y -= step.y; + } + + return result; +} + +fn collisionResponseSlide(step: *Vec2, collision: CollisionResult) void { + var new_step = step.multiplyScalar(collision.time); + + const remaining_time = 1 - collision.time; + const dotprod = (step.x * collision.normal.y + step.y * collision.normal.x) * remaining_time; + new_step.x += dotprod * collision.normal.y; + new_step.y += dotprod * collision.normal.x; + + step.* = new_step; +} + +fn listNearestSolids(self: *Game, gpa: Allocator, bounds: Rect) ![]Rect { + var result: std.ArrayList(Rect) = .empty; + errdefer result.deinit(gpa); + + var distances: std.ArrayList(f32) = .empty; + defer distances.deinit(gpa); + + const top_left = self.tilegrid.toTileSpace(Vec2.init(bounds.left(), bounds.top())); + const bottom_right = self.tilegrid.toTileSpace(Vec2.init(bounds.right(), bounds.bottom())); + + var y = @floor(top_left.y); + while (y < bottom_right.y) : (y += 1) { + var x = @floor(top_left.x); + while (x < bottom_right.x) : (x += 1) { + const x_i32: i32 = @intFromFloat(x); + const y_i32: i32 = @intFromFloat(y); + if (!self.tilegrid.isInBounds(x_i32, y_i32)) continue; + + const tile = self.tilegrid.get(@intCast(x_i32), @intCast(y_i32)); + if (tile.solid) { + const tile_collider = Rect{ + .pos = self.tilegrid.fromTileSpace(Vec2.init(x, y)), + .size = self.tilegrid.tile_size + }; + try result.append(gpa, tile_collider); + try distances.append(gpa, Vec2.distanceSqr(tile_collider.center(), bounds.center())); + } + } + } + + const Context = struct { + bounds_center: Vec2, + + fn lessThanFn(ctx: @This(), lhs: Rect, rhs: Rect) bool { + const lhs_distance = Vec2.distanceSqr(lhs.center(), ctx.bounds_center); + const rhs_distance = Vec2.distanceSqr(rhs.center(), ctx.bounds_center); + return lhs_distance < rhs_distance; + } + }; + + const ctx = Context{ + .bounds_center = bounds.center() + }; + std.mem.sort(Rect, result.items, ctx, Context.lessThanFn); + + return try result.toOwnedSlice(gpa); +} + +pub fn tick(self: *Game, frame: *Engine.Frame) !void { + const dt = frame.deltaTime(); + + const canvas_size = Vec2.init(20 * 16, 15 * 16); + frame.graphics.canvas_size = canvas_size; + + if (frame.isKeyPressed(.F3)) { + frame.show_debug = !frame.show_debug; + } + + frame.drawRectangle(.{ + .rect = .init(0, 0, canvas_size.x, canvas_size.y), + .color = rgb(20, 20, 20) + }); + + const camera_offset = canvas_size.divideScalar(2).sub(self.player); + frame.pushTransform(camera_offset, .init(1, 1)); + defer frame.popTransform(); + + self.drawTilemap(frame); + + var dir = Vec2.init(0, 0); + if (frame.isKeyDown(.W)) { + dir.y -= 1; + } + if (frame.isKeyDown(.S)) { + dir.y += 1; + } + if (frame.isKeyDown(.A)) { + dir.x -= 1; + } + if (frame.isKeyDown(.D)) { + dir.x += 1; + } + dir = dir.normalized(); + + if (dir.x != 0 or dir.y != 0) { + self.player_anim_state.update(self.player_anim, dt); + self.player_walk_sound.play(frame, .{ + .sounds = self.assets.move_sound, + .fixed_delay = .init(0.1, 0.15), + .volume = .init(0.025, 0.03), + .rng = self.rng.random() + }); + } else { + self.player_anim_state.frame_index = 0; + } + + const velocity = dir.multiplyScalar(50); + var step = velocity.multiplyScalar(dt); + + const player_collider_size = Vec2.init(20, 20); + const player_collider = Rect{ + .pos = self.player.sub(player_collider_size.divideScalar(2)), + .size = player_collider_size, + }; + + { + // const solids = try self.listNearestSolids(frame.arena.allocator(), getStepBounds(player_collider, step)); + // for (solids) |solid| { + // if (sweptAABB(player_collider, step, solid)) |collision| { + // collisionResponseSlide(&step, collision); + // } + // } + + inline for (.{ + // Vec2.init(0, 0), + // Vec2.init(1, 0), + Vec2.init(0, 1), + // Vec2.init(1, 1), + }) |corner_offset| { + const corner = player_collider.pos.add(player_collider.size.multiply(corner_offset)); + var iter = RaycastTileIterator.init( + self.tilegrid.toTileSpace(corner), + self.tilegrid.toTileSpace(corner.add(step)), + ); + while (iter.next()) |collision| { + if (!self.tilegrid.isInBounds(collision.tile_x, collision.tile_y)) break; + const tile = self.tilegrid.get(@intCast(collision.tile_x), @intCast(collision.tile_y)); + if (tile.solid) { + const time = collision.distance / step.divide(self.tilegrid.tile_size).length(); + collisionResponseSlide(&step, .{ + .normal = .initFromInt(i32, collision.normal_x, collision.normal_y), + .time = time + }); + + const pos = Vec2.initFromInt(i32, collision.tile_x, collision.tile_y).multiply(self.tilegrid.tile_size).add(self.tilegrid.origin); + frame.drawRectangle(.{ + .rect = Rect{ + .pos = pos, + .size = self.tilegrid.tile_size, + }, + .color = rgba(200, 20, 20, 0.5) + }); + break; + } + } + } + } + + self.player = self.player.add(step); + + if (dir.x < 0) { + self.last_faced_left = true; + } else if (dir.x > 0) { + self.last_faced_left = false; + } + + var size = self.assets.players_tilemap.tile_size; + if (self.last_faced_left) { + size.x *= -1; + } + frame.drawRectangle(.{ + .rect = .{ + .pos = self.player.sub(size.divideScalar(2)), + .size = size, + }, + .color = rgb(255, 255, 255), + .sprite = .{ + .texture = self.player_anim.texture, + .uv = self.player_anim.frames[self.player_anim_state.frame_index].uv + } + }); + + frame.drawRectangle(.{ + .rect = player_collider, + .color = rgba(20, 255, 255, 0.5) + }); + + + const max_hand_length = 32; + if (frame.input.mouse_position) |mouse_screen| { + const mouse = mouse_screen.sub(camera_offset); + const player_to_mouse = mouse.sub(self.player); + self.hand_offset = mouse.sub(self.player).limitLength(max_hand_length); + + const opacity = clamp((player_to_mouse.length() - max_hand_length) / 16, 0, 1); + drawTile(frame, .{ + .pos = mouse.sub(self.assets.weapons_tilemap.tile_size.multiplyScalar(0.5)), + .tilemap = self.assets.weapons_tilemap, + .color = rgba(255, 255, 255, opacity), + .tile = .init(4, 2) + }); + frame.hide_cursor = true; + + if (false) { + var iter = RaycastTileIterator.init( + self.tilegrid.toTileSpace(self.player), + self.tilegrid.toTileSpace(mouse), + ); + while (iter.next()) |item| { + if (!self.tilegrid.isInBounds(item.tile_x, item.tile_y)) break; + + const tile = self.tilegrid.get(@intCast(item.tile_x), @intCast(item.tile_y)); + const pos = Vec2.initFromInt(i32, item.tile_x, item.tile_y).multiply(self.tilegrid.tile_size).add(self.tilegrid.origin); + + frame.drawRectangle(.{ + .rect = Rect{ + .pos = pos, + .size = self.tilegrid.tile_size, + }, + .color = rgba(200, 20, 20, 0.5) + }); + frame.drawRectangle(.{ + .rect = Rect{ + .pos = pos.add(self.tilegrid.tile_size.multiplyScalar(0.25)).add(self.tilegrid.tile_size.multiplyScalar(0.25).multiply(.initFromInt(i32, item.normal_x, item.normal_y))), + .size = self.tilegrid.tile_size.divideScalar(2), + }, + .color = rgba(20, 200, 20, 0.5) + }); + + if (tile.solid) { + break; + } + } + } + } + + const hand = self.player.add(self.hand_offset); + var hand_flip_x: f32 = 1; + if (self.hand_offset.x < 0) { + hand_flip_x *= -1; + } + const hand_scale = Vec2.init(1, hand_flip_x); + const weapon_size = self.assets.weapons_tilemap.tile_size; + drawTile(frame, .{ + .pos = hand.add(weapon_size.multiplyScalar(-0.5).multiply(hand_scale)), + .scale = hand_scale, + .tilemap = self.assets.weapons_tilemap, + .tile = .init(0, 0), + .origin = weapon_size.multiplyScalar(0.5).multiply(hand_scale), + .rotation = self.hand_offset.getAngle() + }); + + if (frame.isMousePressed(.left)) { + try self.bullets.append(self.gpa, .{ + .position = hand, + .velocity = self.hand_offset.normalized().multiplyScalar(100) + }); + } + + for (self.bullets.items) |*bullet| { + bullet.position = bullet.position.add(bullet.velocity.multiplyScalar(dt)); + + const bullet_size = Vec2.init(16, 16); + frame.drawRectangle(.{ + .rect = .{ + .pos = bullet.position.sub(bullet_size.multiplyScalar(0.5)), + .size = bullet_size + }, + .color = rgb(200, 10, 10) + }); + } +} + +pub fn debug(self: *Game) !void { + if (!imgui.beginWindow(.{ + .name = "Game", + .pos = Vec2.init(20, 20), + .size = Vec2.init(200, 200), + })) { + return; + } + defer imgui.endWindow(); + + imgui.textFmt("Position: {}, {}", .{ self.player.x, self.player.y }); +} diff --git a/src/main.zig b/src/main.zig new file mode 100644 index 0000000..9a6aadc --- /dev/null +++ b/src/main.zig @@ -0,0 +1,8 @@ +const Engine = @import("./engine/root.zig"); + +var engine: Engine = undefined; + +pub fn main() !void { + try engine.run(.{}); +} + diff --git a/src/raycast_tile_iterator.zig b/src/raycast_tile_iterator.zig new file mode 100644 index 0000000..f3257f9 --- /dev/null +++ b/src/raycast_tile_iterator.zig @@ -0,0 +1,97 @@ +const Engine = @import("./engine/root.zig"); +const Vec2 = Engine.Vec2; + +// DDA Algorithm: https://lodev.org/cgtutor/raycasting.html +const RaycastTileIterator = @This(); + +max_distance: f32, +ray_length_1d: Vec2, +check_x: i32, +check_y: i32, +step_x: i32, +step_y: i32, +unit_step_size: Vec2, + +const Item = struct { + tile_x: i32, + tile_y: i32, + normal_x: i32, + normal_y: i32, + distance: f32, +}; + +pub fn init(origin: Vec2, target: Vec2) RaycastTileIterator { + const target_origin = target.sub(origin); + const max_distance = target_origin.length(); + const dir = target_origin.normalized(); + + var unit_step_size_x: f32 = 0; + if (dir.x != 0) { + unit_step_size_x = dir.y / dir.x; + } + + var unit_step_size_y: f32= 0; + if (dir.y != 0) { + unit_step_size_y = dir.x / dir.y; + } + + const unit_step_size = Vec2{ + .x = Vec2.init(1, unit_step_size_x).length(), + .y = Vec2.init(unit_step_size_y, 1).length() + }; + + const step_x: i32 = if (dir.x < 0) -1 else 1; + const step_y: i32 = if (dir.y < 0) -1 else 1; + + const step_x_f32: f32 = @floatFromInt(step_x); + const step_y_f32: f32 = @floatFromInt(step_y); + + const ray_length_1d = (Vec2{ + .x = ((step_x_f32 + 1)/2 - step_x_f32 * @mod(origin.x, 1)), + .y = ((step_y_f32 + 1)/2 - step_y_f32 * @mod(origin.y, 1)) + }).multiply(unit_step_size); + + const check_x: i32 = @intFromFloat(origin.x); + const check_y: i32 = @intFromFloat(origin.y); + + return RaycastTileIterator{ + .max_distance = max_distance, + .ray_length_1d = ray_length_1d, + .check_x = check_x, + .check_y = check_y, + .step_x = step_x, + .step_y = step_y, + .unit_step_size = unit_step_size + }; +} + +pub fn next(self: *RaycastTileIterator) ?Item { + if (self.ray_length_1d.x > self.max_distance and self.ray_length_1d.y > self.max_distance) { + return null; + } + + var normal_x: i32 = 0; + var normal_y: i32 = 0; + var distance: f32 = undefined; + if (self.ray_length_1d.x < self.ray_length_1d.y) { + distance = self.ray_length_1d.x; + + normal_x = -self.step_x; + self.check_x += self.step_x; + self.ray_length_1d.x += self.unit_step_size.x; + } else { + distance = self.ray_length_1d.y; + + normal_y = -self.step_y; + self.check_y += self.step_y; + self.ray_length_1d.y += self.unit_step_size.y; + } + + return .{ + .distance = distance, + .tile_x = self.check_x, + .tile_y = self.check_y, + .normal_x = normal_x, + .normal_y = normal_y + }; +} diff --git a/tools/png-to-icon.zig b/tools/png-to-icon.zig new file mode 100644 index 0000000..424b4fc --- /dev/null +++ b/tools/png-to-icon.zig @@ -0,0 +1,56 @@ +const std = @import("std"); +const STBImage = @import("stb_image"); + +// https://en.wikipedia.org/wiki/ICO_(file_format)#Icon_file_structure + +pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); + defer _ = gpa.deinit(); + + const args = try std.process.argsAlloc(allocator); + defer std.process.argsFree(allocator, args); + + if (args.len != 3) { + std.debug.print("Usage: ./png-to-icon ", .{}); + std.process.exit(1); + } + + const cwd = std.fs.cwd(); + const input_png_path = args[1]; + const output_ico_path = args[2]; + + const input_png_data = try cwd.readFileAlloc(allocator, input_png_path, 1024 * 1024 * 5); + defer allocator.free(input_png_data); + + const png_image = try STBImage.load(input_png_data); + defer png_image.deinit(); + + std.debug.assert(png_image.width > 0 and png_image.width <= 256); + std.debug.assert(png_image.height > 0 and png_image.height <= 256); + + const output_ico_file = try std.fs.cwd().createFile(output_ico_path, .{ }); + defer output_ico_file.close(); + + var buffer: [4096 * 4]u8 = undefined; + var writer = output_ico_file.writer(&buffer); + + // ICONDIR structure + try writer.interface.writeInt(u16, 0, .little); // Must always be zero + try writer.interface.writeInt(u16, 1, .little); // Image type. 1 for .ICO + try writer.interface.writeInt(u16, 1, .little); // Number of images + + // ICONDIRENTRY structure + try writer.interface.writeInt(u8, @truncate(png_image.width), .little); // Image width + try writer.interface.writeInt(u8, @truncate(png_image.height), .little); // Image height + try writer.interface.writeInt(u8, 0, .little); // Number of colors in color pallete. 0 means that color pallete is not used + try writer.interface.writeInt(u8, 0, .little); // Must always be zero + try writer.interface.writeInt(u16, 0, .little); // Color plane + try writer.interface.writeInt(u16, 32, .little); // Bits per pixel + try writer.interface.writeInt(u32, @intCast(input_png_data.len), .little); // Image size in bytes + try writer.interface.writeInt(u32, 22, .little); // Offset to image data from the start + + // PNG image data + try writer.interface.writeAll(input_png_data); + try writer.interface.flush(); +}