A library for parsing Tiled maps.
fix layers_by_name
+39
-12
+1
-1
build.zig.zon
+1
-1
build.zig.zon
+36
-8
src/Map.zig
+36
-8
src/Map.zig
···
5
5
infinite: bool,
6
6
orientation: Orientation,
7
7
8
-
layers: std.StringHashMapUnmanaged(Layer),
8
+
layers_by_name: std.StringHashMapUnmanaged(Layer),
9
+
layers: std.ArrayList(Layer),
9
10
tilesets: std.ArrayList(Tileset),
10
11
11
12
background_color: ?Color = null,
···
33
34
.background_color = if (json_map.backgroundcolor) |color| color else null,
34
35
.class = if (json_map.class) |c| try alloc.dupe(u8, c) else null,
35
36
.tilesets = .empty,
37
+
.layers_by_name = .empty,
36
38
.layers = .empty,
37
39
};
38
40
···
46
48
if (json_map.layers) |json_layers| {
47
49
for (json_layers) |json_layer| {
48
50
const layer = try Layer.fromJson(alloc, json_layer);
49
-
try map.layers.put(alloc, layer.name, layer);
51
+
try map.layers.append(alloc, layer);
52
+
try map.layers_by_name.put(alloc, layer.name, layer);
50
53
}
51
54
}
52
55
···
73
76
pub fn deinit(self: *Map, allocator: Allocator) void {
74
77
if (self.class) |class| allocator.free(class);
75
78
76
-
var layers_it = self.layers.valueIterator();
77
-
while (layers_it.next()) |value_ptr| {
78
-
value_ptr.*.deinit(allocator);
79
+
for (self.layers.items) |*layer| {
80
+
layer.deinit(allocator);
79
81
}
80
82
self.layers.deinit(allocator);
83
+
84
+
self.layers_by_name.deinit(allocator);
81
85
82
86
for (self.tilesets.items) |*tileset| {
83
87
tileset.deinit(allocator);
···
106
110
107
111
/// Finds first object
108
112
pub fn findObjectByClass(self: Map, class: []const u8) ?Object {
109
-
var layer_it = self.layers.valueIterator();
113
+
var layer_it = self.layers_by_name.valueIterator();
110
114
while (layer_it.next()) |layer| {
111
115
if (layer.content == .object_group) {
112
116
if (layer.content.object_group.getByClass(class)) |object| {
···
119
123
120
124
/// Finds first object by name
121
125
pub fn findObject(self: Map, name: []const u8) ?Object {
122
-
var layer_it = self.layers.valueIterator();
123
-
while (layer_it.next()) |layer| {
126
+
// var layer_it = self.layers_by_name.valueIterator();
127
+
// while (layer_it.next()) |layer| {
128
+
for (self.layers.items) |layer| {
124
129
if (layer.content == .object_group) {
125
130
if (layer.content.object_group.get(name)) |object| {
126
131
return object;
···
179
184
pub const RenderOrder = enum { @"right-down", @"right-up", @"left-down", @"left-up" };
180
185
pub const StaggerAxis = enum { x, y };
181
186
pub const StaggerIndex = enum { odd, even };
187
+
};
188
+
189
+
pub const Gid = packed struct(u32) {
190
+
flags: Flags,
191
+
gid: u28,
192
+
193
+
pub fn fromInt(item: u32) Gid {
194
+
return @bitCast(item);
195
+
}
196
+
};
197
+
198
+
pub const Flags = packed struct(u4) {
199
+
flipped_horizontally: bool,
200
+
flipped_vertically: bool,
201
+
flipped_diagonally: bool,
202
+
rotated_120: bool,
203
+
204
+
pub const clear: Flags = .{
205
+
.flipped_horizontally = false,
206
+
.flipped_vertically = false,
207
+
.flipped_diagonally = false,
208
+
.rotated_120 = false,
209
+
};
182
210
};
183
211
184
212
const Map = @This();
-1
src/layer.zig
-1
src/layer.zig
+2
-2
test/maps.zig
+2
-2
test/maps.zig
···
37
37
38
38
try expectEqual(false, map.infinite);
39
39
40
-
const layer = map.layers.get("Tile Layer 1").?;
40
+
const layer = map.layers_by_name.get("Tile Layer 1").?;
41
41
try expectEqual(1, layer.content.tile_layer.data.items[0]);
42
42
}
43
43
···
64
64
65
65
try expectEqual(true, map.infinite);
66
66
67
-
const layer = map.layers.get("ground").?;
67
+
const layer = map.layers_by_name.get("ground").?;
68
68
try expectEqual(7, layer.content.tile_layer.chunks.?[0].data[0]);
69
69
}
70
70