public override void Update(GameTime gameTime)
        {
            float TempsÉcoulé = (float)gameTime.ElapsedGameTime.TotalSeconds;

            TempsÉcouléDepuisMAJ += TempsÉcoulé;

            if (EstEnMarche)
            {
                AnimationPlayer.Update(gameTime.ElapsedGameTime, true, Matrix.Identity);
            }
            else
            {
                AnimationPlayer.Update(new TimeSpan(0, 0, 0), true, Matrix.Identity);
            }

            if (TempsÉcouléDepuisMAJ >= IntervalleMAJ)
            {
                EffectuerMiseÀJour();
                TempsÉcouléDepuisMAJ = 0;
            }

            CalculerMatriceMonde();

            #region Sons
            if (Entend())
            {
                if (Vector3.Distance(Position, PositionJoueurAttaqué) < 1)
                {
                    Volume = VOLUME_FAIBLE;
                }

                else
                {
                    Volume = VOLUME_FAIBLE / Vector3.Distance(Position, PositionJoueurAttaqué);
                }

                GestionSons.Play(Grognement, true, Volume);
            }

            else
            {
                GestionSons.PauseSoundEffect(Grognement);
            }

            #endregion

            //ShouldDraw = CaméraJeu.Frustum.Intersects(ZoneCollision) && (Vector3.Distance(Position, CaméraJeu.Position) <= 15 * Delta.X);

            ZombieInfo z = new ZombieInfo(Position, Rotation, NuméroIdentification, NomModèle, Échelle, NomTexture, IntervalleMAJ, Grognement, NB_PAS, NomAnim);
            base.Update(gameTime);
        }
 void Awake()
 {
     Instance = this;
 }
Beispiel #3
0
        void GérerControlePC(float tempsÉcoulé)
        {
            float deltaX, deltaY;

            Vector3 moveVector = Vector3.Zero;

            if ((GestionInput.EstEnfoncée(Keys.Space)) && PeutSauter)
            {
                GestionSons.PauseSoundEffect(NomMarche);
                GestionSons.Play(NomJumpSon, false, VOLUME_MOYEN);
                VitesseSaut = DEFAULT_JUMP_SPEED;
                PeutSauter  = false;
            }
            moveVector.Z = GérerTouche(Keys.W) - GérerTouche(Keys.S);
            moveVector.X = GérerTouche(Keys.A) - GérerTouche(Keys.D);
            if (moveVector != Vector3.Zero)
            {
                if (GestionInput.EstEnfoncée(Keys.LeftShift))
                {
                    moveVector = moveVector * 2;
                }

                if (!SonDeMarcheActivé)
                {
                    GestionSons.PauseSoundEffect(NomMarche);
                }
                if (PeutSauter && SonDeMarcheActivé && (moveVector.X > STADE_MARCHE_VITE || moveVector.X < -STADE_MARCHE_VITE ||
                                                        moveVector.Z > STADE_MARCHE_VITE || moveVector.Z < -STADE_MARCHE_VITE))
                {
                    GestionSons.PauseSoundEffect(NomMarcheLente);
                    GestionSons.Play(NomMarche, true, VOLUME_MOYEN);
                }
                else if (PeutSauter && SonDeMarcheActivé)
                {
                    GestionSons.PauseSoundEffect(NomMarche);
                    GestionSons.Play(NomMarcheLente, true, VOLUME_MOYEN);
                }

                moveVector *= tempsÉcoulé * VitesseCamera;
                Bouger(moveVector);
            }

            if (CurrentMouseState != PreviousMouseState)
            {
                deltaX = CurrentMouseState.X - (Game.GraphicsDevice.Viewport.Width / 2);
                deltaY = CurrentMouseState.Y - (Game.GraphicsDevice.Viewport.Height / 2);

                RotationSouris = new Vector3(RotationSouris.X - 0.1f * deltaX * tempsÉcoulé, RotationSouris.Y - 0.1f * deltaY * tempsÉcoulé, RotationSouris.Z);

                deltaX = 0;
                deltaY = 0;
                if (RotationSouris.Y < MathHelper.ToRadians(-75.0f))
                {
                    RotationSouris = new Vector3(RotationSouris.X, RotationSouris.Y - (RotationSouris.Y - MathHelper.ToRadians(-75.0f)), RotationSouris.Z);
                }

                if (RotationSouris.Y > MathHelper.ToRadians(75.0f))
                {
                    RotationSouris = new Vector3(RotationSouris.X, RotationSouris.Y - (RotationSouris.Y - MathHelper.ToRadians(75.0f)), RotationSouris.Z);
                }
                Rotation = new Vector3(-MathHelper.Clamp(RotationSouris.Y, MathHelper.ToRadians(-40), MathHelper.ToRadians(75.0f)),
                                       MathHelper.WrapAngle(RotationSouris.X), 0);
            }
            Mouse.SetPosition(Game.GraphicsDevice.Viewport.Width / 2, Game.GraphicsDevice.Viewport.Height / 2);
            PreviousMouseState = CurrentMouseState;
        }
Beispiel #4
0
        void GérerManette(float tempsÉcoulé)
        {
            float   deltaX, deltaY;
            Vector3 moveVector = Vector3.Zero;

            if (GestionInput.EstBoutonEnfoncée(Buttons.LeftStick))
            {
                moveVector = moveVector * 2;
            }
            //Gérer les sauts
            if ((GestionInput.EstBoutonEnfoncée(Buttons.A)) && PeutSauter)
            {
                GestionSons.PauseSoundEffect(NomMarche);
                GestionSons.Play(NomJumpSon, false, VOLUME_MOYEN);
                VitesseSaut = DEFAULT_JUMP_SPEED;
                PeutSauter  = false;
            }
            //Gérer les déplacements du joystick droit
            CameraLookAt.Y          += GérerBouton(Buttons.RightThumbstickUp) - GérerBouton(Buttons.RightThumbstickDown);
            CameraLookAt.X          += GérerBouton(Buttons.RightThumbstickRight) - GérerBouton(Buttons.RightThumbstickLeft);
            deltaY                   = CameraLookAt.Y - (Game.GraphicsDevice.Viewport.Height / 2f);
            deltaX                   = CameraLookAt.X - (Game.GraphicsDevice.Viewport.Width / 2f);
            GamePadRotationBuffer.Y += GamePad.GetState(PlayerIndex).ThumbSticks.Right.Y * 0.01f * deltaY * tempsÉcoulé;
            GamePadRotationBuffer.X += GamePad.GetState(PlayerIndex).ThumbSticks.Right.X * 0.01f * deltaX * tempsÉcoulé;


            //Déplacement de la caméra avec le joystick gauche
            moveVector.Z = GamePad.GetState(PlayerIndex).ThumbSticks.Left.Y;
            moveVector.X = -GamePad.GetState(PlayerIndex).ThumbSticks.Left.X;

            //Fait déplacer le Joueur
            if (moveVector != Vector3.Zero)
            {
                if (!SonDeMarcheActivé)
                {
                    GestionSons.PauseSoundEffect(NomMarche);
                }
                if (PeutSauter && SonDeMarcheActivé && (moveVector.X > STADE_MARCHE_VITE || moveVector.X < -STADE_MARCHE_VITE ||
                                                        moveVector.Z > STADE_MARCHE_VITE || moveVector.Z < -STADE_MARCHE_VITE))
                {
                    GestionSons.PauseSoundEffect(NomMarcheLente);
                    GestionSons.Play(NomMarche, true, VOLUME_MOYEN);
                }
                else if (PeutSauter && SonDeMarcheActivé)
                {
                    GestionSons.PauseSoundEffect(NomMarche);
                    GestionSons.Play(NomMarcheLente, true, VOLUME_MOYEN);
                }

                moveVector *= tempsÉcoulé * VitesseCamera;
                Bouger(moveVector);
            }

            if (GamePadRotationBuffer.Y < MathHelper.ToRadians(-ANGLE_ROTATION))
            {
                GamePadRotationBuffer.Y = GamePadRotationBuffer.Y - (GamePadRotationBuffer.Y - MathHelper.ToRadians(-ANGLE_ROTATION));
            }

            if (GamePadRotationBuffer.Y > MathHelper.ToRadians(ANGLE_ROTATION))
            {
                GamePadRotationBuffer.Y = GamePadRotationBuffer.Y - (GamePadRotationBuffer.Y - MathHelper.ToRadians(ANGLE_ROTATION));
            }

            Rotation = new Vector3(MathHelper.Clamp(GamePadRotationBuffer.Y + RotationInitiale.X, MathHelper.ToRadians(-ANGLE_ROTATION), MathHelper.ToRadians(ANGLE_ROTATION)),
                                   MathHelper.WrapAngle(GamePadRotationBuffer.X + RotationInitiale.Y), 0);


            deltaX = 0;
            deltaY = 0;
        }
Beispiel #5
0
        public override void Update(GameTime gameTime)
        {
            if (PreviousPosition != Position)
            {
                AnimationPlayer.Update(gameTime.ElapsedGameTime, true, Matrix.Identity);
            }
            else
            {
                AnimationPlayer.Update(new TimeSpan(0, 0, 0), true, Matrix.Identity);
            }

            PreviousPosition = Position;
            float TempsÉcoulé = (float)gameTime.ElapsedGameTime.TotalSeconds;

            CurrentGamePad    = GamePad.GetState(PlayerIndex);
            CurrentMouseState = Mouse.GetState();

            if (GestionInput.EstManetteActivée)
            {
                GérerManette(TempsÉcoulé);
            }
            else if (GestionInput.EstSourisActive || GestionInput.EstClavierActivé)
            {
                GérerControlePC(TempsÉcoulé);
            }
            else
            {
                GestionSons.PauseSoundEffect(NomMarcheLente);
                GestionSons.PauseSoundEffect(NomMarche);
            }

            if (!PeutSauter)
            {
                VitesseSaut              += TempsÉcoulé * GRAVITY;
                PositionCamera.Y         += VitesseSaut;
                CaméraJeu.CameraLookAt.Y += VitesseSaut;
            }

            if (PositionCamera.Y < PositionInitialeCamera - 1)
            {
                VitesseSaut = ASCEND_JUMP_SPEED;
                Remonte     = true;
            }
            // je peux surement mettre les deux methode ensemble
            if (Remonte)
            {
                GestionSons.Play(NomLandingSon, false, VOLUME_FAIBLE);
                VitesseSaut              -= (TempsÉcoulé * GRAVITY);
                PositionCamera.Y         += VitesseSaut;
                CaméraJeu.CameraLookAt.Y += VitesseSaut;

                if (PositionCamera.Y > PositionInitialeCamera)
                {
                    float ajusterVue = CaméraJeu.CameraLookAt.Y - PositionCamera.Y;
                    PositionCamera.Y         = PositionInitialeCamera;
                    CaméraJeu.CameraLookAt.Y = ajusterVue + PositionCamera.Y;
                    PeutSauter = true;
                    Remonte    = false;
                }
            }
            // a voir
            ZoneCollisionPowerUps = new BoundingSphere(Position, RAYON_COLLISION);
            ZoneBruit             = new BoundingSphere(Position, RAYON_ZONE_BRUIT);

            foreach (GameComponent c in Game.Components)
            {
                if (c is ObjetTournoyant)
                {
                    ObjetTournoyant o = c as ObjetTournoyant;
                    if (GestionCollisions.CollisionJoueurObjet(o.ZoneCollision, ZoneCollisionPowerUps))
                    {
                        Game.Components.Remove(c);
                        LampeDePoche.TempsÉcouléeDepuisBatterieTrouvée = 0;
                        break;
                    }
                }
            }

            Frustum = new BoundingFrustum(Matrix.Multiply(View, Projection));
            if (IsCurrentPlayer)
            {
                PlayerInfo p = new PlayerInfo(Position, Rotation, PreviousPosition, Port, IP);
            }
            CalculerMonde();
            base.Update(gameTime);
        }