284 lines
8.2 KiB
Zig
284 lines
8.2 KiB
Zig
const std = @import("std");
|
|
|
|
const Property = @import("./property.zig");
|
|
const xml = @import("./xml.zig");
|
|
const Color = @import("./color.zig");
|
|
const Object = @import("./object.zig");
|
|
const Position = @import("./position.zig");
|
|
|
|
const Layer = @This();
|
|
|
|
pub const TileVariant = struct {
|
|
width: u32,
|
|
height: u32,
|
|
data: []u32,
|
|
|
|
fn initDataFromXml(
|
|
arena: std.mem.Allocator,
|
|
scratch: *std.heap.ArenaAllocator,
|
|
lexer: *xml.Lexer,
|
|
) ![]u32 {
|
|
var iter = xml.TagParser.init(lexer);
|
|
const attrs = try iter.begin("data");
|
|
|
|
const encoding = attrs.get("encoding") orelse "csv";
|
|
// TODO: compression
|
|
|
|
var temp_tiles: std.ArrayList(u32) = .empty;
|
|
|
|
if (std.mem.eql(u8, encoding, "csv")) {
|
|
const text = try lexer.nextExpectText();
|
|
var split_iter = std.mem.splitScalar(u8, text, ',');
|
|
while (split_iter.next()) |raw_tile_id| {
|
|
const tile_id_str = std.mem.trim(u8, raw_tile_id, &std.ascii.whitespace);
|
|
const tile_id = try std.fmt.parseInt(u32, tile_id_str, 10);
|
|
try temp_tiles.append(scratch.allocator(), tile_id);
|
|
}
|
|
} else {
|
|
return error.UnknownEncodingType;
|
|
}
|
|
|
|
try iter.finish("data");
|
|
|
|
return try arena.dupe(u32, temp_tiles.items);
|
|
}
|
|
|
|
pub fn get(self: TileVariant, x: usize, y: usize) ?u32 {
|
|
if ((0 <= x and x < self.width) and (0 <= y and y < self.height)) {
|
|
return self.data[y * self.width + x];
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
|
|
pub const ImageVariant = struct {
|
|
pub const Image = struct {
|
|
// TODO: format
|
|
source: []const u8,
|
|
transparent_color: ?Color,
|
|
width: ?u32,
|
|
height: ?u32,
|
|
|
|
fn initFromXml(arena: std.mem.Allocator, lexer: *xml.Lexer) !Image {
|
|
var iter = xml.TagParser.init(lexer);
|
|
const attrs = try iter.begin("image");
|
|
|
|
// TODO: format
|
|
const source = try attrs.getDupe(arena, "source") orelse return error.MissingSource;
|
|
const width = try attrs.getNumber(u32, "width") orelse null;
|
|
const height = try attrs.getNumber(u32, "height") orelse null;
|
|
const transparent_color = try attrs.getColor("trans", false);
|
|
|
|
try iter.finish("image");
|
|
|
|
return Image{
|
|
.source = source,
|
|
.transparent_color = transparent_color,
|
|
.width = width,
|
|
.height = height
|
|
};
|
|
}
|
|
};
|
|
|
|
repeat_x: bool,
|
|
repeat_y: bool,
|
|
image: ?Image
|
|
};
|
|
|
|
pub const ObjectVariant = struct {
|
|
pub const DrawOrder = enum {
|
|
top_down,
|
|
index,
|
|
|
|
const map: std.StaticStringMap(DrawOrder) = .initComptime(.{
|
|
.{ "topdown", .top_down },
|
|
.{ "index", .index },
|
|
});
|
|
};
|
|
|
|
color: ?Color,
|
|
draw_order: DrawOrder,
|
|
items: []Object
|
|
};
|
|
|
|
pub const GroupVariant = struct {
|
|
layers: []Layer
|
|
};
|
|
|
|
pub const Type = enum {
|
|
tile,
|
|
object,
|
|
image,
|
|
group,
|
|
|
|
const name_map: std.StaticStringMap(Type) = .initComptime(.{
|
|
.{ "layer", .tile },
|
|
.{ "objectgroup", .object },
|
|
.{ "imagelayer", .image },
|
|
.{ "group", .group }
|
|
});
|
|
|
|
fn toXmlName(self: Type) []const u8 {
|
|
return switch (self) {
|
|
.tile => "layer",
|
|
.object => "objectgroup",
|
|
.image => "imagelayer",
|
|
.group => "group",
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Variant = union(Type) {
|
|
tile: TileVariant,
|
|
object: ObjectVariant,
|
|
image: ImageVariant,
|
|
group: GroupVariant
|
|
};
|
|
|
|
id: u32,
|
|
name: []const u8,
|
|
class: []const u8,
|
|
opacity: f32,
|
|
visible: bool,
|
|
tint_color: ?Color,
|
|
offset_x: f32,
|
|
offset_y: f32,
|
|
parallax_x: f32,
|
|
parallax_y: f32,
|
|
properties: Property.List,
|
|
variant: Variant,
|
|
|
|
pub fn initFromXml(
|
|
arena: std.mem.Allocator,
|
|
scratch: *std.heap.ArenaAllocator,
|
|
lexer: *xml.Lexer,
|
|
) !Layer {
|
|
const value = try lexer.peek() orelse return error.MissingStartTag;
|
|
if (value != .start_tag) return error.MissingStartTag;
|
|
|
|
var layer_type = Type.name_map.get(value.start_tag.name) orelse return error.UnknownLayerType;
|
|
|
|
var iter = xml.TagParser.init(lexer);
|
|
const attrs = try iter.begin(layer_type.toXmlName());
|
|
|
|
const id = try attrs.getNumber(u32, "id") orelse return error.MissingId;
|
|
const name = try attrs.getDupe(arena, "name") orelse "";
|
|
const class = try attrs.getDupe(arena, "class") orelse "";
|
|
const opacity = try attrs.getNumber(f32, "opacity") orelse 1;
|
|
const visible = try attrs.getBool("visible", "1", "0") orelse true;
|
|
const offset_x = try attrs.getNumber(f32, "offsetx") orelse 0;
|
|
const offset_y = try attrs.getNumber(f32, "offsety") orelse 0;
|
|
const parallax_x = try attrs.getNumber(f32, "parallaxx") orelse 1;
|
|
const parallax_y = try attrs.getNumber(f32, "parallaxy") orelse 1;
|
|
const tint_color = try attrs.getColor("tintcolor", true);
|
|
|
|
var variant: Variant = undefined;
|
|
switch (layer_type) {
|
|
.tile => {
|
|
const width = try attrs.getNumber(u32, "width") orelse return error.MissingWidth;
|
|
const height = try attrs.getNumber(u32, "height") orelse return error.MissingHeight;
|
|
variant = .{
|
|
.tile = TileVariant{
|
|
.width = width,
|
|
.height = height,
|
|
.data = &[0]u32{}
|
|
}
|
|
};
|
|
},
|
|
.image => {
|
|
const repeat_x = try attrs.getBool("repeatx", "1", "0") orelse false;
|
|
const repeat_y = try attrs.getBool("repeaty", "1", "0") orelse false;
|
|
variant = .{
|
|
.image = ImageVariant{
|
|
.repeat_x = repeat_x,
|
|
.repeat_y = repeat_y,
|
|
.image = null
|
|
}
|
|
};
|
|
},
|
|
.object => {
|
|
const draw_order = try attrs.getEnum(ObjectVariant.DrawOrder, "draworder", ObjectVariant.DrawOrder.map) orelse .top_down;
|
|
const color = try attrs.getColor("color", true);
|
|
|
|
variant = .{
|
|
.object = ObjectVariant{
|
|
.color = color,
|
|
.draw_order = draw_order,
|
|
.items = &.{}
|
|
}
|
|
};
|
|
},
|
|
.group => {
|
|
variant = .{
|
|
.group = .{
|
|
.layers = &.{}
|
|
}
|
|
};
|
|
},
|
|
}
|
|
|
|
var properties: Property.List = .empty;
|
|
var objects: std.ArrayList(Object) = .empty;
|
|
var layers: std.ArrayList(Layer) = .empty;
|
|
|
|
while (try iter.next()) |node| {
|
|
if (node.isTag("properties")) {
|
|
properties = try Property.List.initFromXml(arena, scratch, lexer);
|
|
continue;
|
|
}
|
|
|
|
if (variant == .tile and node.isTag("data")) {
|
|
variant.tile.data = try TileVariant.initDataFromXml(arena, scratch, lexer);
|
|
continue;
|
|
}
|
|
|
|
if (variant == .image and node.isTag("image")) {
|
|
variant.image.image = try ImageVariant.Image.initFromXml(arena, lexer);
|
|
continue;
|
|
}
|
|
|
|
if (variant == .object and node.isTag("object")) {
|
|
const object = try Object.initFromXml(arena, scratch, lexer);
|
|
try objects.append(scratch.allocator(), object);
|
|
continue;
|
|
}
|
|
|
|
if (variant == .group and isLayerNode(node)) {
|
|
const layer = try initFromXml(arena, scratch, lexer);
|
|
try layers.append(scratch.allocator(), layer);
|
|
continue;
|
|
}
|
|
|
|
try iter.skip();
|
|
}
|
|
|
|
try iter.finish(layer_type.toXmlName());
|
|
|
|
if (variant == .object) {
|
|
variant.object.items = try arena.dupe(Object, objects.items);
|
|
}
|
|
|
|
if (variant == .group) {
|
|
variant.group.layers = try arena.dupe(Layer, layers.items);
|
|
}
|
|
|
|
return Layer{
|
|
.id = id,
|
|
.name = name,
|
|
.class = class,
|
|
.opacity = opacity,
|
|
.visible = visible,
|
|
.tint_color = tint_color,
|
|
.offset_x = offset_x,
|
|
.offset_y = offset_y,
|
|
.parallax_x = parallax_x,
|
|
.parallax_y = parallax_y,
|
|
.properties = properties,
|
|
.variant = variant,
|
|
};
|
|
}
|
|
|
|
pub fn isLayerNode(node: xml.TagParser.Node) bool {
|
|
return node.isTag("layer") or node.isTag("objectgroup") or node.isTag("imagelayer") or node.isTag("group");
|
|
}
|