Пример #1
0
 public Alien(Alien alien)
     : base(alien)
 {
     OnDestroyedEvent += OnDestroy;
     DeltaX = alien.DeltaX;
     DeltaY = alien.DeltaY;
     Command = alien.Command;
 }
Пример #2
0
        public static List<Alien> Build(int playerNumber, int waveSize, int startX, int deltaX)
        {
            var map = Match.GetInstance().Map;
            var deltaY = playerNumber == 1 ? -1 : 1;
            var middleHeightOfMap = map.Height / 2;

            // make sure aliens dont go out of map
            while (map.IsOutOfXBounds(startX + 3 * deltaX * (waveSize - 1)))
            {
                startX -= 3 * deltaX;
            }

            // Spawn
            var wave = new List<Alien>();
            var alienY = middleHeightOfMap + deltaY;
            var alienX = startX;
            Alien alien = null;
            for (var i = 0; i < waveSize; i++)
            {
                try
                {
                    alien = new Alien(playerNumber) { X = alienX, Y = alienY };
                    alien.DeltaX = deltaX;

                    map.AddEntity(alien);
                    wave.Add(alien);

                    //test
                    Match.GetInstance().Map.AddTempEntity(new NodeEntity(Match.GetInstance().Depth, alien));
                }
                catch (CollisionException ex)
                {
                    var depth = Match.GetInstance().Depth;

                    var nodeAlien = new NodeEntity(depth, alien);
                    Match.GetInstance().Map.AddTempEntity(nodeAlien);//for undo purposes

                    //keep up with score kill special case
                    Match.GetInstance().Map.AddKillEntity(nodeAlien);
                    Match.GetInstance().Map.AddKillEntity(new NodeEntity(depth, ex.Entity, hasMoved: false, isKillLikely: true));

                    // Alien[0]
                    // Missile[1]

                    ex.Entity.Destroy();

                    if (ex.Entity.GetType() == typeof(Missile))
                    {
                        ((Missile)ex.Entity).ScoreKill(alien);
                    }
                }

                alienX += 3 * deltaX;
            }

            return wave;
        }
Пример #3
0
        private void IssueShootOrder(Alien alien)
        {
            if (alien == null) return;

            ShotEnergy -= ShotEnergyCost;

            switch (alien.Command)
            {
                case AlienCommand.MoveForward:
                    alien.Command = AlienCommand.MoveForwardAndShoot;
                    break;
                case AlienCommand.MoveSideways:
                    alien.Command = AlienCommand.MoveSidewaysAndShoot;
                    break;
            }
        }
Пример #4
0
        public void UndoIssueShootOrdersIfPossible(Alien shotAlien)
        {
            ShotEnergy--;
            if (shotAlien == null) return;
            ShotEnergy += ShotEnergyCost;

            switch (shotAlien.Command)
            {
                case AlienCommand.MoveForwardAndShoot:
                    shotAlien.Command = AlienCommand.MoveForward;
                    break;
                case AlienCommand.MoveSidewaysAndShoot:
                    shotAlien.Command = AlienCommand.MoveSideways;
                    break;
            }
        }
Пример #5
0
        public Alien TestAddAlien(int x, int y)
        {
            var alien = new Alien(PlayerNumber) { X = x, Y = y };
            Match.GetInstance().Map.AddEntity(alien);

            Waves.Insert(0, new List<Alien> { alien });
            return alien;
        }
Пример #6
0
        public void IssueShootOrdersIfPossible(Alien shotAlien)
        {
            if (_debugPreventShoot) return;

            if (_debugAllShoot)
            {
                TestIssueShootOrderToAll();
                return;
            }

            ChargeShotEnergy();
            if (!CanShoot()) return;

            IssueShootOrder(shotAlien);
        }