A library for parsing Tiled maps.
Simplify layers (#4)
* fix and update examples
* specifying LICENCE is standard
* use just one list of layers
* increment version
authored by
Kent Smith
and committed by
GitHub
694b0de3
c9651616
+36
-51
+5
-5
README.md
+5
-5
README.md
···
45
45
### Maps
46
46
47
47
```zig
48
-
const map = try tmz.Map.initFromFile(allocator, "map.tmj");
48
+
var map = try tmz.Map.initFromFile(allocator, "map.tmj");
49
49
defer map.deinit(allocator);
50
50
51
51
std.debug.info("Map size: {d} x {d}\n", .{ map.width, map.height });
52
52
53
-
const object = map.getObject("player");
53
+
const object = map.findObject("player");
54
54
if (object) |player| {
55
55
std.debug.info("Player position: {d},{d}\n", .{ player.x, player.y });
56
56
}
57
57
58
-
const ground_layer = map.layers.get("ground");
58
+
const ground_layer = map.findLayer("ground");
59
59
if (ground_layer) |layer| {
60
60
for (layer.content.data.items) |gid| {
61
61
const tile = map.getTile(gid);
62
62
if (tile) |t| {
63
-
drawTile(tile.image, tile.x, tile.y, tile.orientation);
63
+
drawTile(t.image, t.x, t.y, t.orientation);
64
64
}
65
65
}
66
66
}
···
73
73
### Tilesets
74
74
75
75
```zig
76
-
const tileset = try tmz.Tileset.initFromSlice(allocator, @embedFile("tileset.tsj"));
76
+
var tileset = try tmz.Tileset.initFromSlice(allocator, @embedFile("tileset.tsj"));
77
77
defer tileset.deinit(allocator);
78
78
79
79
if (tileset.name) |name| {
+2
-1
build.zig.zon
+2
-1
build.zig.zon
···
1
1
.{
2
2
.name = .tmz,
3
-
.version = "0.2.4",
3
+
.version = "0.3.0",
4
4
.fingerprint = 0xcc3a94566dc4ab5d, // Changing this has security and trust implications.
5
5
.minimum_zig_version = "0.15.1",
6
6
.dependencies = .{},
7
7
.paths = .{
8
8
"build.zig",
9
9
"build.zig.zon",
10
+
"LICENSE",
10
11
"src",
11
12
},
12
13
}
+26
-42
src/Map.zig
+26
-42
src/Map.zig
···
5
5
infinite: bool,
6
6
orientation: Orientation,
7
7
8
-
layers_by_name: std.StringHashMapUnmanaged(Layer),
9
-
layers: std.ArrayList(Layer),
8
+
layers: std.StringHashMapUnmanaged(Layer),
10
9
properties: std.StringHashMapUnmanaged(Property),
11
10
tilesets: std.ArrayList(Tileset),
12
11
···
35
34
.background_color = if (json_map.backgroundcolor) |color| color else null,
36
35
.class = if (json_map.class) |c| try alloc.dupe(u8, c) else null,
37
36
.tilesets = .empty,
38
-
.layers_by_name = .empty,
39
37
.layers = .empty,
40
38
.properties = .empty,
41
39
};
···
50
48
if (json_map.layers) |json_layers| {
51
49
for (json_layers) |json_layer| {
52
50
const layer = try Layer.fromJson(alloc, json_layer);
53
-
try map.layers.append(alloc, layer);
54
-
try map.layers_by_name.put(alloc, layer.name, layer);
51
+
try map.layers.put(alloc, layer.name, layer);
55
52
}
56
53
}
57
54
···
85
82
pub fn deinit(self: *Map, allocator: Allocator) void {
86
83
if (self.class) |class| allocator.free(class);
87
84
88
-
for (self.layers.items) |*layer| {
89
-
layer.deinit(allocator);
85
+
var layers_it = self.layers.valueIterator();
86
+
while (layers_it.next()) |layer| {
87
+
layer.*.deinit(allocator);
90
88
}
91
89
self.layers.deinit(allocator);
92
90
93
-
self.layers_by_name.deinit(allocator);
94
-
95
91
for (self.tilesets.items) |*tileset| {
96
92
tileset.deinit(allocator);
97
93
}
98
94
self.tilesets.deinit(allocator);
99
95
100
96
var properties_it = self.properties.valueIterator();
101
-
while (properties_it.next()) |value_ptr| {
102
-
value_ptr.*.deinit(allocator);
97
+
while (properties_it.next()) |prop| {
98
+
prop.*.deinit(allocator);
103
99
}
104
100
self.properties.deinit(allocator);
105
101
}
···
119
115
120
116
/// Finds first object
121
117
pub fn findObjectByClass(self: Map, class: []const u8) ?Object {
122
-
var layer_it = self.layers_by_name.valueIterator();
118
+
var layer_it = self.layers.valueIterator();
123
119
while (layer_it.next()) |layer| {
124
120
if (layer.content == .object_group) {
125
121
if (layer.content.object_group.getByClass(class)) |object| {
···
132
128
133
129
/// Finds first object by name
134
130
pub fn findObject(self: Map, name: []const u8) ?Object {
135
-
// var layer_it = self.layers_by_name.valueIterator();
136
-
// while (layer_it.next()) |layer| {
137
-
for (self.layers.items) |layer| {
131
+
var it = self.layers.valueIterator();
132
+
while (it.next()) |layer| {
138
133
if (layer.content == .object_group) {
139
134
if (layer.content.object_group.get(name)) |object| {
140
135
return object;
···
144
139
return null;
145
140
}
146
141
142
+
/// Finds first layer by name
143
+
pub fn findLayer(self: Map, name: []const u8) ?Layer {
144
+
return self.layers.get(name);
145
+
}
146
+
147
147
/// Finds first layer by class
148
148
pub fn findLayerByClass(self: Map, class: []const u8) ?Layer {
149
-
var it = filterLayersByClass(self.layers.items, class);
150
-
return it.next();
149
+
var it = self.layers.valueIterator();
150
+
while (it.next()) |layer| {
151
+
if (layer.class) |layer_class| {
152
+
return if (std.mem.eql(u8, class, layer_class)) layer.* else null;
153
+
}
154
+
}
155
+
return null;
151
156
}
152
157
153
158
/// Finds all layers by class, appending them to the provided list
154
159
pub fn findLayersByClass(self: Map, allocator: Allocator, class: []const u8, out: *std.ArrayList(Layer)) !void {
155
-
var it = filterLayersByClass(self.layers.items, class);
160
+
var it = self.layers.valueIterator();
156
161
while (it.next()) |layer| {
157
-
try out.append(allocator, layer);
158
-
}
159
-
}
160
-
161
-
fn filterLayersByClass(layers: []const Layer, class: []const u8) FilterLayersByClass {
162
-
return .{ .layers = layers, .class = class };
163
-
}
164
-
165
-
const FilterLayersByClass = struct {
166
-
layers: []const Layer,
167
-
class: []const u8,
168
-
index: usize = 0,
169
-
170
-
fn next(self: *FilterLayersByClass) ?Layer {
171
-
while (self.index < self.layers.len) {
172
-
const layer = self.layers[self.index];
173
-
self.index += 1;
174
-
if (layer.class) |layer_class| {
175
-
if (std.mem.eql(u8, layer_class, self.class)) {
176
-
return layer;
177
-
}
178
-
}
162
+
if (layer.class) |layer_class| {
163
+
if (std.mem.eql(u8, class, layer_class)) try out.append(allocator, layer.*);
179
164
}
180
-
return null;
181
165
}
182
-
};
166
+
}
183
167
184
168
pub fn pixelWidth(self: Map) u32 {
185
169
return self.width * self.tile_width;
+3
-3
test/maps.zig
+3
-3
test/maps.zig
···
38
38
39
39
try expectEqual(false, map.infinite);
40
40
41
-
const layer = map.layers_by_name.get("Tile Layer 1").?;
41
+
const layer = map.findLayer("Tile Layer 1").?;
42
42
try expectEqual(1, layer.content.tile_layer.data.items[0]);
43
43
}
44
44
···
76
76
77
77
try expectEqual(true, map.infinite);
78
78
79
-
const layer = map.layers_by_name.get("ground").?;
79
+
const layer = map.findLayer("ground").?;
80
80
const chunks = layer.content.tile_layer.chunks.?;
81
81
try expectEqual(2, chunks.len);
82
82
try expectEqual(7, chunks[1].data[0]);
···
90
90
91
91
try expectEqual(true, map.infinite);
92
92
93
-
const layer = map.layers_by_name.get("ground").?;
93
+
const layer = map.findLayer("ground").?;
94
94
try expectEqual(7, layer.content.tile_layer.chunks.?[0].data[0]);
95
95
}
96
96