Esempio n. 1
0
        public override void Draw(MonoGameRenderer renderer)
        {
            //// draw backdround
            renderer.DrawBattleBackground();
            renderer.DrawBattleMenu();
            renderer.DrawBattleStateButtons();
            renderer.DrawHeroMenuText();
            renderer.DrawEnemyMenuText();

            for (int i = 0; i < renderer.ShieldsCasted.Count; i++)
            {
                if (renderer.ShieldsCasted[i].IsVisible)
                {
                    renderer.ShieldsCasted[i].Draw(EntryPoint.Game.SpriteBatch);
                }
                else
                {
                    renderer.ShieldsCasted.Remove(renderer.ShieldsCasted[i]);
                }
            }

            foreach (var spell in renderer.SpellsCasted)
            {
                spell.Draw(EntryPoint.Game.SpriteBatch);
                spell.Update(renderer.GameTime);
            }

            renderer.DrawHero();
            renderer.DrawEnemyHero();

            renderer.MainHero.Update(renderer);
            renderer.EnemyHero.Update(renderer);

            renderer.DrawSpellInfoWindow();
        }
Esempio n. 2
0
        public override void Execute(MonoGameRenderer renderer)
        {
            Button gobackButton = renderer.GoBackButton;
            bool mouseOverGoBack = gobackButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);

            if (Keyboard.GetState().IsKeyDown(Keys.Space) && this.state.IsKeyUp(Keys.Space))
            {
                EntryPoint.Game.Renderer = new MonoGameRenderer();
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(EntryPoint.Game.Renderer);
            }

            this.state = Keyboard.GetState();

            if (mouseOverGoBack)
            {
                gobackButton.ChangeToHoverImage();
            }
            else
            {
                gobackButton.ChangeToInactiveImage();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverGoBack)
            {
                gobackButton.ChangeToClickedImage();
                EntryPoint.Game.Renderer = new MonoGameRenderer();
                ////EntryPoint.game.renderer.ShouldPlayerMove = true;
                // StateMachine.CurrentState.NextState = StateMachine.menuSelectState;
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(EntryPoint.Game.Renderer);
            }
        }
Esempio n. 3
0
 public override void Execute(MonoGameRenderer renderer)
 {
     KeyboardState state = Keyboard.GetState();
     if (state.IsKeyDown(Keys.Enter))
     {
         StateMachine.ChangeState();
     }
 }
Esempio n. 4
0
 public override void ActOnPlayer(Character mainCharacter, MonoGameRenderer renderer)
 {
     if (this.TileRectangle.Contains(mainCharacter.Bounds))
     {
         StateMachine.CurrentState.NextState = StateMachine.FireMap;
         StateMachine.ChangeState();
         StateMachine.CurrentState.Execute(renderer);
     }
 }
Esempio n. 5
0
        public override void Draw(MonoGameRenderer renderer)
        {
            renderer.DrawBackGround();

            renderer.BlueButton.Sprite.Rectangle = new Rectangle(415, 350, 450, 80);
            renderer.GreenButton.Sprite.Rectangle = new Rectangle(415, 250, 450, 80);
            renderer.RedButton.Sprite.Rectangle = new Rectangle(415, 450, 450, 80);

            renderer.DrawStartMenuButtons();
        }
Esempio n. 6
0
        public override void Draw(MonoGameRenderer renderer)
        {
            renderer.DrawMap(renderer.FireMap);
            renderer.UpdateMap(renderer.FireMap);

            renderer.RedCastle.Sprite.Rectangle = new Rectangle(666, 35, renderer.BlueCastle.Sprite.Rectangle.Width, renderer.BlueCastle.Sprite.Rectangle.Height);
            renderer.DrawRedCastle();

            renderer.DrawMainCharacter();
            renderer.UpdateMainCharacter();
        }
Esempio n. 7
0
        public override void Execute(MonoGameRenderer renderer)
        {
            base.Execute(renderer);
            foreach (var tile in renderer.FireMap.TileMap)
            {
                tile.ActOnPlayer(renderer.MainCharacter, renderer);
            }

            renderer.MainHero.Health = renderer.MainHero.MaxHealth;
            renderer.MainHero.Mana = renderer.MainHero.MaxMana;
            renderer.MainHero.Update(renderer);
        }
        public override void Draw(MonoGameRenderer renderer)
        {
            renderer.DrawBlackBackground();
            renderer.DrawBlueCastle();
            renderer.DrawRedCastle();
            renderer.DrawGreenCastle();

            renderer.BlueButton.Sprite.Rectangle = new Rectangle(175, 500, 250, 80);
            renderer.GreenButton.Sprite.Rectangle = new Rectangle(875, 500, 250, 80);
            renderer.RedButton.Sprite.Rectangle = new Rectangle(530, 500, 250, 80);

            renderer.DrawSchoolSelectButtons();
        }
Esempio n. 9
0
 public override void Draw(MonoGameRenderer renderer)
 {
     if (renderer.MainHero.HasWon)
     {
         renderer.DrawBlackBackground();
         renderer.DrawWinLogo();
         renderer.DrawGoBackButton();
     }
     else
     {
         renderer.DrawLoserBackground();
         renderer.DrawGoBackButton();
     }
 }
Esempio n. 10
0
        public override void Execute(MonoGameRenderer renderer)
        {
            KeyboardState state = Keyboard.GetState();

            if (state.IsKeyDown(Keys.Up))
            {
                renderer.MainCharacter.CharacterMovement = CharacterMovement.Up;
                Vector2 velocity = new Vector2(0, -5);
                renderer.MainCharacter.Velocity = velocity;
            }
            else if (state.IsKeyDown(Keys.Down))
            {
                renderer.MainCharacter.CharacterMovement = CharacterMovement.Down;
                Vector2 velocity = new Vector2(0, 5);
                renderer.MainCharacter.Velocity = velocity;
            }
            else if (state.IsKeyDown(Keys.Left))
            {
                renderer.MainCharacter.CharacterMovement = CharacterMovement.Left;
                Vector2 velocity = new Vector2(-5, 0);
                renderer.MainCharacter.Velocity = velocity;
            }
            else if (state.IsKeyDown(Keys.Right))
            {
                renderer.MainCharacter.CharacterMovement = CharacterMovement.Right;
                Vector2 velocity = new Vector2(5, 0);
                renderer.MainCharacter.Velocity = velocity;
            }
            else
            {
                renderer.MainCharacter.CharacterMovement = CharacterMovement.Stationary;
                Vector2 velocity = new Vector2(0, 0);
                renderer.MainCharacter.Velocity = velocity;
            }

            if (renderer.EnemyCounter == 0)
            {
                renderer.MainHero.HasWon = true;
                StateMachine.CurrentState.NextState = StateMachine.GameOverState;
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(renderer);
                return;
            }
        }
Esempio n. 11
0
        public override void ActOnPlayer(Character mainCharacter, MonoGameRenderer renderer)
        {
            if (this.TileRectangle.Intersects(mainCharacter.Bounds))
            {
                renderer.Enemy = this;
                renderer.EnemyHero = UIInitializer.CreateEnemyHero(EntryPoint.Game.Content);
                if (renderer.PoisonMap.EnemyCounter == 1)
                {
                    renderer.EnemyHero.Level = 3;
                    renderer.EnemyHero.Health = renderer.MainHero.MaxHealth;
                    renderer.EnemyHero.Mana = renderer.MainHero.MaxMana;
                }
                else if (renderer.PoisonMap.EnemyCounter == 2)
                {
                    renderer.EnemyHero.Level = 2;
                    renderer.EnemyHero.Health = (int)(renderer.MainHero.MaxHealth * 0.75);
                    renderer.EnemyHero.Mana = (int)(renderer.MainHero.MaxMana * 0.75);
                }
                else if (renderer.PoisonMap.EnemyCounter == 3)
                {
                    renderer.EnemyHero.Level = 1;
                    renderer.EnemyHero.Health = (int)(renderer.MainHero.MaxHealth * 0.60);
                    renderer.EnemyHero.Mana = (int)(renderer.MainHero.MaxMana * 0.60);
                }

                renderer.EnemyHero.Texture = EntryPoint.Game.Content.Load<Texture2D>("BigGreenMage");
                renderer.EnemyHero.MagicSchool = SpellType.Poison;
                renderer.EnemyHero.PlayerSpells = renderer.PoisonSpells;
                renderer.EnemyHero.Update(renderer);

                if (!this.IsDefeated)
                {
                    StateMachine.BattleState.IsInitialized = false;
                    StateMachine.PreviousState = StateMachine.PoisonMap;
                    StateMachine.CurrentState.NextState = StateMachine.BattleState;
                    StateMachine.BattleState.NextState = StateMachine.EndTurnState;
                    StateMachine.EndTurnState.NextState = StateMachine.EnemyTurnState;
                    StateMachine.EnemyTurnState.NextState = StateMachine.BattleState;
                    StateMachine.ChangeState();
                    StateMachine.CurrentState.Execute(renderer);
                }
            }
        }
Esempio n. 12
0
        public override void ActOnPlayer(Character mainCharacter, MonoGameRenderer renderer)
        {
            bool isMainCharacterXInRectangleWhenPressingLeft = mainCharacter.Bounds.Left + mainCharacter.Velocity.X <= TileRectangle.Right &&
                      mainCharacter.Bounds.Left + mainCharacter.Velocity.X >= TileRectangle.Left;

            bool isMainCharacterXInRectangleWhenPressingRight = mainCharacter.Bounds.Right + mainCharacter.Velocity.X >= TileRectangle.Left &&
                 mainCharacter.Bounds.Right + mainCharacter.Velocity.X <= TileRectangle.Right;

            bool isMainCharacterYInRectangleWhenPressingDown = mainCharacter.Bounds.Bottom + mainCharacter.Velocity.Y >= TileRectangle.Top &&
                 mainCharacter.Bounds.Bottom + mainCharacter.Velocity.Y <= TileRectangle.Bottom;

            bool isMainCharacterYInRectangleWhenPressingUp = mainCharacter.Bounds.Top + mainCharacter.Velocity.Y <= TileRectangle.Bottom &&
                 mainCharacter.Bounds.Top + mainCharacter.Velocity.Y >= TileRectangle.Top;

            if (isMainCharacterXInRectangleWhenPressingLeft)
            {
                if (isMainCharacterYInRectangleWhenPressingDown)
                {
                    Vector2 velocity = new Vector2(0, 0);
                    mainCharacter.Velocity = velocity;
                }
                else if (isMainCharacterYInRectangleWhenPressingUp)
                {
                    Vector2 velocity = new Vector2(0, 0);
                    mainCharacter.Velocity = velocity;
                }
            }

            if (isMainCharacterXInRectangleWhenPressingRight)
            {
                if (isMainCharacterYInRectangleWhenPressingDown)
                {
                    Vector2 velocity = new Vector2(0, 0);
                    mainCharacter.Velocity = velocity;
                }
                else if (isMainCharacterYInRectangleWhenPressingUp)
                {
                    Vector2 velocity = new Vector2(0, 0);
                    mainCharacter.Velocity = velocity;
                }
            }
        }
Esempio n. 13
0
 public override void Draw(MonoGameRenderer renderer)
 {
     renderer.DrawInitialScreenAnimation();
     renderer.UpdateInitialScreenAnimation();
 }
Esempio n. 14
0
 public abstract void Execute(MonoGameRenderer renderer);
Esempio n. 15
0
 public override void Draw(MonoGameRenderer renderer)
 {
     renderer.DrawCreditsBackground();
     renderer.DrawCreditsSprite();
     renderer.DrawGoBackButton();
 }
Esempio n. 16
0
 public virtual void ActOnPlayer(Character mainCharacter, MonoGameRenderer renderer)
 {
 }
Esempio n. 17
0
 public abstract void Draw(MonoGameRenderer renderer);
Esempio n. 18
0
        public override void Execute(MonoGameRenderer renderer)
        {
            if (!this.IsInitialized)
            {
                StateMachine.BattleState.NextState = StateMachine.EndTurnState;
                renderer.EnemyHero.HasBeenAfflicted = false;
                this.IsInitialized = true;
            }

            if (renderer.EnemyHero.Health <= 0 || Keyboard.GetState().IsKeyDown(Keys.Enter))
            {
                renderer.MainHero.Experiecnce += renderer.EnemyHero.Level * 100;
                if (renderer.MainHero.Experiecnce >= renderer.MainHero.ExperienceNeeded)
                {
                    renderer.MainHero.Experiecnce = renderer.MainHero.Experiecnce - renderer.MainHero.ExperienceNeeded;
                    renderer.MainHero.ExperienceNeeded = renderer.MainHero.ExperienceNeeded * 2;
                    renderer.MainHero.Level = renderer.MainHero.Level + 1;
                }

                renderer.MainHero.Affliction = Affliction.None;
                renderer.EnemyHero.Affliction = Affliction.None;
                renderer.MainHero.Health = renderer.MainHero.MaxHealth;
                renderer.MainHero.Mana = renderer.MainHero.MaxMana;
                renderer.MainHero.Armor = 0;
                renderer.Enemy.IsDefeated = true;
                renderer.EnemyCounter--;
                if (StateMachine.PreviousState == StateMachine.IceMap)
                {
                    renderer.IceMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.FireMap)
                {
                    renderer.FireMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.PoisonMap)
                {
                    renderer.PoisonMap.EnemyCounter--;
                }

                StateMachine.CurrentState.NextState = StateMachine.PreviousState;
                StateMachine.ChangeState();
                StateMachine.BattleState.NextState = StateMachine.EndTurnState;
                StateMachine.CurrentState.Execute(renderer);
            }

            if (renderer.EnemyHero.Level >= 3)
            {
                if (renderer.EnemyHero.Health > renderer.EnemyHero.MaxHealth / 2)
                {
                    CastBigSpell(renderer);
                    return;
                }
            }

            if (renderer.EnemyHero.Level >= 2)
            {
                if (renderer.EnemyHero.Armor <= 0)
                {
                    if (renderer.EnemyHero.Mana >= renderer.EnemyHero.PlayerSpells[1].ManaCost)
                    {
                        if (renderer.EnemyHero.Armor == 0)
                        {
                            if (renderer.EnemyHero.MagicSchool == SpellType.Fire)
                            {
                                renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.FireShield(true));
                            }
                            else if (renderer.EnemyHero.MagicSchool == SpellType.Ice)
                            {
                                renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.IceBarrier(true));
                            }
                            else if (renderer.EnemyHero.MagicSchool == SpellType.Poison)
                            {
                                renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.PoisonCloud(true));
                            }
                        }

                        renderer.EnemyHero.Armor = renderer.EnemyHero.PlayerSpells[1].Armor;
                        renderer.EnemyHero.Mana -= renderer.EnemyHero.PlayerSpells[1].ManaCost;
                        renderer.EnemyHero.Affliction = Affliction.None;

                        renderer.MainHero.HasBeenHit = false;
                        AddManaPerTurn(renderer);
                        StateMachine.BattleState.IsInitialized = false;
                        StateMachine.ChangeState();
                        StateMachine.CurrentState.Execute(renderer);
                        return;
                    }
                    else
                    {
                        CastSmallSpell(renderer);
                    }
                }
                else
                {
                    if (renderer.EnemyHero.Mana >= renderer.EnemyHero.PlayerSpells[2].ManaCost && renderer.EnemyHero.Level >= 3)
                    {
                        CastBigSpell(renderer);
                        return;
                    }
                    else
                    {
                        CastSmallSpell(renderer);
                    }
                }
            }
            else if (renderer.EnemyHero.Level >= 1)
            {
                CastSmallSpell(renderer);
            }

            if (renderer.MainHero.Health <= 0)
            {
                StateMachine.CurrentState.NextState = StateMachine.GameOverState;
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(renderer);
                return;
            }
        }
Esempio n. 19
0
        private static void CastSmallSpell(MonoGameRenderer renderer)
        {
            if (renderer.EnemyHero.MagicSchool == SpellType.Fire)
            {
                renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Fireball(true));
            }
            else if (renderer.EnemyHero.MagicSchool == SpellType.Ice)
            {
                renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Icebolt(true));
            }
            else if (renderer.EnemyHero.MagicSchool == SpellType.Poison)
            {
                renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Poisonbolt(true));
            }

            renderer.EnemyHero.Mana -= renderer.EnemyHero.PlayerSpells[0].ManaCost;
            if (renderer.EnemyHero.Affliction == Affliction.Poisoned)
            {
                if (renderer.MainHero.Mana > 0)
                {
                    renderer.MainHero.Mana -= 5;
                }

                if (renderer.MainHero.Mana < 0)
                {
                    renderer.MainHero.Mana = 0;
                }
            }

            renderer.MainHero.HasBeenHit = false;
            AddManaPerTurn(renderer);
            StateMachine.BattleState.IsInitialized = false;
            StateMachine.ChangeState();
            StateMachine.CurrentState.Execute(renderer);
            return;
        }
Esempio n. 20
0
        public override void Execute(MonoGameRenderer renderer)
        {
            if (renderer.EnemyHero.Health <= 0 || Keyboard.GetState().IsKeyDown(Keys.Enter))
            {
                renderer.MainHero.Experiecnce += renderer.EnemyHero.Level * 100;
                if (renderer.MainHero.Experiecnce >= renderer.MainHero.ExperienceNeeded)
                {
                    renderer.MainHero.Experiecnce = renderer.MainHero.Experiecnce - renderer.MainHero.ExperienceNeeded;
                    renderer.MainHero.ExperienceNeeded = renderer.MainHero.ExperienceNeeded * 2;
                    renderer.MainHero.Level = renderer.MainHero.Level + 1;
                }

                renderer.MainHero.Affliction = Affliction.None;
                renderer.EnemyHero.Affliction = Affliction.None;
                renderer.MainHero.Health = renderer.MainHero.MaxHealth;
                renderer.MainHero.Mana = renderer.MainHero.MaxMana;
                renderer.MainHero.Armor = 0;
                renderer.Enemy.IsDefeated = true;
                renderer.EnemyCounter--;
                if (StateMachine.PreviousState == StateMachine.IceMap)
                {
                    renderer.IceMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.FireMap)
                {
                    renderer.FireMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.PoisonMap)
                {
                    renderer.PoisonMap.EnemyCounter--;
                }

                StateMachine.CurrentState.NextState = StateMachine.PreviousState;
                StateMachine.ChangeState();
                StateMachine.BattleState.NextState = StateMachine.EndTurnState;
                StateMachine.CurrentState.Execute(renderer);
            }

            Button endTurnButton = renderer.EndTurnButton;
            endTurnButton.ChangeToInactiveImage();

            bool mouseOverEndTurn = endTurnButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);

            if (mouseOverEndTurn)
            {
                endTurnButton.ChangeToHoverImage();
            }
            else
            {
                endTurnButton.ChangeToInactiveImage();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && this.mouseState.LeftButton == ButtonState.Released && mouseOverEndTurn && renderer.SpellsCasted.Count == 0)
            {
                endTurnButton.ChangeToClickedImage();
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(renderer);
            }

            this.mouseState = Mouse.GetState();
        }
Esempio n. 21
0
 public override void Draw(MonoGameRenderer renderer)
 {
 }
Esempio n. 22
0
        public virtual void Update(MonoGameRenderer renderer)
        {
            this.MaxHealth = STARTING_HEALTH + (this.Level * 20);
            this.MaxMana = STARTING_MANA + (this.Level * 20);

            for (int i = 0; i < renderer.ShieldsCasted.Count; i++)
            {
                if (renderer.ShieldsCasted[i].Bounds.Intersects(this.Bounds))
                {
                    if (this.Armor <= 0)
                    {
                        renderer.ShieldsCasted[i].IsVisible = false;
                    }
                }
            }

            if (this.Affliction == Enumerations.Affliction.None)
            {
                 this.DamageIncrease = 0;
            }

            if (this.Turns == 0)
            {
                this.Affliction = Enumerations.Affliction.None;
                this.DamageIncrease = 0;
            }

            if (!this.HasBeenAfflicted)
            {
                if (this.Affliction == Enumerations.Affliction.Burning)
                {
                    if (this.Turns == 0)
                    {
                        this.Affliction = Enumerations.Affliction.None;
                    }
                    else
                    {
                        this.Health = this.Health - 10;
                        this.Turns--;
                    }
                }

                if (this.Affliction == Enumerations.Affliction.Frozen)
                {
                    if (this.Turns == 0)
                    {
                        this.Affliction = Enumerations.Affliction.None;
                        this.DamageIncrease = 0;
                    }
                    else
                    {
                        this.DamageIncrease = 10;
                        this.Turns--;
                    }
                }
                else if (this.Affliction == Enumerations.Affliction.Poisoned)
                {
                    if (this.Turns == 0)
                    {
                        this.Affliction = Enumerations.Affliction.None;
                    }
                    else
                    {
                        this.Health = this.Health - 5;
                        this.Turns--;
                    }
                }

                this.HasBeenAfflicted = true;
            }

            if (!this.HasBeenHit)
            {
                Random rng = new Random();

                for (int i = 0; i < renderer.SpellsCasted.Count; i++)
                {
                    if (renderer.SpellsCasted[i].Bounds.Intersects(this.Bounds) && renderer.SpellsCasted[i].MySpell.Armor == 0)
                    {
                        bool isFireAgainstIce = this.MagicSchool == SpellType.Ice && renderer.SpellsCasted[i].MySpell.Type == SpellType.Fire;
                        bool isPoisonAgainstFire = this.MagicSchool == SpellType.Fire && renderer.SpellsCasted[i].MySpell.Type == SpellType.Poison;
                        bool isIceAgainstPoison = this.MagicSchool == SpellType.Poison && renderer.SpellsCasted[i].MySpell.Type == SpellType.Ice;

                        if (this.Armor > 0)
                        {
                            if (isFireAgainstIce || isPoisonAgainstFire || isIceAgainstPoison)
                            {
                                int damage = (renderer.SpellsCasted[i].MySpell.Damage + this.DamageIncrease) - (int)(this.Armor / 2);
                                if (damage > 0)
                                {
                                    this.Health = this.Health - damage;
                                    this.Armor = 0;
                                }
                                else
                                {
                                    this.Armor = Math.Abs(damage) * 2;
                                }
                            }
                            else
                            {
                                this.Armor = this.Armor - (renderer.SpellsCasted[i].MySpell.Damage + this.DamageIncrease);
                                if (this.Armor < 0)
                                {
                                    this.Health = this.Health + this.Armor;
                                    this.Armor = 0;
                                }
                            }
                        }
                        else
                        {
                            int number = rng.Next(1, 101);
                            if (number < renderer.SpellsCasted[i].MySpell.ChanceToCauseAffliction)
                            {
                                if (renderer.SpellsCasted[i].MySpell.Type == SpellType.Ice)
                                {
                                    this.Affliction = Enumerations.Affliction.Frozen;
                                    this.Turns = 2;
                                }
                                else if (renderer.SpellsCasted[i].MySpell.Type == SpellType.Fire)
                                {
                                    this.Affliction = Enumerations.Affliction.Burning;
                                    this.Turns = 2;
                                }
                                else
                                {
                                    this.Affliction = Enumerations.Affliction.Poisoned;
                                    this.Turns = 2;
                                }
                            }

                            this.Health = this.Health - (renderer.SpellsCasted[i].MySpell.Damage + this.DamageIncrease);
                        }

                        renderer.SpellsCasted.Remove(renderer.SpellsCasted[i]);
                        this.HasBeenHit = true;
                    }
                }
            }
        }
Esempio n. 23
0
        public override void Execute(MonoGameRenderer renderer)
        {
            Button startButton = renderer.GreenButton;
            Button exitButton = renderer.RedButton;
            Button optionsButton = renderer.BlueButton;

            bool mouseOverStart = startButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverExit = exitButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverOptions = optionsButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);

            if (mouseOverStart)
            {
                startButton.ChangeToHoverImage();
            }
            else
            {
                startButton.ChangeToInactiveImage();
            }

            if (mouseOverExit)
            {
                exitButton.ChangeToHoverImage();
            }
            else
            {
                exitButton.ChangeToInactiveImage();
            }

            if (mouseOverOptions)
            {
                optionsButton.ChangeToHoverImage();
            }
            else
            {
                optionsButton.ChangeToInactiveImage();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverStart)
            {
                startButton.ChangeToClickedImage();
                StateMachine.CurrentState.NextState = StateMachine.SchoolSelectState;
                ////EntryPoint.game.renderer.ShouldPlayerMove = true;
                StateMachine.ChangeState();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverExit)
            {
                exitButton.ChangeToClickedImage();
                ////EntryPoint.game.renderer.ShouldPlayerMove = true;
                ////StateMachine.ChangeState();
                EntryPoint.Game.Exit();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverOptions)
            {
                optionsButton.ChangeToClickedImage();
                ////EntryPoint.game.renderer.ShouldPlayerMove = true;
                StateMachine.CurrentState.NextState = StateMachine.CreditsState;
                StateMachine.ChangeState();
            }
        }
Esempio n. 24
0
 private static void AddManaPerTurn(MonoGameRenderer renderer)
 {
     if (renderer.EnemyHero.Mana < renderer.EnemyHero.MaxMana)
     {
         renderer.EnemyHero.Mana += 10;
         if (renderer.EnemyHero.Mana > renderer.EnemyHero.MaxMana)
         {
             renderer.EnemyHero.Mana = renderer.EnemyHero.MaxMana;
         }
     }
 }
Esempio n. 25
0
        public override void Execute(MonoGameRenderer renderer)
        {
            if (!this.IsInitialized)
            {
                renderer.BattleStateButtonOne.ChangeToInactiveImage();
                renderer.BattleStateButtonTwo.ChangeToInactiveImage();
                renderer.BattleStateButtonThree.ChangeToInactiveImage();

                this.Index = 3;
                renderer.MainHero.HasBeenAfflicted = false;
                StateMachine.EnemyTurnState.IsInitialized = false;
                this.IsInitialized = true;
            }

            if (renderer.MainHero.Health <= 0)
            {
                StateMachine.CurrentState.NextState = StateMachine.GameOverState;
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(renderer);
                return;
            }

            bool mouseOverOne = renderer.BattleStateButtonOne.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverTwo = renderer.BattleStateButtonTwo.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverThree = renderer.BattleStateButtonThree.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverSpellCast = renderer.SpellCastButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverEndTurn = renderer.EndTurnButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);

            if (this.Index == 3)
            {
                renderer.SpellCastButton.ChangeToClickedImage();
            }
            else
            {
                renderer.SpellCastButton.ChangeToInactiveImage();
                if (mouseOverSpellCast)
                {
                    renderer.SpellCastButton.ChangeToHoverImage();
                }
            }

            if (mouseOverEndTurn)
            {
                renderer.EndTurnButton.ChangeToHoverImage();
            }
            else
            {
                renderer.EndTurnButton.ChangeToInactiveImage();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && this.mouseState.LeftButton == ButtonState.Released && mouseOverEndTurn && renderer.SpellsCasted.Count == 0)
            {
                renderer.EndTurnButton.ChangeToClickedImage();
                AddManaPerTurn(renderer);
                StateMachine.CurrentState.NextState = StateMachine.EnemyTurnState;
                StateMachine.ChangeState();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverOne && renderer.MainHero.Mana >= renderer.MainHero.PlayerSpells[0].ManaCost)
            {
                renderer.BattleStateButtonOne.ChangeToClickedImage();
                renderer.BattleStateButtonTwo.ChangeToInactiveImage();
                renderer.BattleStateButtonThree.ChangeToInactiveImage();
                this.Index = 0;
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverTwo && renderer.MainHero.Mana >= renderer.MainHero.PlayerSpells[1].ManaCost)
            {
                renderer.BattleStateButtonOne.ChangeToInactiveImage();
                renderer.BattleStateButtonTwo.ChangeToClickedImage();
                renderer.BattleStateButtonThree.ChangeToInactiveImage();
                this.Index = 1;
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverThree && renderer.MainHero.Mana >= renderer.MainHero.PlayerSpells[2].ManaCost)
            {
                renderer.BattleStateButtonOne.ChangeToInactiveImage();
                renderer.BattleStateButtonTwo.ChangeToInactiveImage();
                renderer.BattleStateButtonThree.ChangeToClickedImage();
                this.Index = 2;
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && this.mouseState.LeftButton == ButtonState.Released && mouseOverSpellCast && this.Index != 3)
            {
                renderer.SpellCastButton.ChangeToClickedImage();
                if (this.Index == 0)
                {
                    if (renderer.MainHero.MagicSchool == SpellType.Fire)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Fireball(false));
                    }
                    else if (renderer.MainHero.MagicSchool == SpellType.Ice)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Icebolt(false));
                    }
                    else if (renderer.MainHero.MagicSchool == SpellType.Poison)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Poisonbolt(false));
                    }

                    renderer.MainHero.Mana -= renderer.MainHero.PlayerSpells[0].ManaCost;
                }
                else if (this.Index == 1)
                {
                    if (renderer.MainHero.Armor == 0)
                    {
                        if (renderer.MainHero.MagicSchool == SpellType.Fire)
                        {
                            renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.FireShield(false));
                        }
                        else if (renderer.MainHero.MagicSchool == SpellType.Ice)
                        {
                            renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.IceBarrier(false));
                        }
                        else if (renderer.MainHero.MagicSchool == SpellType.Poison)
                        {
                            renderer.ShieldsCasted.Add(renderer.SpellAnimationFactory.PoisonCloud(false));
                        }
                    }

                    renderer.MainHero.Armor = renderer.MainHero.PlayerSpells[1].Armor;
                    renderer.MainHero.Affliction = Affliction.None;

                    renderer.MainHero.Mana -= renderer.MainHero.PlayerSpells[1].ManaCost;
                }
                else if (this.Index == 2)
                {
                    if (renderer.MainHero.MagicSchool == SpellType.Fire)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Meteor(false));
                    }
                    else if (renderer.MainHero.MagicSchool == SpellType.Ice)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Hurricane(false));
                    }
                    else if (renderer.MainHero.MagicSchool == SpellType.Poison)
                    {
                        renderer.SpellsCasted.Add(renderer.SpellAnimationFactory.Decay(false));
                    }

                    renderer.MainHero.Mana -= renderer.MainHero.PlayerSpells[2].ManaCost;
                }

                if (renderer.MainHero.Affliction == Affliction.Poisoned)
                {
                    if (renderer.MainHero.Mana > 0)
                    {
                        renderer.MainHero.Mana -= 5;
                    }

                    if (renderer.MainHero.Mana < 0)
                    {
                        renderer.MainHero.Mana = 0;
                    }
                }

                renderer.BattleStateButtonOne.ChangeToHoverImage();
                renderer.BattleStateButtonTwo.ChangeToHoverImage();
                renderer.BattleStateButtonThree.ChangeToHoverImage();
                renderer.EnemyHero.HasBeenHit = false;
                AddManaPerTurn(renderer);
                StateMachine.CurrentState.NextState = StateMachine.EndTurnState;
                StateMachine.ChangeState();
            }

            if (renderer.EnemyHero.Health <= 0 || Keyboard.GetState().IsKeyDown(Keys.Enter))
            {
                renderer.MainHero.Experiecnce += renderer.EnemyHero.Level * 100;
                if (renderer.MainHero.Experiecnce >= renderer.MainHero.ExperienceNeeded)
                {
                    renderer.MainHero.Experiecnce = renderer.MainHero.Experiecnce - renderer.MainHero.ExperienceNeeded;
                    renderer.MainHero.ExperienceNeeded = renderer.MainHero.ExperienceNeeded * 2;
                    renderer.MainHero.Level = renderer.MainHero.Level + 1;
                }

                renderer.MainHero.Affliction = Affliction.None;
                renderer.EnemyHero.Affliction = Affliction.None;
                renderer.MainHero.Health = renderer.MainHero.MaxHealth;
                renderer.MainHero.Mana = renderer.MainHero.MaxMana;
                renderer.MainHero.Armor = 0;
                renderer.Enemy.IsDefeated = true;
                renderer.EnemyCounter--;
                if (StateMachine.PreviousState == StateMachine.IceMap)
                {
                    renderer.IceMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.FireMap)
                {
                    renderer.FireMap.EnemyCounter--;
                }
                else if (StateMachine.PreviousState == StateMachine.PoisonMap)
                {
                    renderer.PoisonMap.EnemyCounter--;
                }

                StateMachine.CurrentState.NextState = StateMachine.PreviousState;
                StateMachine.ChangeState();
                StateMachine.CurrentState.Execute(renderer);
            }

            this.mouseState = Mouse.GetState();
            //// when battle ends-> go back to game state
        }
Esempio n. 26
0
        public override void Execute(MonoGameRenderer renderer)
        {
            Button greenButton = renderer.GreenButton;
            Button redButton = renderer.RedButton;
            Button blueButton = renderer.BlueButton;

            bool mouseOverGreen = greenButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverRed = redButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);
            bool mouseOverBlue = blueButton.Sprite.Rectangle.Contains(Mouse.GetState().X, Mouse.GetState().Y);

            if (mouseOverGreen)
            {
                greenButton.ChangeToHoverImage();
            }
            else
            {
                greenButton.ChangeToInactiveImage();
            }

            if (mouseOverRed)
            {
                redButton.ChangeToHoverImage();
            }
            else
            {
                redButton.ChangeToInactiveImage();
            }

            if (mouseOverBlue)
            {
                blueButton.ChangeToHoverImage();
            }
            else
            {
                blueButton.ChangeToInactiveImage();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverGreen)
            {
                greenButton.ChangeToClickedImage();
                Texture2D newTextureForCharacter = EntryPoint.Game.Content.Load<Texture2D>("GreenMage");
                Texture2D newTextureForHero = EntryPoint.Game.Content.Load<Texture2D>("BigGreenMage");

                renderer.MainCharacter.Texture = newTextureForCharacter;
                renderer.MainHero.Texture = newTextureForHero;
                renderer.MainHero.PlayerSpells = renderer.PoisonSpells;
                renderer.MainHero.MagicSchool = RPG.Model.Enumerations.SpellType.Poison;

                renderer.BattleStateButtonOne = renderer.PoisonspitButton;
                renderer.BattleStateButtonTwo = renderer.PoisonCloudButton;
                renderer.BattleStateButtonThree = renderer.DecayButton;

                StateMachine.SchoolSelectState.NextState = StateMachine.PoisonMap;
                StateMachine.ChangeState();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverRed)
            {
                redButton.ChangeToClickedImage();
                Texture2D newTextureForCharacter = EntryPoint.Game.Content.Load<Texture2D>("RedMage");
                Texture2D newTextureForHero = EntryPoint.Game.Content.Load<Texture2D>("BigRedMage");

                renderer.MainCharacter.Texture = newTextureForCharacter;
                renderer.MainHero.Texture = newTextureForHero;
                renderer.MainHero.PlayerSpells = renderer.FireSpells;
                renderer.MainHero.MagicSchool = RPG.Model.Enumerations.SpellType.Fire;

                renderer.BattleStateButtonOne = renderer.FireballButton;
                renderer.BattleStateButtonTwo = renderer.FireShieldButton;
                renderer.BattleStateButtonThree = renderer.MeteorButton;

                StateMachine.SchoolSelectState.NextState = StateMachine.FireMap;
                StateMachine.ChangeState();
            }

            if (Mouse.GetState().LeftButton == ButtonState.Pressed && mouseOverBlue)
            {
                blueButton.ChangeToClickedImage();
                Texture2D newTextureForCharacter = EntryPoint.Game.Content.Load<Texture2D>("BlueMage");
                Texture2D newTextureForHero = EntryPoint.Game.Content.Load<Texture2D>("BigBlueMage");

                renderer.MainCharacter.Texture = newTextureForCharacter;
                renderer.MainHero.Texture = newTextureForHero;
                renderer.MainHero.PlayerSpells = renderer.IceSpells;
                renderer.MainHero.MagicSchool = RPG.Model.Enumerations.SpellType.Ice;

                renderer.BattleStateButtonOne = renderer.IceboltButton;
                renderer.BattleStateButtonTwo = renderer.IceBarrierButton;
                renderer.BattleStateButtonThree = renderer.HurricaneButton;

                StateMachine.SchoolSelectState.NextState = StateMachine.IceMap;
                StateMachine.ChangeState();
            }
        }