Ejemplo n.º 1
0
        public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
        {
            if (levelstart && !otherScreenHasFocus)
            {
                ScreenManager.AddScreen(new MessageBoxScreen("", mouseTexture), null);
                levelstart = false;
            }

            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            if (coveredByOtherScreen)
            {
                pauseAlpha = Math.Min(pauseAlpha + 1f / 32, 1);
            }
            else
            {
                pauseAlpha = Math.Max(pauseAlpha - 1f / 32, 0);
            }

            if (!otherScreenHasFocus)
            {
                Vector2 prevCamPos = cam.position;
                cam.Update(player, objList, backgroundLayer);

                if (!player.isAlive && player.pSprite.isFinished)
                {
                    cam.position      = new Vector2(0, 0);
                    backgroundLayer   = TileLayer.FromFile(content, "Content/Layers/LevelOneBackgroundLayer.txt");
                    player._playerPos = new Vector2(150, 150);
                }

                previousPlayerPos = player._playerPos;
                player.Update(gameTime, objList, cam);

                if (player._lives == 0)
                {
                    ScreenManager.RemoveScreen(this);
                    ScreenManager.AddScreen(new GameOverScreen(player, GameOverScreen.gameOverType.GAMEOVER), null);
                }

                // COLLISION
                List <TileObject>     objRemoveList  = new List <TileObject>();
                List <TileObject>     objCreateList  = new List <TileObject>();
                List <AnimatedSprite> animRemoveList = new List <AnimatedSprite>();

                foreach (TileObject c in objList)
                {
                    if (cam.position != prevCamPos)
                    {
                        c.objPos = c.objPos - (cam.position - prevCamPos);
                    }
                    c.Update();

                    if (player._playerRec.Intersects(c.objRec))
                    {
                        if (c.objType == ObjectType.PICKUP)
                        {
                            if (player._health >= 50)
                            {
                                player._health = 100;
                            }
                            else
                            {
                                player._health += 50;
                            }
                            objRemoveList.Add(c);
                        }
                    }

                    foreach (Bullet b in player.bulletList)
                    {
                        if (b.intersectsTarget(c.objRec))
                        {
                            if (c.objType == ObjectType.DESTRUCTIBLE)
                            {
                                bulletDeleteList.Add(b);
                                objRemoveList.Add(c);
                                animList.Add(new AnimatedSprite(explosionTexture, AnimatedSprite.AnimType.PLAY_ONCE, 6, 6, 0.02f, new Vector2(c.objPos.X + c.objRec.Width / 2, c.objPos.Y + c.objRec.Width / 2), 1.5f));
                                sound.Play();
                            }
                            if (c.objType == ObjectType.CRATE)
                            {
                                bulletDeleteList.Add(b);
                                objRemoveList.Add(c);
                                int test = 1;
                                if (this.diff == GameDifficulty.HARD_MODE)
                                {
                                    test = rand.Next(0, 7);
                                }
                                else
                                {
                                    test = rand.Next(0, 5);
                                }
                                if (test == 0)
                                {
                                    objCreateList.Add(new TileObject(heart, ObjectType.PICKUP, new Vector2(c.objRec.X, c.objRec.Y)));
                                }
                            }
                        }
                    }
                }



                foreach (AnimatedSprite a in animList)
                {
                    if (cam.position != prevCamPos)
                    {
                        a.pos = a.pos - (cam.position - prevCamPos);
                    }
                    a.Update(gameTime);


                    if (a.spriteRec.Intersects(player._playerRec) && !a.playerDamaged)
                    {
                        player._health -= 30;
                        a.playerDamaged = true;
                    }
                    if (a.isFinished)
                    {
                        animRemoveList.Add(a);
                    }
                }

                foreach (AnimatedSprite a in animRemoveList)
                {
                    animList.Remove(a);
                }

                foreach (TileObject c in objCreateList)
                {
                    objList.Add(c);
                }

                foreach (TileObject c in objRemoveList)
                {
                    objList.Remove(c);
                }



                foreach (Enemy e in enemyList)
                {
                    if (cam.position != prevCamPos)
                    {
                        e._enemyPos = e._enemyPos - (cam.position - prevCamPos);
                    }
                    e.Update(player._playerRec, gameTime);

                    if (e.returnIntersect(player._playerRec))
                    {
                        if (e.canDamage)
                        {
                            player._health -= 5;
                        }
                    }

                    foreach (Bullet b in e.bulletList)
                    {
                        if (cam.position != prevCamPos)
                        {
                            b._bulletPos = b._bulletPos - (cam.position - prevCamPos);
                        }
                        if (b.intersectsTarget(player._playerRec))
                        {
                            player._health -= 10;
                            eBulletDeleteList.Add(b);
                        }
                    }

                    foreach (Bullet b in eBulletDeleteList)
                    {
                        e.bulletList.Remove(b);
                    }

                    foreach (Bullet b in player.bulletList)
                    {
                        if (b.intersectsTarget(e.enemyRec))
                        {
                            e.health -= 10;
                            bulletDeleteList.Add(b);
                        }
                    }

                    foreach (AnimatedSprite a in animList)
                    {
                        if (a.spriteRec.Intersects(e.enemyRec) && !a.damagedEnemies.Contains(e))
                        {
                            e.health -= 100;
                            a.damagedEnemies.Add(e);
                        }
                    }


                    if (e.health <= 0)
                    {
                        enemyDeleteList.Add(e);
                        if (e._type == EnemyType.normal)
                        {
                            player.score += 10;
                        }
                        if (e._type == EnemyType.fast)
                        {
                            player.score += 20;
                        }
                        if (e._type == EnemyType.hard)
                        {
                            player.score += 50;
                        }
                        if (e._type == EnemyType.projectile)
                        {
                            player.score += 70;
                        }
                        if (e._type == EnemyType.boss)
                        {
                            player.score += 100;
                        }
                    }
                }


                foreach (Bullet b in bulletDeleteList)
                {
                    player.bulletList.Remove(b);
                }

                foreach (Enemy e in enemyDeleteList)
                {
                    enemyList.Remove(e);
                }


                //LEVEL COMPLETE

                if (enemyList.Count == 0)
                {
                    ScreenManager.Game.Components.Remove(particleComponent);
                    isLevelComplete = true;
                }


                if (isLevelComplete)
                {
                    ScreenManager.RemoveScreen(this);
                    ScreenManager.AddScreen(new LevelCompleteScreen(player, this.diff, 50.0f), null);
                }
            }

            if (player.level == 3)
            {
                Emitter t2 = particleComponent.particleEmitterList[0];
                t2.Position = new Vector2((float)random.NextDouble() * (ScreenManager.Game.GraphicsDevice.Viewport.Width), 0);
                if (t2.EmittedNewParticle)
                {
                    float f = MathHelper.ToRadians(t2.LastEmittedParticle.Direction + 180);
                    t2.LastEmittedParticle.Rotation = f;
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            {
                this.Exit();
            }

            Vector2 motion = Vector2.Zero;

            KeyboardState kbs = Keyboard.GetState();

            if (kbs.IsKeyDown(Keys.W))
            {
                motion.Y--;
            }

            if (kbs.IsKeyDown(Keys.S))
            {
                motion.Y++;
            }

            if (kbs.IsKeyDown(Keys.D))
            {
                motion.X++;
            }

            if (kbs.IsKeyDown(Keys.A))
            {
                motion.X--;
            }


            Vector2 prevCamPos = cameraPosition;

            if (motion != Vector2.Zero)
            {
                motion.Normalize();
            }
            cameraPosition += motion * cameraSpeed;


            if (cameraPosition.Y < 0)
            {
                cameraPosition.Y = 0;
            }
            if (cameraPosition.X < 0)
            {
                cameraPosition.X = 0;
            }

            int screenW = GraphicsDevice.Viewport.Width;
            int screenH = GraphicsDevice.Viewport.Height;

            int tilemapWidth  = tileMap.GetLength(1) * tileWidth;
            int tilemapHeight = tileMap.GetLength(0) * tileHeight;

            if (cameraPosition.Y > tilemapHeight - screenH)
            {
                cameraPosition.Y = tilemapHeight - screenH;
            }
            if (cameraPosition.X > tilemapWidth - screenW)
            {
                cameraPosition.X = tilemapWidth - screenW;
            }


            // COLLISION
            previousPlayerPos = player._playerPos;
            player.Update(gameTime);

            List <CollisionObject> objRemoveList = new List <CollisionObject>();

            foreach (CollisionObject c in objList)
            {
                if (prevCamPos != cameraPosition)
                {
                    c.objPos = c.objPos - (cameraPosition - prevCamPos);
                }
                c.Update();

                if (player._playerRec.Intersects(c.objRec))
                {
                    if (c.objType == (int)objectType.destroy)
                    {
                        if (player._health >= 50)
                        {
                            player._health = 100;
                        }
                        else
                        {
                            player._health += 50;
                        }
                        objRemoveList.Add(c);
                    }

                    /*if (c.objType == (int)objectType.collision)
                     * {
                     *  player._playerPos = previousPlayerPos;
                     * }*/
                }
            }



            foreach (CollisionObject c in objRemoveList)
            {
                objList.Remove(c);
            }


            // COLLISION


            foreach (Enemy e in enemyList)
            {
                if (prevCamPos != cameraPosition)
                {
                    e._enemyPos = e._enemyPos - (cameraPosition - prevCamPos);
                }
                e.Update(player._playerRec, gameTime);

                if (e.returnIntersect(new Rectangle((int)player._playerPos.X, (int)player._playerPos.Y, player._playerTexture.Width / 2, player._playerTexture.Height / 2)))
                {
                    if (e.canDamage)
                    {
                        player._health -= 5;
                    }
                }

                foreach (Bullet b in e.bulletList)
                {
                    if (b.intersectsTarget(player._playerRec))
                    {
                        player._health -= 10;
                        eBulletDeleteList.Add(b);
                    }
                }

                foreach (Bullet b in eBulletDeleteList)
                {
                    e.bulletList.Remove(b);
                }

                foreach (Bullet b in player.bulletList)
                {
                    if (b.intersectsTarget(e.enemyRec))
                    {
                        e.health -= 10;
                        bulletDeleteList.Add(b);

                        if (e.health <= 0)
                        {
                            enemyDeleteList.Add(e);
                            // TO DO : increase score based on enemy type
                            player.score += 10;
                        }
                    }
                }
            }



            foreach (Bullet b in bulletDeleteList)
            {
                player.bulletList.Remove(b);
            }

            foreach (Enemy e in enemyDeleteList)
            {
                enemyList.Remove(e);
            }


            base.Update(gameTime);
        }