new stuff

Tools/MapTools/include/Element.h

@@ -0,0 +1,116 @@
+//
+// Created by tv on 29.06.23.
+//
+
+#ifndef SPOONTOOL_ELEMENT_H
+#define SPOONTOOL_ELEMENT_H
+
+#include<list>
+#include<string>
+#include"Transform.h"
+#include"Link.h"
+
+enum LayerConfig{
+    Common, //Cmn
+    Paint, //Pnt
+    //Online, //Vss
+    Rainmaker, //Vlf
+    Tower, //Vgl
+    Area, //Var
+    Night, //Night
+    Day, //Day
+    Temporary //Tmp
+};
+
+inline std::string ToStringYaml(LayerConfig cfg){
+    if(cfg == Common){
+        return "Cmn";
+    } else if(cfg == Paint){
+        return "Pnt";
+    } else if(cfg == Rainmaker) {
+        return "Vlf";
+    } else if(cfg == Tower) {
+        return "Vgl";
+    } else if(cfg == Area) {
+        return "Var";
+    } else if(cfg == Night) {
+        return "Night";
+    } else if(cfg == Day) {
+        return "Day";
+    } else if(cfg == Temporary) {
+        return "Tmp";
+    }
+}
+
+inline std::string ToString(LayerConfig cfg){
+    if(cfg == Common){
+        return "Common";
+    } else if(cfg == Paint){
+        return "Paint";
+    } else if(cfg == Rainmaker) {
+        return "Rainmaker";
+    } else if(cfg == Tower) {
+        return "Tower";
+    } else if(cfg == Area) {
+        return "Area";
+    } else if(cfg == Night) {
+        return "Night";
+    } else if(cfg == Day) {
+        return "Day";
+    } else if(cfg == Temporary) {
+        return "Temporary";
+    }
+}
+
+inline LayerConfig ToLayerConfig(std::string cfg){
+    if(cfg == "Cmn"){
+        return Common;
+    } else if(cfg == "Pnt"){
+        return Paint;
+    } else if(cfg == "Vlf") {
+        return Rainmaker;
+    } else if(cfg == "Vgl") {
+        return Tower;
+    } else if(cfg == "Var") {
+        return Area;
+    } else if(cfg == "Night") {
+        return Night;
+    } else if(cfg == "Day") {
+        return Day;
+    } else if(cfg == "Tmp") {
+        return Temporary;
+    }
+}
+
+class Element{
+public:
+    Element() = default;
+
+    Element(const YAML::Node &ObjNode,std::list<std::string> PropertyBlockList = {});
+    unsigned int runtimeID = static_cast<unsigned int>(rand());
+
+    Transform TF = Transform();
+    std::string Type = "Unnamed Type";
+    std::string Name = "Unnamed Element";
+
+    std::string ModelName = "null";
+
+    LayerConfig Layer = Common;
+
+    std::vector<long> Parameters = std::vector<long>();
+    std::vector<float> FloatParameters = std::vector<float>();
+
+    //std::map<std::string,std::vector<Link>> Links = std::map<std::string,std::vector<Link>>();
+
+    std::vector<Link> Links = std::vector<Link>();
+    std::map<std::string,std::string> OtherOptions = std::map<std::string,std::string>();
+
+    bool IsLinkDest = false;
+    void YamlInsert(YAML::Emitter &Emitter);
+
+    virtual ~Element() = default;
+protected:
+    virtual void YamlInsertBody(YAML::Emitter &Emitter);
+};
+
+#endif //SPOONTOOL_ELEMENT_H

Tools/MapTools/include/LevelObject.h

@@ -0,0 +1,89 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_LEVELOBJECT_H
+#define SPOONTOOL_LEVELOBJECT_H
+
+#include<Transform.h>
+#include<Link.h>
+
+#include<yaml-cpp/yaml.h>
+#include "SpecialObjectParams.h"
+#include "Element.h"
+
+
+namespace Teams{
+    constexpr long Player = 0;
+    constexpr long Neutral = 1;
+    constexpr long Enemy = 2;
+
+    constexpr std::array<long,3> AllOptions = {Player,Neutral,Enemy};
+
+    inline constexpr std::string TeamToText(long team) {
+        switch(team){
+            case 0:
+                return "Player";
+            case 1:
+                return "Neutral";
+            case 2:
+                return "Enemy";
+            default:
+                return "Invalid";
+        }
+    }
+}
+
+namespace DropId{
+    constexpr long Default = -1;
+    constexpr long Armor = 8;
+    constexpr long Map = 9;
+    constexpr long Key = 10;
+    constexpr long OneSphere = 11;
+    constexpr long FiveSphere = 12;
+    constexpr long TenSphere = 13;
+    constexpr long Bubbler = 14;
+    constexpr long Bazooka = 15;
+
+    constexpr std::array<long,9> AllOptions = {Default,Armor,Map,Key,OneSphere,FiveSphere,TenSphere,Bubbler,Bazooka};
+
+    inline constexpr std::string DropIdToText(long team) {
+        switch(team){
+            case -1:
+                return "Default";
+            case 8:
+                return "Armor";
+            case 9:
+                return "Map";
+            case 10:
+                return "Key";
+            case 11:
+                return "1 Sphere";
+            case 12:
+                return "5 Spheres";
+            case 13:
+                return "10 Spheres";
+            case 14:
+                return "Bubbler";
+            case 15:
+                return "Bazooka";
+            default:
+                return "Invalid";
+        }
+    }
+}
+
+struct LevelObject: public Element{
+    LevelObject(const YAML::Node &ObjNode);
+
+protected:
+    void YamlInsertBody(YAML::Emitter &Emitter) override;
+public:
+    long Team;
+    long DropId;
+
+    ~LevelObject() = default;
+};
+
+
+#endif //SPOONTOOL_LEVELOBJECT_H

Tools/MapTools/include/Link.h

@@ -0,0 +1,45 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_LINK_H
+#define SPOONTOOL_LINK_H
+
+#include <yaml-cpp/yaml.h>
+#include<string>
+
+constexpr std::array<const char*, 12> LinkTypes = {
+        "Spawner",
+        "Rail",
+        "Area",
+        "AutoWarpPointLink",
+        "Switch",
+        "SwitchSender",
+        "LiftBindable",
+        "GraphNode",
+        "ObjToGraphNode",
+        "ObjToGraphNodeOneway",
+        "BoneBindable",
+        "ToGachihokoTargetPoint",
+};
+
+struct Link {
+    inline Link() : Name("Rail"), Destination("Undefined Destination"), UnitFile("") {}
+
+    Link(const YAML::Node &ObjNode);
+
+    // DefinitionName in byaml
+    std::string Name;
+
+    // DestUnitId in byaml
+    std::string Destination;
+
+    // UnitFileName in byaml
+    static constexpr char LinkUnitFileID[] = "UnitFile";
+    std::string UnitFile;
+
+    void InsertIntoYaml(YAML::Emitter &Emitter);
+
+};
+
+#endif //SPOONTOOL_LINK_H

Tools/MapTools/include/Map.h

@@ -0,0 +1,33 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_MAP_H
+#define SPOONTOOL_MAP_H
+
+#include<boost/filesystem.hpp>
+#include<LevelObject.h>
+#include<Rail.h>
+
+
+struct Map {
+    //STREEFUNCS
+    Map();
+
+    void Save(boost::filesystem::path FileLocation);
+
+    boost::filesystem::path ActiveLocation = "";
+
+    void Export(boost::filesystem::path YamlOut);
+
+    std::vector<LevelObject> Objects;
+
+    std::vector<Rail> Rails;
+
+
+};
+
+Map ConvertFromYaml(boost::filesystem::path File);
+
+
+#endif //SPOONTOOL_MAP_H

Tools/MapTools/include/Rail.h

@@ -0,0 +1,57 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_RAIL_H
+#define SPOONTOOL_RAIL_H
+
+#include<Transform.h>
+#include<Link.h>
+#include<RailPoint.h>
+
+#include<yaml-cpp/yaml.h>
+#include<RailPoint.h>
+#include "Element.h"
+
+enum RailType{
+    Linear,
+    Bezier
+};
+
+inline std::string ToString(RailType railType){
+    if(railType == Linear){
+        return "Linear";
+    } else if(railType == Bezier){
+        return "Bezier";
+    }
+}
+
+inline RailType ToRailType(std::string railType){
+    if(railType == "Linear"){
+        return Linear;
+    } else if(railType == "Bezier"){
+        return Bezier;
+    }
+}
+
+constexpr std::array<RailType,2> AllRailTypeOptions = {Linear,Bezier};
+
+struct Rail: public Element{
+
+    Rail(const YAML::Node &ObjNode);
+    explicit Rail(const Vector3 &Position);
+
+    std::list<RailPoint> Points = std::list<RailPoint>();
+
+    RailType RailType = Linear;
+    bool IsClosed = false;
+    bool IsLadder = false;
+    long Priority = 100;
+
+    ~Rail() override = default;
+
+protected:
+    void YamlInsertBody(YAML::Emitter &Emitter) override;
+};
+
+#endif //SPOONTOOL_RAIL_H

Tools/MapTools/include/RailPoint.h

@@ -0,0 +1,33 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_RAILPOINT_H
+#define SPOONTOOL_RAILPOINT_H
+
+#include<Vector3.h>
+#include<Transform.h>
+#include<Link.h>
+
+#include<yaml-cpp/yaml.h>
+#include"Element.h"
+
+struct RailPoint: public Element{
+    RailPoint(const YAML::Node &ObjNode);
+    explicit RailPoint(const Vector3& pos);
+
+protected:
+
+    void YamlInsertBody(YAML::Emitter &Emitter) override;
+public:
+
+    std::vector<Vector3> m_controlPoints = std::vector<Vector3>();
+
+    Vector3 m_offset = {0,0,0};
+
+    bool m_useOffset = false;
+
+    ~RailPoint() override = default;
+};
+
+#endif //SPOONTOOL_RAILPOINT_H

Tools/MapTools/include/SpecialObjectParamVersions/All.h

@@ -0,0 +1,18 @@
+//
+// Created by tv on 09.05.23.
+//
+
+#ifndef SPOONTOOL_ALL_H
+#define SPOONTOOL_ALL_H
+#include<SpecialObjectParams.h>
+
+
+inline SpecialObjectParams* GetSpecParamsBySpoonID(std::string spoontype){
+    return new SpecialObjectParams();
+}
+
+inline SpecialObjectParams* GetSpecParamsBySubID(std::string spoontype){
+    return new SpecialObjectParams();
+}
+
+#endif //SPOONTOOL_ALL_H

Tools/MapTools/include/SpecialObjectParamVersions/Default.h

@@ -0,0 +1,24 @@
+//
+// Created by tv on 09.05.23.
+//
+
+#ifndef SPOONTOOL_DEFAULT_H
+#define SPOONTOOL_DEFAULT_H
+#include<SpecialObjectParams.h>
+
+class DefaultObjParams : public SpecialObjectParams {
+public:
+    DefaultObjParams() : SpecialObjectParams(){
+
+    }
+
+    void ParseOut(YAML::Node node) override {
+        return;
+    }
+
+    void InsertYaml(YAML::Emitter &Emitter) override {
+
+    }
+};
+
+#endif //SPOONTOOL_DEFAULT_H

Tools/MapTools/include/SpecialObjectParams.h

@@ -0,0 +1,23 @@
+//
+// Created by tv on 07.05.23.
+//
+
+#ifndef SPOONTOOL_SPECIALOBJECTPARAMS_H
+#define SPOONTOOL_SPECIALOBJECTPARAMS_H
+
+#include<yaml-cpp/yaml.h>
+
+struct SpecialObjectParams {
+public:
+    SpecialObjectParams();
+
+    virtual void ParseOut(YAML::Node node);
+
+    virtual void InsertYaml(YAML::Emitter& Emitter);
+
+    virtual ~SpecialObjectParams() = default;
+
+    std::vector<std::string> GetMiscParamBlockList();
+};
+
+#endif //SPOONTOOL_SPECIALOBJECTPARAMS_H

Tools/MapTools/include/Transform.h

@@ -0,0 +1,19 @@
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_TRANSFORM_H
+#define SPOONTOOL_TRANSFORM_H
+#include<Vector3.h>
+#include<yaml-cpp/yaml.h>
+
+struct Transform{
+
+    inline Transform(): Position(0,0,0), Scale(1,1,1), Rotation(0,0,0) {}
+
+    Vector3 Position,Scale,Rotation;
+
+    void InsertIntoYaml(YAML::Emitter &Emitter);
+};
+
+#endif //SPOONTOOL_TRANSFORM_H

Tools/MapTools/include/Vector3.h

@@ -0,0 +1,29 @@
+
+//
+// Created by tv on 30.04.23.
+//
+
+#ifndef SPOONTOOL_VECTOR3_H
+#define SPOONTOOL_VECTOR3_H
+
+#include <yaml-cpp/yaml.h>
+#include<boost/algorithm/string.hpp>
+#include<iostream>
+
+struct Vector3{
+
+    Vector3(YAML::Node node);
+    float X,Y,Z;
+
+    inline Vector3(float x,float y,float z) : X(x),Y(y),Z(z){}
+
+    inline void InsertIntoYaml(YAML::Emitter &Emitter){
+        Emitter << YAML::BeginMap;
+        Emitter << YAML::Key << "X" << YAML::Value << X;
+        Emitter << YAML::Key << "Y" << YAML::Value << Y;
+        Emitter << YAML::Key << "Z" << YAML::Value << Z;
+        Emitter << YAML::EndMap;
+
+    }
+};
+#endif //SPOONTOOL_VECTOR3_H