Exemplo n.º 1
0
        public bool Update(GameTime time)
        {
            if (IsPaused)
            {
                mLastTimeResources = time.TotalGameTime.TotalMilliseconds - (time.TotalGameTime.TotalMilliseconds - mLastTimeResources);
                foreach (var player in BuildingsByPlayer.Keys)
                {
                    foreach (var unit in BuildingsByPlayer[player])
                    {
                        if (unit.UnitType == UnitTypes.Quarry || unit.UnitType == UnitTypes.GoldMine)
                        {
                            unit.IsPaused(time);
                        }
                    }
                }
                return(false);
            }

            if (mLastTimeResources + 5000 < time.TotalGameTime.TotalMilliseconds)
            {
                foreach (var player in Resources.Keys)
                {
                    Resources[player][Unit.Resources.Gold]++;
                    Resources[player][Unit.Resources.Stone]++;
                }

                mLastTimeResources = time.TotalGameTime.TotalMilliseconds;
            }

            AddQueuedUnits();

            SpatialUnitsByPlayer.Update(UnitsByPlayer);

            TriggerAutoDefense(time);

            RunUnitLifecycle(time);


            if (CheckVictory())
            {
                return(true);
            }
            HeroRespawnManager.Update();
            mEnemy.Update(time);

            InGameTime(time);
            InGameStatistics();
            return(false);
        }
Exemplo n.º 2
0
        private void AttackNearbyEnemyUnits(Players player, Players otherPlayer)
        {
            foreach (var attackingUnit in UnitsByPlayer[player].OfType <IAttackingUnit>())
            {
                if (attackingUnit.HasTarget())
                {
                    continue;
                }

                var target = SpatialUnitsByPlayer.NearestUnit(otherPlayer,
                                                              attackingUnit.Position,
                                                              attackingUnit.GetRange(),
                                                              unit => Math.Abs(AttackModifiers.GetModifier(attackingUnit.UnitType, unit.UnitType)) >= float.Epsilon);
                if (target != null && target is IDamageableUnit attackedUnit)
                {
                    attackingUnit.SetTarget(attackedUnit, false);
                }
            }
        }
Exemplo n.º 3
0
        public bool IsValidBuildingPlace(Players playerId, Vector2 position, UnitTypes name, float rotation)
        {
            ABuilding unit;

            switch (name)
            {
            case UnitTypes.Gate:
                unit = new Gate(playerId, position, rotation, mGridSize);
                break;

            case UnitTypes.Wall:
                unit = new Wall(playerId, position, rotation, mGridSize);
                break;

            default:
                return(false);
            }

            var blockedFields  = unit.BlockedFields();
            var passableFields = unit.PassableFields();

            var validBuildPlace = !AreFieldsOccupied(blockedFields, passableFields);

            const int buildingRangeToEnemy = 5 * GameScreen.GridSize;

            foreach (var otherPlayer in UnitsByPlayer.Keys)
            {
                if (otherPlayer == Players.Global || otherPlayer == playerId)
                {
                    continue;
                }
                if (!validBuildPlace)
                {
                    break;
                }

                validBuildPlace &= SpatialUnitsByPlayer.UnitsInRange(otherPlayer, position * GameScreen.GridSize, buildingRangeToEnemy).Count == 0;
            }

            return(validBuildPlace);
        }