114 lines
3.6 KiB
Zig
114 lines
3.6 KiB
Zig
const std = @import("std");
|
|
|
|
const Point = struct {
|
|
x: f64 = 0,
|
|
y: f64 = 0,
|
|
};
|
|
|
|
const Object = struct {
|
|
height: u64 = 0,
|
|
id: u64 = 0,
|
|
name: []const u8,
|
|
polyline: []Point,
|
|
rotation: f64 = 0,
|
|
@"type": []const u8 = "",
|
|
visible: bool = true,
|
|
width: u64 = 0,
|
|
x: f64 = 0,
|
|
y: f64 = 0,
|
|
};
|
|
|
|
const Layer = struct {
|
|
data: []u64 = &.{},
|
|
objects: []Object = &.{},
|
|
height: u64 = 0,
|
|
id: u64,
|
|
name: []const u8,
|
|
draworder: enum { topdown, none } = .none,
|
|
opacity: u64,
|
|
@"type": enum { tilelayer, objectgroup },
|
|
visible: bool,
|
|
width: u64 = 0,
|
|
x: i64,
|
|
y: i64,
|
|
};
|
|
|
|
const MapType = struct {
|
|
compressionlevel: i64 = -1,
|
|
height: u64 = 0,
|
|
infinite: bool = false,
|
|
layers: []Layer,
|
|
nextlayerid: u64 = 0,
|
|
nextobjectid: u64 = 0,
|
|
orientation: enum { orthogonal } = .orthogonal,
|
|
renderorder: enum { @"right-down" } = .@"right-down",
|
|
tiledversion: []const u8 = "",
|
|
tileheight: u64 = 0,
|
|
tilesets: []struct { firstgid: u64, source: []const u8 },
|
|
tilewidth: u64 = 0,
|
|
@"type": enum { map } = .map,
|
|
version: []const u8 = "",
|
|
width: u64 = 0,
|
|
};
|
|
|
|
const KB = 1024;
|
|
var heap: [64 * KB]u8 = undefined;
|
|
var fba = std.heap.FixedBufferAllocator.init(&heap);
|
|
var alloc = fba.allocator();
|
|
|
|
pub fn main() anyerror!void {
|
|
const cwd = std.fs.cwd();
|
|
var output = try cwd.createFile("map.zig", .{});
|
|
defer output.close();
|
|
|
|
var argsIter = std.process.args();
|
|
const progName = (try argsIter.next(alloc)) orelse "";
|
|
defer alloc.free(progName);
|
|
std.log.info("{s}", .{progName});
|
|
|
|
while (try argsIter.next(alloc)) |arg| {
|
|
defer alloc.free(arg);
|
|
std.log.info("{s}", .{arg});
|
|
var filebuffer: [64 * KB]u8 = undefined;
|
|
var filecontents = try cwd.readFile(arg, &filebuffer);
|
|
|
|
@setEvalBranchQuota(10000);
|
|
var tokenstream = std.json.TokenStream.init(filecontents);
|
|
const options = std.json.ParseOptions{ .allocator = fba.allocator() };
|
|
const map = try std.json.parse(MapType, &tokenstream, options);
|
|
defer std.json.parseFree(MapType, map, options);
|
|
|
|
var outlist = std.ArrayList(u8).init(alloc);
|
|
defer outlist.deinit();
|
|
|
|
try outlist.appendSlice("const std = @import(\"std\");\n");
|
|
try outlist.appendSlice("const Vec2 = std.meta.Vector(2,i32);\n");
|
|
|
|
var outbuffer: [4 * KB]u8 = undefined;
|
|
for (map.layers) |layer| {
|
|
switch (layer.@"type") {
|
|
.tilelayer => {
|
|
var outcontent = try std.fmt.bufPrint(&outbuffer, "pub const {s}: [{}]u8 = .{any};\n", .{ layer.name, layer.data.len, layer.data });
|
|
_ = try outlist.appendSlice(outcontent);
|
|
},
|
|
.objectgroup => {
|
|
var outcontent = try std.fmt.bufPrint(&outbuffer, "pub const {s}: [{}][2]Vec2 = [_][2]Vec2{{", .{ layer.name, layer.objects.len });
|
|
try outlist.appendSlice(outcontent);
|
|
|
|
for (layer.objects) |obj| {
|
|
try outlist.appendSlice(".{");
|
|
for (obj.polyline) |point| {
|
|
var pointf = try std.fmt.bufPrint(&outbuffer, ".{{ {}, {} }},", .{ @floatToInt(i32, obj.x + point.x), @floatToInt(i32, obj.y + point.y) });
|
|
try outlist.appendSlice(pointf);
|
|
}
|
|
try outlist.appendSlice("}, ");
|
|
}
|
|
try outlist.appendSlice("};\n");
|
|
},
|
|
}
|
|
}
|
|
std.log.info("{s}", .{outlist.items});
|
|
_ = try output.writeAll(outlist.items);
|
|
}
|
|
}
|