Inheritance: ICombatEntity
Beispiel #1
0
 public static void Serialize(BinaryWriter s, RTSTeam team)
 {
     s.Write(team.Type);
     RTSRace.Serialize(s, team.Race);
     if (team.Input != null)
     {
         s.Write(true);
         s.Write(ReflectedScript.GetKey(team.Input));
         team.Input.Serialize(s);
     }
     else
     {
         s.Write(false);
     }
     s.Write(team.ColorScheme.Name);
     s.Write(team.ColorScheme.Primary);
     s.Write(team.ColorScheme.Secondary);
     s.Write(team.ColorScheme.Tertiary);
     s.Write(team.Buildings.Count);
     foreach (var building in team.Buildings)
     {
         RTSBuilding.Serialize(s, building);
     }
     s.Write(team.Units.Count);
     foreach (var unit in team.Units)
     {
         RTSUnit.Serialize(s, unit);
     }
     s.Write(team.Squads.Count);
     foreach (var squad in team.Squads)
     {
         RTSSquad.Serialize(s, squad);
     }
 }
Beispiel #2
0
 public override void SetUnit(RTSUnit u)
 {
     base.SetUnit(u);
     if(unit != null) {
         unit.OnAttackMade += unit_OnAttackMade;
     }
 }
Beispiel #3
0
 public static void Serialize(BinaryWriter s, RTSUnit e)
 {
     s.Write(e.Data.Index);
     s.Write(e.UUID);
     s.Write(e.State);
     s.Write(e.ViewDirection);
     s.Write(e.GridPosition);
     s.Write(e.Height);
     if (e.Target != null)
     {
         s.Write(true);
         s.Write(e.Target.UUID);
     }
     else
     {
         s.Write(false);
     }
     s.Write(e.Health);
     s.Write(e.MovementMultiplier);
     s.Write(e.Resources);
     if (e.ActionController != null)
     {
         s.Write(true);
         e.ActionController.Serialize(s);
     }
     else
     {
         s.Write(false);
     }
     if (e.CombatController != null)
     {
         s.Write(true);
         e.CombatController.Serialize(s);
     }
     else
     {
         s.Write(false);
     }
     if (e.MovementController != null)
     {
         s.Write(true);
         e.MovementController.Serialize(s);
     }
     else
     {
         s.Write(false);
     }
     if (e.AnimationController != null)
     {
         s.Write(true);
         e.AnimationController.Serialize(s);
     }
     else
     {
         s.Write(false);
     }
 }
Beispiel #4
0
        // Computes The Damage To Deal With Access To A Random Number And A Target
        public int ComputeDamage(double rand)
        {
            RTSUnit t   = Target as RTSUnit;
            int     dmg = Data.BaseCombatData.ComputeDamageDealt(rand);

            if (t != null)
            {
                dmg = t.Data.BaseCombatData.ComputeDamageReceived(dmg);
            }
            return(dmg);
        }
 public override void SetUnit(RTSUnit u)
 {
     base.SetUnit(u);
     if(unit != null) {
         // Prevent Units From Running Toward The Location Of A Killed Target
         unit.OnNewTarget += (S, T) => {
             if(mc != null && T == null)
                 mc.Waypoints = null;
         };
     }
 }
Beispiel #6
0
        // Unit Addition And Removal
        public RTSUnit AddUnit(int type, Vector2 pos)
        {
            // Check For Unit Type Existence
            RTSUnitData data = Race.Units[type];

            if (data == null)
            {
                DevConsole.AddCommand("data null");
                return(null);
            }
            // Check For Unit Cap
            if (data.CurrentCount >= data.MaxCount)
            {
                return(null);
            }

            // Check For Population Cap
            if (data.PopulationCost + Population > PopulationCap)
            {
                return(null);
            }

            // Check For Capital Cost
            if (data.CapitalCost > Capital)
            {
                return(null);
            }

            // Produce Unit
            Capital    -= data.CapitalCost;
            Population += data.PopulationCost;
            data.CurrentCount++;

            // Create Unit
            RTSUnit unit = new RTSUnit(this, data, pos);

            unit.ActionController    = data.DefaultActionController.CreateInstance <ACUnitActionController>();
            unit.AnimationController = data.DefaultAnimationController.CreateInstance <ACUnitAnimationController>();
            unit.MovementController  = data.DefaultMoveController.CreateInstance <ACUnitMovementController>();
            unit.CombatController    = data.DefaultCombatController.CreateInstance <ACUnitCombatController>();
            Units.Add(unit);
            if (OnUnitSpawn != null)
            {
                OnUnitSpawn(unit);
            }
            return(unit);
        }
Beispiel #7
0
        public void Remove(RTSUnit u)
        {
            // Make Sure Unit Is In The Squad
            if (u.Squad == this)
            {
                // Remove All References
                units.Remove(u);
                u.OnDestruction -= OnUnitDestruction;

                // Send Update Event
                if (OnUnitRemoval != null)
                {
                    OnUnitRemoval(this, u);
                }

                // Check Death Condition
                if (IsDead && OnDeath != null)
                {
                    OnDeath(this);
                }
            }
        }
Beispiel #8
0
        // Adds A Combatant To This Squad
        public void Add(RTSUnit u)
        {
            // Units Cannot Be Added Twice
            if (u.Squad == this)
            {
                return;
            }

            // Squad Invariant Performed Here
            if (u.Squad != null)
            {
                u.Squad.Remove(u);
            }

            u.Squad = this;
            units.Add(u);
            u.OnDestruction += OnUnitDestruction;
            if (OnUnitAddition != null)
            {
                OnUnitAddition(this, u);
            }
        }
 public BTaskUnitDecision(GameState g, RTSUnit u)
     : base(1)
 {
     unit = u;
     state = g;
 }
        private void AddTask(GameState s, RTSUnit unit)
        {
            // Init The Unit
            if(unit.CombatController != null) unit.CombatController.Init(s, this, unit.Data.CombatControllerInitArgs);
            if(unit.MovementController != null) unit.MovementController.Init(s, this, unit.Data.MovementControllerInitArgs);
            if(unit.AnimationController != null) unit.AnimationController.Init(s, this, unit.Data.AnimationControllerInitArgs);
            if(unit.ActionController != null) unit.ActionController.Init(s, this, unit.Data.ActionControllerInitArgs);

            var btu = new BTaskUnitDecision(s, unit);
            unit.OnDestruction += (o) => {
                tbEntityDecisions.RemoveTask(btu);
            };
            tbEntityDecisions.AddTask(btu);
        }
Beispiel #11
0
        // Unit Addition And Removal
        public RTSUnit AddUnit(int type, Vector2 pos)
        {
            // Check For Unit Type Existence
            RTSUnitData data = Race.Units[type];
            if (data == null) {
                DevConsole.AddCommand("data null");
                return null;
            }
            // Check For Unit Cap
            if(data.CurrentCount >= data.MaxCount) return null;

            // Check For Population Cap
            if(data.PopulationCost + Population > PopulationCap) return null;

            // Check For Capital Cost
            if(data.CapitalCost > Capital) return null;

            // Produce Unit
            Capital -= data.CapitalCost;
            Population += data.PopulationCost;
            data.CurrentCount++;

            // Create Unit
            RTSUnit unit = new RTSUnit(this, data, pos);
            unit.ActionController = data.DefaultActionController.CreateInstance<ACUnitActionController>();
            unit.AnimationController = data.DefaultAnimationController.CreateInstance<ACUnitAnimationController>();
            unit.MovementController = data.DefaultMoveController.CreateInstance<ACUnitMovementController>();
            unit.CombatController = data.DefaultCombatController.CreateInstance<ACUnitCombatController>();
            Units.Add(unit);
            if(OnUnitSpawn != null)
                OnUnitSpawn(unit);
            return unit;
        }
Beispiel #12
0
 public override void SetUnit(RTSUnit u)
 {
     base.SetUnit(u);
     if(unit != null) {
         unit.OnAttackMade += unit_OnAttackMade;
         unit.OnDestruction += unit_OnDestruction;
         unit.OnDamage += unit_OnDamage;
     }
 }
 public void OnUnitSpawn(RTSUnit u)
 {
     if(u.Data == Data)
         instances.Add(u);
 }
 private void OnUnitSpawn(RTSUnit u)
 {
     ImpactRegion r = FindRegion(u);
     r.Selected.Add(u);
     r.PopCount++;
     u.OnDestruction += OnUnitDeath;
 }
Beispiel #15
0
 public static void Serialize(BinaryWriter s, RTSUnit e)
 {
     s.Write(e.Data.Index);
     s.Write(e.UUID);
     s.Write(e.State);
     s.Write(e.ViewDirection);
     s.Write(e.GridPosition);
     s.Write(e.Height);
     if(e.Target != null) {
         s.Write(true);
         s.Write(e.Target.UUID);
     }
     else {
         s.Write(false);
     }
     s.Write(e.Health);
     s.Write(e.MovementMultiplier);
     s.Write(e.Resources);
     if(e.ActionController != null) {
         s.Write(true);
         e.ActionController.Serialize(s);
     }
     else {
         s.Write(false);
     }
     if(e.CombatController != null) {
         s.Write(true);
         e.CombatController.Serialize(s);
     }
     else {
         s.Write(false);
     }
     if(e.MovementController != null) {
         s.Write(true);
         e.MovementController.Serialize(s);
     }
     else {
         s.Write(false);
     }
     if(e.AnimationController != null) {
         s.Write(true);
         e.AnimationController.Serialize(s);
     }
     else {
         s.Write(false);
     }
 }
 public static bool IsUnitDead(RTSUnit u)
 {
     return IsEntityDead(u);
 }
Beispiel #17
0
        public void Remove(RTSUnit u)
        {
            // Make Sure Unit Is In The Squad
            if(u.Squad == this) {
                // Remove All References
                units.Remove(u);
                u.OnDestruction -= OnUnitDestruction;

                // Send Update Event
                if(OnUnitRemoval != null)
                    OnUnitRemoval(this, u);

                // Check Death Condition
                if(IsDead && OnDeath != null)
                    OnDeath(this);
            }
        }
Beispiel #18
0
        // Adds A Combatant To This Squad
        public void Add(RTSUnit u)
        {
            // Units Cannot Be Added Twice
            if(u.Squad == this) return;

            // Squad Invariant Performed Here
            if(u.Squad != null) u.Squad.Remove(u);

            u.Squad = this;
            units.Add(u);
            u.OnDestruction += OnUnitDestruction;
            if(OnUnitAddition != null)
                OnUnitAddition(this, u);
        }
Beispiel #19
0
        public static RTSTeam Deserialize(BinaryReader s, int index, GameState state)
        {
            int     t    = s.ReadInt32();
            RTSTeam team = new RTSTeam(index, t);

            team.Race = RTSRace.Deserialize(s, state);
            if (s.ReadBoolean())
            {
                string it = s.ReadString();
                team.Input = state.Scripts[it].CreateInstance <ACInputController>();
                team.Input.Deserialize(s);
                team.Input.Init(state, index, null);
            }

            RTSColorScheme scheme = new RTSColorScheme();

            scheme.Name      = s.ReadString();
            scheme.Primary   = s.ReadVector3();
            scheme.Secondary = s.ReadVector3();
            scheme.Tertiary  = s.ReadVector3();
            team.ColorScheme = scheme;

            int?       target;
            var        du = new Dictionary <int, RTSUnit>();
            List <int> su;

            int         c = s.ReadInt32();
            RTSBuilding building;

            for (int i = 0; i < c; i++)
            {
                building = RTSBuilding.Deserialize(s, team, out target);
                team.buildings.Add(building);
                if (target.HasValue)
                {
                    // TODO: Add A Target Binding
                }
                state.CGrid.Add(building);
            }

            c = s.ReadInt32();
            RTSUnit unit;

            for (int i = 0; i < c; i++)
            {
                unit = RTSUnit.Deserialize(s, team, out target);
                du.Add(unit.UUID, unit);
                team.units.Add(unit);
                if (target.HasValue)
                {
                    // TODO: Add A Target Binding
                }
            }

            c = s.ReadInt32();
            RTSSquad squad;

            for (int i = 0; i < c; i++)
            {
                squad = RTSSquad.Deserialize(s, team, out su);
                team.squads.Add(squad);
                foreach (int uuid in su)
                {
                    if (du.TryGetValue(uuid, out unit))
                    {
                        squad.Add(unit);
                    }
                    else
                    {
                        throw new Exception("Could Not Find A Unit With The Specified UUID");
                    }
                }
            }
            return(team);
        }
Beispiel #20
0
        public static RTSUnit Deserialize(BinaryReader s, RTSTeam team, out int?target)
        {
            int     type = s.ReadInt32();
            RTSUnit e    = team.AddUnit(type, Vector2.Zero);

            if (e == null)
            {
                throw new Exception("Could Not Create A Unit That Was Previously Created");
            }
            e.UUID          = s.ReadInt32();
            e.State         = s.ReadInt32();
            e.ViewDirection = s.ReadVector2();
            e.GridPosition  = s.ReadVector2();
            e.Height        = s.ReadSingle();
            if (s.ReadBoolean())
            {
                target = s.ReadInt32();
            }
            else
            {
                target = null;
            }
            e.Health             = s.ReadInt32();
            e.MovementMultiplier = s.ReadSingle();
            e.Resources          = s.ReadInt32();
            if (s.ReadBoolean())
            {
                if (e.ActionController != null)
                {
                    e.ActionController.Deserialize(s);
                }
            }
            else
            {
                e.ActionController = null;
            }
            if (s.ReadBoolean())
            {
                if (e.CombatController != null)
                {
                    e.CombatController.Deserialize(s);
                }
            }
            else
            {
                e.CombatController = null;
            }
            if (s.ReadBoolean())
            {
                if (e.MovementController != null)
                {
                    e.MovementController.Deserialize(s);
                }
            }
            else
            {
                e.MovementController = null;
            }
            if (s.ReadBoolean())
            {
                if (e.AnimationController != null)
                {
                    e.AnimationController.Deserialize(s);
                }
            }
            else
            {
                e.AnimationController = null;
            }
            return(e);
        }
        public void SetData(RTSUnit u)
        {
            if(prevUnit != null)
                prevUnit.OnDamage -= u_OnDamage;
            prevUnit = u;

            u.OnDamage += u_OnDamage;
            rectHealthFore.Width = (int)(u.GetHealthRatio() * uic.IconSize);
            rectHealthFore.Color = Color.Lerp(uic.HealthMinColor, uic.HealthMaxColor, u.GetHealthRatio());

            Texture2D t;
            if(iconLib.TryGetValue(u.IconKey, out t)) {
                icon.Texture = t;
            }

            txtName.Text = u.Data.FriendlyName;
            uiCStats.SetStats(u.Data.BaseCombatData);
        }
 public void OnUnitSpawn(RTSUnit u)
 {
     DevConsole.AddCommand("spawn");
     Point cc = HashHelper.Hash(u.GridPosition, GameState.CGrid.numCells, GameState.CGrid.size);
     RTSBuilding b = GameState.CGrid.EStatic[cc.X, cc.Y];
     if (b != null) {
         foreach (var bc in barracksControllers) {
             if (b.UUID == bc.barracks.UUID) {
                 bc.army.Add(u);
                 u.OnDestruction += bc.OnUnitDeath;
             }
         }
     }
 }