StreetLight
/
zig-ldtk
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Parse levels

dev
Louis Pearson 2022-08-03 11:25:37 -06:00
parent c4c8b9c378
commit d2a8d304f9
2 changed files with 195 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

249
src/LDtk.zig
View File

@ -1,71 +1,85 @@
const std = @import("std"); const std = @import("std");
const json = struct { // Utility functions
pub fn object(value_opt: ?std.json.Value) ?std.json.ObjectMap { pub fn object(value_opt: ?std.json.Value) ?std.json.ObjectMap {
const value = value_opt orelse return null; const value = value_opt orelse return null;
return switch (value) { return switch (value) {
.Object => |obj| obj, .Object => |obj| obj,
else => null, else => null,
}; };
} }
pub fn array(value_opt: ?std.json.Value) ?std.json.Array { pub fn array(value_opt: ?std.json.Value) ?std.json.Array {
const value = value_opt orelse return null; const value = value_opt orelse return null;
return switch (value) { return switch (value) {
.Array => |arr| arr, .Array => |arr| arr,
else => null, else => null,
}; };
} }
pub fn string(value_opt: ?std.json.Value) ?[]const u8 { pub fn string(value_opt: ?std.json.Value) ?[]const u8 {
const value = value_opt orelse return null; const value = value_opt orelse return null;
return switch (value) { return switch (value) {
.String => |str| str, .String => |str| str,
else => null, else => null,
}; };
} }
pub fn boolean(value_opt: ?std.json.Value) ?bool { pub fn string_list(alloc: std.mem.Allocator, array_opt: ?std.json.Value) ![][]const u8 {
const value = value_opt orelse return null; const arr = array(array_opt) orelse return &[_][]const u8{};
return switch (value) { var list = try std.ArrayList([]const u8).initCapacity(alloc, arr.items.len);
.Bool => |b| b, defer list.deinit();
else => null, for (arr.items) |value| {
}; list.appendAssumeCapacity(string(value) orelse return error.InvalidString);
} }
return list.toOwnedSlice();
}
pub fn integer(value_opt: ?std.json.Value) ?i64 { pub fn boolean(value_opt: ?std.json.Value) ?bool {
const value = value_opt orelse return null; const value = value_opt orelse return null;
return switch (value) { return switch (value) {
.Integer => |int| int, .Bool => |b| b,
else => null, else => null,
}; };
} }
pub fn enum_from_value(comptime T: type, value_opt: ?std.json.Value) ?T { pub fn integer(value_opt: ?std.json.Value) ?i64 {
const value = value_opt orelse return null; const value = value_opt orelse return null;
return switch (value) { return switch (value) {
.String => |str| std.meta.stringToEnum(T, str), .Integer => |int| int,
else => null, else => null,
}; };
} }
pub fn pos_from_value(value_opt: ?std.json.Value) ?[2]i64 { fn float(value_opt: ?std.json.Value) ?f64 {
const value = array(value_opt) orelse return null; const value = value_opt orelse return null;
return .{ return switch (value) {
integer(value[0]) orelse return null, .Float => |float| float,
integer(value[1]) orelse return null, else => null,
}; };
} }
pub fn posf_from_value(value_opt: ?std.json.Value) ?[2]i64 { pub fn enum_from_value(comptime T: type, value_opt: ?std.json.Value) ?T {
const value = array(value_opt) orelse return null; const value = value_opt orelse return null;
return .{ return switch (value) {
float(value[0]) orelse return null, .String => |str| std.meta.stringToEnum(T, str),
float(value[1]) orelse return null, else => null,
}; };
} }
};
pub fn pos_from_value(value_opt: ?std.json.Value) ?[2]i64 {
const value = array(value_opt) orelse return null;
const x = integer(value.items[0]) orelse return null;
const y = integer(value.items[1]) orelse return null;
return [2]i64{ x, y };
}
pub fn posf_from_value(value_opt: ?std.json.Value) ?[2]f64 {
const value = array(value_opt) orelse return null;
const x = float(value.items[0]) orelse return null;
const y = float(value.items[1]) orelse return null;
return [2]f64{ x, y };
}
/// 1. LDtk Json root /// 1. LDtk Json root
pub const Root = struct { pub const Root = struct {
@ -167,21 +181,23 @@ pub const LayerInstance = struct {
pub fn fromJSON(alloc: std.mem.Allocator, layer_value: std.json.Value) !LayerInstance { pub fn fromJSON(alloc: std.mem.Allocator, layer_value: std.json.Value) !LayerInstance {
const layer_obj = object(layer_value) orelse return error.InvalidLayer; const layer_obj = object(layer_value) orelse return error.InvalidLayer;
const __type = enum_from_value(LayerType, layer.get("__type")) orelse return error.InvalidType; const __type = enum_from_value(LayerType, layer_obj.get("__type")) orelse return error.InvalidType;
const grid = grid: { const grid = grid: {
if (__type == .IntGrid and array(layer.get("intGridCsv"))) |intGridCsv| grid: { if (__type == .IntGrid) {
const grid = std.ArrayList(i64).initCapacity(alloc, intGridCsv.items.len); if (array(layer_obj.get("intGridCsv"))) |intGridCsv| {
defer grid.deinit(); var grid_list = try std.ArrayList(i64).initCapacity(alloc, intGridCsv.items.len);
defer grid_list.deinit();
for (grid) |int| { for (intGridCsv.items) |int| {
grid.appendAssumeCapacity(integer(int) orelse return error.InvalidInt); grid_list.appendAssumeCapacity(integer(int) orelse return error.InvalidInt);
}
break :grid grid_list.toOwnedSlice();
} }
break :grid grid.toOwnedSlice();
} }
break :grid &[0]i64{}; break :grid &[0]i64{};
}; };
return LayerInstance { return LayerInstance{
.__cHei = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, .__cHei = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.__cWid = integer(layer_obj.get("__cWid")) orelse return error.InvalidCWid, .__cWid = integer(layer_obj.get("__cWid")) orelse return error.InvalidCWid,
.__gridSize = integer(layer_obj.get("__gridSize")) orelse return error.InvalidGridSize, .__gridSize = integer(layer_obj.get("__gridSize")) orelse return error.InvalidGridSize,
@ -190,13 +206,14 @@ pub const LayerInstance = struct {
.__pxTotalOffsetX = integer(layer_obj.get("__pxTotalOffsetX")) orelse return error.InvalidTotalOffsetX, .__pxTotalOffsetX = integer(layer_obj.get("__pxTotalOffsetX")) orelse return error.InvalidTotalOffsetX,
.__pxTotalOffsetY = integer(layer_obj.get("__pxTotalOffsetY")) orelse return error.InvalidTotalOffsetY, .__pxTotalOffsetY = integer(layer_obj.get("__pxTotalOffsetY")) orelse return error.InvalidTotalOffsetY,
.__tilesetDefUid = integer(layer_obj.get("__tilesetDefUid")) orelse return error.InvalidTilesetDefUid, .__tilesetDefUid = integer(layer_obj.get("__tilesetDefUid")) orelse return error.InvalidTilesetDefUid,
.__tilesetRelPath = integer(layer_obj.get("__tilesetRelPath")) orelse return error.InvalidTilesetRelPath, .__tilesetRelPath = string(layer_obj.get("__tilesetRelPath")) orelse return error.InvalidTilesetRelPath,
.__type = __type, .__type = __type,
.autoLayerTiles = try TileInstance.fromJSON(alloc, layer_obj.get("autoLayerTiles")), .autoLayerTiles = try TileInstance.fromJSONMany(alloc, layer_obj.get("autoLayerTiles")),
.entityInstances = try EntityInstance.fromJSON(alloc, layer_obj.get("entityInstances")), .entityInstances = try EntityInstance.fromJSONMany(alloc, layer_obj.get("entityInstances")),
.gridTiles = try TileInstance.fromJSON(alloc, layer_obj.get("gridTiles")), .gridTiles = try TileInstance.fromJSONMany(alloc, layer_obj.get("gridTiles")),
.iid = string(layer_obj.get("iid")) orelse return error.InvalidIID, .iid = string(layer_obj.get("iid")) orelse return error.InvalidIID,
.intGridCsv = grid, .intGridCsv = grid,
.layerDefUid = integer(layer_obj.get("layerDefUid")) orelse return error.InvalidLayerDefUid,
.levelId = integer(layer_obj.get("levelId")) orelse return error.InvalidLevelId, .levelId = integer(layer_obj.get("levelId")) orelse return error.InvalidLevelId,
.overrideTilesetUid = integer(layer_obj.get("overrideTilesetUid")) orelse return error.InvalidOverrideTilesetUid, .overrideTilesetUid = integer(layer_obj.get("overrideTilesetUid")) orelse return error.InvalidOverrideTilesetUid,
.pxOffsetX = integer(layer_obj.get("pxOffsetX")) orelse return error.InvalidPxOffsetX, .pxOffsetX = integer(layer_obj.get("pxOffsetX")) orelse return error.InvalidPxOffsetX,
@ -205,11 +222,12 @@ pub const LayerInstance = struct {
}; };
} }
pub fn fromJSONMany(alloc: std.mem.Allocator, layers: std.json.Array) ![]LayerInstance { pub fn fromJSONMany(alloc: std.mem.Allocator, layers_opt: ?std.json.Value) ![]LayerInstance {
const layers = array(layers_opt) orelse return &[_]LayerInstance{};
var ldtk_layers = try std.ArrayList(LayerInstance).initCapacity(alloc, layers.items.len); var ldtk_layers = try std.ArrayList(LayerInstance).initCapacity(alloc, layers.items.len);
defer ldtk_layers.deinit(); // levels will be returned using toOwnedSlice defer ldtk_layers.deinit(); // levels will be returned using toOwnedSlice
for (layers.items) |layer_value| { for (layers.items) |layer_value| {
ldtk_layers.appendAssumeCapacity(try fromJSON(layer_value)); ldtk_layers.appendAssumeCapacity(try fromJSON(alloc, layer_value));
} }
return ldtk_layers.toOwnedSlice(); return ldtk_layers.toOwnedSlice();
} }
@ -235,7 +253,8 @@ const TileInstance = struct {
/// The Tile ID in the corresponding tileset /// The Tile ID in the corresponding tileset
t: i64, t: i64,
pub fn fromJSON(tile: std.json.Value) !TileInstance { pub fn fromJSON(tile_opt: ?std.json.Value) !TileInstance {
const tile = object(tile_opt) orelse return error.InvalidTileInstance;
const f = @intToEnum(FlipBits, integer(tile.get("f")) orelse return error.InvalidFlipBits); const f = @intToEnum(FlipBits, integer(tile.get("f")) orelse return error.InvalidFlipBits);
const px = pos_from_value(tile.get("px")) orelse return error.InvalidPx; const px = pos_from_value(tile.get("px")) orelse return error.InvalidPx;
const src = pos_from_value(tile.get("src")) orelse return error.InvalidSrc; const src = pos_from_value(tile.get("src")) orelse return error.InvalidSrc;
@ -247,6 +266,16 @@ const TileInstance = struct {
.t = t, .t = t,
}; };
} }
pub fn fromJSONMany(alloc: std.mem.Allocator, tiles_opt: ?std.json.Value) ![]TileInstance {
const tiles = array(tiles_opt) orelse return &[_]TileInstance{};
var ldtk_tiles = try std.ArrayList(TileInstance).initCapacity(alloc, tiles.items.len);
defer ldtk_tiles.deinit(); // levels will be returned using toOwnedSlice
for (tiles.items) |tile_value| {
ldtk_tiles.appendAssumeCapacity(try fromJSON(tile_value));
}
return ldtk_tiles.toOwnedSlice();
}
}; };
const FlipBits = enum(u4) { const FlipBits = enum(u4) {
@ -260,7 +289,7 @@ const FlipBits = enum(u4) {
const EntityInstance = struct { const EntityInstance = struct {
__grid: [2]i64, __grid: [2]i64,
__identifier: []const u8, __identifier: []const u8,
__pivot: [2]f32, __pivot: [2]f64,
__smartColor: []const u8, __smartColor: []const u8,
__tags: [][]const u8, __tags: [][]const u8,
__tile: ?TilesetRectangle, __tile: ?TilesetRectangle,
@ -271,19 +300,20 @@ const EntityInstance = struct {
px: [2]i64, px: [2]i64,
width: i64, width: i64,
pub fn fromJSON(alloc: std.mem.Allocator, entity: std.json.Value) !TileInstance { pub fn fromJSON(alloc: std.mem.Allocator, entity_opt: std.json.Value) !EntityInstance {
const __grid = pos_from_value(tile.get("__grid")) orelse return error.InvalidGrid; const entity = object(entity_opt) orelse return error.InvalidEntityInstance;
const __identifier = string(tile.get("__identifier")) orelse return error.InvalidIdentifier; const __grid = pos_from_value(entity.get("__grid")) orelse return error.InvalidGrid;
const __pivot = posf_from_value(tile.get("__pivot")) orelse return error.InvalidPivot; const __identifier = string(entity.get("__identifier")) orelse return error.InvalidIdentifier;
const __smartColor = string(tile.get("__smartColor")) orelse return error.InvalidSmartColor; const __pivot = posf_from_value(entity.get("__pivot")) orelse return error.InvalidPivot;
const __tags = pos_from_value(tile.get("__tags")) orelse return error.InvalidTags; const __smartColor = string(entity.get("__smartColor")) orelse return error.InvalidSmartColor;
const __tile: ?[]TilesetRectangle = null; // TilesetRectangle.fromJSON(); const __tags = try string_list(alloc, entity.get("__tags"));
const defUid = integer(tile.get("defUid")) orelse return error.InvalidDefUid; const __tile = try TilesetRectangle.fromJSON(entity.get("__tile"));
const fieldInstances = try FieldInstance.fromJSON(alloc); const defUid = integer(entity.get("defUid")) orelse return error.InvalidDefUid;
const height = integer(tile.get("height")) orelse return error.InvalidHeight; const fieldInstances = try FieldInstance.fromJSONMany(alloc, entity.get("fieldInstances"));
const iid = string(tile.get("iid")) orelse return error.InvalidIid; const height = integer(entity.get("height")) orelse return error.InvalidHeight;
const px = pos_from_value(tile.get("px")) orelse return error.InvalidPx; const iid = string(entity.get("iid")) orelse return error.InvalidIid;
const width = integer(tile.get("width")) orelse return error.InvalidWidth; const px = pos_from_value(entity.get("px")) orelse return error.InvalidPx;
const width = integer(entity.get("width")) orelse return error.InvalidWidth;
return EntityInstance{ return EntityInstance{
.__grid = __grid, .__grid = __grid,
@ -300,6 +330,16 @@ const EntityInstance = struct {
.width = width, .width = width,
}; };
} }
pub fn fromJSONMany(alloc: std.mem.Allocator, entities_opt: ?std.json.Value) ![]EntityInstance {
const entities = array(entities_opt) orelse return &[_]EntityInstance{};
var ldtk_entities = try std.ArrayList(EntityInstance).initCapacity(alloc, entities.items.len);
defer ldtk_entities.deinit(); // levels will be returned using toOwnedSlice
for (entities.items) |entity_value| {
ldtk_entities.appendAssumeCapacity(try fromJSON(alloc, entity_value));
}
return ldtk_entities.toOwnedSlice();
}
}; };
/// 2.4. Field Instance /// 2.4. Field Instance
@ -312,19 +352,33 @@ pub const FieldInstance = struct {
__value: []const u8, __value: []const u8,
defUid: i64, defUid: i64,
pub fn fromJSON(alloc: std.mem.Allocator, field: std.json.Value) !FieldInstance { pub fn fromJSON(field_value: ?std.json.Value) !?FieldInstance {
const field = object(field_value) orelse return error.InvalidFieldInstance;
const __identifier = string(field.get("__identifier")) orelse return error.InvalidIdentifier; const __identifier = string(field.get("__identifier")) orelse return error.InvalidIdentifier;
const __tile = string(field.get("__tile")) orelse return error.InvalidTile; const __tile = try TilesetRectangle.fromJSON(field.get("__tile"));
const __type = string(field.get("__type")) orelse return error.InvalidType; const __type = string(field.get("__type")) orelse return error.InvalidType;
const __value = string(field.get("__value")) orelse return error.InvalidValue; const __value = string(field.get("__value")) orelse return error.InvalidValue;
const defUid = integer(field.get("defUid")) orelse return error.InvalidIDefUid; const defUid = integer(field.get("defUid")) orelse return error.InvalidIDefUid;
return FieldInstance { return FieldInstance{
.__identifier = __identifier, .__identifier = __identifier,
.__tile = __tile, .__tile = __tile,
.__type = __type, .__type = __type,
.__value = __value, .__value = __value,
.defUid = defUid,
}; };
} }
pub fn fromJSONMany(alloc: std.mem.Allocator, fields_opt: ?std.json.Value) ![]FieldInstance {
const fields = array(fields_opt) orelse return &[_]FieldInstance{};
var ldtk_fields = try std.ArrayList(FieldInstance).initCapacity(alloc, fields.items.len);
defer ldtk_fields.deinit(); // levels will be returned using toOwnedSlice
for (fields.items) |field_value| {
if (try fromJSON(field_value)) |field| {
ldtk_fields.appendAssumeCapacity(field);
}
}
return ldtk_fields.toOwnedSlice();
}
}; };
const FieldType = union(enum) { const FieldType = union(enum) {
@ -418,12 +472,23 @@ const EntityDefinition = struct {
const FieldDefinition = []const u8; const FieldDefinition = []const u8;
/// 3.2.2. Tileset rectangle /// 3.2.2. Tileset rectangle
const TilesetRectangle = struct { pub const TilesetRectangle = struct {
h: i64,
tilesetUid: i64, tilesetUid: i64,
w: i64, w: i64,
h: i64,
x: i64, x: i64,
y: i64, y: i64,
pub fn fromJSON(tile_rect_opt: ?std.json.Value) !TilesetRectangle {
const tile_rect = object(tile_rect_opt) orelse return error.InvalidTileRect;
return TilesetRectangle{
.tilesetUid = integer(tile_rect.get("tilesetUid")) orelse return error.InvalidTilesetUid,
.w = integer(tile_rect.get("w")) orelse return error.InvalidW,
.h = integer(tile_rect.get("h")) orelse return error.InvalidH,
.x = integer(tile_rect.get("x")) orelse return error.InvalidX,
.y = integer(tile_rect.get("y")) orelse return error.InvalidY,
};
}
}; };
/// 3.3. Tileset definition /// 3.3. Tileset definition

76
src/main.zig
View File

@ -25,7 +25,7 @@ test "load default/empty ldtk file" {
const ldtk_levels = try extract_levels(testing.allocator, levels); const ldtk_levels = try extract_levels(testing.allocator, levels);
defer testing.allocator.free(ldtk_levels); defer testing.allocator.free(ldtk_levels);
var ldtk_root = LDtk.Root { var ldtk_root = LDtk.Root{
.bgColor = string(root.get("bgColor")) orelse return error.InvalidBGColor, .bgColor = string(root.get("bgColor")) orelse return error.InvalidBGColor,
// .defs = ldtk_defs, // .defs = ldtk_defs,
.externalLevels = boolean(root.get("externalLevels")) orelse return error.InvalidExternalLevels, .externalLevels = boolean(root.get("externalLevels")) orelse return error.InvalidExternalLevels,
@ -76,6 +76,7 @@ pub fn extract_levels(alloc: std.mem.Allocator, levels: std.json.Array) ![]LDtk.
defer ldtk_levels.deinit(); // levels will be returned using toOwnedSlice defer ldtk_levels.deinit(); // levels will be returned using toOwnedSlice
for (levels.items) |level_value| { for (levels.items) |level_value| {
const level_obj = object(level_value) orelse return error.InvalidLevel; const level_obj = object(level_value) orelse return error.InvalidLevel;
const layer_instances = if (level_obj.get("layerInstances")) |layerInstances| try LDtk.LayerInstance.fromJSONMany(alloc, layerInstances) else null;
ldtk_levels.appendAssumeCapacity(.{ ldtk_levels.appendAssumeCapacity(.{
.__bgColor = string(level_obj.get("__bgColor")), .__bgColor = string(level_obj.get("__bgColor")),
// TODO // TODO
@ -88,8 +89,7 @@ pub fn extract_levels(alloc: std.mem.Allocator, levels: std.json.Array) ![]LDtk.
.fieldInstances = &[_]LDtk.FieldInstance{}, .fieldInstances = &[_]LDtk.FieldInstance{},
.identifier = string(level_obj.get("identifier")) orelse return error.InvalidIdentifier, .identifier = string(level_obj.get("identifier")) orelse return error.InvalidIdentifier,
.iid = string(level_obj.get("iid")) orelse return error.InvalidIID, .iid = string(level_obj.get("iid")) orelse return error.InvalidIID,
// TODO .layerInstances = layer_instances,
.layerInstances = null,
.pxHei = integer(level_obj.get("pxHei")) orelse return error.InvalidPxHei, .pxHei = integer(level_obj.get("pxHei")) orelse return error.InvalidPxHei,
.pxWid = integer(level_obj.get("pxWid")) orelse return error.InvalidPxWid, .pxWid = integer(level_obj.get("pxWid")) orelse return error.InvalidPxWid,
.uid = integer(level_obj.get("uid")) orelse return error.InvalidUID, .uid = integer(level_obj.get("uid")) orelse return error.InvalidUID,
@ -101,41 +101,41 @@ pub fn extract_levels(alloc: std.mem.Allocator, levels: std.json.Array) ![]LDtk.
return ldtk_levels.toOwnedSlice(); return ldtk_levels.toOwnedSlice();
} }
pub fn extract_layers(alloc: std.mem.Allocator, layers: std.json.Array) ![]LDtk.LayerInstance { // pub fn extract_layers(alloc: std.mem.Allocator, layers: std.json.Array) ![]LDtk.LayerInstance {
var ldtk_layers = try std.ArrayList(LDtk.LayerInstance).initCapacity(alloc, layers.items.len); // var ldtk_layers = try std.ArrayList(LDtk.LayerInstance).initCapacity(alloc, layers.items.len);
defer ldtk_layers.deinit(); // levels will be returned using toOwnedSlice // defer ldtk_layers.deinit(); // levels will be returned using toOwnedSlice
for (layers.items) |layer_value| { // for (layers.items) |layer_value| {
const layer_obj = object(layer_value) orelse return error.InvalidLayer; // const layer_obj = object(layer_value) orelse return error.InvalidLayer;
const __type = enum_from_value(LDtk.LayerType, layer_obj.get("__type")) orelse return error.InvalidType; // const __type = enum_from_value(LDtk.LayerType, layer_obj.get("__type")) orelse return error.InvalidType;
const autoLayerTiles = if (__type == .AutoLayer) {} else null; // const autoLayerTiles = if (__type == .AutoLayer) {} else null;
const entityInstances = if (__type == .Entities) {} else null; // const entityInstances = if (__type == .Entities) {} else null;
const gridTiles = if (__type == .Tiles) {} else null; // const gridTiles = if (__type == .Tiles) {} else null;
const intGridCsv = if (__type == .IntGrid) {} else null; // const intGridCsv = if (__type == .IntGrid) {} else null;
ldtk_layers.appendAssumeCapacity(.{ // ldtk_layers.appendAssumeCapacity(.{
.__cHei = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .__cHei = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.__cWid = integer(layer_obj.get("__cWid")) orelse return error.InvalidCWid, // .__cWid = integer(layer_obj.get("__cWid")) orelse return error.InvalidCWid,
.__gridSize = integer(layer_obj.get("__gridSize")) orelse return error.InvalidGridSize, // .__gridSize = integer(layer_obj.get("__gridSize")) orelse return error.InvalidGridSize,
.__identifier = string(layer_obj.get("__identifier")) orelse return error.InvalidIdentifier, // .__identifier = string(layer_obj.get("__identifier")) orelse return error.InvalidIdentifier,
.__opacity = float(layer_obj.get("__opacity")) orelse return error.InvalidOpacity, // .__opacity = float(layer_obj.get("__opacity")) orelse return error.InvalidOpacity,
.__pxTotalOffsetX = integer(layer_obj.get("__pxTotalOffsetX")) orelse return error.InvalidTotalOffsetX, // .__pxTotalOffsetX = integer(layer_obj.get("__pxTotalOffsetX")) orelse return error.InvalidTotalOffsetX,
.__pxTotalOffsetY = integer(layer_obj.get("__pxTotalOffsetY")) orelse return error.InvalidTotalOffsetY, // .__pxTotalOffsetY = integer(layer_obj.get("__pxTotalOffsetY")) orelse return error.InvalidTotalOffsetY,
.__tilesetDefUid = integer(layer_obj.get("__tilesetDefUid")) orelse return error.InvalidTilesetDefUid, // .__tilesetDefUid = integer(layer_obj.get("__tilesetDefUid")) orelse return error.InvalidTilesetDefUid,
.__tilesetRelPath = integer(layer_obj.get("__tilesetRelPath")) orelse return error.InvalidTilesetRelPath, // .__tilesetRelPath = integer(layer_obj.get("__tilesetRelPath")) orelse return error.InvalidTilesetRelPath,
.__type = __type, // .__type = __type,
.autoLayerTiles = autoLayerTiles, // .autoLayerTiles = autoLayerTiles,
.entityInstances = entityInstances, // .entityInstances = entityInstances,
.gridTiles = gridTiles, // .gridTiles = gridTiles,
.iid = string(layer_obj.get("iid")) orelse return error.InvalidIID, // .iid = string(layer_obj.get("iid")) orelse return error.InvalidIID,
.intGridCsv = integer(layer_obj.get("intGridCsv")) orelse return error.InvalidGridCsv, // .intGridCsv = integer(layer_obj.get("intGridCsv")) orelse return error.InvalidGridCsv,
.levelId = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .levelId = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.overrideTilesetUid = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .overrideTilesetUid = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.pxOffsetX = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .pxOffsetX = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.pxOffsetY = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .pxOffsetY = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
.visible = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei, // .visible = integer(layer_obj.get("__cHei")) orelse return error.InvalidCHei,
}); // });
} // }
return ldtk_layers.toOwnedSlice(); // return ldtk_layers.toOwnedSlice();
} // }
fn object(value_opt: ?std.json.Value) ?std.json.ObjectMap { fn object(value_opt: ?std.json.Value) ?std.json.ObjectMap {
const value = value_opt orelse return null; const value = value_opt orelse return null;