+463

src/layer.zig

reviewed

··· 1 1 + pub const TileLayer = struct { 2 2 + data: std.ArrayListUnmanaged(u32), 3 3 + chunks: ?[]Chunk = null, 4 4 + 5 5 + pub fn fromJson(allocator: Allocator, json_layer: Layer.JsonLayer) !TileLayer { 6 6 + var layer: TileLayer = .{ 7 7 + .data = .empty, 8 8 + }; 9 9 + if (json_layer.layer_data) |json_data| { 10 10 + try layer.data.insertSlice(allocator, 0, json_data); 11 11 + } 12 12 + return layer; 13 13 + } 14 14 + 15 15 + pub fn deinit(self: *TileLayer, allocator: Allocator) void { 16 16 + self.data.deinit(allocator); 17 17 + } 18 18 + }; 19 19 + 20 20 + pub const ObjectGroup = struct { 21 21 + objects: std.ArrayListUnmanaged(Object), 22 22 + 23 23 + pub fn fromJson(allocator: Allocator, json_layer: Layer.JsonLayer) !ObjectGroup { 24 24 + var object_group: ObjectGroup = .{ 25 25 + .objects = .empty, 26 26 + }; 27 27 + if (json_layer.objects) |json_objects| { 28 28 + for (json_objects) |json_object| { 29 29 + // var object = json_object; 30 30 + // if (json_object.type) |object_type| object.type = try allocator.dupe(u8, object_type); 31 31 + const object = try Object.fromJson(allocator, json_object); 32 32 + try object_group.objects.append(allocator, object); 33 33 + } 34 34 + } 35 35 + 36 36 + return object_group; 37 37 + } 38 38 + 39 39 + pub fn deinit(self: *ObjectGroup, allocator: Allocator) void { 40 40 + for (self.objects.items) |*object| { 41 41 + object.deinit(allocator); 42 42 + } 43 43 + self.objects.deinit(allocator); 44 44 + } 45 45 + 46 46 + pub fn findByClass(self: ObjectGroup, class: []const u8) ?Object { 47 47 + for (self.objects.items) |object| { 48 48 + if (object.class) |object_class| { 49 49 + if (std.mem.eql(u8, object_class, class)) { 50 50 + return object; 51 51 + } 52 52 + } 53 53 + } 54 54 + return null; 55 55 + } 56 56 + }; 57 57 + pub const ImageLayer = struct {}; 58 58 + pub const Group = struct {}; 59 59 + 60 60 + pub const Layer = struct { 61 61 + id: u32, 62 62 + class: ?[]const u8 = null, 63 63 + content: LayerContent, 64 64 + visible: bool, 65 65 + 66 66 + pub fn fromJson(allocator: Allocator, json_layer: JsonLayer) !Layer { 67 67 + return .{ 68 68 + .class = if (json_layer.class) |class| try allocator.dupe(u8, class) else null, 69 69 + .id = json_layer.id, 70 70 + .visible = json_layer.visible, 71 71 + .content = try LayerContent.fromJson(allocator, json_layer), 72 72 + }; 73 73 + } 74 74 + 75 75 + pub fn deinit(self: *Layer, allocator: Allocator) void { 76 76 + if (self.class) |class| allocator.free(class); 77 77 + self.content.deinit(allocator); 78 78 + } 79 79 + 80 80 + /// https://doc.mapeditor.org/en/stable/reference/jsonk-map-format/#layer 81 81 + pub const JsonLayer = struct { 82 82 + /// `tilelayer` only. 83 83 + chunks: ?[]Chunk = null, 84 84 + class: ?[]const u8 = null, 85 85 + /// `tilelayer` only. 86 86 + compression: ?Compression = null, 87 87 + /// Array of unsigned int (GIDs) 88 88 + /// `tilelayer` only. 89 89 + layer_data: ?[]u32 = null, 90 90 + /// `objectgroup` only. 91 91 + draw_order: ?DrawOrder = .topdown, 92 92 + /// `tilelayer` only. 93 93 + encoding: ?Encoding = .csv, 94 94 + /// Row count. Same as map height for fixed-size maps. 95 95 + /// `tilelayer` only. 96 96 + height: ?u32 = null, 97 97 + /// Incremental ID - unique across all layers 98 98 + id: u32, 99 99 + /// `imagelayer` only 100 100 + image: ?[]const u8 = null, 101 101 + /// `group` only 102 102 + layers: ?[]JsonLayer = null, 103 103 + /// Whether layer is locked in the editor 104 104 + locked: bool = false, 105 105 + name: []const u8, 106 106 + /// `objectgroup` only. 107 107 + objects: ?[]Object.JsonObject = null, 108 108 + /// Horizontal layer offset in pixels 109 109 + offset_x: f32 = 0, 110 110 + /// Vertical layer offset in pixels 111 111 + offset_y: f32 = 0, 112 112 + opacity: f32, 113 113 + parallax_x: f32 = 1, 114 114 + parallax_y: f32 = 1, 115 115 + properties: ?std.StringHashMapUnmanaged(Property) = null, 116 116 + /// `imagelayer` only 117 117 + repeat_x: ?bool = null, 118 118 + /// `imagelayer` only 119 119 + repeat_y: ?bool = null, 120 120 + /// X coordinate where layer content starts (for infinite maps) 121 121 + start_x: ?i32 = null, 122 122 + /// Y coordinate where layer content starts (for infinite maps) 123 123 + start_y: ?i32 = null, 124 124 + /// Hex-formatted tint color (#RRGGBB or #AARRGGBB) that is multiplied with any graphics drawn by this layer or any child layers 125 125 + tint_color: ?[]const u8 = null, 126 126 + /// `imagelayer` only 127 127 + transparent_color: ?[]const u8 = null, 128 128 + type: Type, 129 129 + visible: bool, 130 130 + /// Column count. Same as map width for fixed-size maps. 131 131 + /// `tilelayer` only. 132 132 + width: ?u32 = null, 133 133 + /// Horizontal layer offset in tiles. Always 0. 134 134 + x: i32 = 0, 135 135 + /// Vertical layer offset in tiles. Always 0. 136 136 + y: i32 = 0, 137 137 + 138 138 + pub const DrawOrder = enum { topdown, index }; 139 139 + pub const Encoding = enum { csv, base64 }; 140 140 + pub const Type = enum { tilelayer, objectgroup, imagelayer, group }; 141 141 + 142 142 + pub const Compression = enum { 143 143 + none, 144 144 + zlib, 145 145 + gzip, 146 146 + zstd, 147 147 + 148 148 + pub fn jsonParseFromValue(_: Allocator, source: Value, _: ParseOptions) !@This() { 149 149 + return switch (source) { 150 150 + .string, .number_string => |value| cmp: { 151 151 + if (value.len == 0) { 152 152 + break :cmp .none; 153 153 + } else { 154 154 + break :cmp std.meta.stringToEnum(Compression, value) orelse .none; 155 155 + } 156 156 + }, 157 157 + else => .none, 158 158 + }; 159 159 + } 160 160 + }; 161 161 + 162 162 + pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() { 163 163 + var layer = try jsonParser(@This(), allocator, source, options); 164 164 + 165 165 + if (source.object.get("properties")) |props| { 166 166 + const properties = try std.json.innerParseFromValue([]Property, allocator, props, .{}); 167 167 + layer.properties = std.StringHashMapUnmanaged(Property).empty; 168 168 + for (properties) |property| { 169 169 + try layer.properties.?.put(allocator, property.name, property); 170 170 + } 171 171 + } 172 172 + 173 173 + if (layer.type == .tilelayer) { 174 174 + if (layer.chunks) |chunks| { 175 175 + for (chunks) |*chunk| { 176 176 + const chunk_size: usize = chunk.width * chunk.height; 177 177 + if (layer.encoding == .base64) { 178 178 + chunk.data = .{ .csv = parseBase64Data(allocator, chunk.data.base64, chunk_size, layer.compression orelse .none) }; 179 179 + } 180 180 + } 181 181 + } 182 182 + if (source.object.get("data")) |data| { 183 183 + if (layer.encoding == .csv) { 184 184 + layer.layer_data = try std.json.parseFromValueLeaky([]u32, allocator, data, options); 185 185 + } else { 186 186 + const base64_data = try std.json.parseFromValueLeaky([]const u8, allocator, data, options); 187 187 + const layer_size: usize = (layer.width orelse 0) * (layer.height orelse 0); 188 188 + 189 189 + layer.layer_data = parseBase64Data(allocator, base64_data, layer_size, layer.compression orelse .none); 190 190 + } 191 191 + } 192 192 + } 193 193 + return layer; 194 194 + } 195 195 + }; 196 196 + }; 197 197 + 198 198 + pub const LayerContent = union(enum) { 199 199 + tile_layer: TileLayer, 200 200 + object_group: ObjectGroup, 201 201 + image_layer: ImageLayer, 202 202 + group: Group, 203 203 + 204 204 + pub fn fromJson(allocator: Allocator, json_layer: Layer.JsonLayer) !LayerContent { 205 205 + switch (json_layer.type) { 206 206 + .tilelayer => { 207 207 + return .{ 208 208 + .tile_layer = try TileLayer.fromJson(allocator, json_layer), 209 209 + }; 210 210 + }, 211 211 + else => return .{ .object_group = try ObjectGroup.fromJson(allocator, json_layer) }, 212 212 + } 213 213 + } 214 214 + 215 215 + pub fn deinit(self: *LayerContent, allocator: Allocator) void { 216 216 + switch (self.*) { 217 217 + .tile_layer => |*layer| { 218 218 + layer.deinit(allocator); 219 219 + }, 220 220 + .object_group => |*group| { 221 221 + group.deinit(allocator); 222 222 + }, 223 223 + else => {}, 224 224 + } 225 225 + } 226 226 + }; 227 227 + 228 228 + /// https://doc.mapeditor.org/en/stable/reference/json-map-format/#chunk 229 229 + pub const Chunk = struct { 230 230 + /// Array of unsigned int (GIDs) or base64-encoded data 231 231 + data: EncodedData, 232 232 + height: u32, 233 233 + width: u32, 234 234 + x: u32, 235 235 + y: u32, 236 236 + 237 237 + const EncodedData = union(Layer.JsonLayer.Encoding) { 238 238 + csv: []const u32, 239 239 + base64: []const u8, 240 240 + }; 241 241 + 242 242 + pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() { 243 243 + var chunk = try jsonParser(@This(), allocator, source, options); 244 244 + 245 245 + if (source.object.get("data")) |data| { 246 246 + switch (data) { 247 247 + .array => { 248 248 + chunk.data = .{ .csv = try std.json.parseFromValueLeaky([]const u32, allocator, data, options) }; 249 249 + }, 250 250 + .string => { 251 251 + chunk.data = .{ .base64 = try std.json.parseFromValueLeaky([]const u8, allocator, data, options) }; 252 252 + }, 253 253 + else => return error.UnexpectedToken, 254 254 + } 255 255 + } 256 256 + return chunk; 257 257 + } 258 258 + }; 259 259 + 260 260 + /// https://doc.mapeditor.org/en/stable/reference/json-map-format/#object 261 261 + pub const Object = struct { 262 262 + gid: ?u32 = null, 263 263 + height: f32, 264 264 + id: u32, 265 265 + name: []const u8, 266 266 + point: ?bool = null, 267 267 + polygon: ?[]Point = null, 268 268 + polyline: ?[]Point = null, 269 269 + properties: ?[]Property = null, 270 270 + rotation: f32, 271 271 + template: ?[]const u8 = null, 272 272 + text: ?Text = null, 273 273 + class: ?[]const u8 = null, 274 274 + visible: bool, 275 275 + width: f32, 276 276 + x: f32, 277 277 + y: f32, 278 278 + 279 279 + type: Type, 280 280 + 281 281 + pub const Type = enum { 282 282 + rectangle, 283 283 + ellipse, 284 284 + polygon, 285 285 + polyline, 286 286 + tile, 287 287 + text, 288 288 + }; 289 289 + 290 290 + pub fn fromJson(allocator: Allocator, json_object: JsonObject) !Object { 291 291 + const object: Object = .{ 292 292 + .gid = json_object.gid, 293 293 + .height = json_object.height, 294 294 + .id = json_object.id, 295 295 + .name = try allocator.dupe(u8, json_object.name), 296 296 + .point = json_object.point, 297 297 + .class = if (json_object.type) |class| try allocator.dupe(u8, class) else null, 298 298 + .rotation = json_object.rotation, 299 299 + .visible = json_object.visible, 300 300 + .width = json_object.width, 301 301 + .x = json_object.x, 302 302 + .y = json_object.y, 303 303 + 304 304 + .type = set_type: { 305 305 + if (json_object.gid) |_| { 306 306 + break :set_type .tile; 307 307 + } 308 308 + if (json_object.ellipse) |_| { 309 309 + break :set_type .ellipse; 310 310 + } 311 311 + if (json_object.polygon) |_| { 312 312 + break :set_type .polygon; 313 313 + } 314 314 + if (json_object.polyline) |_| { 315 315 + break :set_type .polyline; 316 316 + } 317 317 + if (json_object.text) |_| { 318 318 + break :set_type .text; 319 319 + } 320 320 + break :set_type .rectangle; 321 321 + }, 322 322 + }; 323 323 + return object; 324 324 + } 325 325 + 326 326 + pub fn deinit(self: *Object, allocator: Allocator) void { 327 327 + allocator.free(self.name); 328 328 + if (self.class) |class| allocator.free(class); 329 329 + } 330 330 + 331 331 + const JsonObject = struct { 332 332 + ellipse: ?bool = null, 333 333 + gid: ?u32 = null, 334 334 + height: f32, 335 335 + id: u32, 336 336 + name: []const u8, 337 337 + point: ?bool = null, 338 338 + polygon: ?[]Point = null, 339 339 + polyline: ?[]Point = null, 340 340 + properties: ?[]Property = null, 341 341 + rotation: f32, 342 342 + template: ?[]const u8 = null, 343 343 + text: ?Text = null, 344 344 + type: ?[]const u8 = null, 345 345 + visible: bool, 346 346 + width: f32, 347 347 + x: f32, 348 348 + y: f32, 349 349 + }; 350 350 + }; 351 351 + 352 352 + /// https://doc.mapeditor.org/en/stable/reference/json-map-format/#point 353 353 + pub const Point = struct { 354 354 + x: f32, 355 355 + y: f32, 356 356 + }; 357 357 + 358 358 + /// https://doc.mapeditor.org/en/stable/reference/json-map-format/#text 359 359 + pub const Text = struct { 360 360 + bold: bool, 361 361 + color: []const u8, 362 362 + font_family: []const u8 = "sans-serif", 363 363 + h_align: enum { center, right, justify, left } = .left, 364 364 + italic: bool = false, 365 365 + kerning: bool = true, 366 366 + pixel_size: usize = 16, 367 367 + strikeout: bool = false, 368 368 + text: []const u8, 369 369 + underline: bool = false, 370 370 + v_align: enum { center, bottom, top } = .top, 371 371 + wrap: bool = false, 372 372 + 373 373 + pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() { 374 374 + return try jsonParser(@This(), allocator, source, options); 375 375 + } 376 376 + }; 377 377 + 378 378 + // Decode base64 data (and optionally decompress) into a slice of u32 Global Tile Ids allocated on the heap, caller owns slice 379 379 + fn parseBase64Data(allocator: Allocator, base64_data: []const u8, size: usize, compression: Layer.JsonLayer.Compression) []u32 { 380 380 + const decoded_size = base64_decoder.calcSizeForSlice(base64_data) catch @panic("Unable to decode base64 data"); 381 381 + var decoded = allocator.alloc(u8, decoded_size) catch @panic("OOM"); 382 382 + defer allocator.free(decoded); 383 383 + 384 384 + base64_decoder.decode(decoded, base64_data) catch @panic("Unable to decode base64 data"); 385 385 + 386 386 + const data = allocator.alloc(u32, size) catch @panic("OOM"); 387 387 + 388 388 + const alignment = @alignOf(u32); 389 389 + 390 390 + if (compression != .none) 391 391 + decoded = decompress(allocator, decoded, size, compression); 392 392 + 393 393 + if (size * alignment != decoded.len) 394 394 + @panic("data size does not match Layer dimensions"); 395 395 + 396 396 + for (data, 0..) |*tile, i| { 397 397 + const tile_index = i * alignment; 398 398 + const end = tile_index + alignment; 399 399 + tile.* = std.mem.readInt(u32, decoded[tile_index..end][0..alignment], .little); 400 400 + } 401 401 + 402 402 + return data; 403 403 + } 404 404 + 405 405 + // caller owns returned slice 406 406 + fn decompress(allocator: Allocator, compressed: []const u8, size: usize, compression: Layer.JsonLayer.Compression) []u8 { 407 407 + const decompressed = allocator.alloc(u8, size * @alignOf(u32)) catch @panic("OOM"); 408 408 + var decompressed_buf = std.io.fixedBufferStream(decompressed); 409 409 + var compressed_buf = std.io.fixedBufferStream(compressed); 410 410 + 411 411 + return switch (compression) { 412 412 + .gzip => { 413 413 + std.compress.gzip.decompress(compressed_buf.reader(), decompressed_buf.writer()) catch @panic("Unable to decompress gzip"); 414 414 + return decompressed; 415 415 + }, 416 416 + .zlib => { 417 417 + std.compress.zlib.decompress(compressed_buf.reader(), decompressed_buf.writer()) catch @panic("Unable to decompress zlib"); 418 418 + return decompressed; 419 419 + }, 420 420 + .zstd => { 421 421 + const window_buffer = allocator.alloc(u8, std.compress.zstd.DecompressorOptions.default_window_buffer_len) catch @panic("OOM"); 422 422 + defer allocator.free(window_buffer); 423 423 + 424 424 + var zstd_stream = std.compress.zstd.decompressor(compressed_buf.reader(), .{ .window_buffer = window_buffer }); 425 425 + _ = zstd_stream.reader().readAll(decompressed) catch @panic("Unable to decompress zstd"); 426 426 + 427 427 + return decompressed; 428 428 + }, 429 429 + .none => unreachable, 430 430 + }; 431 431 + } 432 432 + 433 433 + test "Layer" { 434 434 + const allocator = std.testing.allocator; 435 435 + 436 436 + const json = @embedFile("test/object_layer.json"); 437 437 + 438 438 + const parsed_layer = try std.json.parseFromSlice(Value, allocator, json, .{ .ignore_unknown_fields = true }); 439 439 + defer parsed_layer.deinit(); 440 440 + const managed_layer = try std.json.parseFromValue(Layer.JsonLayer, allocator, parsed_layer.value, .{ .ignore_unknown_fields = true }); 441 441 + defer managed_layer.deinit(); 442 442 + const layer = managed_layer.value; 443 443 + 444 444 + const properties = layer.properties.?; 445 445 + var iterator = properties.iterator(); 446 446 + while (iterator.next()) |entry| { 447 447 + try std.testing.expectEqualStrings("custom", entry.value_ptr.name); 448 448 + } 449 449 + 450 450 + try expectEqual(Layer.JsonLayer.DrawOrder.topdown, layer.draw_order); 451 451 + } 452 452 + 453 453 + const Property = @import("property.zig").Property; 454 454 + const tmz = @import("tmz.zig"); 455 455 + const Color = tmz.Color; 456 456 + const jsonParser = tmz.jsonParser; 457 457 + 458 458 + const std = @import("std"); 459 459 + const base64_decoder = std.base64.standard.Decoder; 460 460 + const ParseOptions = std.json.ParseOptions; 461 461 + const Value = std.json.Value; 462 462 + const Allocator = std.mem.Allocator; 463 463 + const expectEqual = std.testing.expectEqual;

+77

src/property.zig

reviewed

··· 1 1 + /// https://doc.mapeditor.org/en/stable/reference/json-map-format/#property 2 2 + pub const Property = struct { 3 3 + name: []const u8, 4 4 + property_type: ?[]const u8, 5 5 + type: enum { string, int, float, bool, color, file } = .string, 6 6 + value: union(enum) { 7 7 + string: []const u8, 8 8 + int: u32, 9 9 + float: f32, 10 10 + bool: bool, 11 11 + color: Color, 12 12 + file: []const u8, 13 13 + }, 14 14 + 15 15 + pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !Property { 16 16 + var property = try tmz.jsonParser(Property, allocator, source, options); 17 17 + const value = source.object.get("value") orelse return error.UnexpectedToken; 18 18 + property.value = switch (property.type) { 19 19 + .string => .{ .string = try std.json.innerParseFromValue([]const u8, allocator, value, options) }, 20 20 + .int => .{ .int = try std.json.innerParseFromValue(u32, allocator, value, options) }, 21 21 + .float => .{ .float = try std.json.innerParseFromValue(f32, allocator, value, options) }, 22 22 + .bool => .{ .bool = try std.json.innerParseFromValue(bool, allocator, value, options) }, 23 23 + .color => .{ .color = try std.json.innerParseFromValue(Color, allocator, value, options) }, 24 24 + .file => .{ .file = try std.json.innerParseFromValue([]const u8, allocator, value, options) }, 25 25 + }; 26 26 + 27 27 + return property; 28 28 + } 29 29 + }; 30 30 + 31 31 + test "Property is parsed correctly" { 32 32 + const properties_json = @embedFile("test/properties.json"); 33 33 + 34 34 + const parsed_value = try std.json.parseFromSlice(Value, std.testing.allocator, properties_json, .{ .ignore_unknown_fields = true }); 35 35 + defer parsed_value.deinit(); 36 36 + const managed_properties = try std.json.parseFromValue([]Property, std.testing.allocator, parsed_value.value, .{ .ignore_unknown_fields = true }); 37 37 + defer managed_properties.deinit(); 38 38 + 39 39 + const properties = managed_properties.value; 40 40 + const string_prop = properties[0]; 41 41 + try std.testing.expectEqualStrings("name", string_prop.name); 42 42 + try std.testing.expectEqual(.string, string_prop.type); 43 43 + try std.testing.expectEqualStrings("game", string_prop.value.string); 44 44 + 45 45 + const int_prop = properties[1]; 46 46 + try std.testing.expectEqualStrings("width", int_prop.name); 47 47 + try std.testing.expectEqual(.int, int_prop.type); 48 48 + try std.testing.expectEqual(640, int_prop.value.int); 49 49 + 50 50 + const float_prop = properties[2]; 51 51 + try std.testing.expectEqualStrings("scale", float_prop.name); 52 52 + try std.testing.expectEqual(.float, float_prop.type); 53 53 + try std.testing.expectEqual(1.5, float_prop.value.float); 54 54 + 55 55 + const color_prop = properties[3]; 56 56 + try std.testing.expectEqualStrings("bg", color_prop.name); 57 57 + try std.testing.expectEqual(.color, color_prop.type); 58 58 + try std.testing.expectEqual(Color{ .a = 0xff, .r = 0xa0, .g = 0xb0, .b = 0xc0 }, color_prop.value.color); 59 59 + 60 60 + const bool_prop = properties[4]; 61 61 + try std.testing.expectEqualStrings("fullscreen", bool_prop.name); 62 62 + try std.testing.expectEqual(.bool, bool_prop.type); 63 63 + try std.testing.expectEqual(true, bool_prop.value.bool); 64 64 + 65 65 + const file_prop = properties[5]; 66 66 + try std.testing.expectEqualStrings("splashscreen", file_prop.name); 67 67 + try std.testing.expectEqual(.file, file_prop.type); 68 68 + try std.testing.expectEqualStrings("splashscreen.png", file_prop.value.file); 69 69 + } 70 70 + 71 71 + const std = @import("std"); 72 72 + const ParseOptions = std.json.ParseOptions; 73 73 + const Value = std.json.Value; 74 74 + const Allocator = std.mem.Allocator; 75 75 + 76 76 + const tmz = @import("tmz.zig"); 77 77 + const Color = tmz.Color;

+24

src/test/images_tileset.tsj

reviewed

··· 1 1 + { "columns":0, 2 2 + "grid": 3 3 + { 4 4 + "height":1, 5 5 + "orientation":"orthogonal", 6 6 + "width":1 7 7 + }, 8 8 + "margin":0, 9 9 + "name":"test", 10 10 + "spacing":0, 11 11 + "tilecount":1, 12 12 + "tiledversion":"1.11.2", 13 13 + "tileheight":16, 14 14 + "tiles":[ 15 15 + { 16 16 + "id":0, 17 17 + "image":"tile.png", 18 18 + "imageheight":16, 19 19 + "imagewidth":16 20 20 + }], 21 21 + "tilewidth":16, 22 22 + "type":"tileset", 23 23 + "version":"1.10" 24 24 + }

+32

src/test/object_layer.json

reviewed

··· 1 1 + { 2 2 + "draworder": "topdown", 3 3 + "id": 2, 4 4 + "name": "Object Layer 1", 5 5 + "objects": [ 6 6 + { 7 7 + "height": 19, 8 8 + "id": 1, 9 9 + "name": "", 10 10 + "rotation": 0, 11 11 + "text": { 12 12 + "text": "Hello World", 13 13 + "wrap": true 14 14 + }, 15 15 + "type": "", 16 16 + "visible": true, 17 17 + "width": 91.4375, 18 18 + "x": 70, 19 19 + "y": 44.6353383458647 20 20 + } 21 21 + ], 22 22 + "opacity": 1, 23 23 + "properties":[{ 24 24 + "name":"custom", 25 25 + "type":"int", 26 26 + "value":50 27 27 + }], 28 28 + "type": "objectgroup", 29 29 + "visible": true, 30 30 + "x": 0, 31 31 + "y": 0 32 32 + }

+38

src/test/properties.json

reviewed

··· 1 1 + [ 2 2 + { 3 3 + "name": "name", 4 4 + "propertytype": "", 5 5 + "type": "string", 6 6 + "value": "game" 7 7 + }, 8 8 + { 9 9 + "name": "width", 10 10 + "propertytype": "", 11 11 + "type": "int", 12 12 + "value": 640 13 13 + }, 14 14 + { 15 15 + "name": "scale", 16 16 + "propertytype": "", 17 17 + "type": "float", 18 18 + "value": 1.5 19 19 + }, 20 20 + { 21 21 + "name": "bg", 22 22 + "propertytype": "", 23 23 + "type": "color", 24 24 + "value": "#ffa0b0c0" 25 25 + }, 26 26 + { 27 27 + "name": "fullscreen", 28 28 + "propertytype": "", 29 29 + "type": "bool", 30 30 + "value": true 31 31 + }, 32 32 + { 33 33 + "name": "splashscreen", 34 34 + "propertytype": "", 35 35 + "type": "file", 36 36 + "value": "splashscreen.png" 37 37 + } 38 38 + ]

+107

src/test/source_tileset.tsj

reviewed

··· 1 1 + { "backgroundcolor":"#ffaaff", 2 2 + "columns":37, 3 3 + "image":"tilemap.png", 4 4 + "imageheight":475, 5 5 + "imagewidth":628, 6 6 + "margin":0, 7 7 + "name":"tiles", 8 8 + "properties":[ 9 9 + { 10 10 + "name":"custom", 11 11 + "type":"int", 12 12 + "value":50 13 13 + }], 14 14 + "spacing":1, 15 15 + "tilecount":1131, 16 16 + "tiledversion":"1.11.2", 17 17 + "tileheight":16, 18 18 + "tiles":[ 19 19 + { 20 20 + "id":0, 21 21 + "objectgroup": 22 22 + { 23 23 + "draworder":"index", 24 24 + "id":3, 25 25 + "name":"", 26 26 + "objects":[ 27 27 + { 28 28 + "height":12, 29 29 + "id":2, 30 30 + "name":"", 31 31 + "rotation":0, 32 32 + "type":"", 33 33 + "visible":true, 34 34 + "width":12, 35 35 + "x":2, 36 36 + "y":2 37 37 + }], 38 38 + "opacity":1, 39 39 + "type":"objectgroup", 40 40 + "visible":true, 41 41 + "x":0, 42 42 + "y":0 43 43 + } 44 44 + }, 45 45 + { 46 46 + "animation":[ 47 47 + { 48 48 + "duration":100, 49 49 + "tileid":0 50 50 + }, 51 51 + { 52 52 + "duration":100, 53 53 + "tileid":1 54 54 + }, 55 55 + { 56 56 + "duration":100, 57 57 + "tileid":2 58 58 + }, 59 59 + { 60 60 + "duration":100, 61 61 + "tileid":3 62 62 + }], 63 63 + "id":3 64 64 + }], 65 65 + "tilewidth":16, 66 66 + "transformations": 67 67 + { 68 68 + "hflip":true, 69 69 + "preferuntransformed":true, 70 70 + "rotate":false, 71 71 + "vflip":true 72 72 + }, 73 73 + "type":"tileset", 74 74 + "version":"1.10", 75 75 + "wangsets":[ 76 76 + { 77 77 + "colors":[ 78 78 + { 79 79 + "color":"#ff0000", 80 80 + "name":"Dirt", 81 81 + "probability":1, 82 82 + "tile":892 83 83 + }, 84 84 + { 85 85 + "color":"#00ff00", 86 86 + "name":"Grass", 87 87 + "probability":1, 88 88 + "tile":888 89 89 + }], 90 90 + "name":"Ground", 91 91 + "tile":1002, 92 92 + "type":"mixed", 93 93 + "wangtiles":[ 94 94 + { 95 95 + "tileid":888, 96 96 + "wangid":[2, 2, 2, 2, 2, 2, 2, 2] 97 97 + }, 98 98 + { 99 99 + "tileid":889, 100 100 + "wangid":[2, 2, 2, 2, 2, 2, 2, 2] 101 101 + }, 102 102 + { 103 103 + "tileid":892, 104 104 + "wangid":[1, 1, 1, 1, 1, 1, 1, 1] 105 105 + }] 106 106 + }] 107 107 + }

src/test/tile.png

reviewed

This is a binary file and will not be displayed.

src/test/tilemap.png

reviewed

This is a binary file and will not be displayed.

+5

src/test/tileset.tsj

reviewed

··· 1 1 + { 2 2 + "source": "./src/test/source_tileset.tsj", 3 3 + "type":"tileset", 4 4 + "version":"1.10" 5 5 + }

+162

src/tileset.zig

reviewed

··· 1 1 + pub const Tileset = struct { 2 2 + columns: u32, 3 3 + tile_count: u32, 4 4 + tile_width: u32, 5 5 + tile_height: u32, 6 6 + first_gid: u32, 7 7 + image: ?[]const u8, 8 8 + 9 9 + tiles: std.AutoHashMapUnmanaged(u32, Tile), 10 10 + 11 11 + pub fn initFromFile(allocator: Allocator, path: []const u8) anyerror!Tileset { 12 12 + const file = try std.fs.cwd().openFile(path, .{}); 13 13 + defer file.close(); 14 14 + 15 15 + const json = try file.reader().readAllAlloc(allocator, std.math.maxInt(u32)); 16 16 + defer allocator.free(json); 17 17 + 18 18 + return try initFromSlice(allocator, json); 19 19 + } 20 20 + 21 21 + pub fn initFromSlice(allocator: Allocator, json: []const u8) !Tileset { 22 22 + const parsed_value = try std.json.parseFromSlice(std.json.Value, allocator, json, .{ .ignore_unknown_fields = true }); 23 23 + defer parsed_value.deinit(); 24 24 + 25 25 + const tileset = try std.json.parseFromValue(JsonTileset, allocator, parsed_value.value, .{ .ignore_unknown_fields = true }); 26 26 + defer tileset.deinit(); 27 27 + 28 28 + const json_tileset = tileset.value; 29 29 + 30 30 + return fromJson(allocator, json_tileset); 31 31 + } 32 32 + 33 33 + pub fn deinit(self: *Tileset, allocator: Allocator) void { 34 34 + if (self.image) |image| allocator.free(image); 35 35 + 36 36 + self.tiles.deinit(allocator); 37 37 + } 38 38 + 39 39 + pub fn fromJson(allocator: Allocator, tileset_json: JsonTileset) !Tileset { 40 40 + if (tileset_json.source) |source| { 41 41 + var tileset = try Tileset.initFromFile(allocator, source); 42 42 + tileset.first_gid = tileset_json.firstgid orelse 1; 43 43 + 44 44 + return tileset; 45 45 + } 46 46 + 47 47 + var tileset: Tileset = .{ 48 48 + .columns = tileset_json.columns orelse 0, 49 49 + .tile_count = tileset_json.tilecount orelse 0, 50 50 + .tile_width = tileset_json.tilewidth orelse 0, 51 51 + .tile_height = tileset_json.tileheight orelse 0, 52 52 + .first_gid = tileset_json.firstgid orelse 1, 53 53 + .image = if (tileset_json.image) |image| try allocator.dupe(u8, image) else null, 54 54 + .tiles = .empty, 55 55 + }; 56 56 + 57 57 + var tiles_by_id: std.AutoHashMapUnmanaged(u32, Tile.JsonTile) = .empty; 58 58 + defer tiles_by_id.deinit(allocator); 59 59 + 60 60 + if (tileset_json.tiles) |json_tiles| { 61 61 + for (json_tiles) |json_tile| { 62 62 + try tiles_by_id.put(allocator, json_tile.id, json_tile); 63 63 + } 64 64 + } 65 65 + 66 66 + var x: u32 = 0; 67 67 + var y: u32 = 0; 68 68 + 69 69 + var gid = tileset.first_gid - 1; 70 70 + 71 71 + const last_gid: u32 = gid + tileset.tile_count - 1; 72 72 + while (gid <= last_gid) : (gid += 1) { 73 73 + var tile: Tile = .{ 74 74 + .tileset = tileset, 75 75 + .image = tileset.image, 76 76 + .id = gid, 77 77 + .x = x * (tileset_json.tilewidth.? + tileset_json.spacing) + tileset_json.margin, 78 78 + .y = y * (tileset_json.tileheight.? + tileset_json.spacing) + tileset_json.margin, 79 79 + .width = tileset_json.tilewidth.?, 80 80 + .height = tileset_json.tileheight.?, 81 81 + }; 82 82 + 83 83 + if (tiles_by_id.get(gid)) |json_tile| { 84 84 + tile.animation = json_tile.animation; 85 85 + // tile = Tile.fromJson(json_tile); 86 86 + } 87 87 + try tileset.tiles.put(allocator, gid, tile); 88 88 + if (x >= @as(i64, @intCast(tileset.columns)) - 1) { 89 89 + y += 1; 90 90 + x = 0; 91 91 + } else { 92 92 + x += 1; 93 93 + } 94 94 + } 95 95 + 96 96 + return tileset; 97 97 + } 98 98 + 99 99 + pub const JsonTileset = struct { 100 100 + columns: ?u32 = null, 101 101 + tilecount: ?u32 = null, 102 102 + firstgid: ?u32 = 1, 103 103 + margin: u32 = 0, 104 104 + source: ?[]const u8 = null, 105 105 + spacing: u32 = 0, 106 106 + image: ?[]const u8 = null, 107 107 + tiles: ?[]Tile.JsonTile = null, 108 108 + tilewidth: ?u32 = null, 109 109 + tileheight: ?u32 = null, 110 110 + }; 111 111 + }; 112 112 + 113 113 + pub const Tile = struct { 114 114 + id: u32 = 1, 115 115 + x: u32, 116 116 + y: u32, 117 117 + width: u32, 118 118 + height: u32, 119 119 + tileset: Tileset, 120 120 + image: ?[]const u8 = null, 121 121 + animation: ?[]const Frame = null, 122 122 + 123 123 + // pub fn fromJson(json_tile: JsonTile) Tile { 124 124 + // return .{ 125 125 + // .id = json_tile.id, 126 126 + // // .x = if (json_tile.x) |x| x else 0, 127 127 + // // .y = if (json_tile.y) |y| y else 0, 128 128 + // // .width = if (json_tile.width) |width| width else 0, 129 129 + // // .height = if (json_tile.height) |height| height else 0, 130 130 + // }; 131 131 + // } 132 132 + 133 133 + pub const JsonTile = struct { 134 134 + id: u32, 135 135 + x: ?u32 = null, 136 136 + y: ?u32 = null, 137 137 + width: ?u32 = null, 138 138 + height: ?u32 = null, 139 139 + animation: ?[]const Frame = null, 140 140 + }; 141 141 + }; 142 142 + 143 143 + pub const Frame = struct { 144 144 + duration: u32, 145 145 + tile_id: u32, 146 146 + 147 147 + pub fn jsonParseFromValue(allocator: Allocator, source: std.json.Value, options: std.json.ParseOptions) !@This() { 148 148 + return try jsonParser(@This(), allocator, source, options); 149 149 + } 150 150 + }; 151 151 + 152 152 + inline fn get(value: anytype) @TypeOf(value) { 153 153 + return if (value) |v| return v else null; 154 154 + } 155 155 + 156 156 + const std = @import("std"); 157 157 + const Allocator = std.mem.Allocator; 158 158 + const expectEqualDeep = std.testing.expectEqualDeep; 159 159 + const expectEqual = std.testing.expectEqual; 160 160 + const expectEqualStrings = std.testing.expectEqualStrings; 161 161 + 162 162 + const jsonParser = @import("tmz.zig").jsonParser;

+141

src/tmz.zig

reviewed

··· 1 1 + pub const Property = @import("property.zig").Property; 2 2 + 3 3 + pub const Tileset = tileset.Tileset; 4 4 + pub const Tile = tileset.Tile; 5 5 + pub const loadTilesetFromSlice = Tileset.initFromSlice; 6 6 + pub const loadTilesetFromFile = Tileset.initFromFile; 7 7 + 8 8 + pub const Color = packed struct(u32) { 9 9 + a: u8 = 0, 10 10 + r: u8 = 0, 11 11 + g: u8 = 0, 12 12 + b: u8 = 0, 13 13 + 14 14 + pub fn jsonParseFromValue(_: std.mem.Allocator, source: Value, _: ParseOptions) !@This() { 15 15 + return try parseColor(source.string); 16 16 + } 17 17 + }; 18 18 + 19 19 + // parses a Hex-formatted color (#RRGGBB or #AARRGGBB) string and returns 20 20 + // a Color. If no alpha channel value specified, defaults to 0 21 21 + fn parseColor(color_string: []const u8) !Color { 22 22 + if (color_string.len > 9 or color_string.len < 6) return error.UnexpectedToken; 23 23 + // buffer for the color_string stripped of '#' 24 24 + var hex_color: [8]u8 = @splat(0); 25 25 + // buffer for actual bytes parsed 26 26 + var color: [4]u8 = @splat(0); 27 27 + 28 28 + _ = std.mem.replace(u8, color_string, "#", "", &hex_color); 29 29 + // Handle strings with no alpha color defined 30 30 + if (color_string.len < 8) { 31 31 + // use same buffers for 32-bit color, but just use 6 bytes ascii and 32 32 + // 3 bytes for actual values 33 33 + _ = std.fmt.hexToBytes(color[1..4], hex_color[0..6]) catch return error.UnexpectedToken; 34 34 + } else { 35 35 + _ = std.fmt.hexToBytes(&color, &hex_color) catch return error.UnexpectedToken; 36 36 + } 37 37 + return std.mem.bytesToValue(Color, &color); 38 38 + } 39 39 + 40 40 + test "Color is parsed from string" { 41 41 + const full_color = "#ccaaffee"; 42 42 + const expected_full_color: Color = .{ 43 43 + .a = 0xcc, 44 44 + .r = 0xaa, 45 45 + .g = 0xff, 46 46 + .b = 0xee, 47 47 + }; 48 48 + 49 49 + try std.testing.expectEqual(expected_full_color, try parseColor(full_color)); 50 50 + 51 51 + const no_alpha_color = "#bbaadd"; 52 52 + const expected_no_alpha_color: Color = .{ 53 53 + .a = 0, 54 54 + .r = 0xbb, 55 55 + .g = 0xaa, 56 56 + .b = 0xdd, 57 57 + }; 58 58 + 59 59 + try std.testing.expectEqual(expected_no_alpha_color, try parseColor(no_alpha_color)); 60 60 + 61 61 + const weird_color = "#DeaDBeeF"; 62 62 + const expected_weird_color: Color = .{ 63 63 + .a = 0xde, 64 64 + .r = 0xad, 65 65 + .g = 0xbe, 66 66 + .b = 0xef, 67 67 + }; 68 68 + 69 69 + try std.testing.expectEqual(expected_weird_color, try parseColor(weird_color)); 70 70 + 71 71 + try std.testing.expectError(error.UnexpectedToken, parseColor("##bbaabbee")); 72 72 + } 73 73 + 74 74 + // converts masheduppropertynames to Zig style snake_case field names and 75 75 + // ignores data, value and properties so they can be handled later 76 76 + pub fn jsonParser(T: type, allocator: Allocator, source: Value, options: ParseOptions) !T { 77 77 + var t: T = undefined; 78 78 + 79 79 + inline for (@typeInfo(T).@"struct".fields) |field| { 80 80 + if (comptime eql(u8, field.name, "data") or eql(u8, field.name, "value") or eql(u8, field.name, "properties")) continue; 81 81 + 82 82 + const size = comptime std.mem.replacementSize(u8, field.name, "_", ""); 83 83 + var tiled_name: [size]u8 = undefined; 84 84 + _ = std.mem.replace(u8, field.name, "_", "", &tiled_name); 85 85 + 86 86 + const source_field = source.object.get(&tiled_name); 87 87 + if (source_field) |s| { 88 88 + @field(t, field.name) = try std.json.innerParseFromValue(field.type, allocator, s, options); 89 89 + } else { 90 90 + if (field.default_value_ptr) |val| { 91 91 + @field(t, field.name) = @as(*align(1) const field.type, @ptrCast(val)).*; 92 92 + } 93 93 + } 94 94 + } 95 95 + 96 96 + return t; 97 97 + } 98 98 + 99 99 + const TestJson = struct { 100 100 + property_id: u8 = 0, 101 101 + data: u8, 102 102 + value: u8, 103 103 + 104 104 + pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: std.json.ParseOptions) !@This() { 105 105 + return try jsonParser(@This(), allocator, source, options); 106 106 + } 107 107 + }; 108 108 + 109 109 + test "jsonParser works" { 110 110 + const test_json = 111 111 + \\{ 112 112 + \\ "propertyid": 9, 113 113 + \\ "data": 8, 114 114 + \\ "value": 7 115 115 + \\} 116 116 + ; 117 117 + const parsed_value = try std.json.parseFromSlice(Value, std.testing.allocator, test_json, .{}); 118 118 + defer parsed_value.deinit(); 119 119 + 120 120 + const parsed_json = try std.json.parseFromValue(TestJson, std.testing.allocator, parsed_value.value, .{}); 121 121 + defer parsed_json.deinit(); 122 122 + 123 123 + // Property names are "converted" to snake_case 124 124 + try std.testing.expectEqual(9, parsed_json.value.property_id); 125 125 + 126 126 + // `data` and `value` fields are ignored 127 127 + try std.testing.expectEqual(0xaa, parsed_json.value.data); 128 128 + try std.testing.expectEqual(0xaa, parsed_json.value.value); 129 129 + } 130 130 + test { 131 131 + std.testing.refAllDeclsRecursive(@This()); 132 132 + } 133 133 + 134 134 + const std = @import("std"); 135 135 + const eql = std.mem.eql; 136 136 + const Allocator = std.mem.Allocator; 137 137 + const ParseOptions = std.json.ParseOptions; 138 138 + const Value = std.json.Value; 139 139 + 140 140 + const tileset = @import("tileset.zig"); 141 141 + const layer = @import("layer.zig");