Esempio n. 1
0
        public MoteurJeu(MoteurSysteme moteurSysteme, MoteurPhysique moteurPhysique)
        {
            statusJeu = Status.MenuAccueil;

            meteo = Meteo.Neige;

            menuManager = new MenuManager(this);

            this.moteurPhysique = moteurPhysique;
            this.moteurSysteme = moteurSysteme;

            evenementUtilisateur = new EvenementUtilisateur();

            menuAccueuilFond = new Sprite(new Rectangle(0, 0, Constante.WindowWidth, Constante.WindowHeight));

            carte = new Carte(moteurPhysique, moteurSysteme.carteArray, Vector2.Zero, 64, 64, 32, 16);

            carte.SetCarte();

            personnage = new Personnage("Meta", new Vector2(3, 3), moteurPhysique.collisionCarte);
            monstres.Add(new Monstre(MonstreType.rondoudou, new Vector2(10, 8), moteurPhysique.collisionCarte));
            //monstres.Add(new Monstre(MonstreType.brasegali, new Vector2(3, 5), moteurPhysique.collisionCarte));

            hud = new HUD(personnage);

            animations.Add(new Animation());

            combat = new Combat(moteurPhysique, evenementUtilisateur);
        }
Esempio n. 2
0
        public Combat(MoteurPhysique moteurPhysique, EvenementUtilisateur evenementUtilisateur)
        {
            this.moteurPhysique = moteurPhysique;
            this.evenementUtilisateur = evenementUtilisateur;
            camera = new Vector2(14*32 - 16 + 8, 0);

            phase = PhaseCombat.Placement;

            hud = new HudCombat(this);
        }
Esempio n. 3
0
        protected override void Initialize()
        {
            moteurSysteme = new MoteurSysteme();
            moteurPhysique = new MoteurPhysique();
            moteurJeu = new MoteurJeu(moteurSysteme, moteurPhysique);
            moteurAudio = new MoteurAudio(moteurJeu);
            moteurGraphique = new MoteurGraphique(moteurJeu);

            base.Initialize();
        }
Esempio n. 4
0
        public void Aggro(Vector2 positionJoueur, MoteurPhysique moteurPhysique)
        {
            if (!isAggro)
            {
                timeToWait = 1;
                MoteurAudio.PlaySound("Aggro");
                isAggro = true;
            }

            if (timeToWait <= 0)
                Bouger(positionJoueur, moteurPhysique);
        }
Esempio n. 5
0
        public Carte(MoteurPhysique moteurPhysique, List<string>[,] charArray, Vector2 camera, int tileWidth, int tileHeight, int tileStepX, int tileStepY)
        {
            this.moteurPhysique = moteurPhysique;
            this.camera = camera;
            this.tileWidth = tileWidth;
            this.tileHeight = tileHeight;
            this.tileStepX = tileStepX;
            this.tileStepY = tileStepY;

            tuileArray = new List<Tuile>[charArray.GetLength(0), charArray.GetLength(1)];

            for (int x = 0; x < charArray.GetLength(0); x++)
                for (int y = 0; y < charArray.GetLength(1); y++)
                    tuileArray[y, x] = new List<Tuile>();

            InitTileArray(charArray);

            tuileHover = new Vector2(10, 10);
        }
Esempio n. 6
0
 public void Bouger(Vector2 tileHover, MoteurPhysique moteurPhysique)
 {
     if (path.Count == 0)
         path = moteurPhysique.GetPath(positionTile, tileHover);
 }
Esempio n. 7
0
        public void Update(GameTime gameTime, Vector2 camera, MoteurPhysique moteurPhysique)
        {
            hauteur = carte[(int)positionTile.X, (int)positionTile.Y];

            if (isCombat)
                positionTile = positionTileCombat;
            else
                positionTile = positionTileCarte;

            timeElapsedMove += (float)gameTime.ElapsedGameTime.TotalSeconds;

            if (timeToWait > 0)
                timeToWait -= (float)gameTime.ElapsedGameTime.TotalSeconds;

            if (message != "")
                timeElapsedMessage += (float)gameTime.ElapsedGameTime.TotalSeconds;

            if (timeElapsedMessage > timeToSay)
            {
                timeElapsedMessage = 0;
                message = "";
            }

            if (timeElapsedMove > timeToMove)
            {
                timeElapsedMove -= timeToMove + Constante.Random.Next(-3, 3);

                if (!isAggro)
                    BougerRnd(moteurPhysique);
            }

            this.camera = camera;

            if (path.Count > 0)
            {
                isMoving = true;

                if (positionTile != path[0])
                    SetDeplacement();
                else
                {
                    deplacement = Vector2.Zero;
                    path.RemoveAt(0);
                }
            }
            else
            {
                isMoving = false;
                deplacement = Vector2.Zero;
            }

            SetDirection();

            if (deplacement != Vector2.Zero)
                deplacement.Normalize();

            positionTile += deplacement * vitesse;

            positionTile.X = (float)Math.Round(positionTile.X, 2, MidpointRounding.ToEven);
            positionTile.Y = (float)Math.Round(positionTile.Y, 2, MidpointRounding.ToEven);

            spriteAnime.IsAnimate(isMoving);
            spriteAnime.Update(gameTime, Constante.ConvertToIso(positionTile) + new Vector2(16, 20 - (hauteur - 1) * 12) + camera);

            if (isCombat)
                positionTileCombat = positionTile;
            else
                positionTileCarte = positionTile;
        }
Esempio n. 8
0
        public void BougerRnd(MoteurPhysique moteurPhysique)
        {
            if (path.Count == 0)
            {
                int radius = 1;

                Vector2 nextPosition;

                do
                {
                nextPosition.X = Constante.Random.Next(-radius, radius);
                nextPosition.Y = Constante.Random.Next(-radius, radius);
                } while ((nextPosition.X <= 0 && nextPosition.X >= Constante.TotalWidth) && ((nextPosition.Y <= 0 && nextPosition.Y >= Constante.TotalHeight)));

                path = moteurPhysique.GetPath(positionTile, positionTile + nextPosition);
            }
        }