caleb-brown/unity-atoms
1
0
Fork 0
mirror of https://github.com/unity-atoms/unity-atoms.git synced 2025-01-21 23:58:49 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added code quality and style changes

Browse Source
This commit is contained in:
Jeff Campbell 2019-04-08 08:51:24 +02:00
commit e65b69d8e9
171 changed files with 1142 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
README.md
View File

@ -112,5 +112,75 @@ The reason for this project structure is that we want to include tests and examp
- use the local source in the example repo
- referencing this git repo in another project's manifest file
### Style Guide
#### Language Usage
* Mark closed types as sealed to enable proper devirtualization (see [here](https://blogs.unity3d.com/2016/07/26/il2cpp-optimizations-devirtualization/) for more info).
* Avoid LINQ usage for runtime usage except where absolutely possible (`ToList` or `ToArray` for example) and avoid using `ForEach`. Using these methods creates easily avoidable garbage. Editor usage is another story as performance is not as generally important.
#### Layout
There is an `.editorconfig` at the root of the repository located [here](/.editorconfig) that can be used by most IDEs to help ensure these settings are automatically applied.
* **Indentation:** 1 tab = 4 spaces (no tab character)
* **Desired width:** 120-130 characters max per line
* **Line Endings:** Unix (LF), with a new-line at the end of each file.
* **White Space:** Trim empty whitespace from the ends of lines.
#### Naming and Formatting
* Namespaces, Defined Types, Methods, and Events should all be in upper pascal case.
* Public fields should be in lower pascal case like `isLoaded` while private fields should be lower pascal case prefixed with a `_` character like `_isLoaded`.
* Public and private properties should be in upper pascal case `IsLoaded`.
* Readonly, static, or const fields should be in upper pascal case `IsLoaded`.
#### Structure
* Follow good encapsulation principles and try to limit exposing fields directly as public; unless necessary everything should be marked as private/protected unless necessary. Where public access to a field is needed, use a public property instead.
* Where classes or methods are not intended for use by a user, mark these as `internal`.
* Order class structure like so:
* Namespace
* Internal classes
* Properties (Public/Private)
* Fields (Public/Private)
* Unity Methods
* Primary Methods
* Helper Methods
* Lines of code that are generally longer than 120-130 characters should generally be broken out into multiple lines. For example, instead of:
`public bool SomeMethodWithManyParams(int param1, float param2, List<int> param3, out int param4, out int param5)...`
do
```
public bool SomeMethodWithManyParams(
int param1,
float param2,
List<int> param3,
out int param4,
out int param5)...
```
#### Example Formatting
```
using System;
using UnityEngine;
namespace Example
{
public class Foo : MonoBehavior
{
public int SomeValue { get { return _someValue; } }
[SerializeField]
private int _someValue;
private const string Warning = "Somethings wrong!";
private void Update()
{
// Do work
Debug.Log(Warning);
}
}
}
```
### Pull requests
Pull requests should be made to the [canary branch](https://github.com/AdamRamberg/unity-atoms/tree/canary).

105
Source/AtomicTags/AtomicTags.cs
View File

@ -7,16 +7,22 @@ using UnityEngine;
namespace UnityAtoms
{
public class AtomicTags : MonoBehaviour, ISerializationCallbackReceiver
public sealed class AtomicTags : MonoBehaviour, ISerializationCallbackReceiver
{
public ReadOnlyList<StringConstant> Tags { get; private set; }
private SortedList<string, StringConstant> sortedTags = new SortedList<string, StringConstant>();
private static Dictionary<string, List<GameObject>> taggedGOs = new Dictionary<string, List<GameObject>>();
private static Dictionary<GameObject, AtomicTags> instances = new Dictionary<GameObject, AtomicTags>();
private SortedList<string, StringConstant> _sortedTags = new SortedList<string, StringConstant>();
private static readonly Dictionary<string, List<GameObject>> TaggedGameObjects
= new Dictionary<string, List<GameObject>>();
private static readonly Dictionary<GameObject, AtomicTags> AtomicTagInstances
= new Dictionary<GameObject, AtomicTags>();
public List<StringConstant> _tags = new List<StringConstant>();
#region Serialization
public List<StringConstant> _tags = new List<StringConstant>();
public void OnBeforeSerialize()
{
#if UNITY_EDITOR
@ -25,7 +31,7 @@ namespace UnityAtoms
&& !EditorApplication.isCompiling) return;
#endif
_tags.Clear();
foreach (var kvp in sortedTags)
foreach (var kvp in _sortedTags)
{
_tags.Add(kvp.Value);
}
@ -33,55 +39,58 @@ namespace UnityAtoms
public void OnAfterDeserialize()
{
sortedTags = new SortedList<string, StringConstant>();
_sortedTags = new SortedList<string, StringConstant>();
for (int i = 0; i != _tags.Count; i++)
{
if (_tags[i] == null || _tags[i].Value == null) continue;
if (sortedTags.ContainsKey(_tags[i].Value)) continue;
sortedTags.Add(_tags[i].Value, _tags[i]);
if (_sortedTags.ContainsKey(_tags[i].Value)) continue;
_sortedTags.Add(_tags[i].Value, _tags[i]);
}
}
#endregion
#if UNITY_EDITOR
private void OnValidate()
{
OnAfterDeserialize(); // removes double values and nulls
_tags = sortedTags.Values.ToList();
#if UNITY_EDITOR
_tags = _sortedTags.Values.ToList();
// this null value is just for easier editing and could also be archived with an custom inspector
if(!EditorApplication.isPlaying){ _tags.Add(null); }
#endif
}
#endif
#region Lifecycle
private void Awake()
{
Tags = new ReadOnlyList<StringConstant>(sortedTags.Values);
Tags = new ReadOnlyList<StringConstant>(_sortedTags.Values);
}
private void OnEnable()
{
if (!instances.ContainsKey(this.gameObject)) instances.Add(this.gameObject, this);
foreach (var stringConstant in Tags)
if (!AtomicTagInstances.ContainsKey(gameObject)) AtomicTagInstances.Add(gameObject, this);
for (var i = 0; i < Tags.Count; i++)
{
var stringConstant = Tags[i];
if (stringConstant == null) continue;
var tag = stringConstant.Value;
if (!taggedGOs.ContainsKey(tag)) taggedGOs.Add(tag, new List<GameObject>());
taggedGOs[tag].Add(this.gameObject);
};
var atomicTag = stringConstant.Value;
if (!TaggedGameObjects.ContainsKey(atomicTag)) TaggedGameObjects.Add(atomicTag, new List<GameObject>());
TaggedGameObjects[atomicTag].Add(gameObject);
}
}
private void OnDisable()
{
if (instances.ContainsKey(this.gameObject)) instances.Remove(this.gameObject);
foreach (var stringConstant in Tags)
if (AtomicTagInstances.ContainsKey(gameObject)) AtomicTagInstances.Remove(gameObject);
for (var i = 0; i < Tags.Count; i++)
{
var stringConstant = Tags[i];
if (stringConstant == null) continue;
var tag = stringConstant.Value;
if (taggedGOs.ContainsKey(tag)) taggedGOs[tag].Remove(this.gameObject);
};
var atomicTag = stringConstant.Value;
if (TaggedGameObjects.ContainsKey(atomicTag)) TaggedGameObjects[atomicTag].Remove(gameObject);
}
}
#endregion
@ -89,54 +98,54 @@ namespace UnityAtoms
public bool HasTag(string atomicTag)
{
if (atomicTag == null) return false;
return sortedTags.ContainsKey(atomicTag);
return _sortedTags.ContainsKey(atomicTag);
}
public void AddTag(StringConstant atomicTag)
{
if (atomicTag == null || atomicTag.Value == null) return;
if (sortedTags.ContainsKey(atomicTag.Value)) return;
sortedTags.Add(atomicTag.Value, atomicTag);
if (_sortedTags.ContainsKey(atomicTag.Value)) return;
_sortedTags.Add(atomicTag.Value, atomicTag);
Tags = new ReadOnlyList<StringConstant>(sortedTags.Values);
Tags = new ReadOnlyList<StringConstant>(_sortedTags.Values);
// Update static accessors:
if (!taggedGOs.ContainsKey(atomicTag.Value)) taggedGOs.Add(atomicTag.Value, new List<GameObject>());
taggedGOs[atomicTag.Value].Add(this.gameObject);
if (!TaggedGameObjects.ContainsKey(atomicTag.Value)) TaggedGameObjects.Add(atomicTag.Value, new List<GameObject>());
TaggedGameObjects[atomicTag.Value].Add(this.gameObject);
}
public void RemoveTag(string atomicTag)
{
if (atomicTag == null) return;
if (sortedTags.ContainsKey(atomicTag)) return;
sortedTags.Remove(atomicTag);
if (_sortedTags.ContainsKey(atomicTag)) return;
_sortedTags.Remove(atomicTag);
Tags = new ReadOnlyList<StringConstant>(sortedTags.Values);
Tags = new ReadOnlyList<StringConstant>(_sortedTags.Values);
// Update static accessors:
if (!taggedGOs.ContainsKey(atomicTag)) return; // this should never happen
taggedGOs[atomicTag].Remove(this.gameObject);
if (!TaggedGameObjects.ContainsKey(atomicTag)) return; // this should never happen
TaggedGameObjects[atomicTag].Remove(this.gameObject);
}
public static GameObject FindByTag(string tag)
{
if (!taggedGOs.ContainsKey(tag)) return null;
return taggedGOs[tag][0];
if (!TaggedGameObjects.ContainsKey(tag)) return null;
return TaggedGameObjects[tag][0];
}
public static GameObject[] FindAllByTag(string tag)
{
if (!taggedGOs.ContainsKey(tag)) return null;
return taggedGOs[tag].ToArray();
if (!TaggedGameObjects.ContainsKey(tag)) return null;
return TaggedGameObjects[tag].ToArray();
}
public static void FindAllByTagNoAlloc(string tag, List<GameObject> output)
{
output.Clear();
if (!taggedGOs.ContainsKey(tag)) return;
for (var i = 0; i < taggedGOs[tag].Count; ++i)
if (!TaggedGameObjects.ContainsKey(tag)) return;
for (var i = 0; i < TaggedGameObjects[tag].Count; ++i)
{
output.Add(taggedGOs[tag][i]);
output.Add(TaggedGameObjects[tag][i]);
}
}
@ -149,8 +158,8 @@ namespace UnityAtoms
/// </returns>
public static AtomicTags GetForGameObject(GameObject go)
{
if (!instances.ContainsKey(go)) return null;
return instances[go];
if (!AtomicTagInstances.ContainsKey(go)) return null;
return AtomicTagInstances[go];
}
/// <summary>
@ -163,11 +172,9 @@ namespace UnityAtoms
/// </returns>
public static ReadOnlyList<StringConstant> GetAtomicTags(GameObject go)
{
if (!instances.ContainsKey(go)) return null;
var atomicTags = instances[go];
if (!AtomicTagInstances.ContainsKey(go)) return null;
var atomicTags = AtomicTagInstances[go];
return atomicTags.Tags;
}
}
}

75
Source/AtomicTags/ReadOnlyList.cs
View File

@ -1,35 +1,62 @@
using System.Collections;
using System.Collections.Generic;
using System.Collections.Generic;
namespace UnityAtoms {
/// <summary>
/// This is basically an IList without everything that could mutate the list
/// </summary>
public class ReadOnlyList<T> : IEnumerable, IEnumerable<T> {
private readonly IList<T> referenceList;
namespace UnityAtoms
{
/// <summary>
/// This is basically an IList without everything that could mutate the list
/// </summary>
public class ReadOnlyList<T> : IEnumerable<T>
{
private readonly IList<T> _referenceList;
public ReadOnlyList(IList<T> referenceList) { this.referenceList = referenceList; }
public ReadOnlyList(IList<T> referenceList)
{
_referenceList = referenceList;
}
public IEnumerator<T> GetEnumerator() { return referenceList.GetEnumerator(); }
#region IEnumerable<T>
IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
public IEnumerator<T> GetEnumerator()
{
return _referenceList.GetEnumerator();
}
public bool Contains(T item) { return referenceList.Contains(item); }
public int IndexOf(T item) { return referenceList.IndexOf(item); }
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public void CopyTo(T[] array, int arrayIndex) { referenceList.CopyTo(array, arrayIndex); }
#endregion
public int Count {
get { return referenceList.Count; }
}
public bool Contains(T item)
{
return _referenceList.Contains(item);
}
public bool IsReadOnly {
get { return true; }
}
public int IndexOf(T item)
{
return _referenceList.IndexOf(item);
}
public T this[int index] {
get { return referenceList[index]; }
}
}
public void CopyTo(T[] array, int arrayIndex)
{
_referenceList.CopyTo(array, arrayIndex);
}
}
public int Count
{
get { return _referenceList.Count; }
}
public bool IsReadOnly
{
get { return true; }
}
public T this[int index]
{
get { return _referenceList[index]; }
}
}
}

26
Source/AtomicUI/UIContainer.cs
View File

@ -1,18 +1,22 @@
using System.Collections.Generic;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms.UI
{
public class UIContainer : MonoBehaviour, IGameEventListener<string>
{
[FormerlySerializedAs("UIStateVariable")]
[SerializeField]
private StringVariable UIStateVariable = null;
[SerializeField]
private List<StringConstant> VisibleForStates = null;
private StringVariable _UIStateVariable;
void Start()
[FormerlySerializedAs("VisibleForStates")]
[SerializeField]
private List<StringConstant> _visibleForStates;
private void Start()
{
StateNameChanged(UIStateVariable.Value);
StateNameChanged(_UIStateVariable.Value);
}
public void OnEventRaised(string stateName)
@ -22,7 +26,7 @@ namespace UnityAtoms.UI
private void StateNameChanged(string stateName)
{
if (VisibleForStates.Exists((state) => state.Value == stateName))
if (_visibleForStates.Exists((state) => state.Value == stateName))
{
GetComponent<CanvasGroup>().alpha = 1f;
GetComponent<CanvasGroup>().blocksRaycasts = true;
@ -38,17 +42,17 @@ namespace UnityAtoms.UI
private void Awake()
{
if (UIStateVariable.Changed != null)
if (_UIStateVariable.Changed != null)
{
UIStateVariable.Changed.RegisterListener(this);
_UIStateVariable.Changed.RegisterListener(this);
}
}
private void OnDestroy()
{
if (UIStateVariable.Changed != null)
if (_UIStateVariable.Changed != null)
{
UIStateVariable.Changed.UnregisterListener(this);
_UIStateVariable.Changed.UnregisterListener(this);
}
}
}

167
Source/Base/ConditionalGameActionHelper.cs
View File

@ -1,148 +1,185 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public class ConditionalGameActionHelper<T1, GA, C> where GA : GameAction<T1> where C : GameFunction<bool, T1>
[Serializable]
public abstract class ConditionalGameActionHelper<T1, GA, C>
where GA : GameAction<T1>
where C : GameFunction<bool, T1>
{
[FormerlySerializedAs("Condition")]
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
private C _condition;
[FormerlySerializedAs("Action")]
[SerializeField]
private GA ElseAction = null;
private GA _action;
[FormerlySerializedAs("VoidAction")]
[SerializeField]
private VoidAction ElseVoidAction = null;
private VoidAction _voidAction;
[FormerlySerializedAs("ElseAction")]
[SerializeField]
private GA _elseAction;
[FormerlySerializedAs("ElseVoidAction")]
[SerializeField]
private VoidAction _elseVoidAction;
public void Do(T1 t1)
{
if (Condition == null || Condition.Call(t1))
if (_condition == null || _condition.Call(t1))
{
if (Action != null) { Action.Do(t1); }
if (VoidAction != null) { VoidAction.Do(); }
if (_action != null) { _action.Do(t1); }
if (_voidAction != null) { _voidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
if (_elseAction != null) { _elseAction.Do(t1); }
if (_elseVoidAction != null) { _elseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, GA, C> where GA : GameAction<T1, T2> where C : GameFunction<bool, T1, T2>
[Serializable]
public abstract class ConditionalGameActionHelper<T1, T2, GA, C>
where GA : GameAction<T1, T2>
where C : GameFunction<bool, T1, T2>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
private C _condition;
[SerializeField]
private GA ElseAction = null;
private GA _action;
[SerializeField]
private VoidAction ElseVoidAction = null;
private VoidAction _voidAction;
[SerializeField]
private GA _elseAction;
[SerializeField]
private VoidAction _elseVoidAction;
public void Do(T1 t1, T2 t2)
{
if (Condition == null || Condition.Call(t1, t2))
if (_condition == null || _condition.Call(t1, t2))
{
if (Action != null) { Action.Do(t1, t2); }
if (VoidAction != null) { VoidAction.Do(); }
if (_action != null) { _action.Do(t1, t2); }
if (_voidAction != null) { _voidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
if (_elseAction != null) { _elseAction.Do(t1, t2); }
if (_elseVoidAction != null) { _elseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, GA, C> where GA : GameAction<T1, T2, T3> where C : GameFunction<bool, T1, T2, T3>
[Serializable]
public abstract class ConditionalGameActionHelper<T1, T2, T3, GA, C>
where GA : GameAction<T1, T2, T3>
where C : GameFunction<bool, T1, T2, T3>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
private C _condition;
[SerializeField]
private GA ElseAction = null;
private GA _action;
[SerializeField]
private VoidAction ElseVoidAction = null;
private VoidAction _voidAction;
[SerializeField]
private GA _elseAction;
[SerializeField]
private VoidAction _elseVoidAction;
public void Do(T1 t1, T2 t2, T3 t3)
{
if (Condition == null || Condition.Call(t1, t2, t3))
if (_condition == null || _condition.Call(t1, t2, t3))
{
if (Action != null) { Action.Do(t1, t2, t3); }
if (VoidAction != null) { VoidAction.Do(); }
if (_action != null) { _action.Do(t1, t2, t3); }
if (_voidAction != null) { _voidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
if (_elseAction != null) { _elseAction.Do(t1, t2, t3); }
if (_elseVoidAction != null) { _elseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, T4, GA, C> where GA : GameAction<T1, T2, T3, T4> where C : GameFunction<bool, T1, T2, T3, T4>
[Serializable]
public abstract class ConditionalGameActionHelper<T1, T2, T3, T4, GA, C>
where GA : GameAction<T1, T2, T3, T4>
where C : GameFunction<bool, T1, T2, T3, T4>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
private C _condition;
[SerializeField]
private GA ElseAction = null;
private GA _action;
[SerializeField]
private VoidAction ElseVoidAction = null;
private VoidAction _voidAction;
[SerializeField]
private GA _elseAction;
[SerializeField]
private VoidAction _elseVoidAction;
public void Do(T1 t1, T2 t2, T3 t3, T4 t4)
{
if (Condition == null || Condition.Call(t1, t2, t3, t4))
if (_condition == null || _condition.Call(t1, t2, t3, t4))
{
if (Action != null) { Action.Do(t1, t2, t3, t4); }
if (VoidAction != null) { VoidAction.Do(); }
if (_action != null) { _action.Do(t1, t2, t3, t4); }
if (_voidAction != null) { _voidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3, t4); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
if (_elseAction != null) { _elseAction.Do(t1, t2, t3, t4); }
if (_elseVoidAction != null) { _elseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, T4, T5, GA, C> where GA : GameAction<T1, T2, T3, T4, T5> where C : GameFunction<bool, T1, T2, T3, T4, T5>
[Serializable]
public abstract class ConditionalGameActionHelper<T1, T2, T3, T4, T5, GA, C>
where GA : GameAction<T1, T2, T3, T4, T5>
where C : GameFunction<bool, T1, T2, T3, T4, T5>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
private C _condition;
[SerializeField]
private GA ElseAction = null;
private GA _action;
[SerializeField]
private VoidAction ElseVoidAction = null;
private VoidAction _voidAction;
[SerializeField]
private GA _elseAction;
[SerializeField]
private VoidAction _elseVoidAction;
public void Do(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{
if (Condition == null || Condition.Call(t1, t2, t3, t4, t5))
if (_condition == null || _condition.Call(t1, t2, t3, t4, t5))
{
if (Action != null) { Action.Do(t1, t2, t3, t4, t5); }
if (VoidAction != null) { VoidAction.Do(); }
if (_action != null) { _action.Do(t1, t2, t3, t4, t5); }
if (_voidAction != null) { _voidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3, t4, t5); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
if (_elseAction != null) { _elseAction.Do(t1, t2, t3, t4, t5); }
if (_elseVoidAction != null) { _elseVoidAction.Do(); }
}
}
}

15
Source/Base/CreateOnAwake/CreateEventOnAwake.cs
View File

@ -4,7 +4,7 @@ using UnityEngine.Events;
namespace UnityAtoms
{
public class CreateEventOnAwake<T, E1, E2, L1, L2, GA1, GA2, UER1, UER2, MH> : MonoBehaviour
public abstract class CreateEventOnAwake<T, E1, E2, L1, L2, GA1, GA2, UER1, UER2, MH> : MonoBehaviour
where E1 : GameEvent<T> where E2 : GameEvent<T, GameObject>
where L1 : GameEventListener<T, GA1, E1, UER1> where L2 : GameEventListener<T, GameObject, GA2, E2, UER2>
where GA1 : GameAction<T> where GA2 : GameAction<T, GameObject>
@ -12,13 +12,16 @@ namespace UnityAtoms
where MH : MonoHook<E1, E2, T, GameObjectGameObjectFunction>
{
public bool CreateEvent = true;
public bool CreateEventWithGameObject = false;
public bool CreateEventWithGameObject;
public List<MH> MonoHooks;
public L1 Listener = null;
public L2 ListenerWithGameObject = null;
void Awake()
public L1 Listener;
public L2 ListenerWithGameObject;
private void Awake()
{
var e1 = CreateEvent ? ScriptableObject.CreateInstance<E1>() : null;
var e2 = CreateEventWithGameObject ? ScriptableObject.CreateInstance<E2>() : null;
@ -39,7 +42,7 @@ namespace UnityAtoms
{
for (int i = 0; MonoHooks != null && i < MonoHooks.Count; ++i)
{
MonoHooks[i].EventWithGORef = e2;
MonoHooks[i].EventWithGameObjectReference = e2;
}
if (ListenerWithGameObject != null)
{

68
Source/Base/CreateOnAwake/CreateListOnAwake.cs
View File

@ -1,66 +1,80 @@
using UnityEngine;
using UnityEngine.Events;
using UnityAtoms.Utils;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public class CreateListOnAwake<T, L, E, TEL, TELR, GA1, GA2, UER> : MonoBehaviour
public abstract class CreateListOnAwake<T, L, E, TEL, TELR, GA1, GA2, UER> : MonoBehaviour
where L : ScriptableObjectList<T, E> where E : GameEvent<T>
where TEL : GameEventListener<T, TELR, E, UER>
where TELR : GameAction<T>
where GA1 : GameAction<L> where GA2 : GameAction<L, GameObject>
where UER : UnityEvent<T>
{
[FormerlySerializedAs("CreateAddedEvent")]
[SerializeField]
private bool CreateAddedEvent = true;
[SerializeField]
private bool CreateRemovedEvent = true;
[SerializeField]
private bool CreateClearedEvent = false;
private bool _createAddedEvent = true;
[FormerlySerializedAs("CreateRemovedEvent")]
[SerializeField]
private TEL AddedListener = null;
[SerializeField]
private TEL RemovedListener = null;
[SerializeField]
private VoidListener ClearedListener = null;
private bool _createRemovedEvent = true;
[FormerlySerializedAs("CreateClearedEvent")]
[SerializeField]
private GA1 OnListCreate = null;
[SerializeField]
private GA2 OnListCreateWithGO = null;
private bool _createClearedEvent;
void Awake()
[FormerlySerializedAs("AddedListener")]
[SerializeField]
private TEL _addedListener;
[FormerlySerializedAs("RemovedListener")]
[SerializeField]
private TEL _removedListener;
[FormerlySerializedAs("ClearedListener")]
[SerializeField]
private VoidListener _clearedListener;
[FormerlySerializedAs("OnListCreate")]
[SerializeField]
private GA1 _onListCreate;
[FormerlySerializedAs("OnListCreateWithGO")]
[SerializeField]
private GA2 _onListCreateWithGO;
private void Awake()
{
var list = DynamicAtoms.CreateList<T, L, E>(CreateAddedEvent, CreateRemovedEvent, CreateClearedEvent);
var list = DynamicAtoms.CreateList<T, L, E>(_createAddedEvent, _createRemovedEvent, _createClearedEvent);
if (list.Added != null)
{
if (AddedListener != null)
if (_addedListener != null)
{
AddedListener.GameEvent = list.Added;
AddedListener.GameEvent.RegisterListener(AddedListener);
_addedListener.GameEvent = list.Added;
_addedListener.GameEvent.RegisterListener(_addedListener);
}
}
if (list.Removed != null)
{
if (RemovedListener != null)
if (_removedListener != null)
{
RemovedListener.GameEvent = list.Removed;
RemovedListener.GameEvent.RegisterListener(RemovedListener);
_removedListener.GameEvent = list.Removed;
_removedListener.GameEvent.RegisterListener(_removedListener);
}
}
if (list.Cleared != null)
{
if (ClearedListener != null)
if (_clearedListener != null)
{
ClearedListener.GameEvent = list.Cleared;
ClearedListener.GameEvent.RegisterListener(ClearedListener);
_clearedListener.GameEvent = list.Cleared;
_clearedListener.GameEvent.RegisterListener(_clearedListener);
}
}
if (OnListCreate != null) { OnListCreate.Do(list); }
if (OnListCreateWithGO != null) { OnListCreateWithGO.Do(list, gameObject); }
if (_onListCreate != null) { _onListCreate.Do(list); }
if (_onListCreateWithGO != null) { _onListCreateWithGO.Do(list, gameObject); }
}
}
}

66
Source/Base/CreateOnAwake/CreateVariableOnAwake.cs
View File

@ -1,53 +1,69 @@
using UnityEngine;
using UnityEngine.Events;
using UnityAtoms.Utils;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public class CreateVariableOnAwake<T, V, E1, E2, L1, L2, GA1, GA2, GA3, GA4, UER1, UER2> : MonoBehaviour
where V : ScriptableObjectVariable<T, E1, E2> where E1 : GameEvent<T> where E2 : GameEvent<T, T>
where L1 : GameEventListener<T, GA1, E1, UER1> where L2 : GameEventListener<T, T, GA2, E2, UER2>
where GA1 : GameAction<T> where GA2 : GameAction<T, T>
where GA3 : GameAction<V> where GA4 : GameAction<V, GameObject>
where UER1 : UnityEvent<T> where UER2 : UnityEvent<T, T>
public abstract class CreateVariableOnAwake<T, V, E1, E2, L1, L2, GA1, GA2, GA3, GA4, UER1, UER2> : MonoBehaviour
where V : ScriptableObjectVariable<T, E1, E2>
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
where L1 : GameEventListener<T, GA1, E1, UER1>
where L2 : GameEventListener<T, T, GA2, E2, UER2>
where GA1 : GameAction<T>
where GA2 : GameAction<T, T>
where GA3 : GameAction<V>
where GA4 : GameAction<V, GameObject>
where UER1 : UnityEvent<T>
where UER2 : UnityEvent<T, T>
{
[FormerlySerializedAs("CreateChangedEvent")]
[SerializeField]
private bool CreateChangedEvent = true;
[SerializeField]
private bool CreateChangedWithHistoryEvent = false;
private bool _createChangedEvent = true;
[FormerlySerializedAs("CreateChangedWithHistoryEvent")]
[SerializeField]
private L1 Listener = null;
[SerializeField]
private L2 ListenerWithHistory = null;
private bool _createChangedWithHistoryEvent;
[FormerlySerializedAs("Listener")]
[SerializeField]
private GA3 OnVariableCreate = null;
[SerializeField]
private GA4 OnVariableCreateWithGO = null;
private L1 _listener;
void Awake()
[FormerlySerializedAs("ListenerWithHistory")]
[SerializeField]
private L2 _listenerWithHistory;
[FormerlySerializedAs("OnVariableCreate")]
[SerializeField]
private GA3 _onVariableCreate;
[FormerlySerializedAs("OnVariableCreateWithGO")]
[SerializeField]
private GA4 _onVariableCreateWithGO;
private void Awake()
{
var variable = DynamicAtoms.CreateVariable<T, V, E1, E2>(CreateChangedEvent, CreateChangedWithHistoryEvent);
var variable = DynamicAtoms.CreateVariable<T, V, E1, E2>(_createChangedEvent, _createChangedWithHistoryEvent);
if (variable.Changed != null)
{
if (Listener != null)
if (_listener != null)
{
Listener.GameEvent = variable.Changed;
Listener.GameEvent.RegisterListener(Listener);
_listener.GameEvent = variable.Changed;
_listener.GameEvent.RegisterListener(_listener);
}
}
if (variable.ChangedWithHistory != null)
{
if (ListenerWithHistory != null)
if (_listenerWithHistory != null)
{
ListenerWithHistory.GameEvent = variable.ChangedWithHistory;
ListenerWithHistory.GameEvent.RegisterListener(ListenerWithHistory);
_listenerWithHistory.GameEvent = variable.ChangedWithHistory;
_listenerWithHistory.GameEvent.RegisterListener(_listenerWithHistory);
}
}
if (OnVariableCreate != null) { OnVariableCreate.Do(variable); }
if (OnVariableCreateWithGO != null) { OnVariableCreateWithGO.Do(variable, gameObject); }
if (_onVariableCreate != null) { _onVariableCreate.Do(variable); }
if (_onVariableCreateWithGO != null) { _onVariableCreateWithGO.Do(variable, gameObject); }
}
}
}

28
Source/Base/GameEvent.cs
View File

@ -5,47 +5,47 @@ namespace UnityAtoms
{
public abstract class GameEvent<T> : ScriptableObject
{
private readonly List<IGameEventListener<T>> eventListeners = new List<IGameEventListener<T>>();
private readonly List<IGameEventListener<T>> _eventListeners = new List<IGameEventListener<T>>();
public void Raise(T item)
{
for (int i = eventListeners.Count - 1; i >= 0; i--)
eventListeners[i].OnEventRaised(item);
for (int i = _eventListeners.Count - 1; i >= 0; i--)
_eventListeners[i].OnEventRaised(item);
}
public void RegisterListener(IGameEventListener<T> listener)
{
if (!eventListeners.Contains(listener))
eventListeners.Add(listener);
if (!_eventListeners.Contains(listener))
_eventListeners.Add(listener);
}
public void UnregisterListener(IGameEventListener<T> listener)
{
if (eventListeners.Contains(listener))
eventListeners.Remove(listener);
if (_eventListeners.Contains(listener))
_eventListeners.Remove(listener);
}
}
public abstract class GameEvent<T1, T2> : ScriptableObject
{
private readonly List<IGameEventListener<T1, T2>> eventListeners = new List<IGameEventListener<T1, T2>>();
private readonly List<IGameEventListener<T1, T2>> _eventListeners = new List<IGameEventListener<T1, T2>>();
public void Raise(T1 item1, T2 item2)
{
for (int i = eventListeners.Count - 1; i >= 0; i--)
eventListeners[i].OnEventRaised(item1, item2);
for (int i = _eventListeners.Count - 1; i >= 0; i--)
_eventListeners[i].OnEventRaised(item1, item2);
}
public void RegisterListener(IGameEventListener<T1, T2> listener)
{
if (!eventListeners.Contains(listener))
eventListeners.Add(listener);
if (!_eventListeners.Contains(listener))
_eventListeners.Add(listener);
}
public void UnregisterListener(IGameEventListener<T1, T2> listener)
{
if (eventListeners.Contains(listener))
eventListeners.Remove(listener);
if (_eventListeners.Contains(listener))
_eventListeners.Remove(listener);
}
}
}

50
Source/Base/GameEventListener.cs
View File

@ -1,25 +1,31 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public abstract class GameEventListener<T, GA, E, UER> : MonoBehaviour, IGameEventListener<T> where GA : GameAction<T> where E : GameEvent<T> where UER : UnityEvent<T>
public abstract class GameEventListener<T, GA, E, UER> : MonoBehaviour, IGameEventListener<T>
where GA : GameAction<T>
where E : GameEvent<T> where UER : UnityEvent<T>
{
[FormerlySerializedAs("Event")]
[SerializeField]
private E Event = null;
private E _event;
public E GameEvent { get { return Event; } set { Event = value; } }
public E GameEvent { get { return _event; } set { _event = value; } }
[FormerlySerializedAs("UnityEventResponse")]
[SerializeField]
private UER UnityEventResponse = null;
private UER _unityEventResponse;
[FormerlySerializedAs("GameActionResponses")]
[SerializeField]
private List<GA> GameActionResponses = new List<GA>();
private List<GA> _gameActionResponses = new List<GA>();
private void OnEnable()
{
if (Event == null) return;
if (_event == null) return;
GameEvent.RegisterListener(this);
}
@ -30,45 +36,51 @@ namespace UnityAtoms
public void OnEventRaised(T item)
{
if (UnityEventResponse != null) { UnityEventResponse.Invoke(item); }
for (int i = 0; GameActionResponses != null && i < GameActionResponses.Count; ++i)
if (_unityEventResponse != null) { _unityEventResponse.Invoke(item); }
for (int i = 0; _gameActionResponses != null && i < _gameActionResponses.Count; ++i)
{
GameActionResponses[i].Do(item);
_gameActionResponses[i].Do(item);
}
}
}
public abstract class GameEventListener<T1, T2, GA, E, UER> : MonoBehaviour, IGameEventListener<T1, T2> where GA : GameAction<T1, T2> where E : GameEvent<T1, T2> where UER : UnityEvent<T1, T2>
public abstract class GameEventListener<T1, T2, GA, E, UER> : MonoBehaviour, IGameEventListener<T1, T2>
where GA : GameAction<T1, T2>
where E : GameEvent<T1, T2>
where UER : UnityEvent<T1, T2>
{
[FormerlySerializedAs("Event")]
[SerializeField]
private E Event = null;
private E _event;
public E GameEvent { get { return Event; } set { Event = value; } }
public E GameEvent { get { return _event; } set { _event = value; } }
[FormerlySerializedAs("UnityEventResponse")]
[SerializeField]
private UER UnityEventResponse = null;
private UER _unityEventResponse;
[FormerlySerializedAs("GameActionResponses")]
[SerializeField]
private List<GA> GameActionResponses = new List<GA>();
private List<GA> _gameActionResponses = new List<GA>();
private void OnEnable()
{
if (Event == null) return;
if (_event == null) return;
GameEvent.RegisterListener(this);
}
private void OnDisable()
{
if (Event == null) return;
if (_event == null) return;
GameEvent.UnregisterListener(this);
}
public void OnEventRaised(T1 first, T2 second)
{
if (UnityEventResponse != null) { UnityEventResponse.Invoke(first, second); }
for (int i = 0; GameActionResponses != null && i < GameActionResponses.Count; ++i)
if (_unityEventResponse != null) { _unityEventResponse.Invoke(first, second); }
for (int i = 0; _gameActionResponses != null && i < _gameActionResponses.Count; ++i)
{
GameActionResponses[i].Do(first, second);
_gameActionResponses[i].Do(first, second);
}
}
}

10
Source/Base/ScriptableObjectList.cs
View File

@ -5,16 +5,20 @@ using UnityAtoms.Extensions;
namespace UnityAtoms
{
public abstract class ScriptableObjectList<T, E> : ScriptableObject where E : GameEvent<T>
public abstract class ScriptableObjectList<T, E> : ScriptableObject
where E : GameEvent<T>
{
[SerializeField]
private List<T> list = new List<T>();
public E Added;
public E Removed;
public VoidEvent Cleared;
public int Count { get { return list.Count; } }
[SerializeField]
private List<T> list = new List<T>();
public void Add(T item)
{
if (!list.Contains(item))

17
Source/Base/ScriptableObjectReference.cs
View File

@ -1,16 +1,23 @@
namespace UnityAtoms
{
public abstract class ScriptableObjectReference<T, V, E1, E2> where E1 : GameEvent<T> where E2 : GameEvent<T, T> where V : ScriptableObjectVariable<T, E1, E2>
public abstract class ScriptableObjectReference<T, V, E1, E2>
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
where V : ScriptableObjectVariable<T, E1, E2>
{
public bool UseConstant = true;
public bool UseConstant;
public T ConstantValue;
public V Variable;
public ScriptableObjectReference() { }
public ScriptableObjectReference(T value)
protected ScriptableObjectReference()
{
UseConstant = true;
}
protected ScriptableObjectReference(T value) : this()
{
ConstantValue = value;
}

15
Source/Base/SetVariableValue.cs
View File

@ -1,18 +1,25 @@
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public abstract class SetVariableValue<T, V, R, E1, E2> : VoidAction where E1 : GameEvent<T> where E2 : GameEvent<T, T> where V : ScriptableObjectVariable<T, E1, E2> where R : ScriptableObjectReference<T, V, E1, E2>
public abstract class SetVariableValue<T, V, R, E1, E2> : VoidAction
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
where V : ScriptableObjectVariable<T, E1, E2>
where R : ScriptableObjectReference<T, V, E1, E2>
{
[FormerlySerializedAs("Variable")]
[SerializeField]
private V Variable = null;
private V _variable;
[FormerlySerializedAs("Value")]
[SerializeField]
private R Value = null;
private R _value;
public override void Do()
{
Variable.Value = Value.Value;
_variable.Value = _value.Value;
}
}
}

7
Source/Base/Variable/EquatableScriptableObjectVariable.cs
View File

@ -1,8 +1,11 @@
using System;
using System;
namespace UnityAtoms
{
public abstract class EquatableScriptableObjectVariable<T, E1, E2> : ScriptableObjectVariable<T, E1, E2> where T : IEquatable<T> where E1 : GameEvent<T> where E2 : GameEvent<T, T>
public abstract class EquatableScriptableObjectVariable<T, E1, E2> : ScriptableObjectVariable<T, E1, E2>
where T : IEquatable<T>
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
{
protected override bool AreEqual(T t1, T t2)
{

5
Source/Base/Variable/IWithApplyChange.cs
View File

@ -2,7 +2,10 @@ using System;
namespace UnityAtoms
{
public interface IWithApplyChange<T, E1, E2> where T : IEquatable<T> where E1 : GameEvent<T> where E2 : GameEvent<T, T>
public interface IWithApplyChange<T, E1, E2>
where T : IEquatable<T>
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
{
bool ApplyChange(T amount);
bool ApplyChange(EquatableScriptableObjectVariable<T, E1, E2> amount);

21
Source/Base/Variable/ScriptableObjectVariable.cs
View File

@ -1,15 +1,20 @@
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public abstract class ScriptableObjectVariable<T, E1, E2> : ScriptableObjectVariableBase<T>, IWithOldValue<T> where E1 : GameEvent<T> where E2 : GameEvent<T, T>
public abstract class ScriptableObjectVariable<T, E1, E2> : ScriptableObjectVariableBase<T>,
IWithOldValue<T>
where E1 : GameEvent<T>
where E2 : GameEvent<T, T>
{
public override T Value { get { return value; } set { SetValue(value); } }
public override T Value { get { return _value; } set { SetValue(value); } }
public T OldValue { get { return oldValue; } }
public T OldValue { get { return _oldValue; } }
[FormerlySerializedAs("oldValue")]
[SerializeField]
private T oldValue;
private T _oldValue;
public E1 Changed;
@ -25,12 +30,12 @@ namespace UnityAtoms
public bool SetValue(T newValue)
{
if (!AreEqual(value, newValue))
if (!AreEqual(_value, newValue))
{
oldValue = value;
value = newValue;
_oldValue = _value;
_value = newValue;
if (Changed != null) { Changed.Raise(newValue); }
if (ChangedWithHistory != null) { ChangedWithHistory.Raise(value, oldValue); }
if (ChangedWithHistory != null) { ChangedWithHistory.Raise(_value, _oldValue); }
return true;
}

14
Source/Base/Variable/ScriptableObjectVariableBase.cs
View File

@ -1,33 +1,35 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
public abstract class ScriptableObjectVariableBase<T> : ScriptableObject, IWithValue<T>
{
public virtual T Value { get { return _value; } set { throw new NotImplementedException(); } }
[Multiline]
public string DeveloperDescription = "";
public virtual T Value { get { return value; } set { throw new NotImplementedException(); } }
[FormerlySerializedAs("value")]
[SerializeField]
protected T value;
protected T _value;
protected bool Equals(ScriptableObjectVariableBase<T> other) {
return EqualityComparer<T>.Default.Equals(value, other.value);
return EqualityComparer<T>.Default.Equals(_value, other._value);
}
public override bool Equals(object obj) {
if (ReferenceEquals(null, obj)) return false;
if (ReferenceEquals(this, obj)) return true;
if (obj.GetType() != this.GetType()) return false;
if (obj.GetType() != GetType()) return false;
return Equals((ScriptableObjectVariableBase<T>) obj);
}
public override int GetHashCode() {
unchecked {
return EqualityComparer<T>.Default.GetHashCode(value);
return EqualityComparer<T>.Default.GetHashCode(_value);
}
}

3
Source/Bool/BoolBoolEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Event x 2", fileName = "BoolBoolEvent", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class BoolBoolEvent : GameEvent<bool, bool> { }
public sealed class BoolBoolEvent : GameEvent<bool, bool> { }
}

2
Source/Bool/BoolConstant.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Constant", fileName = "BoolConstant", order = CreateAssetMenuUtils.Order.CONSTANT)]
public class BoolConstant : ScriptableObjectVariableBase<bool> { }
public sealed class BoolConstant : ScriptableObjectVariableBase<bool> { }
}

3
Source/Bool/BoolEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Event", fileName = "BoolEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class BoolEvent : GameEvent<bool> { }
public sealed class BoolEvent : GameEvent<bool> { }
}

2
Source/Bool/BoolList.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/List", fileName = "BoolList", order = CreateAssetMenuUtils.Order.LIST)]
public class BoolList : ScriptableObjectList<bool, BoolEvent> { }
public sealed class BoolList : ScriptableObjectList<bool, BoolEvent> { }
}

7
Source/Bool/BoolListener.cs
View File

@ -1,4 +1,9 @@
namespace UnityAtoms
{
public class BoolListener : GameEventListener<bool, BoolAction, BoolEvent, UnityBoolEvent> { }
public sealed class BoolListener : GameEventListener<
bool,
BoolAction,
BoolEvent,
UnityBoolEvent>
{ }
}

6
Source/Bool/BoolReference.cs
View File

@ -3,5 +3,9 @@ using System;
namespace UnityAtoms
{
[Serializable]
public class BoolReference : ScriptableObjectReference<bool, BoolVariable, BoolEvent, BoolBoolEvent> { }
public sealed class BoolReference : ScriptableObjectReference<
bool,
BoolVariable,
BoolEvent,
BoolBoolEvent> { }
}

4
Source/Bool/BoolVariable.cs
View File

@ -1,7 +1,7 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Variable", fileName = "BoolVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class BoolVariable : EquatableScriptableObjectVariable<bool, BoolEvent, BoolBoolEvent> { }
public sealed class BoolVariable : EquatableScriptableObjectVariable<bool, BoolEvent, BoolBoolEvent> { }
}

8
Source/Bool/ConditionalBoolAction.cs
View File

@ -1,5 +1,6 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
@ -7,14 +8,15 @@ namespace UnityAtoms
public class ConditionalBoolGameActionHelper : ConditionalGameActionHelper<bool, BoolAction, BoolBoolFunction> { }
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Conditional", fileName = "ConditionalBoolAction", order = CreateAssetMenuUtils.Order.CONDITIONAL)]
public class ConditionalBoolAction : BoolAction
public sealed class ConditionalBoolAction : BoolAction
{
[FormerlySerializedAs("Conditional")]
[SerializeField]
private ConditionalBoolGameActionHelper Conditional = null;
private ConditionalBoolGameActionHelper _conditional;
public override void Do(bool t1)
{
Conditional.Do(t1);
_conditional.Do(t1);
}
}
}

10
Source/Bool/SetBoolVariableValue.cs
View File

@ -1,7 +1,13 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Bool/Set Variable", fileName = "SetBoolVariableValueAction", order = CreateAssetMenuUtils.Order.SET_VARIABLE)]
public class SetBoolVariableValue : SetVariableValue<bool, BoolVariable, BoolReference, BoolEvent, BoolBoolEvent> { }
public sealed class SetBoolVariableValue : SetVariableValue<
bool,
BoolVariable,
BoolReference,
BoolEvent,
BoolBoolEvent>
{ }
}

2
Source/Bool/UnityBoolEvent.cs
View File

@ -4,5 +4,5 @@ using UnityEngine.Events;
namespace UnityAtoms
{
[Serializable]
public class UnityBoolEvent : UnityEvent<bool> { }
public sealed class UnityBoolEvent : UnityEvent<bool> { }
}

4
Source/Collider/ColliderEvent.cs
View File

@ -1,7 +1,7 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Collider/Event", fileName = "ColliderEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class ColliderEvent : GameEvent<Collider> { }
public sealed class ColliderEvent : GameEvent<Collider> { }
}

3
Source/Collider/ColliderGameObjectEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Collider/Event with GameObject", fileName = "ColliderGameObjectEvent", order = CreateAssetMenuUtils.Order.EVENT_WITH_GO)]
public class ColliderGameObjectEvent : GameEvent<Collider, GameObject> { }
public sealed class ColliderGameObjectEvent : GameEvent<Collider, GameObject> { }
}

8
Source/Collider/ColliderGameObjectListener.cs
View File

@ -2,5 +2,11 @@ using UnityEngine;
namespace UnityAtoms
{
public class ColliderGameObjectListener : GameEventListener<Collider, GameObject, ColliderGameObjectAction, ColliderGameObjectEvent, UnityColliderGameObjectEvent> { }
public sealed class ColliderGameObjectListener : GameEventListener<
Collider,
GameObject,
ColliderGameObjectAction,
ColliderGameObjectEvent,
UnityColliderGameObjectEvent>
{ }
}

2
Source/Collider/UnityColliderGameObjectEvent.cs
View File

@ -5,5 +5,5 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class UnityColliderGameObjectEvent : UnityEvent<Collider, GameObject> { }
public sealed class UnityColliderGameObjectEvent : UnityEvent<Collider, GameObject> { }
}

4
Source/Collider2D/Collider2DEvent.cs
View File

@ -1,7 +1,7 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Collider2D/Event", fileName = "Collider2DEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class Collider2DEvent : GameEvent<Collider2D> { }
public sealed class Collider2DEvent : GameEvent<Collider2D> { }
}

3
Source/Collider2D/Collider2DGameObjectEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Collider2D/Event with GameObject", fileName = "Collider2DGameObjectEvent", order = CreateAssetMenuUtils.Order.EVENT_WITH_GO)]
public class Collider2DGameObjectEvent : GameEvent<Collider2D, GameObject> { }
public sealed class Collider2DGameObjectEvent : GameEvent<Collider2D, GameObject> { }
}

8
Source/Collider2D/Collider2DGameObjectListener.cs
View File

@ -2,5 +2,11 @@ using UnityEngine;
namespace UnityAtoms
{
public class Collider2DGameObjectListener : GameEventListener<Collider2D, GameObject, Collider2DGameObjectAction, Collider2DGameObjectEvent, UnityCollider2DGameObjectEvent> { }
public sealed class Collider2DGameObjectListener : GameEventListener<
Collider2D,
GameObject,
Collider2DGameObjectAction,
Collider2DGameObjectEvent,
UnityCollider2DGameObjectEvent>
{ }
}

4
Source/Collider2D/Collider2DList.cs
View File

@ -1,7 +1,7 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Collider2D/List", fileName = "Collider2DList", order = CreateAssetMenuUtils.Order.LIST)]
public class Collider2DList : ScriptableObjectList<Collider2D, Collider2DEvent> { }
public sealed class Collider2DList : ScriptableObjectList<Collider2D, Collider2DEvent> { }
}

7
Source/Collider2D/Collider2DListener.cs
View File

@ -2,5 +2,10 @@ using UnityEngine;
namespace UnityAtoms
{
public class Collider2DListener : GameEventListener<Collider2D, Collider2DAction, Collider2DEvent, UnityCollider2DEvent> { }
public sealed class Collider2DListener : GameEventListener<
Collider2D,
Collider2DAction,
Collider2DEvent,
UnityCollider2DEvent>
{ }
}

18
Source/Collider2D/CreateCollider2DEventOnAwake.cs
View File

@ -3,12 +3,16 @@ using UnityEngine;
namespace UnityAtoms
{
public class CreateCollider2DEventOnAwake : CreateEventOnAwake<
Collider2D, Collider2DEvent, Collider2DGameObjectEvent,
Collider2DListener, Collider2DGameObjectListener,
Collider2DAction, Collider2DGameObjectAction,
UnityCollider2DEvent, UnityCollider2DGameObjectEvent,
Collider2DHook
>
public sealed class CreateCollider2DEventOnAwake : CreateEventOnAwake<
Collider2D,
Collider2DEvent,
Collider2DGameObjectEvent,
Collider2DListener,
Collider2DGameObjectListener,
Collider2DAction,
Collider2DGameObjectAction,
UnityCollider2DEvent,
UnityCollider2DGameObjectEvent,
Collider2DHook>
{ }
}

11
Source/Collider2D/CreateCollider2DListOnAwake.cs
View File

@ -2,5 +2,14 @@ using UnityEngine;
namespace UnityAtoms
{
public class CreateCollider2DListOnAwake : CreateListOnAwake<Collider2D, Collider2DList, Collider2DEvent, Collider2DListener, Collider2DAction, Collider2DListAction, Collider2DListGameObjectAction, UnityCollider2DEvent> { }
public sealed class CreateCollider2DListOnAwake : CreateListOnAwake<
Collider2D,
Collider2DList,
Collider2DEvent,
Collider2DListener,
Collider2DAction,
Collider2DListAction,
Collider2DListGameObjectAction,
UnityCollider2DEvent>
{ }
}

2
Source/Collider2D/UnityCollider2DEvent.cs
View File

@ -5,5 +5,5 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class UnityCollider2DEvent : UnityEvent<Collider2D> { }
public sealed class UnityCollider2DEvent : UnityEvent<Collider2D> { }
}

2
Source/Collider2D/UnityCollider2DGameObjectEvent.cs
View File

@ -5,5 +5,5 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class UnityCollider2DGameObjectEvent : UnityEvent<Collider2D, GameObject> { }
public sealed class UnityCollider2DGameObjectEvent : UnityEvent<Collider2D, GameObject> { }
}

3
Source/Color/ColorColorEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/Event x 2", fileName = "ColorColorEvent", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class ColorColorEvent : GameEvent<Color, Color> { }
public sealed class ColorColorEvent : GameEvent<Color, Color> { }
}

2
Source/Color/ColorConstant.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/Constant", fileName = "ColorConstant", order = CreateAssetMenuUtils.Order.CONSTANT)]
public class ColorConstant : ScriptableObjectVariableBase<Color> { }
public sealed class ColorConstant : ScriptableObjectVariableBase<Color> { }
}

3
Source/Color/ColorEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/Event", fileName = "ColorEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class ColorEvent : GameEvent<Color> { }
public sealed class ColorEvent : GameEvent<Color> { }
}

2
Source/Color/ColorList.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/List", fileName = "ColorList", order = CreateAssetMenuUtils.Order.LIST)]
public class ColorList : ScriptableObjectList<Color, ColorEvent> { }
public sealed class ColorList : ScriptableObjectList<Color, ColorEvent> { }
}

7
Source/Color/ColorListener.cs
View File

@ -2,5 +2,10 @@ using UnityEngine;
namespace UnityAtoms
{
public class ColorListener : GameEventListener<Color, ColorAction, ColorEvent, UnityColorEvent> { }
public sealed class ColorListener : GameEventListener<
Color,
ColorAction,
ColorEvent,
UnityColorEvent>
{ }
}

7
Source/Color/ColorReference.cs
View File

@ -4,5 +4,10 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class ColorReference : ScriptableObjectReference<Color, ColorVariable, ColorEvent, ColorColorEvent> { }
public sealed class ColorReference : ScriptableObjectReference<
Color,
ColorVariable,
ColorEvent,
ColorColorEvent>
{ }
}

2
Source/Color/ColorVariable.cs
View File

@ -3,7 +3,7 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/Variable", fileName = "ColorVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class ColorVariable : ScriptableObjectVariable<Color, ColorEvent, ColorColorEvent>
public sealed class ColorVariable : ScriptableObjectVariable<Color, ColorEvent, ColorColorEvent>
{
protected override bool AreEqual(Color first, Color second)
{

10
Source/Color/ConditionalColorAction.cs
View File

@ -1,20 +1,22 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[Serializable]
public class ConditionalColorGameActionHelper : ConditionalGameActionHelper<Color, ColorAction, BoolColorFunction> { }
public sealed class ConditionalColorGameActionHelper : ConditionalGameActionHelper<Color, ColorAction, BoolColorFunction> { }
[CreateAssetMenu(menuName = "Unity Atoms/Color/Conditional", fileName = "ConditionalColorAction", order = CreateAssetMenuUtils.Order.CONDITIONAL)]
public class ConditionalColorAction : ColorAction
public sealed class ConditionalColorAction : ColorAction
{
[FormerlySerializedAs("Conditional")]
[SerializeField]
private ConditionalColorGameActionHelper Conditional = null;
private ConditionalColorGameActionHelper _conditional;
public override void Do(Color t1)
{
Conditional.Do(t1);
_conditional.Do(t1);
}
}
}

8
Source/Color/SetColorVariableValue.cs
View File

@ -3,5 +3,11 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Color/Set Variable", fileName = "SetColorVariableValueAction", order = CreateAssetMenuUtils.Order.SET_VARIABLE)]
public class SetColorVariableValue : SetVariableValue<Color, ColorVariable, ColorReference, ColorEvent, ColorColorEvent> { }
public sealed class SetColorVariableValue : SetVariableValue<
Color,
ColorVariable,
ColorReference,
ColorEvent,
ColorColorEvent>
{ }
}

2
Source/Color/UnityColorEvent.cs
View File

@ -5,5 +5,5 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class UnityColorEvent : UnityEvent<Color> { }
public sealed class UnityColorEvent : UnityEvent<Color> { }
}

21
Source/Editor/GameEventEditor.cs
View File

@ -3,7 +3,8 @@ using UnityEngine;
namespace UnityAtoms
{
public class GameEventEditor<T, E> : Editor where E : GameEvent<T>
public abstract class GameEventEditor<T, E> : Editor
where E : GameEvent<T>
{
public override void OnInspectorGUI()
{
@ -20,29 +21,29 @@ namespace UnityAtoms
}
[CustomEditor(typeof(BoolEvent))]
public class BoolEventEditor : GameEventEditor<bool, BoolEvent> { }
public sealed class BoolEventEditor : GameEventEditor<bool, BoolEvent> { }
[CustomEditor(typeof(Collider2DEvent))]
public class Collider2DEventEditor : GameEventEditor<Collider2D, Collider2DEvent> { }
public sealed class Collider2DEventEditor : GameEventEditor<Collider2D, Collider2DEvent> { }
[CustomEditor(typeof(ColorEvent))]
public class ColorEventEditor : GameEventEditor<Color, ColorEvent> { }
public sealed class ColorEventEditor : GameEventEditor<Color, ColorEvent> { }
[CustomEditor(typeof(FloatEvent))]
public class FloatEventEditor : GameEventEditor<float, FloatEvent> { }
public sealed class FloatEventEditor : GameEventEditor<float, FloatEvent> { }
[CustomEditor(typeof(GameObjectEvent))]
public class GameObjectEventEditor : GameEventEditor<GameObject, GameObjectEvent> { }
public sealed class GameObjectEventEditor : GameEventEditor<GameObject, GameObjectEvent> { }
[CustomEditor(typeof(IntEvent))]
public class IntGameEventEditor : GameEventEditor<int, IntEvent> { }
public sealed class IntGameEventEditor : GameEventEditor<int, IntEvent> { }
[CustomEditor(typeof(Vector2Event))]
public class Vector2EventEditor : GameEventEditor<Vector2, Vector2Event> { }
public sealed class Vector2EventEditor : GameEventEditor<Vector2, Vector2Event> { }
[CustomEditor(typeof(Vector3Event))]
public class Vector3EventEditor : GameEventEditor<Vector3, Vector3Event> { }
public sealed class Vector3EventEditor : GameEventEditor<Vector3, Vector3Event> { }
[CustomEditor(typeof(VoidEvent))]
public class VoidEventEditor : GameEventEditor<Void, VoidEvent> { }
public sealed class VoidEventEditor : GameEventEditor<Void, VoidEvent> { }
}

30
Source/Editor/ReferenceDrawer.cs
View File

@ -5,17 +5,17 @@ namespace UnityAtoms
{
public abstract class ReferenceDrawer : PropertyDrawer
{
private readonly string[] popupOptions =
private static readonly string[] PopupOptions =
{ "Use Constant", "Use Variable" };
private GUIStyle popupStyle;
private static GUIStyle PopupStyle;
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (popupStyle == null)
if (PopupStyle == null)
{
popupStyle = new GUIStyle(GUI.skin.GetStyle("PaneOptions"));
popupStyle.imagePosition = ImagePosition.ImageOnly;
PopupStyle = new GUIStyle(GUI.skin.GetStyle("PaneOptions"));
PopupStyle.imagePosition = ImagePosition.ImageOnly;
}
label = EditorGUI.BeginProperty(position, label, property);
@ -30,15 +30,15 @@ namespace UnityAtoms
// Calculate rect for configuration button
Rect buttonRect = new Rect(position);
buttonRect.yMin += popupStyle.margin.top;
buttonRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
buttonRect.yMin += PopupStyle.margin.top;
buttonRect.width = PopupStyle.fixedWidth + PopupStyle.margin.right;
position.xMin = buttonRect.xMax;
// Store old indent level and set it to 0, the PrefixLabel takes care of it
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
int result = EditorGUI.Popup(buttonRect, useConstant.boolValue ? 0 : 1, popupOptions, popupStyle);
int result = EditorGUI.Popup(buttonRect, useConstant.boolValue ? 0 : 1, PopupOptions, PopupStyle);
useConstant.boolValue = result == 0;
@ -54,24 +54,24 @@ namespace UnityAtoms
}
[CustomPropertyDrawer(typeof(BoolReference))]
public class BoolReferenceDrawer : ReferenceDrawer { }
public sealed class BoolReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(ColorReference))]
public class ColorReferenceDrawer : ReferenceDrawer { }
public sealed class ColorReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(FloatReference))]
public class FloatReferenceDrawer : ReferenceDrawer { }
public sealed class FloatReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(IntReference))]
public class IntReferenceDrawer : ReferenceDrawer { }
public sealed class IntReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(StringReference))]
public class StringReferenceDrawer : ReferenceDrawer { }
public sealed class StringReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(Vector2Reference))]
public class Vector2ReferenceDrawer : ReferenceDrawer { }
public sealed class Vector2ReferenceDrawer : ReferenceDrawer { }
[CustomPropertyDrawer(typeof(Vector3Reference))]
public class Vector3ReferenceDrawer : ReferenceDrawer { }
public sealed class Vector3ReferenceDrawer : ReferenceDrawer { }
}
}

4
Source/Extensions/MonoBehaviourExtensions.cs
View File

@ -16,7 +16,7 @@ namespace UnityAtoms.Extensions
return mb.StartCoroutine(SetTimeout(function, delay));
}
static IEnumerator SetTimeout(Action function, float delay)
private static IEnumerator SetTimeout(Action function, float delay)
{
yield return new WaitForSeconds(delay);
function();
@ -27,7 +27,7 @@ namespace UnityAtoms.Extensions
return mb.StartCoroutine(SetInterval(function, delay));
}
static IEnumerator SetInterval(Action function, float delay)
private static IEnumerator SetInterval(Action function, float delay)
{
while (true && function != null)
{

1
Source/Extensions/TransformExtensions.cs
View File

@ -5,7 +5,6 @@ namespace UnityAtoms.Extensions
{
public static class TransformExtensions
{
/* Finds a child to this transform by name. Searches not only the first level in the
* tree hierarchy of child objects, but all the children, grand children, and so on.
*/

10
Source/Float/ConditionalFloatAction.cs
View File

@ -1,20 +1,22 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[Serializable]
public class ConditionalFloatGameActionHelper : ConditionalGameActionHelper<float, FloatAction, BoolFloatFunction> { }
public sealed class ConditionalFloatGameActionHelper : ConditionalGameActionHelper<float, FloatAction, BoolFloatFunction> { }
[CreateAssetMenu(menuName = "Unity Atoms/Float/Conditional", fileName = "ConditionalFloatAction", order = CreateAssetMenuUtils.Order.CONDITIONAL)]
public class ConditionalFloatAction : FloatAction
public sealed class ConditionalFloatAction : FloatAction
{
[FormerlySerializedAs("Conditional")]
[SerializeField]
private ConditionalFloatGameActionHelper Conditional = null;
private ConditionalFloatGameActionHelper _conditional;
public override void Do(float t1)
{
Conditional.Do(t1);
_conditional.Do(t1);
}
}
}

2
Source/Float/FloatConstant.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/Constant", fileName = "FloatConstant", order = CreateAssetMenuUtils.Order.CONSTANT)]
public class FloatConstant : ScriptableObjectVariableBase<float> { }
public sealed class FloatConstant : ScriptableObjectVariableBase<float> { }
}

2
Source/Float/FloatEvent.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/Event", fileName = "FloatEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class FloatEvent : GameEvent<float> { }
public sealed class FloatEvent : GameEvent<float> { }
}

3
Source/Float/FloatFloatEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/Event x 2", fileName = "FloatFloatEvent", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class FloatFloatEvent : GameEvent<float, float> { }
public sealed class FloatFloatEvent : GameEvent<float, float> { }
}

2
Source/Float/FloatList.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/List", fileName = "FloatList", order = CreateAssetMenuUtils.Order.LIST)]
public class FloatList : ScriptableObjectList<float, FloatEvent> { }
public sealed class FloatList : ScriptableObjectList<float, FloatEvent> { }
}

7
Source/Float/FloatListener.cs
View File

@ -1,4 +1,9 @@
namespace UnityAtoms
{
public class FloatListener : GameEventListener<float, FloatAction, FloatEvent, UnityFloatEvent> { }
public sealed class FloatListener : GameEventListener<
float,
FloatAction,
FloatEvent,
UnityFloatEvent>
{ }
}

7
Source/Float/FloatReference.cs
View File

@ -3,5 +3,10 @@ using System;
namespace UnityAtoms
{
[Serializable]
public class FloatReference : ScriptableObjectReference<float, FloatVariable, FloatEvent, FloatFloatEvent> { }
public sealed class FloatReference : ScriptableObjectReference<
float,
FloatVariable,
FloatEvent,
FloatFloatEvent>
{ }
}

2
Source/Float/FloatVariable.cs
View File

@ -3,7 +3,7 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/Variable", fileName = "FloatVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class FloatVariable : EquatableScriptableObjectVariable<float, FloatEvent, FloatFloatEvent>, IWithApplyChange<float, FloatEvent, FloatFloatEvent>
public sealed class FloatVariable : EquatableScriptableObjectVariable<float, FloatEvent, FloatFloatEvent>, IWithApplyChange<float, FloatEvent, FloatFloatEvent>
{
public bool ApplyChange(float amount)
{

8
Source/Float/SetFloatVariableValue.cs
View File

@ -3,5 +3,11 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Float/Set Variable", fileName = "SetFloatVariableValueAction", order = CreateAssetMenuUtils.Order.SET_VARIABLE)]
public class SetFloatVariableValue : SetVariableValue<float, FloatVariable, FloatReference, FloatEvent, FloatFloatEvent> { }
public sealed class SetFloatVariableValue : SetVariableValue<
float,
FloatVariable,
FloatReference,
FloatEvent,
FloatFloatEvent>
{ }
}

2
Source/Float/UnityFloatEvent.cs
View File

@ -4,5 +4,5 @@ using UnityEngine.Events;
namespace UnityAtoms
{
[Serializable]
public class UnityFloatEvent : UnityEvent<float> { }
public sealed class UnityFloatEvent : UnityEvent<float> { }
}

2
Source/GameObject/GameObjectEvent.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/Event", fileName = "GameObjectEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class GameObjectEvent : GameEvent<GameObject> { }
public sealed class GameObjectEvent : GameEvent<GameObject> { }
}

3
Source/GameObject/GameObjectGameObjectEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/Event x 2", fileName = "GameObjectGameObjectEvent", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class GameObjectGameObjectEvent : GameEvent<GameObject, GameObject> { }
public sealed class GameObjectGameObjectEvent : GameEvent<GameObject, GameObject> { }
}

2
Source/GameObject/GameObjectList.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/List", fileName = "GameObjectList", order = CreateAssetMenuUtils.Order.LIST)]
public class GameObjectList : ScriptableObjectList<GameObject, GameObjectEvent> { }
public sealed class GameObjectList : ScriptableObjectList<GameObject, GameObjectEvent> { }
}

7
Source/GameObject/GameObjectListener.cs
View File

@ -2,5 +2,10 @@ using UnityEngine;
namespace UnityAtoms
{
public class GameObjectListener : GameEventListener<GameObject, GameObjectAction, GameObjectEvent, UnityGameObjectEvent> { }
public sealed class GameObjectListener : GameEventListener<
GameObject,
GameObjectAction,
GameObjectEvent,
UnityGameObjectEvent>
{ }
}

7
Source/GameObject/GameObjectReference.cs
View File

@ -4,5 +4,10 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class GameObjectReference : ScriptableObjectReference<GameObject, GameObjectVariable, GameObjectEvent, GameObjectGameObjectEvent> { }
public sealed class GameObjectReference : ScriptableObjectReference<
GameObject,
GameObjectVariable,
GameObjectEvent,
GameObjectGameObjectEvent>
{ }
}

5
Source/GameObject/GameObjectVariable.cs
View File

@ -3,7 +3,10 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/Variable", fileName = "GameObjectVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class GameObjectVariable : ScriptableObjectVariable<GameObject, GameObjectEvent, GameObjectGameObjectEvent>
public sealed class GameObjectVariable : ScriptableObjectVariable<
GameObject,
GameObjectEvent,
GameObjectGameObjectEvent>
{
protected override bool AreEqual(GameObject first, GameObject second)
{

18
Source/GameObject/GetUnusedGameObject.cs
View File

@ -1,5 +1,6 @@
using UnityEngine;
using UnityEngine;
using UnityAtoms.Extensions;
using UnityEngine.Serialization;
#if UNITY_EDITOR
using UnityAtoms.Logger;
#endif
@ -10,27 +11,30 @@ namespace UnityAtoms
* If no unused GameObject is found a new one is instantiated and added to the GameObjectList.
*/
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/Get Unused GameObject (GameObject - (V3, Quat))", fileName = "GetUnusedGameObject")]
public class GetUnusedGameObject : GameObjectVector3QuaternionFunction
public sealed class GetUnusedGameObject : GameObjectVector3QuaternionFunction
{
[FormerlySerializedAs("List")]
[SerializeField]
private GameObjectList List = null;
private GameObjectList _list;
[FormerlySerializedAs("Prefab")]
[SerializeField]
private GameObject Prefab = null;
private GameObject _prefab;
[FormerlySerializedAs("IsNotUsed")]
[SerializeField]
private BoolGameObjectFunction IsNotUsed = null;
private BoolGameObjectFunction _isNotUsed;
public override GameObject Call(Vector3 position, Quaternion quaternion)
{
if (IsNotUsed == null)
if (_isNotUsed == null)
{
#if UNITY_EDITOR
AtomsLogger.Warning("IsUsed must be defined when using GetUnusedGameObject");
#endif
}
return List.List.GetOrInstantiate(Prefab, position, quaternion, IsNotUsed.Call);
return _list.List.GetOrInstantiate(_prefab, position, quaternion, _isNotUsed.Call);
}
}
}

8
Source/GameObject/SetGameObjectVariableValue.cs
View File

@ -3,5 +3,11 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/GameObject/Set Variable", fileName = "SetGameObjectVariableValueAction", order = CreateAssetMenuUtils.Order.SET_VARIABLE)]
public class SetGameObjectVariableValue : SetVariableValue<GameObject, GameObjectVariable, GameObjectReference, GameObjectEvent, GameObjectGameObjectEvent> { }
public sealed class SetGameObjectVariableValue : SetVariableValue<
GameObject,
GameObjectVariable,
GameObjectReference,
GameObjectEvent,
GameObjectGameObjectEvent>
{ }
}

2
Source/GameObject/UnityGameObjectEvent.cs
View File

@ -5,5 +5,5 @@ using UnityEngine;
namespace UnityAtoms
{
[Serializable]
public class UnityGameObjectEvent : UnityEvent<GameObject> { }
public sealed class UnityGameObjectEvent : UnityEvent<GameObject> { }
}

10
Source/Int/ConditionalIntAction.cs
View File

@ -1,20 +1,22 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[Serializable]
public class ConditionalIntGameActionHelper : ConditionalGameActionHelper<int, IntAction, BoolIntFunction> { }
public sealed class ConditionalIntGameActionHelper : ConditionalGameActionHelper<int, IntAction, BoolIntFunction> { }
[CreateAssetMenu(menuName = "Unity Atoms/Int/Conditional", fileName = "ConditionalIntAction", order = CreateAssetMenuUtils.Order.CONDITIONAL)]
public class ConditionalIntAction : IntAction
public sealed class ConditionalIntAction : IntAction
{
[FormerlySerializedAs("Conditional")]
[SerializeField]
private ConditionalIntGameActionHelper Conditional = null;
private ConditionalIntGameActionHelper _conditional;
public override void Do(int t1)
{
Conditional.Do(t1);
_conditional.Do(t1);
}
}
}

2
Source/Int/IntConstant.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/Constant", fileName = "IntConstant", order = CreateAssetMenuUtils.Order.CONSTANT)]
public class IntConstant : ScriptableObjectVariableBase<int> { }
public sealed class IntConstant : ScriptableObjectVariableBase<int> { }
}

2
Source/Int/IntEvent.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/Event", fileName = "IntEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class IntEvent : GameEvent<int> { }
public sealed class IntEvent : GameEvent<int> { }
}

3
Source/Int/IntIntEvent.cs
View File

@ -2,7 +2,6 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/Event x 2", fileName = "IntIntEvent", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class IntIntEvent : GameEvent<int, int> { }
public sealed class IntIntEvent : GameEvent<int, int> { }
}

2
Source/Int/IntList.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/List", fileName = "IntList", order = CreateAssetMenuUtils.Order.LIST)]
public class IntList : ScriptableObjectList<int, IntEvent> { }
public sealed class IntList : ScriptableObjectList<int, IntEvent> { }
}

2
Source/Int/IntListener.cs
View File

@ -1,4 +1,4 @@
namespace UnityAtoms
{
public class IntListener : GameEventListener<int, IntAction, IntEvent, UnityIntEvent> { }
public sealed class IntListener : GameEventListener<int, IntAction, IntEvent, UnityIntEvent> { }
}

7
Source/Int/IntReference.cs
View File

@ -3,5 +3,10 @@ using System;
namespace UnityAtoms
{
[Serializable]
public class IntReference : ScriptableObjectReference<int, IntVariable, IntEvent, IntIntEvent> { }
public sealed class IntReference : ScriptableObjectReference<
int,
IntVariable,
IntEvent,
IntIntEvent>
{ }
}

4
Source/Int/IntVariable.cs
View File

@ -1,9 +1,9 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/Variable", fileName = "IntVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class IntVariable : EquatableScriptableObjectVariable<int, IntEvent, IntIntEvent>, IWithApplyChange<int, IntEvent, IntIntEvent>
public sealed class IntVariable : EquatableScriptableObjectVariable<int, IntEvent, IntIntEvent>, IWithApplyChange<int, IntEvent, IntIntEvent>
{
public bool ApplyChange(int amount)
{

8
Source/Int/SetIntVariableValue.cs
View File

@ -3,5 +3,11 @@ using UnityEngine;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Int/Set Variable", fileName = "SetIntVariableValueAction", order = CreateAssetMenuUtils.Order.SET_VARIABLE)]
public class SetIntVariableValue : SetVariableValue<int, IntVariable, IntReference, IntEvent, IntIntEvent> { }
public sealed class SetIntVariableValue : SetVariableValue<
int,
IntVariable,
IntReference,
IntEvent,
IntIntEvent>
{ }
}

2
Source/Int/UnityIntEvent.cs
View File

@ -4,5 +4,5 @@ using UnityEngine.Events;
namespace UnityAtoms
{
[Serializable]
public class UnityIntEvent : UnityEvent<int> { }
public sealed class UnityIntEvent : UnityEvent<int> { }
}

8
Source/Logger/AtomsLogger.cs
View File

@ -4,21 +4,21 @@ namespace UnityAtoms.Logger
{
public static class AtomsLogger
{
private const string logPrefix = "Unity Atoms :: ";
private const string LogPrefix = "Unity Atoms :: ";
public static void Log(string msg)
{
Debug.Log(logPrefix + msg);
Debug.Log(LogPrefix + msg);
}
public static void Warning(string msg)
{
Debug.LogWarning(logPrefix + msg);
Debug.LogWarning(LogPrefix + msg);
}
public static void Error(string msg)
{
Debug.LogError(logPrefix + msg);
Debug.LogError(LogPrefix + msg);
}
}
}

8
Source/Mobile/TouchUserInput/ConditionalTouchUserInputAction.cs
View File

@ -1,16 +1,16 @@
using System;
using System;
using UnityEngine;
namespace UnityAtoms.Mobile
{
[Serializable]
public class ConditionalTouchUserInputGameActionHelper : ConditionalGameActionHelper<TouchUserInput, TouchUserInputAction, BoolTouchUserInputFunction> { }
public sealed class ConditionalTouchUserInputGameActionHelper : ConditionalGameActionHelper<TouchUserInput, TouchUserInputAction, BoolTouchUserInputFunction> { }
[CreateAssetMenu(menuName = "Unity Atoms/Mobile/Touch User Input/Conditional", fileName = "ConditionalTouchUserInputAction", order = CreateAssetMenuUtils.Order.CONDITIONAL)]
public class ConditionalTouchUserInputAction : TouchUserInputAction
public sealed class ConditionalTouchUserInputAction : TouchUserInputAction
{
[SerializeField]
public ConditionalTouchUserInputGameActionHelper Conditional = null;
public ConditionalTouchUserInputGameActionHelper Conditional;
public override void Do(TouchUserInput t1)
{

88
Source/Mobile/TouchUserInput/DetectTap.cs
View File

@ -1,99 +1,107 @@
using System;
using System;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms.Mobile
{
[Serializable]
public class DetectTap : IGameEventListener<TouchUserInput>
{
[FormerlySerializedAs("FirstTapTimer")]
[SerializeField]
private Timer FirstTapTimer = null;
[SerializeField]
private Timer SecondTapTimer = null;
[SerializeField]
private FloatReference MaxTimeBetweenTaps = null;
[SerializeField]
private FloatReference MaxDistanceBetweenTaps = null;
[SerializeField]
private FloatReference MaxMovementToCountAsTap = null;
[SerializeField]
private TouchUserInputGameEvent OnTapDetectedEvent = null;
[SerializeField]
private TouchUserInputGameEvent OnDoubleTapDetectedEvent = null;
private Timer _firstTapTimer;
private Vector2 inputPosFirstTapDown;
[FormerlySerializedAs("SecondTapTimer")]
[SerializeField]
private Timer _secondTapTimer;
private void OnEnable()
{
FirstTapTimer.Stop();
SecondTapTimer.Stop();
}
[FormerlySerializedAs("MaxTimeBetweenTaps")]
[SerializeField]
private FloatReference _maxTimeBetweenTaps;
[FormerlySerializedAs("MaxDistanceBetweenTaps")]
[SerializeField]
private FloatReference _maxDistanceBetweenTaps;
[FormerlySerializedAs("MaxMovementToCountAsTap")]
[SerializeField]
private FloatReference _maxMovementToCountAsTap;
[FormerlySerializedAs("OnTapDetectedEvent")]
[SerializeField]
private TouchUserInputGameEvent _onTapDetectedEvent;
[FormerlySerializedAs("OnDoubleTapDetectedEvent")]
[SerializeField]
private TouchUserInputGameEvent _onDoubleTapDetectedEvent;
private Vector2 _inputPosFirstTapDown;
public void OnEventRaised(TouchUserInput touchUserInput)
{
if (!IsPotentialDoubleTapInProgress())
{
FirstTapTimer.Stop();
SecondTapTimer.Stop();
_firstTapTimer.Stop();
_secondTapTimer.Stop();
}
if (touchUserInput.InputState == TouchUserInput.State.Down && CanStartDoubleTap())
{
inputPosFirstTapDown = touchUserInput.InputPos;
FirstTapTimer.Start();
_inputPosFirstTapDown = touchUserInput.InputPos;
_firstTapTimer.Start();
}
else if (touchUserInput.InputState == TouchUserInput.State.Drag && FirstTapTimer.IsStarted() && Vector2.Distance(touchUserInput.InputPos, inputPosFirstTapDown) > MaxMovementToCountAsTap.Value)
else if (touchUserInput.InputState == TouchUserInput.State.Drag && _firstTapTimer.IsStarted() && Vector2.Distance(touchUserInput.InputPos, _inputPosFirstTapDown) > _maxMovementToCountAsTap.Value)
{
FirstTapTimer.Stop();
_firstTapTimer.Stop();
}
else if (touchUserInput.InputState == TouchUserInput.State.Up && WaitingForFinishingFirstTap())
{
if (FirstTapTimer.GetElapsedTime() <= MaxTimeBetweenTaps.Value)
if (_firstTapTimer.GetElapsedTime() <= _maxTimeBetweenTaps.Value)
{
if (OnTapDetectedEvent != null)
if (_onTapDetectedEvent != null)
{
OnTapDetectedEvent.Raise(touchUserInput);
_onTapDetectedEvent.Raise(touchUserInput);
}
SecondTapTimer.Start();
_secondTapTimer.Start();
}
FirstTapTimer.Stop();
_firstTapTimer.Stop();
}
else if (touchUserInput.InputState == TouchUserInput.State.Down && WaitingForSecondTap())
{
if (Vector2.Distance(touchUserInput.InputPos, inputPosFirstTapDown) <= MaxDistanceBetweenTaps.Value && SecondTapTimer.GetElapsedTime() <= MaxTimeBetweenTaps.Value)
if (Vector2.Distance(touchUserInput.InputPos, _inputPosFirstTapDown) <= _maxDistanceBetweenTaps.Value && _secondTapTimer.GetElapsedTime() <= _maxTimeBetweenTaps.Value)
{
if (OnDoubleTapDetectedEvent != null)
if (_onDoubleTapDetectedEvent != null)
{
OnDoubleTapDetectedEvent.Raise(touchUserInput); // OPEN POINT: Should we raise event on state up or down?
_onDoubleTapDetectedEvent.Raise(touchUserInput); // OPEN POINT: Should we raise event on state up or down?
}
}
SecondTapTimer.Stop();
_secondTapTimer.Stop();
}
}
private bool CanStartDoubleTap()
{
return !SecondTapTimer.IsStarted();
return !_secondTapTimer.IsStarted();
}
private bool WaitingForFinishingFirstTap()
{
return FirstTapTimer.IsStarted();
return _firstTapTimer.IsStarted();
}
private bool WaitingForSecondTap()
{
return SecondTapTimer.IsStarted();
return _secondTapTimer.IsStarted();
}
public bool IsPotentialDoubleTapInProgress()
{
return (FirstTapTimer.IsStarted() && FirstTapTimer.GetElapsedTime() <= MaxTimeBetweenTaps.Value) || (SecondTapTimer.IsStarted() && SecondTapTimer.GetElapsedTime() <= MaxTimeBetweenTaps.Value);
return (_firstTapTimer.IsStarted() && _firstTapTimer.GetElapsedTime() <= _maxTimeBetweenTaps.Value) || (_secondTapTimer.IsStarted() && _secondTapTimer.GetElapsedTime() <= _maxTimeBetweenTaps.Value);
}
public bool InUse()
{
return FirstTapTimer != null && SecondTapTimer != null && OnDoubleTapDetectedEvent != null;
return _firstTapTimer != null && _secondTapTimer != null && _onDoubleTapDetectedEvent != null;
}
}

4
Source/Mobile/TouchUserInput/TouchUserInputGameEvent.cs
View File

@ -1,7 +1,7 @@
using UnityEngine;
using UnityEngine;
namespace UnityAtoms.Mobile
{
[CreateAssetMenu(menuName = "Unity Atoms/Mobile/Touch User Input/Event", fileName = "TouchUserInputEvent", order = CreateAssetMenuUtils.Order.EVENT)]
public class TouchUserInputGameEvent : GameEvent<TouchUserInput> { }
public sealed class TouchUserInputGameEvent : GameEvent<TouchUserInput> { }
}

9
Source/Mobile/TouchUserInput/TouchUserInputListener.cs
View File

@ -1,5 +1,10 @@
namespace UnityAtoms.Mobile
namespace UnityAtoms.Mobile
{
public class TouchUserInputListener : GameEventListener<TouchUserInput, TouchUserInputAction, TouchUserInputGameEvent, UnityTouchUserInputEvent> { }
public sealed class TouchUserInputListener : GameEventListener<
TouchUserInput,
TouchUserInputAction,
TouchUserInputGameEvent,
UnityTouchUserInputEvent>
{ }
}

2
Source/Mobile/TouchUserInput/TouchUserInputTouchUserInputGameEvent.cs
View File

@ -3,5 +3,5 @@ using UnityEngine;
namespace UnityAtoms.Mobile
{
[CreateAssetMenu(menuName = "Unity Atoms/Mobile/Touch User Input/Event x 2", fileName = "TouchUserInputx2Event", order = CreateAssetMenuUtils.Order.EVENTx2)]
public class TouchUserInputTouchUserInputGameEvent : GameEvent<TouchUserInput, TouchUserInput> { }
public sealed class TouchUserInputTouchUserInputGameEvent : GameEvent<TouchUserInput, TouchUserInput> { }
}

10
Source/Mobile/TouchUserInput/TouchUserInputTouchUserInputListener.cs
View File

@ -1,5 +1,11 @@
namespace UnityAtoms.Mobile
namespace UnityAtoms.Mobile
{
public class TouchUserInputTouchUserInputListener : GameEventListener<TouchUserInput, TouchUserInput, TouchUserInputTouchUserInputAction, TouchUserInputTouchUserInputGameEvent, UnityTouchUserInputTouchUserInputEvent> { }
public sealed class TouchUserInputTouchUserInputListener : GameEventListener<
TouchUserInput,
TouchUserInput,
TouchUserInputTouchUserInputAction,
TouchUserInputTouchUserInputGameEvent,
UnityTouchUserInputTouchUserInputEvent>
{ }
}

7
Source/Mobile/TouchUserInput/TouchUserInputVariable.cs
View File

@ -3,10 +3,13 @@ using UnityEngine;
namespace UnityAtoms.Mobile
{
[CreateAssetMenu(menuName = "Unity Atoms/Mobile/Touch User Input/Variable", fileName = "TouchUserInputVariable", order = CreateAssetMenuUtils.Order.VARIABLE)]
public class TouchUserInputVariable : ScriptableObjectVariable<TouchUserInput, TouchUserInputGameEvent, TouchUserInputTouchUserInputGameEvent>
public sealed class TouchUserInputVariable : ScriptableObjectVariable<
TouchUserInput,
TouchUserInputGameEvent,
TouchUserInputTouchUserInputGameEvent>
{
[SerializeField]
private DetectTap DetectTap = null;
private DetectTap DetectTap;
private void OnEnable()
{

7
Source/Mobile/TouchUserInput/UnityTouchUserInputEvent.cs
View File

@ -1,11 +1,8 @@
using System;
using System;
using UnityEngine.Events;
namespace UnityAtoms.Mobile
{
[Serializable]
public class UnityTouchUserInputEvent : UnityEvent<TouchUserInput> { }
[Serializable]
public class UnityTouchUserInputTouchUserInputEvent : UnityEvent<TouchUserInput, TouchUserInput> { }
public sealed class UnityTouchUserInputEvent : UnityEvent<TouchUserInput> { }
}

8
Source/Mobile/TouchUserInput/UnityTouchUserInputTouchUserInputEvent.cs Normal file
View File

@ -0,0 +1,8 @@
using System;
using UnityEngine.Events;
namespace UnityAtoms.Mobile
{
[Serializable]
public sealed class UnityTouchUserInputTouchUserInputEvent : UnityEvent<TouchUserInput, TouchUserInput> { }
}

11
Source/Mobile/TouchUserInput/UnityTouchUserInputTouchUserInputEvent.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4a0403191ef2d9549855169b87213829
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

43
Source/Mobile/TouchUserInput/UpdateTouchUserInput.cs
View File

@ -5,64 +5,67 @@ namespace UnityAtoms.Mobile
/* Updates the TouchUserInputVariable on every Update tick. Meant to be placed on a OnUpdateMonoHook.
*/
[CreateAssetMenu(menuName = "Unity Atoms/Mobile/Touch User Input/Update (OnUpdateMonoHook)", fileName = "UpdateTouchUserInputVariable")]
public class UpdateTouchUserInput : VoidAction
public sealed class UpdateTouchUserInput : VoidAction
{
public TouchUserInputVariable TouchUserInputVariable;
private TouchUserInput.State inputState = TouchUserInput.State.None;
private Vector2 inputPos = Vector2.zero;
private Vector2 inputPosLastFrame = Vector2.zero;
private Vector2 inputPosLastDown = Vector2.zero;
private TouchUserInput.State _inputState = TouchUserInput.State.None;
private Vector2 _inputPos = Vector2.zero;
private Vector2 _inputPosLastFrame = Vector2.zero;
private Vector2 _inputPosLastDown = Vector2.zero;
public override void Do()
{
#if (UNITY_ANDROID || UNITY_IOS || UNITY_IPHONE) && !UNITY_EDITOR
if (Input.touchCount > 0)
{
inputPos = Input.GetTouch(0).position;
_inputPos = Input.GetTouch(0).position;
if (Input.GetTouch(0).phase == TouchPhase.Began)
{
inputPosLastDown = inputPos;
inputState = TouchUserInput.State.Down;
_inputPosLastDown = _inputPos;
_inputState = TouchUserInput.State.Down;
}
else if (Input.GetTouch(0).phase == TouchPhase.Ended)
{
inputState = TouchUserInput.State.Up;
_inputState = TouchUserInput.State.Up;
}
else
{
inputState = TouchUserInput.State.Drag;
_inputState = TouchUserInput.State.Drag;
}
}
else
{
inputPos = Vector2.zero;
inputState = TouchUserInput.State.None;
_inputPos = Vector2.zero;
_inputState = TouchUserInput.State.None;
}
#elif UNITY_EDITOR || UNITY_STANDALONE
inputPos = Input.mousePosition;
_inputPos = Input.mousePosition;
if (Input.GetMouseButtonDown(0))
{
inputPosLastDown = inputPos;
inputState = TouchUserInput.State.Down;
_inputPosLastDown = _inputPos;
_inputState = TouchUserInput.State.Down;
}
else if (Input.GetMouseButtonUp(0))
{
inputState = TouchUserInput.State.Up;
_inputState = TouchUserInput.State.Up;
}
else if (Input.GetMouseButton(0))
{
inputState = TouchUserInput.State.Drag;
_inputState = TouchUserInput.State.Drag;
}
else
{
inputState = TouchUserInput.State.None;
_inputState = TouchUserInput.State.None;
}
#endif
TouchUserInputVariable.SetValue(new TouchUserInput(inputState, inputPos, inputPosLastFrame, inputPosLastDown));
inputPosLastFrame = inputPos;
TouchUserInputVariable.SetValue(new TouchUserInput(_inputState, _inputPos, _inputPosLastFrame, _inputPosLastDown));
_inputPosLastFrame = _inputPos;
}
}
}

8
Source/Molecules/Timer/StartTimer.cs
View File

@ -1,16 +1,18 @@
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Molecules/Timer/Start Timer")]
public class StartTimer : VoidAction
public sealed class StartTimer : VoidAction
{
[FormerlySerializedAs("Timer")]
[SerializeField]
private Timer Timer = null;
private Timer _timer;
public override void Do()
{
Timer.Start();
_timer.Start();
}
}
}

8
Source/Molecules/Timer/StopTimer.cs
View File

@ -1,16 +1,18 @@
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Molecules/Timer/Stop Timer")]
public class StopTimer : VoidAction
public sealed class StopTimer : VoidAction
{
[FormerlySerializedAs("Timer")]
[SerializeField]
private Timer Timer = null;
private Timer _timer;
public override void Do()
{
Timer.Stop();
_timer.Stop();
}
}
}

18
Source/Molecules/Timer/Timer.cs
View File

@ -1,22 +1,28 @@
using UnityEngine;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
[CreateAssetMenu(menuName = "Unity Atoms/Molecules/Timer/Timer")]
public class Timer : ScriptableObject
{
public float TimeElapsed = 0f;
public bool Started = false;
public bool Started { get { return _started; } }
public float TimeElapsed;
[FormerlySerializedAs("Started")]
[SerializeField]
private bool _started;
public void Start()
{
Started = true;
_started = true;
}
public void Stop()
{
TimeElapsed = 0f;
Started = false;
_started = false;
}
public float GetElapsedTime()
@ -26,7 +32,7 @@ namespace UnityAtoms
public bool IsStarted()
{
return Started;
return _started;
}
}

17
Source/Molecules/Timer/UpdateTimer.cs
View File

@ -1,20 +1,23 @@
using UnityEngine;
using UnityEngine;
using UnityEngine.Serialization;
namespace UnityAtoms
{
/* Updates the Timer. Meant to be placed on a OnUpdateMonoHook.
*/
/// <summary>
/// Updates the Timer. Meant to be placed on a OnUpdateMonoHook.
/// </summary>
[CreateAssetMenu(menuName = "Unity Atoms/Molecules/Timer/Update Timer")]
public class UpdateTimer : VoidAction
public sealed class UpdateTimer : VoidAction
{
[FormerlySerializedAs("Timer")]
[SerializeField]
private Timer Timer = null;
private Timer _timer;
public override void Do()
{
if (Timer.Started)
if (_timer.Started)
{
Timer.TimeElapsed += Time.deltaTime;
_timer.TimeElapsed += Time.deltaTime;
}
}
}

7
Source/MonoHooks/Collider2DHook.cs
View File

@ -2,5 +2,10 @@ using UnityEngine;
namespace UnityAtoms
{
public abstract class Collider2DHook : MonoHook<Collider2DEvent, Collider2DGameObjectEvent, Collider2D, GameObjectGameObjectFunction> { }
public abstract class Collider2DHook : MonoHook<
Collider2DEvent,
Collider2DGameObjectEvent,
Collider2D,
GameObjectGameObjectFunction>
{ }
}

Some files were not shown because too many files have changed in this diff Show More