fix: world generation using axial coord

src/hex.zig

···
 
 pub const Point = struct { x: f32, y: f32 };
 
-// Cubic coordinates: q + r + s = 0 constraint
-pub const Cubic = struct {
+// Axial coordinates: q + r + s = 0 constraint
+// s = -q-r
+pub const Axial = struct {
     q: i32,
     r: i32,
     s: i32,
 
-    pub fn init(q: i32, r: i32) Cubic {
+    pub fn init(q: i32, r: i32) Axial {
         return .{ .q = q, .r = r, .s = -q - r };
     }
 
-    pub fn add(self: Cubic, other: Cubic) Cubic {
+    pub fn add(self: Axial, other: Axial) Axial {
         return .{ .q = self.q + other.q, .r = self.r + other.r, .s = self.s + other.s };
     }
 
-    pub fn sub(self: Cubic, other: Cubic) Cubic {
+    pub fn sub(self: Axial, other: Axial) Axial {
         return .{ .q = self.q - other.q, .r = self.r - other.r, .s = self.s - other.s };
     }
 
-    pub fn neighbor(self: Cubic, dir: Direction) Cubic {
+    pub fn neighbor(self: Axial, dir: Direction) Axial {
         return self.add(direction_vectors[@intFromEnum(dir)]);
     }
 
-    pub fn toPixel(self: Cubic, size: f32) Point {
+    pub fn toPixel(self: Axial, size: f32) Point {
         const q: f32 = @floatFromInt(self.q);
         const r: f32 = @floatFromInt(self.r);
         return .{
···
         };
     }
 
-    pub fn toOffset(self: Cubic) Offset {
+    // flat-top odd-q
+    pub fn toOffset(self: Axial) Offset {
         const col = self.q;
-        const row = self.r + @divFloor(self.q, 2);
+        const row = self.r + @divFloor(self.q - (self.q & 1), 2);
         return .{ .col = col, .row = row };
     }
 };
···
     col: i32,
     row: i32,
 
-    pub fn toCubic(self: Offset) Cubic {
+    // flat-top odd-q
+    pub fn toAxial(self: Offset) Axial {
         const q = self.col;
-        const r = self.row - @divFloor(self.col, 2);
-        return Cubic.init(q, r);
+        const r = self.row - @divFloor(self.col - (self.col & 1), 2);
+        return Axial.init(q, r);
     }
 };
 
-const direction_vectors = [6]Cubic{
+const direction_vectors = [6]Axial{
     .{ .q = 0, .r = -1, .s = 1 }, // top_left
     .{ .q = 1, .r = -1, .s = 0 }, // top
     .{ .q = 1, .r = 0, .s = -1 }, // top_right
···
     .{ .q = -1, .r = 0, .s = 1 }, // bottom_left
 };
 
-pub const HexCell = struct { inner_radius: f32, outer_radius: f32, height: f32, width: f32, center: Point, cubic: Cubic };
+pub const HexCell = struct { inner_radius: f32, outer_radius: f32, height: f32, width: f32, center: Point, cubic: Axial };
 pub const Cell = HexCell;
 
 pub const HexDirections = enum { top_left, top, top_right, bottom_right, bottom, bottom_left };
···
     return Point{ .x = center.x + x_offset, .y = center.y + y_offset };
 }
 
-pub fn new_hex(outer_radius: f32, cubic: Cubic) HexCell {
+pub fn new_hex(outer_radius: f32, cubic: Axial) HexCell {
     const size = outer_radius;
     const inner = calculate_inner_radius(size);
     const center = cubic.toPixel(size);
···
 pub fn new_hex_at(outer_radius: f32, center: Point) HexCell {
     const size = outer_radius;
     const inner = calculate_inner_radius(size);
-    return HexCell{ .inner_radius = inner, .outer_radius = size, .height = sqrt_3 * size, .width = 2 * size, .center = center, .cubic = Cubic.init(0, 0) };
+    return HexCell{ .inner_radius = inner, .outer_radius = size, .height = sqrt_3 * size, .width = 2 * size, .center = center, .cubic = Axial.init(0, 0) };
 }
 
 pub fn add_hex(base: HexCell, direction: HexDirections) HexCell {

src/main.zig

···
 const lib = @import("zig_civ");
 const rl = @import("raylib");
 
+const screen_offset_x: f32 = 400.0; // center of 800px screen
+const screen_offset_y: f32 = 225.0; // center of 450px screen
+
 fn draw_hex(hex: lib.hex.HexCell) void {
     var corners: [6]lib.hex.Point = undefined;
     for (0..6) |i| {
···
         const start = corners[i];
         const end = corners[@mod(i + 1, 6)];
 
-        std.debug.print("sx: {d} sy: {d} ex:{d} ey:{d}\n", .{ start.x, start.y, end.x, end.y });
-
-        const start_x: i32 = @intFromFloat(@round(start.x));
-        const start_y: i32 = @intFromFloat(@round(start.y));
-        const end_x: i32 = @intFromFloat(@round(end.x));
-        const end_y: i32 = @intFromFloat(@round(end.y));
+        const start_x: i32 = @intFromFloat(@round(start.x + screen_offset_x));
+        const start_y: i32 = @intFromFloat(@round(start.y + screen_offset_y));
+        const end_x: i32 = @intFromFloat(@round(end.x + screen_offset_x));
+        const end_y: i32 = @intFromFloat(@round(end.y + screen_offset_y));
 
         rl.drawLine(start_x, start_y, end_x, end_y, .black);
     }
 }
 
-pub fn main() anyerror!void {
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Axial template: 7x7 grid, center at [3][3], indexed [r+3][q+3]
+    // Hexagon shape for radius 3
+    //const template = [7][7]u1{
+    ////  q: -3  -2  -1   0   1   2   3
+    //.{ 0, 0, 0, 1, 1, 1, 1 }, // r = -3
+    //.{ 0, 0, 1, 1, 1, 1, 1 }, // r = -2
+    //.{ 0, 1, 1, 1, 1, 1, 1 }, // r = -1
+    //.{ 1, 1, 1, 1, 1, 1, 1 }, // r =  0
+    //.{ 1, 1, 1, 1, 1, 1, 0 }, // r =  1
+    //.{ 1, 1, 1, 1, 1, 0, 0 }, // r =  2
+    //.{ 1, 1, 1, 1, 0, 0, 0 }, // r =  3
+    //};
+
+    //const template_rombus = [7][7]u1{
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //.{ 1, 1, 1, 1, 1, 1, 1 },
+    //};
+
+    const template_left_triangle = [7][7]u1{
+        .{ 1, 1, 1, 1, 1, 1, 1 },
+        .{ 1, 1, 1, 1, 1, 1, 0 },
+        .{ 1, 1, 1, 1, 1, 0, 0 },
+        .{ 1, 1, 1, 1, 0, 0, 0 },
+        .{ 1, 1, 1, 0, 0, 0, 0 },
+        .{ 1, 1, 0, 0, 0, 0, 0 },
+        .{ 1, 0, 0, 0, 0, 0, 0 },
+    };
+
+    const template = template_left_triangle;
+
+    var grid = try lib.world.generateFromTemplate(3, &template, 40.0, allocator);
+    defer grid.deinit(allocator);
+
     // Initialization
-    //--------------------------------------------------------------------------------------
     const screenWidth = 800;
     const screenHeight = 450;
     const fps = 60;
 
     rl.initWindow(screenWidth, screenHeight, "raylib.hex-zig [core] example - basic window");
-    defer rl.closeWindow(); // Close window and OpenGL context
+    defer rl.closeWindow();
 
-    rl.setTargetFPS(fps); // Set our game to run at 60 frames-per-second
-    //--------------------------------------------------------------------------------------
+    rl.setTargetFPS(fps);
 
     // Main game loop
-    while (!rl.windowShouldClose()) { // Detect window close button or ESC key
-        // Update
-        //----------------------------------------------------------------------------------
-        // TODO: Update your variables here
-        //----------------------------------------------------------------------------------
-        const template = [5][8]u1{
-            .{ 1, 1, 1, 1, 1, 1, 1, 1 },
-            .{ 1, 1, 1, 0, 0, 1, 1, 1 },
-            .{ 1, 1, 0, 0, 0, 0, 1, 1 },
-            .{ 1, 1, 1, 0, 0, 1, 1, 1 },
-            .{ 1, 1, 1, 1, 1, 1, 1, 1 },
-        };
-        const grid = lib.world.generateWorld(5, 8, &template, 40.0);
-
-        // Draw
-        //----------------------------------------------------------------------------------
+    while (!rl.windowShouldClose()) {
         rl.beginDrawing();
         defer rl.endDrawing();
 
         rl.clearBackground(.white);
 
-        for (grid) |row| {
-            for (row) |maybe_cell| {
-                if (maybe_cell) |cell| {
-                    draw_hex(cell);
-                }
-            }
+        for (grid.items) |cell| {
+            draw_hex(cell);
         }
-
-        //rl.drawText("Congrats! You created your first window!", 190, 200, 20, .light_gray);
-        //----------------------------------------------------------------------------------
     }
 }

src/world.zig

···
 const hex = @import("hex.zig");
 const tst = std.testing;
 
+// Generate hexagon-shaped map with given radius (N rings around center)
+// Uses axial coords: |q|<=N, |r|<=N, |q+r|<=N
+pub fn generateHexWorld(comptime N: i32, outer_radius: f32, allocator: std.mem.Allocator) !std.ArrayListUnmanaged(hex.Cell) {
+    var cells = std.ArrayListUnmanaged(hex.Cell){};
+
+    var q: i32 = -N;
+    while (q <= N) : (q += 1) {
+        const r1 = @max(-N, -q - N);
+        const r2 = @min(N, -q + N);
+        var r: i32 = r1;
+        while (r <= r2) : (r += 1) {
+            try cells.append(allocator, hex.new_hex(outer_radius, hex.Axial.init(q, r)));
+        }
+    }
+
+    return cells;
+}
+
+// Template-based generation using axial coords
+// Template indexed by [r][q] where r,q range from -N to +N
+// Template size is (2*N+1) x (2*N+1), center is at [N][N]
+pub fn generateFromTemplate(comptime N: i32, template: *const [2 * N + 1][2 * N + 1]u1, outer_radius: f32, allocator: std.mem.Allocator) !std.ArrayListUnmanaged(hex.Cell) {
+    var cells = std.ArrayListUnmanaged(hex.Cell){};
+
+    var q: i32 = -N;
+    while (q <= N) : (q += 1) {
+        var r: i32 = -N;
+        while (r <= N) : (r += 1) {
+            const ti_r: usize = @intCast(r + N);
+            const ti_q: usize = @intCast(q + N);
+            if (template[ti_r][ti_q] == 1) {
+                try cells.append(allocator, hex.new_hex(outer_radius, hex.Axial.init(q, r)));
+            }
+        }
+    }
+
+    return cells;
+}
+
+// Old template-based generation (offset coords)
 pub fn generateWorld(comptime H: usize, comptime W: usize, template: *const [H][W]u1, outer_radius: f32) [H][W]?hex.Cell {
     var grid: [H][W]?hex.Cell = undefined;
 
···
         for (0..W) |col| {
             if (template[row][col] == 1) {
                 const offset = hex.Offset{ .col = @intCast(col), .row = @intCast(row) };
-                grid[row][col] = hex.new_hex(outer_radius, offset.toCubic());
+                grid[row][col] = hex.new_hex(outer_radius, offset.toAxial());
             } else {
                 grid[row][col] = null;
             }