1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
// This file is part of ZiRC
//
// Copyright (C) 2021, tslil clingman
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
const std = @import("std");
pub const Object = struct {
height: f32,
width: f32,
texture: u8,
pos_x: f32,
pos_y: f32,
pos_z: f32 = 0,
};
pub const Cell = struct {
floor_height: f32 = 0,
ceiling_height: f32 = DEFAULT_HEIGHT,
draw_down: bool = false,
lower_texture: u8 = 0,
upper_texture: u8 = 0,
floor_texture: u8 = 0,
ceiling_texture: u8 = 2,
vertices: []const [2]f32 = &[_][2]f32{
.{ 0.25, 0.25 },
.{ 0.75, 0.25 },
.{ 0.75, 0.75 },
.{ 0.25, 0.75 },
.{ 0.25, 0.25 },
},
pub const floor = Cell{};
pub const DEFAULT_HEIGHT: f32 = 4;
};
pub const Map = struct {
width: u32,
height: u32,
size: f32 = 64,
cells: std.ArrayList(Cell),
objects: std.ArrayList(Object),
pub fn deinit(self: Map) void {
self.cells.deinit();
self.objects.deinit();
}
pub fn new(width: u32, height: u32, alloc: *std.mem.Allocator) !Map {
var cells = std.ArrayList(Cell).init(alloc);
try cells.ensureTotalCapacity(width * height);
try cells.appendNTimes(Cell.floor, width * height);
var objects = std.ArrayList(Object).init(alloc);
return Map{ .width = width, .height = height, .cells = cells, .objects = objects };
}
pub fn inBounds(self: Map, x: i32, y: i32) bool {
return (x < self.width and x >= 0 and y < self.height and y >= 0);
}
pub fn lookup(self: Map, x: i32, y: i32) Cell {
// std.debug.assert(x >= 0 and y >= 0); // would this work as a compiler hint?
return self.cells.items[@intCast(u32, y) * self.width + @intCast(u32, x)];
}
};
|
