Adding abilities, their UI, and second character

+{
+  "version": "1.0",
+  "components": [ 
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+} 

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &854438021669437657
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 854438021669437656}
+  - component: {fileID: 854438021669437659}
+  m_Layer: 5
+  m_Name: Ability Slot
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &854438021669437656
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438021669437657}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 854438022463020332}
+  - {fileID: 6516049540908268168}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &854438021669437659
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438021669437657}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e9b3f6ca80f5ab44e9b0b70b7730a1fb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  icon: {fileID: 854438021828943663}
+  description: {fileID: 6516049540908268171}
+  playerController: {fileID: 0}
+--- !u!1 &854438021828943661
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 854438021828943660}
+  - component: {fileID: 854438021828943662}
+  - component: {fileID: 854438021828943663}
+  m_Layer: 5
+  m_Name: Icon
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &854438021828943660
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438021828943661}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 854438022463020332}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 30, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &854438021828943662
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438021828943661}
+  m_CullTransparentMesh: 0
+--- !u!114 &854438021828943663
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438021828943661}
+  m_Enabled: 0
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 0}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &854438022463020333
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 854438022463020332}
+  - component: {fileID: 854438022463020329}
+  - component: {fileID: 854438022463020334}
+  - component: {fileID: 854438022463020335}
+  m_Layer: 5
+  m_Name: Ability Button
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &854438022463020332
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438022463020333}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 854438021828943660}
+  m_Father: {fileID: 854438021669437656}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 20.000011, y: -19.999994}
+  m_SizeDelta: {x: 40, y: 40}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &854438022463020329
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438022463020333}
+  m_CullTransparentMesh: 0
+--- !u!114 &854438022463020334
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438022463020333}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 0.8606347, b: 0.6933962, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10907, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!114 &854438022463020335
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 854438022463020333}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 854438022463020334}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 0}
+        m_TargetAssemblyTypeName: 
+        m_MethodName: UseItem
+        m_Mode: 1
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+--- !u!1 &6516049540908268169
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6516049540908268168}
+  - component: {fileID: 6516049540908268170}
+  - component: {fileID: 6516049540908268171}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &6516049540908268168
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6516049540908268169}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 854438021669437656}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 20.000017, y: -2.32}
+  m_SizeDelta: {x: 150, y: 35.354706}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &6516049540908268170
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6516049540908268169}
+  m_CullTransparentMesh: 0
+--- !u!114 &6516049540908268171
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6516049540908268169}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Ability Description

+fileFormatVersion: 2
+guid: a0430c94576a6804fbaf7e382da24739
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 525c34b74c15c8643bf495b515be864d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Ability : ScriptableObject
+{
+    new public string name = "New Ability";
+
+    public string description = "ability does thing";
+    protected GameObject user = null;
+    public Sprite icon = null;
+
+    public List<StatBuffs> buffList = new List<StatBuffs>();
+    public List<StatBuffs> debuffList = new List<StatBuffs>();
+
+    [SerializeField]
+    protected bool doesDamage, doesHealing;
+
+    [SerializeField]
+    protected float abilityValue;
+
+    public float duration;
+    public float cooldown;
+
+    protected Camera cam;
+
+    public virtual void Use(GameObject interactor)
+    {
+        Debug.Log(interactor.name + " is using " + name);
+        user = interactor;
+    }
+
+    public virtual void End()
+    {
+        Debug.Log(name + "'s duration is over");
+    }
+
+    public void SetCam(Camera newCam) {  cam = newCam; }
+
+}
+
+public enum TargetType { Self, Ally, Enemy, Any }
+
+public enum StatBuffs { Damage, Armor, MoveSpeed, AttackSpeed }  
+
+
+
+

+fileFormatVersion: 2
+guid: fa7652459315bf741b3f65d5c33f5352
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.UI;
+
+public class AbilitySlot : MonoBehaviour
+{
+    public Image icon;
+    public Text description;
+
+    public Player_Controller playerController;
+
+    Ability ability;
+
+
+    //Adds item to inventory slot
+    public void AddAbility(Ability newAbility)
+    {
+        ability = newAbility;
+
+        icon.sprite = ability.icon;
+        icon.enabled = true;
+    }
+
+    //clears inventory slot
+    public void ClearSlot()
+    {
+        ability = null;
+
+        icon.sprite = null;
+        icon.enabled = false;
+    }
+
+    //uses item in inventory slot
+    public void UseAbility()
+    {
+        if (ability != null)
+        {
+            ability.Use(playerController.gameObject);
+
+        }
+    }
+}

+fileFormatVersion: 2
+guid: e9b3f6ca80f5ab44e9b0b70b7730a1fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class AbilityUI : MonoBehaviour
+{
+    public Transform abilityParent;
+    public GameObject abilityUI;
+    PlayerManager playerManager;
+
+    public Player_Stats characterStats;
+    Player_Controller playerController;
+
+    public AbilitySlot[] slots;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        playerManager = PlayerManager.instance;
+
+        characterStats = playerManager.player1.GetComponent<Player_Stats>();
+        playerController = playerManager.player1.GetComponent<Player_Controller>();
+
+
+        //Update the Inventory UI every time that the play switches characters
+        playerManager.onCharacterChangeCallback += UpdateUI;
+
+        slots = abilityParent.GetComponentsInChildren<AbilitySlot>();
+
+        for (int i = 0; i < slots.Length; i++)
+        {
+            slots[i].playerController = playerController; 
+            
+            if (i < characterStats.abilities.Count)
+            {
+                slots[i].AddAbility(characterStats.abilities[i]);
+
+            }
+            else
+            {
+                slots[i].ClearSlot();
+            }
+        }
+
+
+    }
+
+    //DOES NOT UPDATE WHEN CHANGING CHARACTERS
+    //FIX PLEASE FUTURE CHARLES 
+    void UpdateUI()
+    {
+        characterStats = playerManager.player1.GetComponent<Player_Stats>();
+        playerController = playerManager.player1.GetComponent<Player_Controller>();
+
+        for (int i = 0; i < slots.Length; i++)
+        {
+            slots[i].playerController = playerController;
+            if (i < characterStats.abilities.Count)
+            {
+                slots[i].AddAbility(characterStats.abilities[i]);
+
+            }
+            else
+            {
+                slots[i].ClearSlot();
+            }
+
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 8aa0742fe19a6ae48b436e917467d586
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[CreateAssetMenu(fileName = "New Ability", menuName = "Ability/Aoe")]
+public class Aoe_Ability : Ability
+{
+    public float areaSize;
+
+    [SerializeField]
+    private AOEType aoeType;
+
+    [SerializeField]
+    private TargetType targetType;
+
+    public float endPoint;
+
+    public Vector3 origin;
+
+    private bool selfOrigin = false;
+
+    [SerializeField]
+    private List<CharacterCombat> targets = new List<CharacterCombat>();
+
+    public override void Use(GameObject user)
+    {
+        base.Use(user);
+
+        if (selfOrigin) origin = user.transform.position;
+        else
+        {
+            Ray ray = cam.ScreenPointToRay(Input.mousePosition);
+            RaycastHit hit;
+
+            if (Physics.Raycast(ray, out hit, 100))
+            {
+                origin = hit.point;
+            }
+        }
+
+        if ( origin != null)
+        {
+            Collider[] colliderArray;
+
+            if (aoeType != AOEType.Cone)
+                CheckArea();
+            else
+                CheckCone();
+
+            foreach (var target in targets)
+            {
+                target.AbilityHit(user.GetComponent<Character_Stats>());
+            }
+
+            targets.Clear();
+        }
+
+       
+    }
+
+    private void CheckCone()
+    {
+        Collider[] colliderArray = Physics.OverlapSphere(origin, areaSize);
+
+        foreach (var collider in colliderArray)
+        {
+            Vector3 directionTowardT = collider.transform.position - origin;
+            float angleFromConeCenter = Vector3.Angle(directionTowardT, Vector3.forward);
+
+            CharacterCombat colliderCombat = collider.gameObject.GetComponent<CharacterCombat>();
+
+            if (colliderCombat != null && angleFromConeCenter <= 45)
+            {
+                switch (targetType)
+                {
+                    case TargetType.Ally:
+                        if (colliderCombat.tag == "Ally") targets.Add(colliderCombat);
+                        break;
+
+                    case TargetType.Enemy:
+                        if (colliderCombat.tag == "Enemy") targets.Add(colliderCombat);
+                        break;
+
+                    case TargetType.Any:
+                        targets.Add(colliderCombat);
+                        break;
+
+                    default:
+                        targets.Add(colliderCombat);
+                        break;
+                }
+            }
+
+        }
+
+        
+
+    }
+
+    private void CheckArea ()
+    {
+        Collider[] collidersNear = null;
+
+       if (aoeType == AOEType.Cube) 
+            collidersNear = Physics.OverlapBox(origin, new Vector3(areaSize, areaSize, areaSize));
+
+       else if (aoeType == AOEType.Sphere)
+            collidersNear = Physics.OverlapSphere(origin, areaSize);
+
+        if (aoeType == AOEType.Line)
+        {
+            Ray aoeLineRay = new Ray(user.transform.position, Vector3.forward);
+            RaycastHit[] collidersHit = Physics.RaycastAll(aoeLineRay);
+
+            for (int i = 0; i < collidersHit.Length; i++)
+            {
+                collidersNear[i] = collidersHit[i].collider;
+            }
+        }
+
+        if (collidersNear != null)
+        {
+            foreach (var collider in collidersNear)
+            {
+                CharacterCombat colliderCombat = collider.gameObject.GetComponent<CharacterCombat>();
+
+                if (colliderCombat != null)
+                {
+                    switch (targetType)
+                    {
+                        case TargetType.Ally:
+                            if (colliderCombat.tag == "Ally") targets.Add(colliderCombat);
+                            break;
+
+                        case TargetType.Enemy:
+                            if (colliderCombat.tag == "Enemy") targets.Add(colliderCombat);
+                            break;
+
+                        case TargetType.Any:
+                            targets.Add(colliderCombat);
+                            break;
+
+                        default:
+                            targets.Add(colliderCombat);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+
+
+    private void OnDrawGizmos()
+    {
+        Gizmos.color = Color.red;
+        Gizmos.DrawSphere(origin, areaSize);
+    }
+}
+
+public enum AOEType { Sphere, Cube, Cone, Line }
+
+

+fileFormatVersion: 2
+guid: 9a40401784437aa48bf06c3387427385
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[CreateAssetMenu(fileName = "New Ability", menuName = "Ability/Passive")]
+public class Passive_Ability : Ability
+{
+
+    public override void Use(GameObject user)
+    {
+
+    }
+}

+fileFormatVersion: 2
+guid: 875560cdadf4c8d43904c4e32642cb56
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[CreateAssetMenu(fileName = "New Ability", menuName = "Ability/Targeted")]
+public class Targeted_Ability : Ability
+{
+    [SerializeField]
+    TargetType targetType;
+
+    GameObject targetCharacter;
+    public override void Use(GameObject user)
+    {
+        base.Use(user);
+
+        Ray ray = cam.ScreenPointToRay(Input.mousePosition);
+        RaycastHit hit;
+
+        if (Physics.Raycast(ray, out hit, 100))
+        {
+            CharacterCombat character = hit.collider.GetComponent<CharacterCombat>();
+
+            switch (targetType)
+            {
+                case TargetType.Self:
+                    //ability affects self
+
+                    break;
+                case TargetType.Ally:
+                    //ability affects targeted ally
+                    if (character != null && character.gameObject.tag == "Ally")
+                    {
+                        Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
+                    }
+                    break;
+
+                case TargetType.Enemy:
+                    //ability affects targeted enemy
+                    if (character != null && character.gameObject.tag == "Enemy")
+                    {
+                        Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
+                    }
+                    break;
+
+                case TargetType.Any:
+                    //ability affects targeted character
+                    if (character != null)
+                    {
+                        Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
+                    }
+                    break;
+
+                default:
+                    //defaults to self
+                    break;
+            }
+        }
+        
+
+    }
+
+
+}
+

+fileFormatVersion: 2
+guid: 29ae035edc32de447921400b0ecd43ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

@@ -2,9 +2,12 @@
 using System.Collections.Generic;
 using UnityEngine;
 
+
+//This controls combat between 2 characters
 public class CharacterCombat : MonoBehaviour
 {
     Character_Stats myStats;
+    //Enemy focusedEnemy;
 
     public float attackSpeed = 1f;
     private float attackCooldown = 0f;
@@ -12,19 +15,38 @@ public class CharacterCombat : MonoBehaviour
     private void Start()
     {
         myStats = GetComponent<Character_Stats>();
+        attackSpeed = myStats.attackSpeed.GetValue();
     }
 
     private void Update()
     {
         attackCooldown -= Time.deltaTime;
     }
-    public void Attacked (Character_Stats targetStats)
+
+    //method for attackng another character
+    public void Attack (Character_Stats targetStats)
     {
+        //if attack not on cooldown
         if (attackCooldown <= 0f)
         {
+            //tells attack target's stats that they take damage
             targetStats.TakeDam(myStats.damage.GetValue());
+            //resets attack timer
             attackCooldown = 1f / attackSpeed;
+            //Keeps attacking target afterwards
+            //focusedEnemy = targetStats.GetComponent<Enemy>();
         }
-        
     }
+
+    public void AbilityHit(Character_Stats targetStats)
+    {
+        //tells attack target's stats that they take damage
+        targetStats.TakeDam(myStats.damage.GetValue());
+    }
+
+    public float GetAttackCooldown() { return attackCooldown; }
+
+
+
+
 }

@@ -3,28 +3,33 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Rendering;
 
+//This is for holding the stats of any character and is used mostly for combat purposes
 public class Character_Stats : MonoBehaviour
 {
-    public int maxHP = 100;
-    public int curHP { get; private set; } 
+    public float curHP { get; private set; }
 
+    public Stat maxHP;
     public Stat damage;
     public Stat armor;
+    public Stat moveSpeed;
+    public Stat attackSpeed;
 
-    private void Awake()
-    {
-        curHP = maxHP;
-    }
+    public List<Ability> abilities = new List<Ability>();
 
-    void Update() 
+    private void Start()
     {
-        if (Input.GetKeyDown(KeyCode.T))
+        foreach(Ability ability in abilities)
         {
-            TakeDam(10);
-        }    
+            ability.SetCam(Camera.main);
+        }
+
+       
+
+        curHP = maxHP.GetValue();
     }
 
-    public void TakeDam (int damage)
+    //Method for taking damage, damage is subtracted by the amount of armor and damage min is 0
+    public void TakeDam (float damage)
     {
         damage -= armor.GetValue();
         damage = Mathf.Clamp(damage, 0, int.MaxValue);
@@ -38,6 +43,19 @@ public class Character_Stats : MonoBehaviour
         }
     }
 
+    public void Heal(float amount)
+    {
+        amount = Mathf.Clamp(amount, 0, int.MaxValue);
+
+        curHP += amount;
+        Debug.Log(gameObject + " heals for " + amount + " of health");
+
+        if (curHP >= maxHP.GetValue())
+        {
+            curHP = maxHP.GetValue();
+        }
+    }
+
     public virtual void Die()
     {
 

@@ -5,6 +5,7 @@ using UnityEngine;
 public class Camera_Controller : MonoBehaviour
 {
     public Transform target;
+    PlayerManager playerManager;
 
     public Vector3 offset;
     public float zoomSpeed = 4f;
@@ -18,12 +19,21 @@ public class Camera_Controller : MonoBehaviour
     private float currentZoom = 10f;
     private float currentYaw = 0f;
 
+    private void Start()
+    {
+        playerManager = PlayerManager.instance;
+
+        target = playerManager.player1.transform;
+    }
+
     void Update()
     {
         currentZoom -= Input.GetAxis("Mouse ScrollWheel") * zoomSpeed;
         currentZoom = Mathf.Clamp(currentZoom, minZoom, maxZoom);
 
         currentYaw -= Input.GetAxis("Horizontal") * yawSpeed * Time.deltaTime;
+
+        target = playerManager.activePerson.gameObject.transform;
     }
 
 
@@ -33,7 +43,5 @@ public class Camera_Controller : MonoBehaviour
         transform.position = target.position - offset * currentZoom;
         transform.LookAt(target.position + Vector3.up * pitch);
         transform.RotateAround(target.position, Vector3.up, currentYaw);
-
-        
     }
 }

@@ -10,13 +10,18 @@ public class Enemy_Controller : MonoBehaviour
 
     Transform target;
     NavMeshAgent agent;
+    CharacterCombat combat;
+    Character_Stats stats;
 
     // Start is called before the first frame update
     void Start()
     {
         target = PlayerManager.instance.player1.transform;
         agent = GetComponent<NavMeshAgent>();
-        
+        combat = GetComponent<CharacterCombat>();
+        stats = GetComponent<Character_Stats>();
+
+        agent.speed = stats.moveSpeed.GetValue();
     }
 
     // Update is called once per frame
@@ -30,12 +35,19 @@ public class Enemy_Controller : MonoBehaviour
             if(distance <= agent.stoppingDistance)
             {
                 //attack
+                Character_Stats targetStats = target.GetComponent<Character_Stats>();
+                if(targetStats != null)
+                {
+                    combat.Attack(targetStats);
+                }
+                
                 FaceTarget();
             }
         }
         
     }
 
+    //make sure to face target when attacking
     void FaceTarget()
     {
         Vector3 direction = (target.position - transform.position).normalized;

@@ -6,6 +6,7 @@ public class Enemy : Interactable
 {
     PlayerManager playerManager;
     Character_Stats myStats;
+    CharacterCombat interactorCombat;
 
     private void Start()
     {
@@ -15,11 +16,46 @@ public class Enemy : Interactable
     public override void Interact(GameObject interactor)
     {
         base.Interact(interactor);
-        //CharacterCombat playerCombat = playerManager.player1.GetComponent<CharacterCombat>();
-        CharacterCombat playerCombat = interactor.GetComponent<CharacterCombat>();
-        if (playerCombat != null)
+        
+
+        interactorCombat = interactor.GetComponent<CharacterCombat>();
+        if (interactorCombat != null)
         {
-            playerCombat.Attacked(myStats);
+            interactorCombat.Attack(myStats);
         }
     }
+
+    private void Update()
+    {
+        //If this interactable is the focus of a character and not interacted with yet
+        //check if character is close enough to interact, if so, set hasInteracted to true
+        if (isFocus)
+        {
+            if (!hasInteracted)
+            {
+                float distance = Vector3.Distance(interactor.position, interactionTransform.position);
+                if (distance <= radius)
+                {
+                    Interact(interactor.gameObject);
+                    hasInteracted = true;
+                }
+            }
+
+            //if the enemy has been attacked, then continue attacking as long they're still focused
+            //and their attack cooldown allows it
+            else if(hasInteracted && interactorCombat.GetAttackCooldown() <= 0)
+            {
+                //Debug.Log(gameObject + " is interacting with " + interactor);
+                float distance = Vector3.Distance(interactor.position, interactionTransform.position);
+                if (distance <= radius)
+                {
+
+                    Interact(interactor.gameObject);
+                }
+            }
+
+
+        }
+    }
+
 }

@@ -7,11 +7,13 @@ public class Interactable : MonoBehaviour
     public float radius = 3f;
     public Transform interactionTransform;
 
-    bool isFocus = false;
-    Transform player;
+    protected bool isFocus = false;
+    protected Transform interactor;
 
-    bool hasInteracted = false;
+    protected bool hasInteracted = false;
 
+    //This is what is called when a character interacts with an interactable. 
+    //This is used as a base and meant to be built upon for more specialised interactables
     public virtual void Interact(GameObject interactor)
     {
         Debug.Log(interactor + " is Interacting with " + this.name);
@@ -20,29 +22,33 @@ public class Interactable : MonoBehaviour
 
     private void Update()
     {
+        //If this interactable is the focus of a character and not interacted with yet
+        //check if character is close enough to interact, if so, set hasInteracted to true
         if (isFocus && !hasInteracted)
         {
-            float distance = Vector3.Distance(player.position, interactionTransform.position);
+            float distance = Vector3.Distance(interactor.position, interactionTransform.position);
             if (distance <= radius)
             {
                 
-                Interact(player.gameObject);
+                Interact(interactor.gameObject);
                 hasInteracted = true;
             }
         }
     }
 
-    public void OnFocused(Transform playerTransform)
+    //Once this interactable has been focused, finds out who is focusing it
+    public void OnFocused(Transform interactorTransform)
     {
         isFocus = true;
-        player = playerTransform;
+        interactor = interactorTransform;
         hasInteracted = false;
     }
 
+    //If interactable is no longer being focused, resets variables
     public void OnDefocused()
     {
         isFocus = false;
-        player = null;
+        interactor = null;
         hasInteracted = false;
 
     }

 using UnityEngine;
 using UnityEngine.UI;
 
+//This is a script for an individual Inventory slot on the UI
 public class InventorySlot : MonoBehaviour
 {
     public Image icon;
@@ -10,11 +11,7 @@ public class InventorySlot : MonoBehaviour
 
     Item item;
 
-    void Awake()
-    {
-        playerController = FindObjectOfType<Player_Controller>();
-    }
-
+    //Adds item to inventory slot
     public void AddItem(Item newItem)
     {
         item = newItem;
@@ -24,6 +21,7 @@ public class InventorySlot : MonoBehaviour
         removeButton.interactable = true;
     }
 
+    //clears inventory slot
     public void ClearSlot()
     {
         item = null;
@@ -33,11 +31,13 @@ public class InventorySlot : MonoBehaviour
         removeButton.interactable = false;
     }
 
+    //removes item from character's inventory
     public void OnRemoveButton(Inventory interactor)
     {
         interactor.Remove(item);
     }
 
+    //uses item in inventory slot
     public void UseItem()
     { 
         if (item != null)

@@ -3,19 +3,38 @@
 public class InventoryUI : MonoBehaviour
 {
     public Transform itemsParent;
-    public GameObject inventoryUI; 
+    public GameObject inventoryUI;
+    PlayerManager playerManager;
 
     public Inventory playerInventory;
+    Player_Controller playerController;
 
     public InventorySlot[] slots;
 
     // Start is called before the first frame update
     void Start()
     {
-        //playerInventory = FindObjectOfType<Player_Controller>().gameObject.GetComponent<Inventory>();
+        playerManager = PlayerManager.instance;
+        playerInventory = playerManager.player2.GetComponent<Inventory>();
+
+        //Update the Inventory UI every time that the inventory is modified
+        playerInventory.onItemChangedCallback += UpdateUI;
+
+        playerInventory = playerManager.player1.GetComponent<Inventory>();
+        playerController = playerManager.player1.GetComponent<Player_Controller>();
+
+        //Update the Inventory UI every time that the inventory is modified
         playerInventory.onItemChangedCallback += UpdateUI;
 
+        //Update the Inventory UI every time that the play switches characters
+        playerManager.onCharacterChangeCallback += UpdateUI;
+
         slots = itemsParent.GetComponentsInChildren<InventorySlot>();
+
+        for (int i = 0; i < slots.Length; i++)
+        {
+            slots[i].playerController = playerController;
+        }
     }
 
     // Update is called once per frame
@@ -30,12 +49,16 @@ public class InventoryUI : MonoBehaviour
 
     void UpdateUI()
     {
-        
+        playerInventory = playerManager.activePerson.GetComponent<Inventory>();
+        playerController = playerManager.activePerson.GetComponent<Player_Controller>();
+
         for (int i = 0; i < slots.Length; i++)
         {
+            slots[i].playerController = playerController;
             if (i < playerInventory.items.Count)
             {
                 slots[i].AddItem(playerInventory.items[i]);
+                
             }
             else
             {

@@ -10,6 +10,7 @@ public class Equipment : Item
     public int armorMod;
     public int damageMod;
 
+    ///equips piece of equipment
     public override void Use(GameObject interactor)
     {
         base.Use(interactor);
@@ -22,4 +23,5 @@ public class Equipment : Item
 
 }
 
+//Slots that equipment can be placed in
 public enum EquipmentSlot { Head, Chest, Legs, RHand, LHand, Feet}
\ No newline at end of file

@@ -15,6 +15,7 @@ public class Item : ScriptableObject
         user = interactor;
     }
 
+    //removes item from users inventory
     public void RemoveFromInventory ()
     {
         user.GetComponent<Inventory>().Remove(this);

 using UnityEngine;
 
+//Put this on any item in the game that can be picked up and put in an inventory
 public class Item_Pickup : Interactable
 {
     public Item item;
 
+    //Interactable 
     public override void Interact(GameObject interactor)
     {
         base.Interact(interactor);
@@ -11,6 +13,7 @@ public class Item_Pickup : Interactable
         Pickup(interactor);
     }
 
+    //picks up item and puts it into the inventory of the character that picked it up
     void Pickup(GameObject interactor)
     {
         Debug.Log("Picking up " + item.name);

@@ -4,6 +4,8 @@ using UnityEngine;
 
 public class PlayerManager : MonoBehaviour
 {
+    //Singleton class for controling player characters
+
     #region Singleton
     public static PlayerManager instance;
 
@@ -13,7 +15,47 @@ public class PlayerManager : MonoBehaviour
     }
 
     #endregion
+    public delegate void OnCharacterChange();
+    public OnCharacterChange onCharacterChangeCallback;
 
     public GameObject player1;
-    public GameObject player2 = null;
+    public GameObject player2;
+
+    public Player_Controller activePerson;
+
+    void Start()
+    {
+        activePerson = player1.GetComponent<Player_Controller>();
+        player1.GetComponent<Player_Controller>().activeCharacter = true;
+        player2.GetComponent<Player_Controller>().activeCharacter = false;
+    }
+
+    void Update()
+    {
+        //press 1 on keyboard to switch to character 1
+        if (Input.GetKeyDown(KeyCode.Alpha1))
+        {
+            player1.GetComponent<Player_Controller>().activeCharacter = true;
+            player2.GetComponent<Player_Controller>().activeCharacter = false;
+            activePerson = player1.GetComponent<Player_Controller>();
+
+            if (onCharacterChangeCallback != null)
+            {
+                onCharacterChangeCallback.Invoke();
+            }
+        }
+
+        //press 2 on keyboard to switch to character 2
+        if (Input.GetKeyDown(KeyCode.Alpha2))
+        {
+            player1.GetComponent<Player_Controller>().activeCharacter = false;
+            player2.GetComponent<Player_Controller>().activeCharacter = true;
+            activePerson = player2.GetComponent<Player_Controller>();
+
+            if (onCharacterChangeCallback != null)
+            {
+                onCharacterChangeCallback.Invoke();
+            }
+        }
+    }
 }

@@ -6,8 +6,10 @@ using UnityEngine;
 public class Player_Controller : MonoBehaviour
 {
     public LayerMask moveMask;
-
     public Interactable focus;
+    PlayerManager playerManager;
+
+    public bool activeCharacter;
 
     Camera cam;
 
@@ -16,6 +18,8 @@ public class Player_Controller : MonoBehaviour
     // Start is called before the first frame update
     void Start()
     {
+        playerManager = PlayerManager.instance;
+
         cam = Camera.main;
         movement = GetComponent<Player_Movement>();
     }
@@ -23,8 +27,16 @@ public class Player_Controller : MonoBehaviour
     // Update is called once per frame
     void Update()
     {
+        if (activeCharacter == false && focus == null)
+        {
+            movement.FollowTarget(playerManager.activePerson.gameObject);
+            
+            return; 
+        }
+
         if (EventSystem.current.IsPointerOverGameObject()) return;
 
+        //shoots ray from mouse position, then moves player to target position
         if (Input.GetMouseButtonDown(0))
         {
             Ray ray = cam.ScreenPointToRay(Input.mousePosition);
@@ -32,7 +44,7 @@ public class Player_Controller : MonoBehaviour
 
             if (Physics.Raycast(ray, out hit, 100))
             {
-                Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
+                //Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
                 //Left mouse button click move
 
                 movement.MovetoPoint(hit.point);
@@ -42,6 +54,7 @@ public class Player_Controller : MonoBehaviour
             }
         }
 
+        //shoots ray from mouse position, if it hits an Interactable object, then that becomes the player's focus
         if (Input.GetMouseButtonDown(1))
         {
             Ray ray = cam.ScreenPointToRay(Input.mousePosition);
@@ -52,16 +65,18 @@ public class Player_Controller : MonoBehaviour
                 Interactable interactable = hit.collider.GetComponent<Interactable>();
                 if (interactable != null)
                 {
+                    //Debug.Log("We hit: " + hit.collider.name + " " + hit.point);
                     SetFocus(interactable);
-                
                 }
-                
-
             }
         }
 
+
+
     }
 
+    //Sets the player's focus
+    //if there was a focus already, then stop focusing on old focus
     void SetFocus(Interactable newFocus)
     {
         if (newFocus != focus)
@@ -70,13 +85,17 @@ public class Player_Controller : MonoBehaviour
                 focus.OnDefocused();
 
             focus = newFocus;
+
+            //Moves character to focus location
             movement.FollowTarget(newFocus);
         }
 
+        //Tells interactable that they are being focused by the player
         newFocus.OnFocused(transform);
         
     }
 
+    //removes the player's current focus
     void RemoveFocus()
     {
         if (focus != null)

@@ -37,6 +37,13 @@ public class Player_Movement : MonoBehaviour
         target = newTarget.interactionTransform;
     }
 
+    public void FollowTarget(GameObject newTarget)
+    {
+        agent.stoppingDistance = 3 * 0.8f;
+        agent.updateRotation = false;
+        target = newTarget.transform;
+    }
+
     public void StopFollowTarget()
     {
         agent.stoppingDistance = 0f;

@@ -10,10 +10,10 @@ public class Player_Stats : Character_Stats
     void Start()
     {
         equipManager = GetComponent<EquipmentManager>();
-        equipManager.onEquipmentChanged += OnEquipmentChanged;  
+        equipManager.onEquipmentChanged += OnEquipmentChanged; 
+        
     }
 
-
     void OnEquipmentChanged (Equipment newItem, Equipment oldItem)
     {
         
@@ -30,4 +30,10 @@ public class Player_Stats : Character_Stats
         }
         
     }
+
+    public override void Die()
+    {
+        base.Die();
+        //player dies
+    }
 }

@@ -7,24 +7,28 @@ using UnityEngine;
 public class Stat 
 {
     [SerializeField]
-    private int baseValue;
+    private float baseValue;
 
-    private List<int> mods = new List<int>();
+    //list of modifiers for the stat
+    private List<float> mods = new List<float>();
 
-    public int GetValue() 
+    //returns base stat value + or - all mods in list
+    public float GetValue() 
     {
-        int finalValue = baseValue;
+        float finalValue = baseValue;
         mods.ForEach(x => finalValue += x);
         return finalValue; 
     }
 
-    public void AddModifier(int modifier)
+    //adds new mod to stat list
+    public void AddModifier(float modifier)
     {
         if (modifier != 0)
             mods.Add(modifier);
     }
 
-    public void RemoveModifier (int modifier)
+    //removes mod from stat list
+    public void RemoveModifier (float modifier)
     {
         if (modifier != 0)
             mods.Remove(modifier);

+fileFormatVersion: 2
+guid: 222d49e3fa5db0942966ef311d623272
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 9a40401784437aa48bf06c3387427385, type: 3}
+  m_Name: Test AOE Ability
+  m_EditorClassIdentifier: 
+  name: New Ability
+  description: ability does thing
+  icon: {fileID: 0}
+  buffList: 
+  debuffList: 
+  doesDamage: 0
+  doesHealing: 0
+  abilityValue: 0
+  duration: 0
+  cooldown: 0
+  areaSize: 0
+  aoeType: 0
+  targetType: 0
+  endPoint: 0
+  damageMod: 0
+  origin: {fileID: 0}
+  targets: []

+fileFormatVersion: 2
+guid: ffefd5183a5978848a3db6f4d4bd27c7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 29ae035edc32de447921400b0ecd43ed, type: 3}
+  m_Name: Test Target Ability
+  m_EditorClassIdentifier: 
+  name: New Ability
+  description: ability does thing
+  icon: {fileID: 10913, guid: 0000000000000000f000000000000000, type: 0}
+  buffList: 
+  debuffList: 
+  doesDamage: 0
+  doesHealing: 0
+  abilityValue: 0
+  duration: 0
+  cooldown: 0
+  targetType: 0

+fileFormatVersion: 2
+guid: 9a814e38b88c05b44a279668bdbe1828
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 68a50c088b022f048bff1cdf765a676a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

@@ -52,3 +52,15 @@ Update Mode: updateDependencies
 The following packages were updated:
   com.unity.ide.vscode from version 1.1.4 to 1.2.3
   com.unity.test-framework from version 1.1.13 to 1.1.19
+
+=== Tue Jan  5 13:14:13 2021
+
+Packages were changed.
+Update Mode: updateDependencies
+
+The following packages were added:
+  com.unity.ide.visualstudio@2.0.5
+The following packages were updated:
+  com.unity.collab-proxy from version 1.2.16 to 1.3.9
+  com.unity.ide.rider from version 1.1.4 to 1.2.1
+  com.unity.textmeshpro from version 2.0.1 to 3.0.1

 {
   "dependencies": {
-    "com.unity.collab-proxy": "1.2.16",
-    "com.unity.ide.rider": "1.1.4",
+    "com.unity.collab-proxy": "1.3.9",
+    "com.unity.ide.rider": "1.2.1",
+    "com.unity.ide.visualstudio": "2.0.5",
     "com.unity.ide.vscode": "1.2.3",
     "com.unity.test-framework": "1.1.19",
-    "com.unity.textmeshpro": "2.0.1",
+    "com.unity.textmeshpro": "3.0.1",
     "com.unity.timeline": "1.2.14",
     "com.unity.ugui": "1.0.0",
     "com.unity.modules.ai": "1.0.0",

 {
   "dependencies": {
     "com.unity.collab-proxy": {
-      "version": "1.2.16",
+      "version": "1.3.9",
       "depth": 0,
       "source": "registry",
       "dependencies": {},
@@ -15,7 +15,7 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.ide.rider": {
-      "version": "1.1.4",
+      "version": "1.2.1",
       "depth": 0,
       "source": "registry",
       "dependencies": {
@@ -23,6 +23,13 @@
       },
       "url": "https://packages.unity.com"
     },
+    "com.unity.ide.visualstudio": {
+      "version": "2.0.5",
+      "depth": 0,
+      "source": "registry",
+      "dependencies": {},
+      "url": "https://packages.unity.com"
+    },
     "com.unity.ide.vscode": {
       "version": "1.2.3",
       "depth": 0,
@@ -42,7 +49,7 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.textmeshpro": {
-      "version": "2.0.1",
+      "version": "3.0.1",
       "depth": 0,
       "source": "registry",
       "dependencies": {
@@ -199,6 +206,18 @@
       "depth": 0,
       "source": "builtin",
       "dependencies": {
+        "com.unity.modules.ui": "1.0.0",
+        "com.unity.modules.imgui": "1.0.0",
+        "com.unity.modules.jsonserialize": "1.0.0",
+        "com.unity.modules.uielementsnative": "1.0.0"
+      }
+    },
+    "com.unity.modules.uielementsnative": {
+      "version": "1.0.0",
+      "depth": 1,
+      "source": "builtin",
+      "dependencies": {
+        "com.unity.modules.ui": "1.0.0",
         "com.unity.modules.imgui": "1.0.0",
         "com.unity.modules.jsonserialize": "1.0.0"
       }

@@ -9,9 +9,12 @@ MonoBehaviour:
   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 13960, guid: 0000000000000000e000000000000000, type: 0}
+  m_Script: {fileID: 13964, guid: 0000000000000000e000000000000000, type: 0}
   m_Name: 
   m_EditorClassIdentifier: 
+  m_EnablePreviewPackages: 0
+  m_EnablePackageDependencies: 0
+  m_AdvancedSettingsExpanded: 1
   m_ScopedRegistriesSettingsExpanded: 1
   oneTimeWarningShown: 0
   m_Registries:
@@ -20,6 +23,7 @@ MonoBehaviour:
     m_Url: https://packages.unity.com
     m_Scopes: []
     m_IsDefault: 1
+    m_Capabilities: 7
   m_UserSelectedRegistryName: 
   m_UserAddingNewScopedRegistry: 0
   m_RegistryInfoDraft:
@@ -30,6 +34,7 @@ MonoBehaviour:
       m_Url: 
       m_Scopes: []
       m_IsDefault: 0
+      m_Capabilities: 0
     m_Modified: 0
     m_Name: 
     m_Url: 

-m_EditorVersion: 2019.4.16f1
-m_EditorVersionWithRevision: 2019.4.16f1 (e05b6e02d63e)
+m_EditorVersion: 2020.1.16f1
+m_EditorVersionWithRevision: 2020.1.16f1 (f483ad6465d6)

@@ -3,7 +3,9 @@
 --- !u!78 &1
 TagManager:
   serializedVersion: 2
-  tags: []
+  tags:
+  - Enemy
+  - Ally
   layers:
   - Default
   - TransparentFX

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!890905787 &1
+VersionControlSettings:
+  m_ObjectHideFlags: 0
+  m_Mode: Visible Meta Files
+  m_CollabEditorSettings:
+    inProgressEnabled: 1

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!162 &1
+EditorUserSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 4
+  m_ConfigSettings:
+    vcSharedLogLevel:
+      value: 0d5e400f0650
+      flags: 0
+  m_VCAutomaticAdd: 1
+  m_VCDebugCom: 0
+  m_VCDebugCmd: 0
+  m_VCDebugOut: 0
+  m_SemanticMergeMode: 2
+  m_VCShowFailedCheckout: 1
+  m_VCOverwriteFailedCheckoutAssets: 1
+  m_VCOverlayIcons: 1
+  m_VCAllowAsyncUpdate: 0