Esempio n. 1
0
        void LftClickedOnGameObject(GameObject obj)
        {
            var gameEntity = obj.GetComponent <AbstractGameObject>();

            if (gameEntity == null || (!FieldOfView.IsVisible(gameEntity) && ChunkManager.staticFogEnabled))
            {
                ClickedOnSpace();
                return;
            }


            if (_choosed)
            {
                var prevEnt = _choosedObj.GetComponent <GameEntity>();

                ClickedOnSpace();
                UnitBar_HTML.ClearUnitBar(prevEnt);
            }

            if (!GroupUtil.IsGround(gameEntity.Group))
            {
                ChooseUnit(gameEntity);
            }
            else
            {
                ClickedOnSpace();
            }
        }
Esempio n. 2
0
        public static void SubStats(AbstractGameObject ent, Stats stats)
        {
            ent.EntStats.SubStats(stats);
            ent.UpgradedStats.SubStats(stats);

            if (ClickManager.IsChoosed(ent.gameObject))
            {
                UnitBar_HTML.UpdateInfo(ent);
            }
        }
Esempio n. 3
0
        public static void ChooseUnit(AbstractGameObject obj)
        {
            AddChooser(obj);

            _choosedObj = obj.gameObject;
            _choosed    = true;

            UnitBar_HTML.SetupUnitBar(obj);
            AbilityBar_HTML.SetupAbilityBar(obj);
        }
Esempio n. 4
0
 void RemoveChoosedGUI()
 {
     if (_choosed)
     {
         var ent = _choosedObj.GetComponent <GameEntity>();
         UnitBar_HTML.ClearUnitBar(ent);
         AbilityBar_HTML.HideAbilityBar();
         // GUI_HpBar.RemoveHP(ent as AbstractGameObject);
         // GUI_UnitBar.RemoveBar(ent as AbstractGameObject);
     }
 }
Esempio n. 5
0
        public static void HealUnit(AbstractGameObject ent, int countHp)
        {
            var maxHp = ent.EntStats.Hp;
            var endHp = ent.UpgradedStats.Hp + countHp;

            if (endHp > maxHp)
            {
                endHp = maxHp;
            }
            ent.UpgradedStats.Hp = endHp;

            if (ClickManager.IsChoosed(ent.gameObject))
            {
                UnitBar_HTML.UpdateInfo(ent);
            }
        }
Esempio n. 6
0
        public void DealDamage(int dmg, AbstractGameObject from)
        {
            UpgradedStats.Hp -= dmg;
            GameSoundManager.PlayOnTakeDamage(PrefabIndex);

            UnitBar_HTML.UpdateInfo(this);
            if (UpgradedStats.Hp > 0)
            {
                return;
            }

            KillSelf();
            QuestManager.OnKilling(from, this);
            UnitEvents.OnKilling(from, this);
            PlayerEvents.OnKilling(from, this);
        }
Esempio n. 7
0
        public static bool AttackTo(UnitOrder order)
        {
            var ent    = order.GetUnit();
            var moveTo = order.GetTo();

            if (ent == null)
            {
                return(true);
            }
            var vec = (moveTo.Pos3D + ent.ExtraPos) - ent.transform.position;

            var chunk       = ChunkManager.GetChunkByNum(ent.ChunkNumber);
            var attackedObj = chunk.GetGameObjectByIndex(ChunkUtil.GetUpper(moveTo.Index));

            if (attackedObj == null)
            {
                return(MoveTo(ent));
            }

            var attackedEnt = attackedObj.GetComponent <GameUnit>();

            if (attackedEnt == null)
            {
                return(true);
            }
            if (attackedEnt.Owner == ent.Owner)
            {
                return(MoveTo(ent));
            }

            UnitBar_HTML.SetupUnitBar(attackedEnt);
            ent.State = EventManager.InProgressEvents.Attack;

            if (!ent.AlreadyAttacked && Mathf.Abs(vec.x) <= MinDist && Mathf.Abs(vec.y) <= MinDist)
            {
                // ent.transform.position = ent.Current3Dpos;
                ent.AlreadyAttacked = true;


                attackedEnt.DealDamage(ent.UpgradedStats.Dmg, ent);

                return(false);
            }
            if (ent.AlreadyAttacked)
            {
                var checkMove = MoveTo(ent);
                if (checkMove)
                {
                    ent.AlreadyAttacked = false;
                }

                return(false);
            }


            ent.MovingTo = moveTo;
            var moveSpeed = GameMoveManager.StaticMoveSpeed;

            var speedVec = vec * moveSpeed / 2f * Time.deltaTime;


            ent.transform.Translate(speedVec);
            return(false);
        }