feat: v2 Kotor-style tile kits and tile layout compile

.cache/kotor_net_area_designer/AreaExportation_AreaExporter.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+using Kotor.NET.Resources.KotorMDL;
+using Kotor.NET.Resources.KotorMDL.Controllers;
+using Kotor.NET.Resources.KotorMDL.Nodes;
+
+namespace Kotor.DevelopmentKit.AreaDesigner.relocate.AreaExportation;
+
+public static class AreaExporter
+{
+    public static MDL RoomToMDL(Room room)
+    {
+        var mdl = new MDL();
+        mdl.Name = "test";
+
+        foreach (var tile in room.Tiles)
+        {
+            mdl.Root.Children.Add(FloorToMDLNode(tile.Floor));
+            //mdl.Root.Children.Add(CeilingToMDLNode(tile.Ceiling));
+            mdl.Root.Children.AddRange(tile.Walls.Where(x => x.Visible).Select(WallToMDLNode));
+            mdl.Root.Children.AddRange(tile.Walls.Select(x => x.DoorFrame).Where(x => x?.Visible == true).Select(DoorFrameToMDLNode));
+            mdl.Root.Children.AddRange(tile.InnerCorners.Where(x => x.Visible == true).Select(InnerCornerToMDLNode));
+            mdl.Root.Children.AddRange(room.Objects.Select(ObjectToMDLNode));
+        }
+
+        mdl.Root.GetAllDescendants().Select((x, i) => x.Name = i.ToString()).ToArray();
+        mdl.RedoNodeNumbers();
+        return mdl;
+    }
+
+    private static MDLNode FloorToMDLNode(Floor floor)
+    {
+        var floorMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{floor.KitID}/{floor.Template.Model}.mdl");
+        floorMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(floor.Position));
+        floorMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(floor.Orientation));
+        return floorMDL.Root;
+    }
+
+    private static MDLNode CeilingToMDLNode(Ceiling ceiling)
+    {
+        var ceilingMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{ceiling.KitID}/{ceiling.Template.Model}.mdl");
+        ceilingMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(ceiling.Position));
+        ceilingMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(ceiling.Orientation));
+        return ceilingMDL.Root;
+    }
+
+    private static MDLNode WallToMDLNode(Wall wall)
+    {
+        var wallMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{wall.KitID}/{wall.Template.Model}.mdl");
+        wallMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(wall.Position));
+        wallMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(wall.Orientation));
+        return wallMDL.Root;
+    }
+
+    private static MDLNode DoorFrameToMDLNode(DoorFrame doorframe)
+    {
+        var doorframeMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{doorframe.KitID}/{doorframe.Template.Model}.mdl");
+        doorframeMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(doorframe.Position));
+        doorframeMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(doorframe.Orientation));
+        return doorframeMDL.Root;
+    }
+
+    private static MDLNode InnerCornerToMDLNode(InnerCorner corner)
+    {
+        var cornerMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{corner.KitID}/{corner.Template.Model}.mdl");
+        cornerMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(corner.Position));
+        cornerMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(corner.Orientation));
+        return cornerMDL.Root;
+    }
+
+    private static MDLNode ObjectToMDLNode(Object @object)
+    {
+        var objectMDL = MDL.FromFile($"{Kit.Manager.ActiveDirectory}/{@object.KitID}/{@object.Template.Model}.mdl");
+        objectMDL.Root.GetController<MDLControllerDataPosition>().AddLinear(0, new(@object.LocalPosition));
+        objectMDL.Root.GetController<MDLControllerDataOrientation>().AddLinear(0, new(@object.LocalOrientation));
+        return objectMDL.Root;
+    }
+}

.cache/kotor_net_area_designer/AreaSerialization_AreaSerializer.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Kotor.DevelopmentKit.AreaDesigner.relocate.KitSerialization;
+using Newtonsoft.Json;
+
+namespace Kotor.DevelopmentKit.AreaDesigner.relocate.AreaSerialization;
+
+public class AreaSerializer
+{
+    public static Area Load(string filepath)
+    {
+        var json = File.ReadAllText(filepath);
+        dynamic data = JsonConvert.DeserializeObject(json);
+        string format = (string)data.format.Value;
+
+        return format switch
+        {
+            "0.1" => AreaSerializer_V0_1.Load(filepath),
+            _ => throw new ArgumentException("Kit version is unsupported.")
+        };
+    }
+
+    public static void Save(string filepath, Area area)
+    {
+        AreaSerializer_V0_1.Save(filepath, area);
+    }
+}

.cache/kotor_net_area_designer/AreaSerialization_AreaSerializer_V0_1.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using Kotor.DevelopmentKit.AreaDesigner.relocate.KitSerialization;
+using Kotor.NET.Graphics.Extensions;
+using Newtonsoft.Json;
+
+namespace Kotor.DevelopmentKit.AreaDesigner.relocate.AreaSerialization;
+
+public class AreaSerializer_V0_1
+{
+    public const string FormatID = "0.1";
+
+    public static Area Load(string filepath)
+    {
+        var json = File.ReadAllText(filepath);
+        dynamic data = JsonConvert.DeserializeObject(json);
+
+        var area = new Area();
+
+        foreach (var roomData in data.rooms.ToObject<dynamic[]>())
+        {
+            var room = new Room();
+            area.AddRoom(room);
+
+            foreach (var tileData in roomData.tiles.ToObject<dynamic[]>())
+            {
+                var tile = new Tile(room, Kit.Manager.Get(tileData.kitID.Value).Tile(tileData.templateID.Value));
+                tile.LocalPosition = new Vector3(tileData.position.ToObject<float[]>());
+                tile.LocalOrientation = ((float[])tileData.orientation.ToObject<float[]>()).ToQuaternion();
+
+                var floorData = tileData.floor;
+                var floorTemplate = Kit.Manager.Get(floorData.kitID.Value).Floor(floorData.templateID.Value);
+                tile.Floor.SwitchTemplate(floorTemplate);
+
+                // TODO
+                //var ceilingData = tileData.ceiling;
+                //var ceilingTemplate = Kit.Manager.Get(ceilingData.kitID.Value).Ceiling(ceilingData.templateID.Value);
+                //tile.Ceiling.SwitchTemplate(ceilingTemplate);
+
+                for (int i = 0; i < tileData.walls.Count; i++)
+                {
+                    var wallData = tileData.walls[i];
+                    var wallTemplate = Kit.Manager.Get(wallData.kitID.Value).Wall(wallData.templateID.Value);
+                    var wall = tile.Walls.ElementAt(i);
+                    wall.SwitchTemplate(wallTemplate);
+                }
+
+                room.Tiles.Add(tile);
+            }
+
+            room.FixWalls();
+        }
+
+        return area;
+    }
+
+    public static void Save(string filepath, Area area)
+    {
+        dynamic data = new ExpandoObject();
+
+        data.format = FormatID;
+
+        data.rooms = area.Rooms.Select(room => new
+        {
+            position = room.Position.ToFloatArray(),
+            orientation = room.Orientation.ToFloatArray(),
+            tiles = room.Tiles.Select(tile => new
+            {
+                kitID = tile.KitID,
+                templateID = tile.TemplateID,
+                position = tile.LocalPosition.ToFloatArray(),
+                orientation = tile.LocalOrientation.ToFloatArray(),
+                floor = new
+                {
+                    kitID = tile.Floor.KitID,
+                    templateID = tile.Floor.TemplateID,
+                },
+                ceiling = new
+                {
+                    kitID = "",
+                    templateID = "",
+                },
+                walls = tile.Walls.Select(x => new
+                {
+                    kitID = x.KitID,
+                    templateID = x.TemplateID,
+                }),
+            })
+        });
+
+        var json = JsonConvert.SerializeObject(data, Formatting.Indented);
+        File.WriteAllText(filepath, json);
+    }
+}

.cache/kotor_net_area_designer/Kit.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Kotor.DevelopmentKit.AreaDesigner.relocate.KitSerialization;
+
+namespace Kotor.DevelopmentKit.AreaDesigner.relocate;
+
+public class Kit
+{
+    public static KitManager Manager { get; } = new();
+
+    public string ID { get; }
+    public string Name { get; }
+    public string FilePath { get; }
+    public int Version { get; }
+    public ICollection<FloorTemplate> Floors { get; init; } = [];
+    public ICollection<TileTemplate> Tiles { get; init; } = [];
+    public ICollection<WallTemplate> Walls { get; init; } = [];
+    public ICollection<DoorFrameTemplate> DoorFrames { get; init; } = [];
+    public ICollection<CeilingTemplate> Ceilings { get; init; } = [];
+    public ICollection<InnerCornerTemplate> InnerCorners { get; init; } = [];
+    public ICollection<OuterCornerTemplate> OuterCorners { get; init; } = [];
+    public ICollection<ObjectTemplate> Objects { get; init; } = [];
+
+    public FloorTemplate Floor(string id) => Floors.Single(x => x.ID == id);
+    public TileTemplate Tile(string id) => Tiles.Single(x => x.ID == id);
+    public WallTemplate Wall(string id) => Walls.Single(x => x.ID == id);
+    public DoorFrameTemplate DoorFrame(string id) => DoorFrames.Single(x => x.ID == id);
+    public CeilingTemplate Ceiling(string id) => Ceilings.Single(x => x.ID == id);
+    public InnerCornerTemplate InnerCorner(string id) => InnerCorners.Single(x => x.ID == id);
+    public OuterCornerTemplate OuterCorner(string id) => OuterCorners.Single(x => x.ID == id);
+    public ObjectTemplate Object(string id) => Objects.Single(x => x.ID == id);
+
+    public Kit(string filepath, string id, int version, string name)
+    {
+        FilePath = filepath;
+        ID = id;
+        Name = name;
+        Version = version;
+    }   
+}
+
+public class KitManager
+{
+    public string ActiveDirectory = @"C:/Kits";
+    public ICollection<Kit> Kits { get; } = [];
+
+    public void Refresh()
+    {
+        Kits.Clear();
+        Directory.GetFiles(Kit.Manager.ActiveDirectory)
+            .Where(x => Path.GetExtension(x).ToLower() == ".kit")
+            .Select(KitSerializer.Load)
+            .ToList()
+            .ForEach(Kits.Add);
+    }
+    public Kit Get(string id) => Kits.Single(x => x.ID == id);
+}