Develop

.gitignore

@@ -13,6 +13,7 @@
 *.userprefs
 *.pidb
 *.booproj
+*.DS_Store
 
 # Unity3D generated meta files
 *.pidb.meta

Core/Game/Abilities/Ability.cs

@@ -9,7 +9,7 @@
 
 namespace Lockstep
 {
-    public abstract class Ability : CerealBehaviour
+    public abstract class Ability : MonoBehaviour//CerealBehaviour
     {
         private bool isCasting;
 
@@ -75,7 +75,6 @@ internal void Setup(LSAgent agent, int id)
                     mainType = mainType.BaseType;
                 }
                 Data = AbilityDataItem.FindInterfacer(mainType);
-
                 if (Data == null)
                 {
                     throw new System.ArgumentException("The Ability of type " + mainType + " has not been registered in database");
@@ -123,13 +122,19 @@ protected virtual void OnInitialize()
 
         internal void Simulate()
         {
+            TemplateSimulate ();
+
             OnSimulate();
             if (isCasting)
             {
                 OnCast();
             }
         }
 
+        protected virtual void TemplateSimulate () {
+
+        }
+
         protected virtual void OnSimulate()
         {
         }

Core/Game/Abilities/AbilityManager.cs

@@ -95,6 +95,16 @@ public void Deactivate() {
                 Abilitys[k].Deactivate();
             }
         }
+        public Ability GetAbility (string name) {
+            for (var k = 0; k < Abilitys.Length; k++) {
+                var ability = Abilitys[k];
+                if (ability.Data != null)
+                if (ability.Data.Name == name) {
+                    return ability;
+                }
+            }
+            return null;
+        }
         public T GetAbility<T>() where T : Ability {
             for (var k = 0; k < Abilitys.Length; k++) {
                 var ability = Abilitys[k] as T;

Core/Game/Abilities/ActiveAbility.cs

@@ -3,15 +3,31 @@
 namespace Lockstep {
     public abstract class ActiveAbility : Ability {
 
+        [SerializeField,FrameCount]
+        protected int _cooldown;
+        public int Cooldown {get {return _cooldown;}}
+
 		public ushort ListenInput {get; private set;}
 
+        private int _heat;
+        public int Heat {get {return _heat;}private set {_heat = value;}}
+
 		protected sealed override void TemplateSetup ()
 		{
             ListenInput = Data.ListenInputID;
 		}
 
         public void Execute(Command com) {
-            OnExecute(com);
+
+            if (Heat <= 0) {
+                OnExecute(com);
+                Heat = Cooldown;
+            }
+        }
+
+        protected override void TemplateSimulate()
+        {
+            Heat--;
         }
 
         protected virtual void OnExecute(Command com) {}

Core/Game/Abilities/Essential/Health.cs

@@ -4,81 +4,120 @@
 
 namespace Lockstep
 {
-	public class Health : Ability
-	{
-		[SerializeField, FixedNumber]
-		private long _maxHealth = FixedMath.One * 100;
+    public class Health : Ability
+    {
+        [SerializeField, FixedNumber]
+        private long _maxHealth = FixedMath.One * 100;
 
-		public long MaxHealth
-		{
-			get { return _maxHealth; }
-			set { _maxHealth = value; }
-		}
+        public long MaxHealth
+        {
+            get { return _maxHealth; }
+        }
+
+        public long DamageMultiplier
+        {
+            get;
+            set;
+        }
 
         public event Action onHealthChange;
-        private long _healthAmount;
-		public long HealthAmount {
+
+        public bool CanLose {
+            get {
+                return HealthAmount > 0;
+            }
+        }
+        public bool CanGain {
             get {
-                return _healthAmount;
+                return HealthAmount < MaxHealth;
+            }
+        }
+
+        [SerializeField, FixedNumber]
+        private long _currentHealth;
+
+        public long HealthAmount
+        {
+            get
+            {
+                return _currentHealth;
             }
-            set {
-                _healthAmount = value;
+            set
+            {
+                _currentHealth = value;
                 if (onHealthChange != null)
-                onHealthChange ();
+                    onHealthChange();
             }
 
         }
 
-		protected override void OnSetup()
-		{
-		}
-
-		protected override void OnInitialize()
-		{
-			HealthAmount = MaxHealth;
-			OnTakeProjectile = null;
-		}
-
-		public void TakeProjectile(LSProjectile projectile)
-		{
-			if (Agent.IsActive && HealthAmount >= 0) {
-				if (OnTakeProjectile .IsNotNull ()) 
-				{
-					OnTakeProjectile (projectile);
-				}
-				TakeRawDamage (projectile.CheckExclusiveDamage (Agent.Tag));               
-			}
-		}
-
-		public void TakeRawDamage (long damage) {
-			HealthAmount -= damage;
-			// don't let the health go below zero
-			if (HealthAmount <= 0) {
-				HealthAmount = 0;
-
-				if (HealthAmount <= 0) {
-					Die ();
-					return;
-				}
-			}
+        protected override void OnSetup()
+        {
+        }
+
+        protected override void OnInitialize()
+        {
+            HealthAmount = MaxHealth;
+            OnTakeProjectile = null;
+        }
+
+        public void TakeProjectile(LSProjectile projectile)
+        {
+            if (Agent.IsActive && HealthAmount >= 0)
+            {
+                if (OnTakeProjectile.IsNotNull())
+                {
+                    OnTakeProjectile(projectile);
+                }
+                TakeDamage(projectile.CheckExclusiveDamage(Agent.Tag));               
+            }
+        }
 
+        public void TakeDamage(long damage)
+        {
+            if (damage >= 0)
+            {
+                damage.Mul(DamageMultiplier);
+                HealthAmount -= damage;
+                // don't let the health go below zero
+                if (HealthAmount <= 0)
+                {
+                    HealthAmount = 0;
+
+                    if (HealthAmount <= 0)
+                    {
+                        Die();
+                        return;
+                    }
+                }
+            }
+            else {
+                HealthAmount -= damage;
+                if (HealthAmount >= this.MaxHealth) {
+                    HealthAmount = MaxHealth;
+                }
+            }
 
-		}
+        }
 
-        public void Die () {
+        public void Die()
+        {
             AgentController.DestroyAgent(Agent);
-            if (Agent.Animator.IsNotNull ()) {
+            if (Agent.Animator.IsNotNull())
+            {
                 Agent.SetState(AnimState.Dying);
                 Agent.Animator.Visualize();
             }
         }
 
-        protected override void OnDeactivate() {
-			OnTakeProjectile = null;
-		}
+        protected override void OnDeactivate()
+        {
+            OnTakeProjectile = null;
+        }
+
+        public event Action<LSProjectile> OnTakeProjectile;
 
-		public event Action<LSProjectile> OnTakeProjectile;
-		public int shieldIndex {get; set;}
+        public int shieldIndex { get; set; }
 
 
     }

Core/Game/Abilities/Essential/HeightSet.cs

@@ -3,15 +3,17 @@
 
 namespace Lockstep
 {
+    [UnityEngine.DisallowMultipleComponent]
     public class HeightSet : Ability
     {
         [SerializeField]
         private int _mapIndex;
 
         public int MapIndex { get { return _mapIndex; } }
 
-        [SerializeField]
+        [SerializeField, FixedNumber]
         private long _bonusHeight;
+        public long BonusHeight {get {return _bonusHeight;}}
 
         private long _offset;
 

Core/Game/Abilities/Essential/Move.cs

@@ -9,7 +9,7 @@ public class Move : ActiveAbility
         public const long GroupDirectStop = FixedMath.One;
         public const long DirectStop = FixedMath.One / 8;
         private const int MinimumOtherStopTime = (int)(LockstepManager.FrameRate / 4);
-        private const int repathRate = (int)LockstepManager.FrameRate * 4 / 4;
+        private const int repathRate = (int)LockstepManager.FrameRate;
         private const int CollisionStopCount = LockstepManager.FrameRate * 2;
         private const long CollisionStopTreshold = FixedMath.One / 2;
 
@@ -26,7 +26,7 @@ public class Move : ActiveAbility
 
         private int RepathRate
         {
-            get { return LSUtility.GetRandom(FixedMath.Create(repathRate).Div(this.Speed).CeilToInt()); }
+            get { return FixedMath.Create(repathRate).Div(this.Speed).CeilToInt(); }
         }
 
         private const int straightRepathRate = repathRate * 4;
@@ -120,12 +120,22 @@ public bool CanMove {
 			get { return _canMove; }
 		}
 
-        [SerializeField]
-        private bool _canTurn = true;
-        public bool CanTurn {get; private set;}
-        [SerializeField, FixedNumber]
-        private long _speed = FixedMath.One * 4;
-        public long Speed {get {return _speed;}}
+		[SerializeField]
+		private bool _canTurn = true;
+		public bool CanTurn {get; private set;}
+
+		[SerializeField, FixedNumber]
+		private long _speed = FixedMath.One * 4;
+
+		public virtual long Speed
+		{
+			get { return _speed; }
+			//set { _speed = value; }
+            //This'll make Speed indeterministic across multiple sessions since the original value isn't stored and reset
+            //Underlying value can't be changed but we can make Speed virtual to return a modified value
+		}
+
+
         [SerializeField, FixedNumber]
         private long _acceleration = FixedMath.One;
         public long Acceleration {get {return _acceleration;}}
@@ -191,7 +201,7 @@ protected override void OnSimulate()
             {
                 if (CanPathfind)
                 {
-                    if (repathCount <= 0)
+                   if (repathCount <= 0)
                     {
                         if (viableDestination)
                         {
@@ -246,6 +256,7 @@ protected override void OnSimulate()
                                 }
                             } else
                             {
+
                             }
                         } else
                         {
@@ -264,7 +275,7 @@ protected override void OnSimulate()
                             repathCount--;
                         } else
                         {
-                            repathCount--;
+                            repathCount-= 2;
                         }
                     }
 
@@ -301,7 +312,7 @@ protected override void OnSimulate()
                 if (distance > closingDistance || movingToWaypoint)
                 {
                     desiredVelocity = (movementDirection);
-                    if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y).AbsMoreThan(FixedMath.Half))
+                    if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y).AbsMoreThan(FixedMath.One / 4))
                     {
                         lastMovementDirection = movementDirection;
                         if (CanTurn)
@@ -347,9 +358,11 @@ protected override void OnSimulate()
             }
         }
 
+        public Command LastCommand;
+
         protected override void OnExecute(Command com)
         {
-
+            LastCommand = com;
             if (com.ContainsData<Vector2d> ())
             {
                 Agent.StopCast(ID);