using System;

using System.Collections.Generic;

    public enum InteractableTypes

    {

        WoodDoor=0,

        MetalDoor,

        Window,

        Lock

    }

public class Program //this can be the ObjectHandler

{

    static List<Interactable> rootActors;

    static List<Interactable> allActors;

    static List<DataStruct> modifiedDatas;

    static List<PlaceHolder> placeHolders;

    public static Dictionary<string, DataStruct> dataMap;//new

    static int loads = 1;

    static int saves = 1;

    public static void Main()

    {

        rootActors = new List<Interactable>();

        allActors = new List<Interactable>();

        modifiedDatas = new List<DataStruct>();

        dataMap = new Dictionary<string, DataStruct>();

        placeHolders = new List<PlaceHolder>();

        //placeholders in the scene

        placeHolders.Add(new PlaceHolder(new DataStruct("doorPH"), InteractableTypes.WoodDoor));

        placeHolders.Add(new PlaceHolder(new DataStruct("windowPH"), InteractableTypes.Window));

        //now we run our simulation

        LoadLevel();                                //load our stock level

        allActors[0].FuckAround(modifiedDatas); //modify both transforms

        allActors[1].FuckAround(modifiedDatas);

        SaveLevel(true);                            //save again, detect the door and add a lock

        LoadLevel();                                //load again, including the lock as a child of window

        Console.Write("\n\n\n");

    }

    static void LoadLevel()

    {

        Console.WriteLine("\nBeginning Load #" + loads);

        //erase Interactables in scene (keep placeholders and data)

        rootActors.Clear();

        allActors.Clear();

        //create objects in scene from placeholders 

        foreach(var ph in placeHolders)//assign objects to the placeholders

        {

            allActors.Add(ph.CreateInteractableFromPlaceholder());

            Console.WriteLine("from placeholder");

        }

        //now create other interactables, non-placeholder origin

        allActors.Add(new WoodDoor(new DataStruct("wooddoor01")));

        Console.WriteLine("from non-placeholder");      

        PrintScene();

        Console.WriteLine($"Finished Load #{loads++}\n");

    }

    static void SaveLevel(bool detect)

    {

        Console.WriteLine("\nBeginning Save #" + saves);

        if(detect) Detection();

        foreach(var obj in allActors)

        {

            UpdateDataMap(obj.data);//consider updating whenever a change happens also.

        }

        PrintScene();

        Console.WriteLine("Finished Save #" + saves++);

    }

    static void Detection() //this just detects the first one in the modified list

    {

        if(modifiedDatas.Count==0) return;

        var obj = FindInteractableByID(modifiedDatas[0].ID);

        obj.SecurityUp();

        modifiedDatas.RemoveAt(0);

    }

    static Interactable FindInteractableByID(string dataID)

    {

        foreach(var actor in allActors)

        {

            if(actor.data.ID == dataID)

                return actor;

        }

        return null;

    }

​

    static public void UpdateDataMap(DataStruct data)

    {

        if(dataMap.ContainsKey(data.ID))

            dataMap[data.ID] = data;

        else

            dataMap.Add(data.ID, data);

    }

    static void PrintScene()

    {

        Console.WriteLine("Scene Snapshot");

        foreach(var actor in allActors)

        {

            //Console.Write("\t");

            actor.Print();

            }

    }   

}

​

//==============================INTERACTABLE=========================================

public abstract class Interactable 

{

    public DataStruct data;

    Interactable child; //maybe null, maybe child

    //protected Interactable(string id){} // constructors

    protected Interactable(DataStruct _data)

    {

        data = _data;

        Init();

    }

    public void Init()

    {

        //update from saved data

        if(Program.dataMap.ContainsKey(data.ID))

            data = Program.dataMap[data.ID];

        if(data.childID != null) //data info says there will be a child object

        {

            //AddChild(BuildObjectFromData(data.childID));

        }

    }

    void PostInit()

    {

    }

    /*//this method will rebuild a previously existing object from the dataMap using its ID.

    public static Interactable BuildObjectFromData(string ID)

    {

        Interactable built = null;  

        DataStruct _data = Program.dataMap[ID];     

​

        switch (_data.type)

        {

            case InteractableTypes.WoodDoor:

                built = new WoodDoor(_data.ID);

                break;

            case InteractableTypes.MetalDoor:

                built = new MetalDoor(_data.ID);

                break;

            case InteractableTypes.Window:

                built = new Window(_data.ID);

                break;

            case InteractableTypes.Lock:

                built = new Lock(_data.ID);

                break;

        }

        return built;

    }*/

​

    public void SecurityUp()

    {       

        Console.WriteLine("upgrading security on " + data.ID);

        data.transform = 0; //reset state/transform

        AddChild(new Lock(new DataStruct("lock_01"))); //create object in scene and link it as child to this Data

    }

    public void AddChild(Interactable ch)

    {

        child = ch;

        data.childID = child.data.ID;

        Program.UpdateDataMap(ch.data);

    }

    public void FuckAround(List<DataStruct> modified)

    {

        data.transform += 1.207; //change the transform

        //if modified, add to list

        modified.Add(data);

    }

    public void Print()

    {

        string temp = string.Empty;

        if(child != null)

            temp = $"[child: {child.data.ID}]";

        Console.WriteLine($"[ID: {data.ID}] [transform: {data.transform}] {temp}");

        if(child != null)

            child.Print();   

    }

}

//==========================INTERACTABLE===SUBCLASSES=================================

public class WoodDoor : Interactable

{

    public WoodDoor(DataStruct _data) : base(_data)

    {

        Console.WriteLine("creating WoodDoor ");

    }

}

public class MetalDoor : Interactable

{

    public MetalDoor(DataStruct _data) : base(_data)

    {

        Console.Write("creating MetalDoor ");

    }

}

public class Window : Interactable

{

    public Window(DataStruct _data) : base(_data)

    {

        Console.Write("creating Window ");

    }

}

public class Lock : Interactable

{

    public Lock(DataStruct _data) : base(_data)

    {

        Console.Write("creating Lock ");

    }

}

//==============================DATA=STRUCT==========================================

public struct DataStruct

{

    public DataStruct(string id)

    {

        ID = id;

    }

    public string ID;

    public string childID;

    public double transform;

}

​

//=================================PLACEHOLDER=======================================

public class PlaceHolder

{   

    public DataStruct data;

    public InteractableTypes type;

    public PlaceHolder(DataStruct _data, InteractableTypes _type)

    {

        data = _data;

        type = _type;

    }

    public Interactable CreateInteractableFromPlaceholder()

    {

        Interactable obj = null;

        switch(type)

        {           

            case InteractableTypes.WoodDoor:

                obj = new WoodDoor(data);

                break;

            case InteractableTypes.MetalDoor:

                obj = new MetalDoor(data);

                break;

            case InteractableTypes.Window:

                obj = new Window(data);

                break;

        }

        return obj;

    }

}

​

​