Added documentation

Author: DanielEverland

Assets/SO Architecture/Documentation/Event-Listeners.txt

@@ -0,0 +1,10 @@
+## Introduction
+Event Listeners are components that listen to a specific Event and then provides a response in the form on a UnityEvent. Note that the type of event listener must match the event type, so if a bool event is expected, you must use an EventListener of type bool as well. Typed events listeners also supports forwarding the raise parameter as a dynamic response
+
+Event listeners are also fully debuggable through a variety of features. A fully featured stacktrace window is available. You can also simulate an incoming event through the inspector, and even select a debug value if the listener is typed. When an event is raised, a gizmo is also drawn to visualize responses
+
+## Script Reference
+The class has a singular function for responding to an event. It differs depending on if a type is expected or not
+
+void OnEventRaised(T)
+void OnEventRaised()

Assets/SO Architecture/Documentation/Events.txt

@@ -0,0 +1,16 @@
+## Introduction
+
+Events also exist as ScriptableObjects in your project. They can contain any single parameter when raising or none. Events are also fully debuggable through the editor using the stacktrace window and the raise button functionality, which also supports the ability to raise events with parameters. If a parameter is specified, a field will be present which allows you to select which value will be passed.
+
+## Script Reference
+Note that you must provide an Event Listener in order to subscribe to events
+
+The base class differs depending on whether an argument is expected or not
+
+void Raise(T)
+void RegisterListener(IGameEventListener<T>)
+void UnregisterListener(IGameEventListener<T>)
+
+void Raise()
+void RegisterListener(IGameEventListener)
+void UnregisterListener(IGameEventListener)

Assets/SO Architecture/Documentation/References.txt

@@ -0,0 +1,16 @@
+## Introduction
+References are how we expose fields in MonoBehaviour scripts that allow us to assign a variable ScriptableObject. They're wrapped in a separate class because you can also choose not to use a ScriptableObject at all, and instead write a constant value in the inspector.
+
+## Script Reference
+To create a Reference field in your MonoBehaviour script, simply declare it like you would any other field
+
+public BoolReference boolValue;
+
+Or use the [SerializeField] attribute if it's not public
+
+[SerializeField]
+private BoolReference boolValue;
+
+You don't have to care whether the Reference is using a constant or a variable, simply reference the Value property
+
+T Value { get; set; }

Assets/SO Architecture/Documentation/Runtime-Set.txt

@@ -0,0 +1,14 @@
+## Introduction
+Runtime Sets are simply a collection of objects that are assigned during runtime. Note that the inspector is merely there for debugging purposes, and not supposed to let you drag data into the set. You can see all objects within the set, click on them to see where they are in the scene view, and even remove entries.
+
+## Script Reference
+There are various ways to interact with the runtime set. Available are the following members
+
+T this[int index]
+
+IList Items { get; }
+int Count { get; }
+Type Type { get; }
+
+void Add(T)
+void Remove(T)

Assets/SO Architecture/Documentation/Variables.txt

@@ -0,0 +1,16 @@
+## Introduction
+Variable ScriptableObject's share a lot of similarities with C# variables. They can be named and contain values of different types. Since they're embedded into a ScriptableObject, which exists as an asset within Unity, modifying both the name and value is very simple and intuitive.
+
+## Script Reference
+Variables have a single property and a couple of functions we can use to modify its value.
+
+Value { get; set; }
+
+SetValue(T)
+SetValue(BaseVariable<T>)
+
+Variables also have a single operator
+
+implicit operator T(BaseVariable<T>)
+
+The reason why you can't implicitly or explicitly assign any value, is because Variables are objects themselves, so it must be clear whether you're changing the reference or the value.