Beispiel #1
0
        //finds a spawning space for the player, trying the center first, with a minimum distance for spacing with asteroids
        public static Vector2 FindPlayerSpawnSpace(Asteroid[] Asteroids, double MinDistance)
        {
            bool TriedCenter = false;
            bool Successful = false;
            Vector2 Position = Vector2.Zero;

            do
            {
                if (!TriedCenter)
                {
                    Position = new Vector2(GameEngine.Width / 2, GameEngine.Height / 2);
                    TriedCenter = true;
                }
                else
                    Position = new Vector2(GameEngine.Width / 2, GameEngine.Height / 2) + Vector2.RandomVector2(new Vector2(-100, -100), new Vector2(100, 100));

                Successful = true;
                foreach (Asteroid asteroid in Asteroids)
                {
                    double Distance = asteroid.Position.EuclideanDistance(Position);

                    if (Distance < MinDistance)
                    {
                        Successful = false;
                        break;
                    }
                }
            }
            while (!Successful);

            return Position;
        }
Beispiel #2
0
        //finds  a spawning space for an asteroid with a minimum distance for spacing between asteroids
        public static Vector2 FindAsteroidSpawnSpace(Asteroid[] Asteroids, double MinDistance)
        {
            bool Successful = false;
            Vector2 Position = Vector2.Zero;

            do
            {
                Position = Vector2.RandomVector2(new Vector2(0,0), new Vector2(GameEngine.Width, GameEngine.Height));

                Successful = true;
                foreach(Asteroid other in Asteroids)
                {
                    double Distance = Position.EuclideanDistance(other.Position);

                    if(Distance < MinDistance)
                    {
                        Successful = false;
                        break;
                    }
                }
            }
            while(!Successful);

            return Position;
        }
Beispiel #3
0
 public Collision(Sprite playerSprite, Alien alien, BulletList bullets, Asteroid asteroids)
 {
     this.playerSprite = playerSprite;
     this.alien = alien;
     this.bullets = bullets;
     this.asteroids = asteroids;
 }
		public void CreateAsteroidsAtPosition(Vector2D position, int sizeMod = 1, int howMany = 2)
		{
			for (int asteroidCount = 0; asteroidCount < howMany; asteroidCount++)
			{
				var asteroid = new Asteroid(this, sizeMod);
				asteroid.SetWithoutInterpolation(new Rectangle(position, asteroid.DrawArea.Size));
			}
		}
Beispiel #5
0
 public AsteroidManager(
     Settings settings, Asteroid.Factory asteroidFactory, LevelHelper level)
 {
     _settings = settings;
     _timeIntervalBetweenSpawns = _settings.maxSpawnTime / (_settings.maxSpawns - _settings.startingSpawns);
     _timeToNextSpawn = _timeIntervalBetweenSpawns;
     _asteroidFactory = asteroidFactory;
     _level = level;
 }
Beispiel #6
0
        private void SpawnWave()
        {
            //Caps the asteroid count
            int asteroidCount = 4 + WavesSurvived;
            if (asteroidCount > MAX_ASTEROIDS) { asteroidCount = MAX_ASTEROIDS; }

            List<Asteroid>SpawnWave = new List<Asteroid>();

            for (int i = 0; i < asteroidCount; i++ )
            {
                Asteroid newAsteroid = new Asteroid(Game, FindAsteroidSpawnSpace(SpawnWave.ToArray(), 50), AsteroidSize.Large);
                SpawnWave.Add(newAsteroid);
            }

            foreach(Asteroid asteroid in SpawnWave)
                Game.SpawnAsteroid(asteroid);
        }
        private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            g.Clear(Color.Black);

            if (!bStarted)
            {
                String drawString = "Asteroids";
                // Create font and brush.
                Font       drawFont  = new Font("Verdana", 48);
                SolidBrush drawBrush = new SolidBrush(Color.Red);

                PointF drawPoint = new PointF(this.ClientRectangle.Width / 4, this.ClientRectangle.Height - iTextHolder);
                // Draw string to screen.
                e.Graphics.DrawString(drawString, drawFont, drawBrush, drawPoint);

                drawString = "AURORA";
                // Create font and brush.
                drawFont  = new Font("TIMES NEW ROMAN", 14);
                drawBrush = new SolidBrush(Color.White);

                drawPoint = new PointF(this.ClientRectangle.Width / 4, this.ClientRectangle.Height - (iTextHolder - 90));
                // Draw string to screen.
                e.Graphics.DrawString(drawString, drawFont, drawBrush, drawPoint);

                if (iTextHolder > this.ClientRectangle.Height + 25)
                {
                    iTextHolder = 25;
                }
                else
                {
                    iTextHolder = iTextHolder + 5;
                }

                return;
            }

            Bullet[] BulletArray = TheShip.BulletArray;
            // Move Ship
            if (TheShip.Active)
            {
                TheShip.Move();
                // check ship is not out of bounds
                TheShip.InRectangle(this.ClientRectangle);
            }
            // Move Bullets
            for (int i = 0; i < BulletArray.Length; i++)
            {
                // check if bullet is still in scope
                if (BulletArray[i] != null)
                {
                    if (BulletArray[i].Active)
                    {
                        BulletArray[i].Move();
                        // trim or reposition bullets
                        if (BulletArray[i].InRectangle(this.ClientRectangle))
                        {
                            BulletArray[i].Active = false;
                        }

                        // test ship & bullet collision
                        if (TheShip.Active)
                        {
                            if (BulletArray[i].IntersectsWith(TheShip.GetBounds(), TheShip.ShipImage))
                            {
                                BulletArray[i].Active = false;
                                TheShip.Active        = false;
                            }
                        }
                    }
                }
            }
            // Move Asteroids
            foreach (Asteroid A in AsteroidList)
            {
                A.Move();
                A.InRectangle(this.ClientRectangle);
            }

            // check for collisions
            for (int j = 0; j < AsteroidList.Count; j++)
            {
                Asteroid A = (Asteroid)AsteroidList[j];
                // if exploding nothing to do
                if (A.Exploding == false)
                {
                    // with bullets
                    for (int i = 0; i < BulletArray.Length; i++)
                    {
                        if (BulletArray[i] != null)
                        {
                            if (BulletArray[i].Active)
                            {
                                if (BulletArray[i].IntersectsWith(A.GetBounds(), A.AsteroidImage))
                                {
                                    A.Exploding = true;
                                    spawnMoreAsteroids(A);
                                    BulletArray[i].Active = false;
                                }
                            }
                        }
                    }

                    // with ship
                    if (TheShip.Active)
                    {
                        if (TheShip.IntersectsWith(A.GetBounds(), A.AsteroidImage))
                        {
                            A.Exploding = true;
                            spawnMoreAsteroids(A);
                            TheShip.Active = false;
                        }
                    }
                }
            }

            // trim any inactive asteroids
            for (int i = 0; i < AsteroidList.Count; i++)
            {
                Asteroid A = (Asteroid)AsteroidList[i];
                if (A.Active)
                {
                    A.Draw(g);
                }
                else
                {
                    AsteroidList.RemoveAt(i);
                }
            }

            for (int i = 0; i < BulletArray.Length; i++)
            {
                if (BulletArray[i] != null)
                {
                    if (BulletArray[i].Active)
                    {
                        BulletArray[i].Draw(g);
                    }
                }
            }

            if (TheShip.Active)
            {
                TheShip.DrawShip(g);
            }
        }
Beispiel #8
0
 public int LevelWinLose(Asteroid asteroid, Player player)
 {
     return(0);
 }
Beispiel #9
0
 private void SpawnAsteroid(Asteroid typeToSpawn, Vector2 position)
 {
     typeToSpawn.SpawnAsteroid(position, Random.insideUnitCircle.normalized);
     typeToSpawn.OnDestroyedEvent = OnEnemyDestroyed;
 }
Beispiel #10
0
        // clear all collisions associated with the specified asteroid
        private void clearCollisions(Asteroid a)
        {
            if(a == null) { return; }

            for(int i=0;i<m_asteroidSystem.size();i++) {
                Asteroid a2 = m_asteroidSystem.getAsteroid(i);
                if(a2.isCollidingWith(a)) {
                    a2.removeCollision(a);
                    a.removeCollision(a2);
                }
            }
        }
Beispiel #11
0
        // Called when [collision with asteroid].

        private void OnCollisionWithAsteroid(Asteroid asteroid)
        {
            asteroid.Collision(damage);
            OnEventDestroy();
        }
Beispiel #12
0
        public void SplitAsteroid()
        {
            // Asteroid has been marked for deletion so spawn smaller versions to fly off in random direction! (Don't split XS sprites)
            Random rand = new Random();

            switch (asteroidSprite.Name)
            {
            case "Enemies/AsteroidS":
                // Split into 4
                Asteroid[] xschildAsteroids = new Asteroid[4];
                for (int i = 0; i < 4; i++)
                {
                    Asteroid xstempAsteroid = new Asteroid();
                    xstempAsteroid.radius         = 1;
                    xstempAsteroid.speed          = rand.Next(200, 400);
                    xstempAsteroid.angle          = rand.Next(361);
                    xstempAsteroid.position       = this.position;
                    xstempAsteroid.offScreen      = false;
                    xstempAsteroid.asteroidSprite = AsteroidsGame.asteroidSprites[0];
                    xschildAsteroids[i]           = xstempAsteroid;
                }
                Asteroid.childAsteroids.AddRange(xschildAsteroids);
                break;

            case "Enemies/AsteroidM":
                // Split into 3
                Asteroid[] schildAsteroids = new Asteroid[3];
                for (int i = 0; i < 3; i++)
                {
                    Asteroid stempAsteroid = new Asteroid();
                    stempAsteroid.radius         = 5;
                    stempAsteroid.speed          = rand.Next(150, 350);
                    stempAsteroid.angle          = rand.Next(361);
                    stempAsteroid.position       = this.position;
                    stempAsteroid.offScreen      = false;
                    stempAsteroid.asteroidSprite = AsteroidsGame.asteroidSprites[1];
                    schildAsteroids[i]           = stempAsteroid;
                }
                Asteroid.childAsteroids.AddRange(schildAsteroids);
                break;

            case "Enemies/AsteroidL":
                // Split into 2
                Asteroid[] mchildAsteroids = new Asteroid[2];
                for (int i = 0; i < 2; i++)
                {
                    Asteroid mtempAsteroid = new Asteroid();
                    mtempAsteroid.radius         = 12;
                    mtempAsteroid.speed          = rand.Next(100, 300);
                    mtempAsteroid.angle          = rand.Next(361);
                    mtempAsteroid.position       = this.position;
                    mtempAsteroid.offScreen      = false;
                    mtempAsteroid.asteroidSprite = AsteroidsGame.asteroidSprites[2];
                    mchildAsteroids[i]           = mtempAsteroid;
                }
                Asteroid.childAsteroids.AddRange(mchildAsteroids);
                break;

            default:
                break;
            }
        }
Beispiel #13
0
        public void UpdateAsteroids(Asteroid asteroidSuper, GameTime theTime, List <SoundEffect> sounds)
        {
            Timer = theTime;
            theAsteroids[0].Visible = false;
            for (int i = 0; i < theAsteroids.Count; i++)
            {
                if (theAsteroids[i].Position.X < (0 - theAsteroids[i].Image.Width))
                {
                    theAsteroids[i].SetPositionX(Graphics.PreferredBackBufferWidth + theAsteroids[i].Image.Width);
                    // thePosition.X = Window.ClientBounds.Width + image.Width;
                    //thePosition = new Vector2(X,Y);
                }
                if (theAsteroids[i].Position.X > (Graphics.PreferredBackBufferWidth + theAsteroids[i].Image.Width))
                {
                    theAsteroids[i].SetPositionX(0 - theAsteroids[i].Image.Width);
                }
                if (theAsteroids[i].Position.Y < (0 - theAsteroids[i].Image.Height))
                {
                    theAsteroids[i].SetPositionY(Graphics.PreferredBackBufferHeight + theAsteroids[i].Image.Height);
                }


                if (theAsteroids[i].Position.Y > Graphics.PreferredBackBufferHeight + theAsteroids[i].Image.Height)
                {
                    theAsteroids[i].SetPositionY(0 - theAsteroids[i].Image.Height);
                }

                theAsteroids[i].SpriteRectangle = new Rectangle((int)theAsteroids[i].Position.X, (int)theAsteroids[i].Position.Y, theAsteroids[i].Image.Width, theAsteroids[i].Image.Height);


                theAsteroids[i].SetPosition(theAsteroids[i].Velocity + theAsteroids[i].Position);
                theAsteroids[i].ImageCenter = new Vector2(theAsteroids[i].SpriteRectangle.Width / 2, theAsteroids[i].SpriteRectangle.Height / 2);

                //Colllision
                for (int w = 0; w < AccessWeapons.TheWeapons.Count; w++)
                {
                    Weapon p = AccessWeapons;
                    if (i != 0)
                    {
                        if (Collided(theAsteroids[i], p.TheWeapons[w], theAsteroids[i].Image))
                        {
                            sounds[(int)Game1.Sounds.Boom].Play();

                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.Small)
                            {
                                Vector2 vtemp = theAsteroids[i].Velocity;
                                Vector2 ptemp = theAsteroids[i].Position;

                                theAsteroids.RemoveAt(i);
                                --i;

                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 2, (int)Asteroid.AsteroidType.ChunkSmall1, -VELOCITYE, VELOCITYE);



                                AccessWeapons.TheWeapons.RemoveAt(w);
                                --w;
                                AccessPlayer.Score += 100;
                            }
                            else if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.Medium)
                            {
                                Vector2 ptemp = theAsteroids[i].Position;
                                theAsteroids.RemoveAt(i);
                                --i;
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkMedium1, -VELOCITYE, VELOCITYE);

                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkMedium2, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkMedium3, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkMedium4, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkMedium5, -VELOCITYE, VELOCITYE);
                                AccessWeapons.TheWeapons.RemoveAt(w);
                                --w;

                                AccessPlayer.Score += 200;
                            }
                            else if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.Large)
                            {
                                Vector2 ptemp = theAsteroids[i].Position;
                                theAsteroids.RemoveAt(i);
                                --i;

                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkLarge1, -VELOCITYE, VELOCITYE);


                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkLarge2, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkLarge3, -VELOCITYE, VELOCITYE);
                                AccessWeapons.TheWeapons.RemoveAt(w);
                                --w;

                                AccessPlayer.Score += 300;
                            }
                            else if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ExtraLarge)
                            {
                                Vector2 ptemp = theAsteroids[i].Position;
                                theAsteroids.RemoveAt(i);
                                --i;

                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkExtra1, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkExtra2, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkExtra3, -VELOCITYE, VELOCITYE);
                                asteroidSuper.CreateAsteroids(asteroidSuper, ptemp.X, ptemp.Y, 1, (int)Asteroid.AsteroidType.ChunkExtra4, -VELOCITYE, VELOCITYE);
                                AccessWeapons.TheWeapons.RemoveAt(w);
                                --w;
                                AccessPlayer.Score += 400;
                            }



                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkSmall1)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 50;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkMedium1)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 100;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkMedium2)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 100;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkMedium3)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 100;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkMedium4)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 100;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkMedium5)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 100;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkLarge1)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 150;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkLarge2)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 150;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkLarge3)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;

                                AccessPlayer.Score += 150;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkExtra1)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 200;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkExtra2)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 200;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkExtra3)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 200;
                            }
                            if (theAsteroids[i].TheType == (int)Asteroid.AsteroidType.ChunkExtra4)
                            {
                                theAsteroids.RemoveAt(i);
                                --i;
                                AccessPlayer.Score += 200;
                            }


                            //if (i > 0)
                            // theAsteroids[i].Time = COLLISIONINTERVAL;
                            Loop = theAsteroids[i].TheType;
                            theAsteroids.TrimExcess();
                        }
                    }
                }


                //check asteroid collisions
                for (int j = 0; j < theAsteroids.Count; j++)
                {
                    if (Collided(theAsteroids[i], theAsteroids[j], theAsteroids[i].Image))
                    {
                        theAsteroids[j].Time -= Timer.ElapsedGameTime.Milliseconds;

                        if (theAsteroids[j].Time < 0)
                        {
                            // sounds[(int)Game1.Sounds.AsteroidCollsion].Play();

                            switch (theAsteroids[i].PlusOrMinus)
                            {
                            case 0:
                                theAsteroids[i].SetVelocityX((-theAsteroids[i].Velocity.X) - (float)random.NextDouble());
                                theAsteroids[i].SetVelocityY((-theAsteroids[i].Velocity.Y) - (float)random.NextDouble());
                                theAsteroids[i].AngularVelocity = -theAsteroids[i].AngularVelocity;
                                theAsteroids[j].SetVelocityX((-theAsteroids[j].Velocity.X) - (float)random.NextDouble());
                                theAsteroids[j].SetVelocityY((-theAsteroids[j].Velocity.Y) - (float)random.NextDouble());
                                theAsteroids[j].AngularVelocity = -theAsteroids[j].AngularVelocity;
                                theAsteroids[i].PlusOrMinus     = 1;
                                break;

                            case 1:
                                theAsteroids[i].SetVelocityX((-theAsteroids[i].Velocity.X) + (float)random.NextDouble());
                                theAsteroids[i].SetVelocityY((-theAsteroids[i].Velocity.Y) + (float)random.NextDouble());
                                theAsteroids[i].AngularVelocity = -theAsteroids[i].AngularVelocity;
                                theAsteroids[j].SetVelocityX((-theAsteroids[j].Velocity.X) + (float)random.NextDouble());
                                theAsteroids[j].SetVelocityY((-theAsteroids[j].Velocity.Y) + (float)random.NextDouble());
                                theAsteroids[j].AngularVelocity = -theAsteroids[j].AngularVelocity;
                                theAsteroids[i].PlusOrMinus     = 0;
                                break;
                            }
                            theAsteroids[j].Time = COLLISIONINTERVAL;
                        }
                    }
                }



                theAsteroids[i].Angle += theAsteroids[i].AngularVelocity;
                //  AngularVelocity*=AngularVelocityDecrement;
                if (theAsteroids[i].Angle > fullRotation)
                {
                    theAsteroids[i].Angle -= fullRotation;
                }
                if (theAsteroids[i].Angle < 0)
                {
                    theAsteroids[i].Angle += fullRotation;
                }
                // i.SetVelocityX(i.Velocity.X + (float)Math.Cos(Angle) * Speed);
                // i.SetVelocityY(Velocity.Y + (float)Math.Sin(Angle) * Speed);
                // SetVelocityX(Velocity.X * VelocityDecrement);
                // SetVelocityY(Velocity.Y * VelocityDecrement);

                // Speed
            }
        }
Beispiel #14
0
        public static void Update()
        {
            for (int i = 0; i < stars.Length; i++)
            {
                if (stars[i] == null)
                {
                    stars[i] = new Star(new Size(Rnd.Next(0, 5), Rnd.Next(0, 5)), true);
                }
                else
                {
                    stars[i].Update(ref stars[i]);
                }
                if (stars[i].Position.X < 0)
                {
                    stars[i] = null;
                }
            }

            for (int i = 0; i < ListAsteroid.Length; i++)
            {
                if (ListAsteroid[i] == null)
                {
                    ListAsteroid[i] = new Asteroid(imageAsteroid);
                }
                ListAsteroid[i]?.Update(ref ListAsteroid[i]);
                if (BulletHits(ref ListAsteroid[i]))
                {
                    continue;
                }
                if (ListAsteroid[i] != null && ship.Collision(ListAsteroid[i]))
                {
                    Log("Корабль подбит");
                    timerBonus.Start();
                    ListAsteroid[i] = null;
                    ship.Damage();
                }
            }
            for (int i = 0; i < bullets.Length; ++i)
            {
                if (bullets[i] != null)
                {
                    bullets[i].Update(ref bullets[i]);
                }
            }
            SystemSounds.Asterisk.Play();
            ship.Update(ref ship);
            if (ship.Live <= 0)
            {
                ship?.Die();
            }
            if (heart != null)
            {
                if (heart.Collision(ship))
                {
                    Log("Колличество жизней увеличено");
                    ship.Heal();
                    heart = null;
                }
                heart?.Update(ref heart);
            }
            GC.Collect();
        }
Beispiel #15
0
 public bool addCollision(Asteroid a)
 {
     if(a == null || m_activeCollisions.Contains(a)) { return false; }
     m_activeCollisions.Add(a);
     return true;
 }
Beispiel #16
0
        public void handleCollisions()
        {
            if (m_projectileSystem == null ||
                m_spaceShipSystem == null ||
                m_asteroidSystem == null ||
                m_explosionSystem == null ||
                m_scoreSystem == null)
            {
                return;
            }

            // remove any collisions that have been handled and are no longer in collision
            for (int i = 0; i < m_asteroidSystem.size(); i++)
            {
                Asteroid a1 = m_asteroidSystem.getAsteroid(i);
                for (int j = 0; j < m_asteroidSystem.size(); j++)
                {
                    Asteroid a2 = m_asteroidSystem.getAsteroid(j);
                    if (i != j &&
                        (a1.isCollidingWith(a2) && !a1.checkCollision(a2)) ||
                        (a2.isCollidingWith(a1) && !a2.checkCollision(a1)))
                    {
                        a1.removeCollision(a2);
                        a2.removeCollision(a1);
                    }
                }
            }

            // check asteroid > asteroid collision
            for (int i = 0; i < m_asteroidSystem.size(); i++)
            {
                for (int j = i + 1; j < m_asteroidSystem.size(); j++)
                {
                    if (i != j && m_asteroidSystem.getAsteroid(i).checkCollision(m_asteroidSystem.getAsteroid(j)))
                    {
                        handleCollision(m_asteroidSystem.getAsteroid(i), m_asteroidSystem.getAsteroid(j));
                    }
                }

                // check projectile > asteroid collision
                for (int j = 0; j < m_projectileSystem.size(); j++)
                {
                    if (m_projectileSystem.getProjectile(j).checkCollision(m_asteroidSystem.getAsteroid(i)))
                    {
                        // [potentially] create a cluster of smaller asteroids if this was a big asteroid
                        m_scoreSystem.addPoints(m_projectileSystem.getProjectile(j).getProjectileSource(), (m_asteroidSystem.getAsteroid(i).bigAsteroid) ? ScoreType.BigAsteroid : ScoreType.SmallAsteroid);

                        if (m_asteroidSystem.getAsteroid(i).bigAsteroid)
                        {
                            m_asteroidSystem.spawnAsteroidCluster(m_asteroidSystem.getAsteroid(i));
                        }

                        m_explosionSystem.spawnExplosion(m_asteroidSystem.getAsteroid(i));

                        clearCollisions(m_asteroidSystem.getAsteroid(i));

                        m_asteroidSystem.removeAsteroid(i);
                        m_projectileSystem.removeProjectile(j);

                        i--;
                        j--;

                        break;
                    }
                }
            }

            // check ship > ship collision
            for (int i = 0; i < m_spaceShipSystem.size(); i++)
            {
                for (int j = i + 1; j < m_spaceShipSystem.size(); j++)
                {
                    if (i != j && m_spaceShipSystem.getSpaceShip(i).checkCollision(m_spaceShipSystem.getSpaceShip(j)))
                    {
                        m_explosionSystem.spawnExplosion(m_spaceShipSystem.getSpaceShip(i));
                        m_explosionSystem.spawnExplosion(m_spaceShipSystem.getSpaceShip(j));

                        m_spaceShipSystem.getSpaceShip(i).reset();
                        m_spaceShipSystem.getSpaceShip(j).reset();
                    }
                }

                // check ship > asteroid collision
                for (int j = 0; j < m_asteroidSystem.size(); j++)
                {
                    if (m_spaceShipSystem.getSpaceShip(i).checkCollision(m_asteroidSystem.getAsteroid(j)))
                    {
                        m_explosionSystem.spawnExplosion(m_spaceShipSystem.getSpaceShip(i));

                        m_spaceShipSystem.getSpaceShip(i).reset();

                        clearCollisions(m_asteroidSystem.getAsteroid(j));

                        m_asteroidSystem.removeAsteroid(j);
                        j--;
                    }
                }

                // check projectile > ship collision
                for (int j = 0; j < m_projectileSystem.size(); j++)
                {
                    if (!m_projectileSystem.getProjectile(j).getProjectileSource().Equals(m_spaceShipSystem.getSpaceShip(i)) &&
                        m_projectileSystem.getProjectile(j).checkCollision(m_spaceShipSystem.getSpaceShip(i)))
                    {
                        m_scoreSystem.addPoints(m_projectileSystem.getProjectile(j).getProjectileSource(), ScoreType.SpaceShip);

                        m_explosionSystem.spawnExplosion(m_spaceShipSystem.getSpaceShip(i));
                        m_spaceShipSystem.getSpaceShip(i).reset();

                        m_projectileSystem.removeProjectile(j);
                        j--;
                    }
                }
            }
        }
Beispiel #17
0
        // spawn a random asteroid at a random location with random attributes
        public void spawnAsteroid()
        {
            int asteroidIndex;
            bool bigAsteroid;
            Random rand = new Random();
            if(rand.Next(0, 99) < 30) {
                // spawn small asteroid (30% chance)
                asteroidIndex = rand.Next(0, 4) + 2;
                bigAsteroid = false;
            }
            else {
                // spawn big asteroid (70% chance)
                asteroidIndex = rand.Next(0, 2) % 2;
                bigAsteroid = true;
            }

            // if there are too many asteroids of this type, do not spawn it
            if(bigAsteroid && m_numberOfBigAsteroids >= m_maxBigAsteroids) { return; }
            if(!bigAsteroid && m_numberOfSmallAsteroids >= m_maxSmallAsteroids) { return; }

            bool isInsideOfAsteroid;
            bool isTooCloseToShip;
            Asteroid newAsteroid = new Asteroid(m_asteroidSprites.getSprite(asteroidIndex), bigAsteroid, m_settings);
            do {
                // make sure that the new asteroid is not too close to a space ship
                isTooCloseToShip = false;
                for(int i=0;i<m_spaceShipSystem.size();i++) {
                    if(m_spaceShipSystem.getSpaceShip(i).checkExtendedCollision(newAsteroid)) {
                        isTooCloseToShip = true;
                    }
                }

                // also make sure that the asteroid is not stuck inside of another asteroid
                isInsideOfAsteroid = false;
                if(!isTooCloseToShip) {
                    for(int i=0;i<m_asteroids.Count();i++) {
                        if(m_asteroids[i].checkCollision(newAsteroid)) {
                            isInsideOfAsteroid = true;
                        }
                    }
                }

                // if it is too close to a ship or inside of another asteroid, then re-randomize its position until it isn't
                if(isTooCloseToShip || isInsideOfAsteroid) {
                    newAsteroid.randomizePosition();
                }
            } while(isTooCloseToShip || isInsideOfAsteroid);

            // store the asteroid
            if(newAsteroid.bigAsteroid) { m_numberOfBigAsteroids++; } else { m_numberOfSmallAsteroids++; }
            m_asteroids.Add(newAsteroid);
        }
Beispiel #18
0
        // handle a collision between two asteroids
        private void handleCollision(Asteroid a1, Asteroid a2)
        {
            if(a1 == a2) { return; }
            if(a1.isCollidingWith(a2) || a2.isCollidingWith(a1)) { return; }

            a1.addCollision(a2);
            a2.addCollision(a1);

            double v = a1.speed;

            double dx = Math.Abs(a2.x - a1.x);
            double dy = Math.Abs(a2.y - a1.y);
            double d = Math.Sqrt((dx * dx) + (dy * dy));

            if(d == 0)
                return;

            double angle_b = Math.Asin(dy / d);
            double angle_d = Math.Asin(Math.Abs(a1.velocity.X) / v);
            double angle_a = (Math.PI / 2.0f) - angle_b - angle_d;
            double angle_c = angle_b - angle_a;

            double v1 = v * Math.Abs(Math.Sin(angle_a));
            double v2 = v * Math.Abs(Math.Cos(angle_a));

            double v1x = v1 * Math.Abs(Math.Cos(angle_c));
            double v1y = v1 * Math.Abs(Math.Sin(angle_c));
            double v2x = v2 * Math.Abs(Math.Cos(angle_b));
            double v2y = v2 * Math.Abs(Math.Sin(angle_b));

            if(a1.velocity.X > 0) {
                if(a1.x < a2.x)
                    v1x = -v1x;
                else
                    v2x = -v2x;
            }
            else {
                if(a1.x > a2.x)
                    v2x = -v2x;
                else
                    v1x = -v1x;
            }

            if(a1.velocity.Y > 0) {
                if(a1.y < a2.y)
                    v1y = -v1y;
                else
                    v2y = -v2y;
            }
            else {
                if(a1.y > a2.y)
                    v2y = -v2y;
                else
                    v1y = -v1y;
            }

            if(double.IsNaN(v1x) || double.IsNaN(v1y) || double.IsNaN(v2x) || double.IsNaN(v2y)) { return; }

            // update the asteroids with their new velocities
            a1.velocity = new Vector2((float) v1x, (float) v1y);
            a2.velocity = new Vector2((float) v2x, (float) v2y);
        }
Beispiel #19
0
        public void spawnAsteroidCluster(GameObject o)
        {
            if(o == null || m_numberOfSmallAsteroids >= m_maxSmallAsteroids) { return; }

            Random rand = new Random();

            // randomly choose how many small asteroids to spawn from a bigger asteroid
            int clusterSize = 0;
            int clusterSeed = rand.Next(0, 100);
                 if(clusterSeed <  34) { clusterSize = 0; } // 34% chance no asteroids
            else if(clusterSeed <  76) { clusterSize = 1; } // 42% chance 1 asteroid
            else if(clusterSeed <  90) { clusterSize = 2; } // 14% chance 2 asteroids
            else if(clusterSeed <  96) { clusterSize = 3; } //  6% chance 3 asteroids
            else if(clusterSeed < 100) { clusterSize = 4; } //  4% chance 4 asteroids

            // create the corresponding number of mini-asteroids, and set their appropriate locations and directions
            // by rotating a pair of x/y co-ordinates around the origin of the original asteroid, randomized at equal
            // intervals and set their velocities so they are moving away from the origin of the original asteroid
            float angle = (float) (rand.NextDouble() * 359.0f);
            float angleIncrement = (360.0f / clusterSize);
            Asteroid newAsteroid;
            for(int i=0;i<clusterSize;i++) {
                newAsteroid = new Asteroid(m_asteroidSprites.getSprite(rand.Next(0, 4) + 2), false, m_settings);

                // calculate the velocities of the new asteroid
                float minVelocity = (float) (rand.NextDouble() * 0.3f) + 0.007f;
                float maxVelocity = (float) (rand.NextDouble() * 2.5f) + 0.8f;
                float xVelocity = (float) ( (((rand.Next(0, 2) % 2) == 0) ? 1 : -1) * (rand.NextDouble() * (maxVelocity - minVelocity) + minVelocity) );
                float yVelocity = (float) ( (((rand.Next(0, 2) % 2) == 0) ? 1 : -1) * (rand.NextDouble() * (maxVelocity - minVelocity) + minVelocity) );

                // set the velocities and locations of the new asteroid
                newAsteroid.position = new Vector2((float) (o.position.X + (o.offset.X * Math.Cos(MathHelper.ToRadians(angle)))), (float) (o.position.Y + (o.offset.Y * Math.Sin(MathHelper.ToRadians(angle)))));
                newAsteroid.velocity = new Vector2((float) (xVelocity * Math.Cos(MathHelper.ToRadians(angle))), (float) (yVelocity * Math.Sin(MathHelper.ToRadians(angle))));

                // store the asteroid
                if(newAsteroid.bigAsteroid) { m_numberOfBigAsteroids++; } else { m_numberOfSmallAsteroids++; }
                m_asteroids.Add(newAsteroid);

                // increment to the next projection angle
                angle += angleIncrement;
            }
        }
Beispiel #20
0
        public void Iteration()
        {
            iteration++;

            /// Fired by the form timer.  This will Move and process all of the space objects.
            ship.Move();

            // Move along the shots.
            // Delete any old ones.

            // Bullet Loop
            for (int i = bullets.Count - 1; i >= 0; i--)
            {
                Bullets bullet = bullets[i];
                bullet.Move();

                if (bullet.Iterations > bullet.life)
                {
                    bullets.Remove(bullet);
                    BullettsFired--;
                }

                // Check if we have hit an asteroid.
                for (int a = asteroids.Count - 1; a >= 0; a--)
                {
                    Asteroid asteroid = asteroids[a];

                    if (asteroid.Area.Contains(bullet.point))
                    {
                        // Add to score.
                        PlayerScore           += asteroid.Score;
                        form2.playerScore.Text = PlayerScore.ToString();

                        // We have a hit.  Remove this asteroid and create more smaller ones if appropriate.
                        int createQty = 1;

                        if (asteroid.Size == Asteroid.Sizes.Large)
                        {
                            createQty = random.Next(1, Level);
                            for (int x = 0; x < createQty; x++)
                            {
                                Asteroid newAsteroid = new Asteroid(asteroid.point.X + 2, asteroid.point.Y, this, Asteroid.Sizes.Medium, asteroid.Colour);
                                asteroids.Add(newAsteroid);
                            }
                        }

                        if (asteroid.Size == Asteroid.Sizes.Medium)
                        {
                            createQty = random.Next(1, Level * 2);
                            for (int x = 0; x < createQty; x++)
                            {
                                Asteroid newAsteroid = new Asteroid(asteroid.point.X + 2, asteroid.point.Y, this, Asteroid.Sizes.Small, asteroid.Colour);
                                asteroids.Add(newAsteroid);
                            }
                        }

                        if (asteroid.Size == Asteroid.Sizes.Small)
                        {
                            createQty = random.Next(1, Level * 3);
                            for (int x = 0; x < createQty; x++)
                            {
                                Asteroid newAsteroid = new Asteroid(asteroid.point.X + 2, asteroid.point.Y, this, Asteroid.Sizes.Tiny, asteroid.Colour);
                                asteroids.Add(newAsteroid);
                            }
                        }

                        asteroids.Remove(asteroid);

                        bullets.Remove(bullet);
                        BullettsFired--;
                    }
                }

                // Phase 2 Check if we have hit the enemy ship
                if (enemyShip1 != null && enemyShip1.Area.Contains(bullet.point) && bullet.Enemy != true)
                {
                    // Add to score.
                    PlayerScore           += 50;
                    form2.playerScore.Text = PlayerScore.ToString();

                    // Remove the object.
                    enemyShip1 = null;

                    soundPlayerGlass.Play();

                    EnemyShipActive = false;
                }

                // Phase 2 - See if the enemy ship has hit us.
                if (bullet.Enemy == true && ship.Area.Contains(bullet.point))
                {
                    // Oh dear we have been hit.  Call the NewShip routine.
                    NewShip();
                    ShowExplosion  = 20;   // Number of times to show explosion
                    ExplosionPoint = bullet.point;

                    break;
                }


                // See is all asteroids have gone.  Need to start the next level.
                if (asteroids.Count <= 0)
                {
                    Level++;
                    NewLevel(Level);
                    return;
                }
            }   // End Bullet list loop.


            // Move the Asteroids.
            foreach (Asteroid asteroid in asteroids)
            {
                asteroid.Move();

                // See if this has hit our ship.
                if (asteroid.Area.IntersectsWith(ship.Area))
                {
                    // Oh dear we have been hit.  Call the NewShip routine.
                    NewShip();
                    ShowExplosion  = 20;   // Number of times to show explosion
                    ExplosionPoint = asteroid.point;

                    break;
                }
            }


            // Phase 2 - Randomly start the enemy ship at the right hand side.
            if (EnemyShipActive == false)
            {
                int randy = random.Next(0, 500);
                if (randy == 250)
                {
                    EnemyShipActive = true;
                    int startPosX = FormSizeX - 2;
                    int startPosY = random.Next(1, FormSizeY);
                    enemyShip1       = new EnemyShip(startPosX, startPosY, this);
                    enemyShip1.Angle = 270.0F;
                }
            }

            if (EnemyShipActive == true)
            {
                enemyShip1.Move();

                if (iteration % 10 == 0)  // Fire every ten iterations.
                {
                    enemyShip1.Shoot();
                }
            }



            // Fire the form paint event to paint the graphics.
            form1.Invalidate();
        }
Beispiel #21
0
 // remove an already existing asteroid
 public bool removeAsteroid(Asteroid a)
 {
     if(a == null) { return false; }
     return removeAsteroid(m_asteroids.IndexOf(a));
 }
Beispiel #22
0
 public bool HitsAsteroid(Asteroid asteroid)
 {
     return(this.posY > asteroid.GetY() && this.posY < asteroid.GetY() + asteroid.GetS() &&
            this.posX > asteroid.GetX() && this.posX < asteroid.GetX() + asteroid.GetS());
 }
        public void Update()
        {
            if (IsUpButtonPressed)
            {
                if (player.Speed < 0)
                {
                    player.Speed = 0;
                }
                if (player.Speed < player.MAX_SPEED)
                {
                    player.Speed++;
                }
            }
            else
            {
                if (player.Speed > 0)
                {
                    player.Speed--;
                }
            }
            if (IsDownButtonPressed)
            {
                if (player.Speed > 0)
                {
                    player.Speed = 0;
                }
                if (player.Speed > -player.MAX_SPEED)
                {
                    player.Speed--;
                }
            }
            else
            {
                if (player.Speed < 0)
                {
                    player.Speed++;
                }
            }
            if (IsLeftButtonPressed)
            {
                player.Rotate(player.ROTATE_DEGREE_INCREMENT);
            }
            if (IsRightButtonPressed)
            {
                player.Rotate(-player.ROTATE_DEGREE_INCREMENT);
            }
            if (IsSpaceBarPressed)
            {
                App.soundPlayer.Play();
                if (player.LastFired == player.FIRE_COOLDOWN && !player.IsDead())
                {
                    player.LastFired = 0;
                    Bullet newBullet = new Bullet(VMath.AddVectors(player.Position, new Vector2(rand.Next(8) - 4, rand.Next(8) - 4)), player.UnitDirectionVector, 20, 3);
                    gameObjects.Add(newBullet);
                }
            }
            if (rand.Next(1, 100) <= 1) //random asteroid spawn chance
            {
                Asteroid newAsteroid = new Asteroid(new Vector2(rand.Next(0, canvasWidth), 0), new Vector2(rand.Next(-180, 180), rand.Next(-180, 180)), rand.Next(1, 5), rand.Next(15, 100));
                gameObjects.Add(newAsteroid);
            }

            foreach (var obj in gameObjects.Where((h => (h is HealthBar))).ToList())
            {
                gameObjects.Remove(obj);
            }
            HealthBar gameHealthBar = new HealthBar(new Vector2(canvasWidth, canvasHeight), new Vector2(0, 0), 0, player.Health);

            gameObjects.Add(gameHealthBar);

            foreach (var obj in gameObjects.ToList())
            {
                obj.Move(canvasWidth, canvasHeight);
                if (obj.IsDead())
                {
                    gameObjects.Remove(obj);
                }
            }

            foreach (var obj in gameObjects.Where((b => (b is Bullet))).ToList())
            {
                if (obj.Position.X < 0 || obj.Position.X > canvasWidth || obj.Position.Y < 0 || obj.Position.Y > canvasHeight)
                {
                    obj.Destroy();
                }
            }
            foreach (var obj in gameObjects.Where((a => (a is Asteroid))).ToList())
            {
                if ((obj.Position.X + obj.Radius > player.Position.X && obj.Position.X - obj.Radius < player.Position.X) && (obj.Position.Y + obj.Radius > player.Position.Y && obj.Position.Y - obj.Radius < player.Position.Y))
                {
                    if (!player.IsDead())
                    {
                        player.AsteroidCollision(obj);
                        obj.Destroy();
                    }
                }
            }
            foreach (var ast in gameObjects.Where((a => (a is Asteroid))).ToList())
            {
                foreach (var bul in gameObjects.Where((b => (b is Bullet))).ToList())
                {
                    if ((ast.Position.X + ast.Radius > bul.Position.X && ast.Position.X - ast.Radius < bul.Position.X) && (ast.Position.Y + ast.Radius > bul.Position.Y && ast.Position.Y - ast.Radius < bul.Position.Y))
                    {
                        gameObjects.Add((ast as Asteroid).Half());
                        bul.Destroy();
                    }
                }
            }
            if (player.Health <= 0)
            {
                gameOver = true;
            }
        }
        public override void Update()
        {
            userInterface.UpdateUI();
            spaceShipScore = Spaceship.GetSpaceshipScore(1);

            switch (createdSpaceShip)
            {
            case 0:
            {
                if (!regularSpaceship.IsSpaceshipAlive)
                {
                    this.isGameOn = false;
                }
                else if (regularSpaceship.Shoot())
                {
                    Lazer lazer = new Lazer
                                  (
                        regularSpaceship.TriangleX, regularSpaceship.TriangleY,
                        regularSpaceship.TriangleV, regularSpaceship.TriangleR, regularSpaceship.Damage, regularSpaceship.GetID
                                  );
                }
            }
            break;

            case 1:
            {
                if (!scoutSpaceship.IsSpaceshipAlive)
                {
                    this.isGameOn = false;
                }
                else if (scoutSpaceship.Shoot())
                {
                    Lazer lazer = new Lazer
                                  (
                        scoutSpaceship.TriangleX, scoutSpaceship.TriangleY,
                        scoutSpaceship.TriangleV, scoutSpaceship.TriangleR, scoutSpaceship.Damage, scoutSpaceship.GetID
                                  );
                }
            }
            break;

            case 2:
            {
                if (!heavySpaceship.IsSpaceshipAlive)
                {
                    this.isGameOn = false;
                }
                else if (heavySpaceship.Shoot())
                {
                    Lazer lazer = new Lazer
                                  (
                        heavySpaceship.TriangleX, heavySpaceship.TriangleY,
                        heavySpaceship.TriangleV, heavySpaceship.TriangleR, heavySpaceship.Damage, heavySpaceship.GetID
                                  );
                }
            }
            break;

            case 3:
            {
                if (!sniperSpaceship.IsSpaceshipAlive)
                {
                    this.isGameOn = false;
                }
                else if (sniperSpaceship.Shoot())
                {
                    Lazer lazer = new Lazer
                                  (
                        sniperSpaceship.TriangleX, sniperSpaceship.TriangleY,
                        sniperSpaceship.TriangleV, sniperSpaceship.TriangleR, sniperSpaceship.Damage, sniperSpaceship.GetID
                                  );
                }
            }
            break;
            }


            if (time[0] >= 10 * (4 - ButtonSeries.GetSelectedMultiplier(2)))
            {
                Asteroid asteroid = new Asteroid();
                time[0] = 0;
            }
            else
            {
                time[0]++;
            }

            if (spaceShipScore >= 2000)
            {
                wave = 2;

                if (time[1] == 600)
                {
                    MissileAsteroid missileAsteroid = new MissileAsteroid();
                    time[1] = 0;
                }
                else
                {
                    time[1]++;
                }
            }

            if (spaceShipScore >= 4000)
            {
                wave = 3;

                if (time[2] == 1000)
                {
                    ScatterAsteroid scatterAsteroid = new ScatterAsteroid();
                    time[2] = 0;
                }
                else
                {
                    time[2]++;
                }
            }

            if (spaceShipScore >= 6000)
            {
                wave = 4;

                if (time[3] == 2000)
                {
                    MissileScatterAsteroid missileScatterAsteroid = new MissileScatterAsteroid();
                    time[3] = 0;
                }
                else
                {
                    time[3]++;
                }
            }

            if (spaceShipScore >= 8000 && ButtonSeries.GetSelectedButtonID(4) == 0)
            {
                wave = 5;

                if (time[4] == 2000)
                {
                    LimitScreen limitScreen = new LimitScreen();
                    time[4] = 0;
                }
                else
                {
                    time[4]++;
                }
            }

            if (spaceShipScore >= 10000)
            {
                if (ButtonSeries.GetSelectedButtonID(4) == 0)
                {
                    wave = 6;
                }
                else
                {
                    wave = 5;
                }

                if (time[5] == 4000)
                {
                    MissileScatterAsteroidMissile missileScatterAsteroidMissile = new MissileScatterAsteroidMissile();
                    time[5] = 0;
                }
                else
                {
                    time[5]++;
                }
            }

            if (spaceShipScore >= 20000)
            {
                if (time[6] == 0)
                {
                    time[6] = 20000 - spaceShipScore / 10;
                }
                else
                {
                    time[6]--;
                }

                if (ButtonSeries.GetSelectedButtonID(2) == 4)
                {
                    wave = 7;
                }
                else
                {
                    wave = 6;
                }

                int t = time[6];
                switch (t)
                {
                case 1:
                {
                    for (int i = 0; i < 200; i++)
                    {
                        Asteroid asteroid = new Asteroid();
                    }
                }
                break;

                case 2000:
                {
                    for (int i = 0; i < 3; i++)
                    {
                        MissileAsteroid missileAsteroid = new MissileAsteroid();
                    }
                }
                break;

                case 4000:
                {
                    for (int i = 0; i < 5; i++)
                    {
                        ScatterAsteroid scatterAsteroid = new ScatterAsteroid();
                    }
                }
                break;

                case 6000:
                {
                    for (int i = 0; i < 3; i++)
                    {
                        MissileScatterAsteroid missileScatterAsteroid = new MissileScatterAsteroid();
                    }
                }
                break;

                case 8000:
                {
                    for (int i = 0; i < 4; i++)
                    {
                        MissileScatterAsteroidMissile missileScatterAsteroidMissile = new MissileScatterAsteroidMissile();
                    }
                }
                break;
                }
            }

            base.Update();
        }
Beispiel #25
0
        private void StartNewGame()
        {
            ship = new Spaceship(Content);
            camera = new SpaceshipCamera(graphics.GraphicsDevice.Viewport, ship);

            int x, y, z, pos_x, pos_y, pos_z;
            Random random = new Random();

            for (int i = 0; i < NUM_ASTEROIDS; ++i)
            {
                x = random.Next(2);
                z = random.Next(2);
                y = random.Next(2);

                pos_x = random.Next(-30, 31);
                pos_y = random.Next(-30, 31);
                pos_z = random.Next(-30, 31);

                asteroids[i] = new Asteroid(Content, new Vector3(x, y, z));
                asteroids[i].Position = new Vector3(pos_x, pos_y, pos_z);
            }

            spriteDrawer = new SpriteDrawer(device, Content);
            spriteManager = new SpriteManager(device, Content);

            spFont = Content.Load<SpriteFont>(@"Arial");
            spBatch = new SpriteBatch(graphics.GraphicsDevice);

            particleSystem = new ParticleSystem(spriteManager);
            jetParticleEffect = new JetParticleEffect(particleSystem, ship);

            points = 0;
            jetParticleEffect.MinXDirection = -0.3f;
            jetParticleEffect.MaxXDirection = 0.3f;
            jetParticleEffect.MinZDirection = 0.6f;
            jetParticleEffect.MaxZDirection = 0.8f;
            jetParticleEffect.MinYDirection = -0.2f;
            jetParticleEffect.MaxYDirection = 0.2f;
            jetParticleEffect.ParticlesPerSecond = 50.0;
            jetParticleEffect.ParticleLifetime = 400.0;
            jetParticleEffect.ParticleSize = 0.5f;
            jetParticleEffect.ParticleSpeed = 0.7f;
            jetParticleEffect.FinalColor = Color.Red;
        }
Beispiel #26
0
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            player = new Sprite(graphics, Content.Load<Texture2D>("playerShip"));

            alien = new Alien(Content, graphics, player);

            spriteBatch = new SpriteBatch(GraphicsDevice);
            background = new Background(graphics.GraphicsDevice, spriteBatch, Content);
            bullets = new BulletList();
            asteroids = new Asteroid(Content, graphics);
            keyboard = new KeyBoardManager(Content);
            collision = new Collision(player, alien, bullets, asteroids);

            font = Content.Load<SpriteFont>("Font");
        }
Beispiel #27
0
 // Collisions
 public virtual void HandleCollision(Asteroid a)
 {
 }
Beispiel #28
0
        //spawns a batch of asteroids independant from the game to be displayed on the background of the main menu
        public static List<Asteroid> SpawnAsteroids(int amount, int distance)
        {
            List<Asteroid> asteroids = new List<Asteroid>();

            for (int i = 0; i < amount; i++)
            {
                Asteroid newAsteroid = new Asteroid(null, FindAsteroidSpawnSpace(asteroids.ToArray(), 50), AsteroidSize.Large);
                asteroids.Add(newAsteroid);
            }

            return asteroids;
        }
Beispiel #29
0
        private void movement_Tick(object sender, EventArgs e)
        {
            // laser movement
            for (int i = 0; i < laser_list.Count; i++)
            {
                Shot s = new Shot();
                s.graphic = laser_list[i].graphic;
                s.x = laser_list[i].x;
                s.y = laser_list[i].y - laser_speed;
                laser_list.RemoveAt(i);
                laser_list.Insert(i, s);

            }

            // asteroid movement
            for (int i = 0; i < asteroid_list.Count; i++)
            {
                Asteroid a = new Asteroid();
                a.graphic = asteroid_list[i].graphic;
                a.x = asteroid_list[i].x;
                a.y = asteroid_list[i].y + asteroid_list[i].speed;
                a.speed = asteroid_list[i].speed;
                a.type = asteroid_list[i].type;
                a.hp = asteroid_list[i].hp;
                a.size = asteroid_list[i].size;
                asteroid_list.RemoveAt(i);
                asteroid_list.Insert(i, a);
            }

            // detect collisions
            // asteroid with ground
            for (int i = 0; i < asteroid_list.Count; i++)
            {
                Asteroid cur_asteroid = asteroid_list[i];

                // COLLISION WITH SHIP
                if ((cur_asteroid.y > (800 - cur_asteroid.size - 100)) && (Math.Abs(cur_asteroid.x - spaceship.Location.X) < 50))
                {
                    // reduce lives
                    numLives = 0;
                    Debug.WriteLine("GAME OVER");
                    // remove all lasers and asteroids
                    asteroid_list.Clear();
                    laser_list.Clear();
                    // disable timers
                    movement_timer.Stop();
                    spawn_timer.Stop();
                    level_timer.Stop();
                    movement_timer.Enabled = false;
                    spawn_timer.Enabled = false;
                    level_timer.Enabled = false;
                    // display game over message
                    countdown_label.Text = "Game Over";
                    countdown_label.Show();
                    // set boolean
                    GameOver = true;
                    lives.Text = "Lives: 0";
                }

                // COLLISION WITH FLOOR
                if (cur_asteroid.y > (800 - cur_asteroid.size))
                {
                    // reduce # lives
                    Debug.WriteLine("LIFE LOST");
                    numLives--;
                    String lives_text = "Lives: " + numLives.ToString();
                    lives.Text = lives_text;
                    // remove graphic
                    asteroid_list.RemoveAt(i);
                    // end game if # lives == 0
                    if (numLives == 0)
                    {
                        Debug.WriteLine("GAME OVER");
                        // remove all lasers and asteroids
                        asteroid_list.Clear();
                        laser_list.Clear();
                        // disable timers
                        movement_timer.Stop();
                        spawn_timer.Stop();
                        level_timer.Stop();
                        movement_timer.Enabled = false;
                        spawn_timer.Enabled = false;
                        level_timer.Enabled = false;
                        // display game over message
                        countdown_label.Text = "Game Over";
                        countdown_label.Show();
                        // set boolean
                        GameOver = true;

                    }
                }

                // COLLISION WITH LASER
                for (int j = 0; j < laser_list.Count; j++)
                {
                    Shot cur_laser = laser_list[j];
                    if ((Math.Abs(cur_asteroid.y - cur_laser.y) < cur_asteroid.size) && (Math.Abs(cur_asteroid.x - cur_laser.x) < cur_asteroid.size))
                    {
                        // decrement asteroid HP
                        cur_asteroid.hp = cur_asteroid.hp - 1;
                        Debug.WriteLine(cur_asteroid.hp);
                        // remove laser
                        laser_list.RemoveAt(j);
                        // increase points & redo label
                        points = points + point_increment;
                        String score_text = "Score: " + points.ToString();
                        score.Text = score_text;
                        // reinsert asteroid
                        if (cur_asteroid.hp != 0)
                        {
                            asteroid_list.RemoveAt(i);
                            asteroid_list.Insert(i, cur_asteroid);
                        }
                        else
                        {
                            asteroid_list.RemoveAt(i);
                        }
                    }
                }

            }

            // redraw objects
            this.Invalidate();
        }
Beispiel #30
0
 public bool removeCollision(Asteroid a)
 {
     if(a == null) { return false; }
     return m_activeCollisions.Remove(a);
 }
Beispiel #31
0
 private void spawn_Tick(object sender, EventArgs e)
 {
     Debug.WriteLine("Spawn Tick");
     // generate an asteroid
     int type = rnd.Next(1,4);
     Debug.WriteLine(type);
     int size, hp;
     if (type == 1)
     {
         size = l1_asteroid_size;
         hp = l1_asteroid_hp;
     }
     else if (type == 2)
     {
         size = l2_asteroid_size;
         hp = l2_asteroid_hp;
     }
     else
     {
         size = l3_asteroid_size;
         hp = l3_asteroid_hp;
     }
     int placement_x = rnd.Next(size, 800 - size);
     System.Drawing.SolidBrush myBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Red);
     System.Drawing.Graphics asteroid;
     asteroid = this.CreateGraphics();
     asteroid.FillRectangle(myBrush, new Rectangle(placement_x, 0, size, size));
     myBrush.Dispose();
     Asteroid a = new Asteroid();
     a.graphic = asteroid;
     a.x = placement_x;
     a.y = 0;
     a.speed = rnd.Next(1, 5);
     a.type = type;
     a.hp = hp;
     a.size = size;
     asteroid_list.Add(a);
 }
Beispiel #32
0
 public bool isCollidingWith(Asteroid a)
 {
     if(a == null) { return false; }
     return m_activeCollisions.Contains(a);
 }
Beispiel #33
0
        // handle a collision between two asteroids
        private void handleCollision(Asteroid a1, Asteroid a2)
        {
            if (a1 == a2)
            {
                return;
            }
            if (a1.isCollidingWith(a2) || a2.isCollidingWith(a1))
            {
                return;
            }

            a1.addCollision(a2);
            a2.addCollision(a1);

            double v = a1.speed;

            double dx = Math.Abs(a2.x - a1.x);
            double dy = Math.Abs(a2.y - a1.y);
            double d  = Math.Sqrt((dx * dx) + (dy * dy));

            if (d == 0)
            {
                return;
            }

            double angle_b = Math.Asin(dy / d);
            double angle_d = Math.Asin(Math.Abs(a1.velocity.X) / v);
            double angle_a = (Math.PI / 2.0f) - angle_b - angle_d;
            double angle_c = angle_b - angle_a;

            double v1 = v * Math.Abs(Math.Sin(angle_a));
            double v2 = v * Math.Abs(Math.Cos(angle_a));

            double v1x = v1 * Math.Abs(Math.Cos(angle_c));
            double v1y = v1 * Math.Abs(Math.Sin(angle_c));
            double v2x = v2 * Math.Abs(Math.Cos(angle_b));
            double v2y = v2 * Math.Abs(Math.Sin(angle_b));

            if (a1.velocity.X > 0)
            {
                if (a1.x < a2.x)
                {
                    v1x = -v1x;
                }
                else
                {
                    v2x = -v2x;
                }
            }
            else
            {
                if (a1.x > a2.x)
                {
                    v2x = -v2x;
                }
                else
                {
                    v1x = -v1x;
                }
            }

            if (a1.velocity.Y > 0)
            {
                if (a1.y < a2.y)
                {
                    v1y = -v1y;
                }
                else
                {
                    v2y = -v2y;
                }
            }
            else
            {
                if (a1.y > a2.y)
                {
                    v2y = -v2y;
                }
                else
                {
                    v1y = -v1y;
                }
            }

            if (double.IsNaN(v1x) || double.IsNaN(v1y) || double.IsNaN(v2x) || double.IsNaN(v2y))
            {
                return;
            }

            // update the asteroids with their new velocities
            a1.velocity = new Vector2((float)v1x, (float)v1y);
            a2.velocity = new Vector2((float)v2x, (float)v2y);
        }