From cfee1a107b16b7f1304fb1871f8db3bef1526f37 Mon Sep 17 00:00:00 2001
From: Susan Yuen <susan_loves_cheese@hotmail.com>
Date: Fri, 4 Nov 2016 15:34:47 -0400
Subject: [PATCH] Attacking now works. Changed MenuButton class to Button
class, incorporated attackConfirm button with other buttons. Wrote function
determining whether enemy unit is in range. Fixed a lot of attacking logic.
---
.../Blaze_Brigade/Blaze_Brigade.csproj | 2 +-
.../{MenuButton.cs => Button.cs} | 10 +-
src/Blaze-Brigade/Blaze_Brigade/Game.cs | 20 +-
.../Blaze_Brigade/GameFunction.cs | 26 ++-
.../Blaze_Brigade/MouseHandler.cs | 120 ++++++------
src/Blaze-Brigade/Blaze_Brigade/Unit.cs | 18 +-
src/Blaze-Brigade/Blaze_Brigade/Warrior.cs | 178 +++++++++++-------
7 files changed, 216 insertions(+), 158 deletions(-)
rename src/Blaze-Brigade/Blaze_Brigade/{MenuButton.cs => Button.cs} (84%)
diff --git a/src/Blaze-Brigade/Blaze_Brigade/Blaze_Brigade.csproj b/src/Blaze-Brigade/Blaze_Brigade/Blaze_Brigade.csproj
index 4e5c91f..7fa8639 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/Blaze_Brigade.csproj
+++ b/src/Blaze-Brigade/Blaze_Brigade/Blaze_Brigade.csproj
@@ -105,7 +105,7 @@
<Compile Include="MainMenu.Designer.cs">
<DependentUpon>MainMenu.cs</DependentUpon>
</Compile>
- <Compile Include="MenuButton.cs" />
+ <Compile Include="Button.cs" />
<Compile Include="MouseHandler.cs" />
<Compile Include="Node.cs" />
<Compile Include="Player.cs" />
diff --git a/src/Blaze-Brigade/Blaze_Brigade/MenuButton.cs b/src/Blaze-Brigade/Blaze_Brigade/Button.cs
similarity index 84%
rename from src/Blaze-Brigade/Blaze_Brigade/MenuButton.cs
rename to src/Blaze-Brigade/Blaze_Brigade/Button.cs
index 7905d35..2ac56c0 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/MenuButton.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/Button.cs
@@ -8,14 +8,14 @@ using Microsoft.Xna.Framework.Graphics;
namespace View
{
// used for the drop down menu buttons when selecting units
- class MenuButton
+ class Button
{
- private MenuButtonType buttonType; // holds the button type
+ private ButtonType buttonType; // holds the button type
private Vector2 pixelCoordinates; // holds the coordinates of the menu button in question
private Texture2D buttonImage;
private bool isActive;
- public MenuButton(MenuButtonType type, Vector2 coordinates, Texture2D image)
+ public Button(ButtonType type, Vector2 coordinates, Texture2D image)
{
buttonType = type;
pixelCoordinates = coordinates;
@@ -28,7 +28,7 @@ namespace View
return pixelCoordinates;
}
- public MenuButtonType getButtonType()
+ public ButtonType getButtonType()
{
return buttonType;
}
@@ -57,7 +57,7 @@ namespace View
}
}
- enum MenuButtonType
+ enum ButtonType
{
Attack,
AttackConfirm,
diff --git a/src/Blaze-Brigade/Blaze_Brigade/Game.cs b/src/Blaze-Brigade/Blaze_Brigade/Game.cs
index 6349f11..200b225 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/Game.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/Game.cs
@@ -263,7 +263,6 @@ namespace Controller
#region Highlight nodes
if (GameState.beforeMove) // if unit has yet to move, display the overall move and attack range of unit
{
-
// Highlight movable nodes in blue
foreach (Node move in GameState.moveableNodes)
{
@@ -294,16 +293,17 @@ namespace Controller
#region Drop Down menu
if (GameState.dropDownMenuOpen) // if dropDowMenu should be opened, draw dropDownMenu
{
- unit.setMenuButtonCoordinates(unit.PixelCoordinates);
- foreach (MenuButton button in unit.getMenuButtons())
+ unit.setButtonCoordinates(unit.PixelCoordinates);
+ foreach (Button button in unit.getButtons())
{
- if (button.getActive())
+ if (button.getActive() && button.getButtonType() != ButtonType.AttackConfirm)
{
spriteBatch.Draw(button.getImage(), button.getPixelCoordinates(), null, Color.White, 0, Vector2.Zero, 1f, SpriteEffects.None, 0f);
}
}
}
- MenuButton confirmButton = unit.getAttackConfirmButton();
+
+ Button confirmButton = unit.getButtonOfType(ButtonType.AttackConfirm);
Vector2 attackInfoLocation2 = new Vector2(519, 0);
if (GameState.attackConfirmOpen)
{
@@ -372,11 +372,11 @@ namespace Controller
//method to return a unit: takes in unit type (warrior/mage/ranger), unit position, and which player's unit (since different model/colors)
private Unit getNewUnit(UnitType unitType, Vector2 unitPosition, int player)
{
- MenuButton attackButton = new MenuButton(MenuButtonType.Attack, unitPosition, Content.Load<Texture2D>("attack"));
- MenuButton moveButton = new MenuButton(MenuButtonType.Move, unitPosition, Content.Load<Texture2D>("move"));
- MenuButton itemButton = new MenuButton(MenuButtonType.Items, unitPosition, Content.Load<Texture2D>("items")); ;
- MenuButton waitButton = new MenuButton(MenuButtonType.Wait, unitPosition, Content.Load<Texture2D>("wait")); ;
- MenuButton attackConfirmButton = new MenuButton(MenuButtonType.AttackConfirm, unitPosition, Content.Load<Texture2D>("attack"));
+ Button attackButton = new Button(ButtonType.Attack, unitPosition, Content.Load<Texture2D>("attack"));
+ Button moveButton = new Button(ButtonType.Move, unitPosition, Content.Load<Texture2D>("move"));
+ Button itemButton = new Button(ButtonType.Items, unitPosition, Content.Load<Texture2D>("items")); ;
+ Button waitButton = new Button(ButtonType.Wait, unitPosition, Content.Load<Texture2D>("wait")); ;
+ Button attackConfirmButton = new Button(ButtonType.AttackConfirm, unitPosition, Content.Load<Texture2D>("attack"));
if (player == 1)
{
diff --git a/src/Blaze-Brigade/Blaze_Brigade/GameFunction.cs b/src/Blaze-Brigade/Blaze_Brigade/GameFunction.cs
index fc9782d..7d4b26b 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/GameFunction.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/GameFunction.cs
@@ -18,17 +18,33 @@ namespace Controller
return false;
}
+ // returns whether or not the enemy unit is within attack range of unit
+ public static bool isEnemyUnitInRange(Graph graph, Unit unit, Unit enemyUnit)
+ {
+ Node attackNode = graph.getNode(enemyUnit.Position.Item1, enemyUnit.Position.Item2);
+ return isNodeAttackable(unit.getClass(), unit.Position.Item1, unit.Position.Item2, attackNode);
+ }
+
// sets all units to "not moved" upon start of a turn
public static void startTurn(Player player)
{
+ // set all buttons to active
foreach (Unit unit in player.getUnits())
{
- MenuButton[] menuButtons = unit.getMenuButtons();
- for (int i = 0; i < menuButtons.Count(); i++)
+ Button[] buttons = unit.getButtons();
+ for (int i = 0; i < buttons.Count(); i++)
{
- menuButtons[i].setActive(true);
+ buttons[i].setActive(true);
}
}
+
+ // sets all game states
+ GameState.playableUnitSelected = false;
+ GameState.selectedUnit = null;
+ GameState.unitToAttack = null;
+ GameState.dropDownMenuOpen = false;
+ GameState.attackConfirmOpen = false;
+ GameState.beforeMove = true;
}
// returns all enemy units in range of the specified unit
@@ -42,11 +58,11 @@ namespace Controller
// checks if specified unit can perform actions
public static bool hasUnitFinishedActions(Unit unit)
{
- if (!unit.isButtonActive(MenuButtonType.Attack))
+ if (!unit.isButtonActive(ButtonType.AttackConfirm))
{
return true;
}
- if (!unit.isButtonActive(MenuButtonType.Wait))
+ if (!unit.isButtonActive(ButtonType.Wait))
{
return true;
}
diff --git a/src/Blaze-Brigade/Blaze_Brigade/MouseHandler.cs b/src/Blaze-Brigade/Blaze_Brigade/MouseHandler.cs
index 91545f9..ebe7d76 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/MouseHandler.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/MouseHandler.cs
@@ -32,7 +32,11 @@ namespace Controller
&& currentMouseState.RightButton == ButtonState.Pressed
&& validX && validY && GameState.playableUnitSelected)
{
- setSelectedUnit(null, false);
+ setSelectedUnit(null, false);
+ turnState = TurnState.Wait;
+ GameState.unitToAttack = null;
+ GameState.attackConfirmOpen = false;
+ GameState.dropDownMenuOpen = false;
}
// checks for single mouse left click inside the game window
@@ -57,7 +61,7 @@ namespace Controller
// determine if player has clicked on a menu button; if so, change turnState
if (getMenuButtonClicked(mouseClickCoordinates) != null)
{
- MenuButton menuButton = getMenuButtonClicked(mouseClickCoordinates);
+ Button menuButton = getMenuButtonClicked(mouseClickCoordinates);
Debug.WriteLine(getMenuButtonClicked(mouseClickCoordinates).getButtonType());
buttonAction(menuButton);
return;
@@ -76,18 +80,25 @@ namespace Controller
// if path finder returns a non-null path, then end node is valid
if (path != null)
{
+ GameState.selectedUnit.getButtonOfType(ButtonType.Move).setActive(false); // move button no longer active
updateUnitPosition(graph, mouseClickCoordinates, path);
+ GameState.beforeMove = false;
+ }
+ else
+ {
+ setSelectedUnit(null, false); // if user clicks on invalid end node, deselect it
+ turnState = TurnState.Wait;
}
}
- if(turnState==TurnState.Attack) //if a unit is clicked after attack is clicked
+ if (turnState == TurnState.Attack) // if a unit is clicked after attack is clicked
{
- Unit unit = getPlayableUnitOnNodeClicked(graph.getNode(mouseClickCoordinates), mouseClickCoordinates, GameState.currentPlayer);
- if (unit != null)
- {
- setAttackedUnit(unit, true);
- GameState.attackConfirmOpen = true; //opens attack confirm button
- unit.getAttackConfirmButton().setActive(true);
+ // gets enemy unit where user clicked
+ Unit unit = getUnitOnNodeClicked(graph.getNode(mouseClickCoordinates), mouseClickCoordinates, GameState.enemyPlayer);
+ if (unit != null && GameFunction.isEnemyUnitInRange(graph, GameState.selectedUnit, unit))
+ {
+ GameState.unitToAttack = unit; // set state of attacked unit
+ GameState.attackConfirmOpen = true; // opens attack confirmation
}
}
}
@@ -96,13 +107,16 @@ namespace Controller
else
{
// if there is a playable, player-owned unit on position clicked, set selected unit status
- Unit unit = getPlayableUnitOnNodeClicked(graph.getNode(mouseClickCoordinates), mouseClickCoordinates, GameState.currentPlayer);
+ Unit unit = getUnitOnNodeClicked(graph.getNode(mouseClickCoordinates), mouseClickCoordinates, GameState.currentPlayer);
if (unit != null)
{
setSelectedUnit(unit, true);
GameFunction.setMovableNodes(graph, unit);
- GameState.dropDownMenuOpen = (true);
- GameState.beforeMove = (true);
+ GameState.dropDownMenuOpen = true;
+ if (unit.getButtonOfType(ButtonType.Move).getActive())
+ {
+ GameState.beforeMove = true;
+ }
}
}
@@ -117,18 +131,12 @@ namespace Controller
GameState.selectedUnit = unit;
}
- //sets selection of unit to attack inside GameFunction
- private static void setAttackedUnit(Unit unit, bool selected)
- {
- GameState.unitToAttack = unit;
- }
-
- // if playable unit exists where user clicked, return it; else, return null
- private static Unit getPlayableUnitOnNodeClicked(Node clickedNode, Vector2 positionClicked, Player currentPlayer)
+ // if unit exists where user clicked (that belongs to player), return it; else, return null
+ private static Unit getUnitOnNodeClicked(Node clickedNode, Vector2 positionClicked, Player player)
{
- for (int i = 0; i < currentPlayer.getNumOfUnits(); i++)
+ for (int i = 0; i < player.getNumOfUnits(); i++)
{
- Unit unit = currentPlayer.getUnits().ElementAt(i);
+ Unit unit = player.getUnits().ElementAt(i);
int unitX = unit.Position.Item1;
int unitY = unit.Position.Item2;
int clickedX = (int)Math.Floor(positionClicked.X / 32);
@@ -145,18 +153,17 @@ namespace Controller
private static void updateUnitPosition(Graph graph, Vector2 position, LinkedList<Node> path)
{
Unit unit = GameState.selectedUnit;
- GameState.isAnimating = (true);
+ GameState.isAnimating = true;
// updates the unit's position to each node in the path (node by node)
foreach (Node node in path)
{
animateUnitPosition(graph, unit, node);
unit.Position = (new Tuple<int, int>(node.getPositionX(), node.getPositionY()));
node.unitOnNode = (unit);
- GameState.dropDownMenuOpen = (true);
-
+ GameState.dropDownMenuOpen = true;
+
}
- GameState.isAnimating = (false);
- GameState.beforeMove = (false);
+ GameState.isAnimating = false;
}
private static void attackAnimation(int direction)
@@ -206,14 +213,14 @@ namespace Controller
{
for (float i = originalLocationY; i <= originalLocationY + 8; i++)
{
- unit.PixelCoordinates = new Vector2(unit.PixelCoordinates.X , unit.PixelCoordinates.Y +1);
+ unit.PixelCoordinates = new Vector2(unit.PixelCoordinates.X, unit.PixelCoordinates.Y + 1);
Game.Instance.Tick();
Thread.Sleep(10);
}
for (float i = unit.PixelCoordinates.Y; i > originalLocationY; i++)
{
- unit.PixelCoordinates = new Vector2(unit.PixelCoordinates.X , unit.PixelCoordinates.Y - 1);
+ unit.PixelCoordinates = new Vector2(unit.PixelCoordinates.X, unit.PixelCoordinates.Y - 1);
Game.Instance.Tick();
Thread.Sleep(10);
}
@@ -286,55 +293,55 @@ namespace Controller
}
// returns a menu button that was clicked; if no menu button was clicked, returns null
- private static MenuButton getMenuButtonClicked(Vector2 mouseCoordinates)
+ private static Button getMenuButtonClicked(Vector2 mouseCoordinates)
{
Unit unit = GameState.selectedUnit;
- MenuButton[] menuButtons = unit.getMenuButtons();
- int clickX = (int) mouseCoordinates.X;
- int clickY = (int) mouseCoordinates.Y;
+ Button[] menuButtons = unit.getButtons();
+ int clickX = (int)mouseCoordinates.X;
+ int clickY = (int)mouseCoordinates.Y;
- for (int i=0; i<menuButtons.Length; i++)
+ for (int i = 0; i < menuButtons.Length; i++)
{
- int buttonX = (int) menuButtons[i].getPixelCoordinates().X;
- int buttonY = (int) menuButtons[i].getPixelCoordinates().Y;
- if (buttonX <= clickX && clickX < buttonX+128 && buttonY <= clickY && clickY < buttonY+32)
+ int buttonX = (int)menuButtons[i].getPixelCoordinates().X;
+ int buttonY = (int)menuButtons[i].getPixelCoordinates().Y;
+ if (buttonX <= clickX && clickX < buttonX + 128 && buttonY <= clickY && clickY < buttonY + 32)
{
if (GameState.dropDownMenuOpen)
{
- return menuButtons[i];
+ return menuButtons[i];
}
}
}
- int ButtonX = (int)unit.getAttackConfirmButton().getPixelCoordinates().X;
- int ButtonY = (int)unit.getAttackConfirmButton().getPixelCoordinates().Y;
+
+ int ButtonX = (int)unit.getButtonOfType(ButtonType.AttackConfirm).getPixelCoordinates().X;
+ int ButtonY = (int)unit.getButtonOfType(ButtonType.AttackConfirm).getPixelCoordinates().Y;
if (ButtonX <= clickX && clickX < ButtonX + 128 && ButtonY <= clickY && clickY < ButtonY + 32)
- {
+ {
if (GameState.attackConfirmOpen)
{
- return unit.getAttackConfirmButton();
+ return unit.getButtonOfType(ButtonType.AttackConfirm);
}
}
return null;
}
// sets which menu option is selected
- private static void buttonAction(MenuButton button)
+ private static void buttonAction(Button button)
{
// take action corresponding to which button was clicked
Unit unit = GameState.selectedUnit;
Unit unit2 = GameState.unitToAttack;
switch (button.getButtonType())
{
-
- case MenuButtonType.Attack: // if attack clicked
+ case ButtonType.Attack: // if attack clicked
turnState = TurnState.Attack;
GameState.dropDownMenuOpen = false; // close the dropdownmenu when selecting who to attack
- button.setActive(false);
break;
- case MenuButtonType.AttackConfirm: // if confirm attack clicked
+ case ButtonType.AttackConfirm: // if confirm attack clicked
button.setActive(false);
- unit.getMenuButtonAt(1).setActive(false);
- int attackDirection=0;
+ unit.getButtonOfType(ButtonType.Move).setActive(false); // move button is no longer active
+ unit.getButtonOfType(ButtonType.Attack).setActive(false); // attack button is no longer active
+ int attackDirection = 0;
if (unit.Position.Item1 < unit2.Position.Item1)
{
attackDirection = 0;
@@ -353,20 +360,21 @@ namespace Controller
}
attackAnimation(attackDirection);
GameState.attackConfirmOpen = false;
- GameState.dropDownMenuOpen = true;
+ setSelectedUnit(null, false);
+ turnState = TurnState.Wait;
break;
- case MenuButtonType.Move: // if moved is clicked
+ case ButtonType.Move: // if moved is clicked
turnState = TurnState.Move;
GameState.dropDownMenuOpen = false; // close the dropdownmenu when selecting where to move
- button.setActive(false);
break;
- case MenuButtonType.Items: // if item is clicked
+ case ButtonType.Items: // if item is clicked
turnState = TurnState.Items;
GameState.dropDownMenuOpen = false;
break;
- case MenuButtonType.Wait: // if wait is clicked
+ case ButtonType.Wait: // if wait is clicked
+ turnState = TurnState.Wait;
GameState.dropDownMenuOpen = false;
- GameState.playableUnitSelected = false;
+ setSelectedUnit(null, false);
button.setActive(false);
break;
@@ -375,4 +383,4 @@ namespace Controller
}
}
}
-}
+}
\ No newline at end of file
diff --git a/src/Blaze-Brigade/Blaze_Brigade/Unit.cs b/src/Blaze-Brigade/Blaze_Brigade/Unit.cs
index 7f9a1c9..5a6eaaa 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/Unit.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/Unit.cs
@@ -23,27 +23,21 @@ namespace Model
int getMovability(); // returns the unit's movability (number of spaces the unit can move in one turn)
int getStats(int i); // returns stat located at i (in order from 0-6: lvl, str, mag, skill, spd, def, res)
-
-
-
-
-
void setEquippedWeapon(Weapon w); // sets the unit's currently equipped weapon
//void setEquipableWeapons(Weapon add); // need to update the weapon array, put new weapon into it
- bool isButtonActive(MenuButtonType buttonType); // indicates whether a button has already been previously selected or not
- void setMenuButtonCoordinates(Vector2 pixelCoordinates); // sets the coordinates of menu buttons
+ bool isButtonActive(ButtonType buttonType); // indicates whether a button has already been previously selected or not
+ void setButtonActive(ButtonType buttonType, bool active);
+ void setButtonCoordinates(Vector2 pixelCoordinates); // sets the coordinates of menu buttons
void animate(int direction); // animate sprite walking the direction specified
void setInitialStats(); // sets initial unit stats upon creation
Texture2D getSpriteImage(); // returns the sprite image of the unit
- Texture2D getButtonImage(MenuButtonType buttonType); // returns the button texture at index i
+ Texture2D getButtonImage(ButtonType buttonType); // returns the button texture at index i
Texture2D getCharInfo(); // returns the char info screen texture
Texture2D getCharAttackInfo(); // returns the char attack info screen texture
Tuple<int, int> Position { get; set;} // gets and sets unit's position by tile
Vector2 PixelCoordinates { get; set; }
- MenuButton getMenuButtonAt(int i);
- MenuButton getAttackConfirmButton();
-
- MenuButton[] getMenuButtons(); // returns the dropdown menu buttons of the unit
+ Button[] getButtons(); // returns the dropdown menu buttons of the unit
+ Button getButtonOfType(ButtonType buttonType);
Rectangle getCurrentFrame(); // returns the current sprite frame in animation sequence
Weapon[] getEquipableWeapons(); // returns array of equipable weapons
Weapon getEquippedWeapon(); // returns weapon the unit is currently equipping
diff --git a/src/Blaze-Brigade/Blaze_Brigade/Warrior.cs b/src/Blaze-Brigade/Blaze_Brigade/Warrior.cs
index f47d64e..3f1265b 100644
--- a/src/Blaze-Brigade/Blaze_Brigade/Warrior.cs
+++ b/src/Blaze-Brigade/Blaze_Brigade/Warrior.cs
@@ -20,28 +20,27 @@ namespace Model
public int Speed { get; set; }
public int Def { get; set; }
public int Res { get; set; }
- public int Level { get; set; }
- private readonly int movability = 4; // all warriors will have 5 movability
+ public int Level { get; set; }
+ private readonly int movability = 4; // all warriors will have 4 movability
private Weapon[] equipableWeapons;
private Weapon equippedWeapon;
private Texture2D spriteImage;
private Vector2 pixelCoordinates;
private Tuple<int, int> position;
- private MenuButton[] menuButtons = new MenuButton[4];
- private MenuButton attackConfirm;
+ private Button[] buttons = new Button[5];
private Texture2D charInfo, charAttackInfo;
private int currentFrame; //the current frame the sprite is on
private int player; // which player this unit belongs to
- public Warrior(Texture2D spriteImage, MenuButton attackButton, MenuButton moveButton,
- MenuButton itemButton, MenuButton waitButton, MenuButton confirmButton, Texture2D charInfo, Texture2D charAttackInfo, Vector2 coordinates, int player)
+ public Warrior(Texture2D spriteImage, Button attackButton, Button moveButton,
+ Button itemButton, Button waitButton, Button confirmButton, Texture2D charInfo, Texture2D charAttackInfo, Vector2 coordinates, int player)
{
this.spriteImage = spriteImage;
- menuButtons[0] = attackButton;
- menuButtons[1] = moveButton;
- menuButtons[2] = itemButton;
- menuButtons[3] = waitButton;
- attackConfirm = confirmButton;
+ buttons[0] = attackButton;
+ buttons[1] = moveButton;
+ buttons[2] = itemButton;
+ buttons[3] = waitButton;
+ buttons[4] = confirmButton;
this.charInfo = charInfo;
this.charAttackInfo = charAttackInfo;
this.player = player;
@@ -50,7 +49,7 @@ namespace Model
int positionY = (int)Math.Round(coordinates.Y / 32);
position = new Tuple<int, int>(positionX, positionY);
currentFrame = 1;
- setMenuButtonCoordinates(pixelCoordinates);
+ setButtonCoordinates(pixelCoordinates);
setInitialStats(); //sets initial warrior stats
}
@@ -74,7 +73,7 @@ namespace Model
}
//returns each stat as an index for incrementing purposes
- public int getStats(int i)
+ public int getStats(int i)
{
int[] allStats = new int[7];
allStats[0] = Level;
@@ -107,46 +106,71 @@ namespace Model
return spriteImage;
}
- public Texture2D getButtonImage(MenuButtonType buttonType)
+ public Texture2D getButtonImage(ButtonType buttonType)
{
switch (buttonType)
{
- case MenuButtonType.Attack: // if attack clicked
- return menuButtons[0].getImage();
- case MenuButtonType.Items: // if moved is clicked
- return menuButtons[2].getImage();
- case MenuButtonType.Move: // if item is clicked
- return menuButtons[1].getImage();
- case MenuButtonType.Wait: // if wait is clicked
- return menuButtons[3].getImage();
- case MenuButtonType.AttackConfirm:
- return attackConfirm.getImage();
+ case ButtonType.Attack: // if attack clicked
+ return buttons[0].getImage();
+ case ButtonType.Move: // if moved is clicked
+ return buttons[1].getImage();
+ case ButtonType.Items: // if item is clicked
+ return buttons[2].getImage();
+ case ButtonType.Wait: // if wait is clicked
+ return buttons[3].getImage();
+ case ButtonType.AttackConfirm:
+ return buttons[4].getImage();
default:
return null;
}
}
// indicates whether a button has already been previously selected or not
- public bool isButtonActive(MenuButtonType buttonType)
+ public bool isButtonActive(ButtonType buttonType)
{
switch (buttonType)
{
- case MenuButtonType.Attack:
- return menuButtons[0].getActive();
- case MenuButtonType.Items:
- return menuButtons[2].getActive();
- case MenuButtonType.Move:
- return menuButtons[1].getActive();
- case MenuButtonType.Wait:
- return menuButtons[3].getActive();
- case MenuButtonType.AttackConfirm:
- return attackConfirm.getActive();
+ case ButtonType.Attack:
+ return buttons[0].getActive();
+ case ButtonType.Move:
+ return buttons[1].getActive();
+ case ButtonType.Items:
+ return buttons[2].getActive();
+ case ButtonType.Wait:
+ return buttons[3].getActive();
+ case ButtonType.AttackConfirm:
+ return buttons[4].getActive();
default:
return false;
}
}
+ public void setButtonActive(ButtonType buttonType, bool active)
+ {
+ switch (buttonType)
+ {
+ case ButtonType.Attack:
+ buttons[0].setActive(active);
+ return;
+ case ButtonType.Move:
+ buttons[1].setActive(active);
+ return;
+ case ButtonType.Items:
+ buttons[2].setActive(active);
+ return;
+ case ButtonType.Wait:
+ buttons[3].setActive(active);
+ return;
+ case ButtonType.AttackConfirm:
+ buttons[4].setActive(active);
+ return;
+
+ default:
+ return;
+ }
+ }
+
public Texture2D getCharInfo()
{
return charInfo;
@@ -154,35 +178,35 @@ namespace Model
public Texture2D getCharAttackInfo()
{
- return charAttackInfo;
+ return charAttackInfo;
}
public Tuple<int, int> Position
- {
+ {
get
- {
- return position;
- }
+ {
+ return position;
+ }
set
- {
- position = value;
- pixelCoordinates = new Vector2(value.Item1 * 32, value.Item2 * 32);
- }
+ {
+ position = value;
+ pixelCoordinates = new Vector2(value.Item1 * 32, value.Item2 * 32);
}
+ }
public Vector2 PixelCoordinates
{
get
- {
- return pixelCoordinates;
- }
+ {
+ return pixelCoordinates;
+ }
set
- {
- pixelCoordinates = value;
- int positionX = (int)Math.Round(PixelCoordinates.X / 32);
- int positionY = (int)Math.Round(PixelCoordinates.Y / 32);
- position = new Tuple<int, int>(positionX, positionY);
- }
+ {
+ pixelCoordinates = value;
+ int positionX = (int)Math.Round(PixelCoordinates.X / 32);
+ int positionY = (int)Math.Round(PixelCoordinates.Y / 32);
+ position = new Tuple<int, int>(positionX, positionY);
+ }
}
public void setEquippedWeapon(Weapon w)
@@ -190,34 +214,50 @@ namespace Model
equippedWeapon = w;
}
- public MenuButton[] getMenuButtons()
+ public Button[] getButtons()
{
- return menuButtons;
+ return buttons;
}
- public MenuButton getMenuButtonAt(int i)
+ public Button getButtonOfType(ButtonType buttonType)
{
- return menuButtons[i];
- }
+ switch (buttonType)
+ {
+ case ButtonType.Attack:
+ return buttons[0];
+ case ButtonType.Move:
+ return buttons[1];
+ case ButtonType.Items:
+ return buttons[2];
+ case ButtonType.Wait:
+ return buttons[3];
+ case ButtonType.AttackConfirm:
+ return buttons[4];
- public MenuButton getAttackConfirmButton()
- {
- return attackConfirm;
+ default:
+ return null;
+ }
}
-
+
// updates menu button positions
- public void setMenuButtonCoordinates(Vector2 pixelCoordinates)
+ public void setButtonCoordinates(Vector2 pixelCoordinates)
{
int increment = 0;
- foreach (MenuButton button in menuButtons)
+ foreach (Button button in buttons)
{
if (button.getActive())
{
- button.setPixelCoordinates((int)(pixelCoordinates.X + 32), (int)(pixelCoordinates.Y + (increment * 32)));
- increment++;
+ if (button.getButtonType() != ButtonType.AttackConfirm)
+ {
+ button.setPixelCoordinates((int)(pixelCoordinates.X + 32), (int)(pixelCoordinates.Y + (increment * 32)));
+ increment++;
+ }
+ else if (GameState.attackConfirmOpen)
+ {
+ button.setPixelCoordinates((int)(pixelCoordinates.X + 32), (int)(pixelCoordinates.Y));
+ }
}
}
- attackConfirm.setPixelCoordinates((int)(pixelCoordinates.X + 32), (int)(pixelCoordinates.Y));
}
public Rectangle getCurrentFrame() //return current frame the sprite is on
@@ -227,7 +267,7 @@ namespace Model
}
// animates the sprite by switching to the correct frame sequences
- public void animate(int direction)
+ public void animate(int direction)
{
#region Walking Down
@@ -252,7 +292,7 @@ namespace Model
#endregion
#region Walking Left
- else if(direction == 1) // for going left
+ else if (direction == 1) // for going left
{
if ((currentFrame < 3) || (currentFrame > 5)) // if unit isnt already going left, set the sprite to default facing left
{
--
GitLab