public void drawSprite(SpriteBatch spriteBatch, BoardFunctionality boardFunc)
{
drawStack(boardFunc.enemySide.Deck, spriteBatch);
drawStack(boardFunc.friendlySide.Deck, spriteBatch);
drawStack(boardFunc.enemySide.Oblivion, spriteBatch);
drawStack(boardFunc.friendlySide.Oblivion, spriteBatch);
drawRevealedRows(boardFunc.enemySide, spriteBatch);
drawRows(boardFunc.friendlySide, spriteBatch);
if (!boardFunc.handFunction.placingCard)
{
drawHand(boardFunc.enemySide, spriteBatch);
drawHand(boardFunc.friendlySide, spriteBatch);
}
drawCasting(boardFunc, spriteBatch);
if (boardFunc.SELECTEDCARD != null)
{
boardFunc.SELECTEDCARD.drawSprite(spriteBatch);
}
if (boardFunc.ENEMYSELECTEDCARD != null && boardFunc.showEnemyCard)
{
boardFunc.ENEMYSELECTEDCARD.drawSprite(spriteBatch);
}
}
public void resumeWithPlayingCard(Side side, Card card, BoardFunctionality boardFunc)
{
if (card.cardProps.type != CardType.Manuever)
{
boardFunc.actionConstructor.moveTo(side.Hand, card.correctRow(side), card, boardFunc);
boardFunc.hidePlayCardFromEnemyAndDisplay(card);
foreach (Effect effect in card.cardProps.effects)
{
if (effect.trigger == Effect.Trigger.OnEnterPlay)
{
assignAbilityToNextSelection(card, effect.ability, boardFunc);
}
}
}
if (card.cardProps.type == CardType.Army)
{
side.canPlayArmy = false;
}
else if (card.cardProps.type == CardType.Manuever)
{
boardFunc.actionConstructor.moveTo(side.Hand, boardFunc.castManuever, card, boardFunc);
int counter = 0;
foreach (Ability ability in card.cardProps.abilities)
{
assignAbilityToNextSelection(card, ability, boardFunc);
counter++;
}
}
else
{
card.cardProps.exhausted = true;
}
}
private void drawCasting(BoardFunctionality boardFunc, SpriteBatch spriteBatch)
{
foreach (Card card in boardFunc.castManuever.cardsInContainer)
{
card.drawSprite(spriteBatch);
}
}
private void updateCardInteractivityInHand(MouseState mouseState, Card card, BoardFunctionality boardFunc)
{
boardFunc.SELECTEDCARD = card;
if (mouseState.LeftButton == ButtonState.Pressed)
{
card.setPos(mouseState.X - card.getWidth() / 2, mouseState.Y - card.getHeight() / 2);
clickedInCardBox = true;
if (!boardFunc.friendlySide.Hand.isWithinModifiedPosition(mouseState, card))
{
placingCard = true;
}
}
if (mouseState.LeftButton == ButtonState.Released && !isWithinProperRow(mouseState, boardFunc) && !boardFunc.friendlySide.Hand.isWithinModifiedPosition(mouseState, card))
{
playManuever(mouseState, card, boardFunc);
placingCard = false;
clickedInCardBox = false;
card.setRegular();
boardFunc.SELECTEDCARD = null;
boardFunc.boardPosLogic.updateBoard(boardFunc);
}
if (mouseState.LeftButton == ButtonState.Released && clickedInCardBox && boardFunc.friendlySide.Hand.isWithinModifiedPosition(mouseState, card))
{
placingCard = false;
clickedInCardBox = false;
boardFunc.state = BoardFunctionality.State.CardView;
card.resetCardSelector();
}
}
public override void useAIAbility(AIPlayer player, BoardFunctionality boardFunc, Card targetCard)
{
if (player != null)
{
targetCard.cardProps.aiCalcDefense -= this.power;
}
}
public void modifyCardInteractivity(MouseState mouseState, BoardFunctionality boardFunc)
{
foreach (Card card in cardsInContainer)
{
cardStateHandler(mouseState, boardFunc, card);
}
}
public override void useAIAbility(AIPlayer player, BoardFunctionality boardFunc, Card targetCard)
{
if (player != null)
{
boardFunc.boardDef.revealBoardForRemainderOfTurn(targetCard, this, boardFunc);
}
}
public override void decide(MouseState mouseState, ContentManager content, BoardFunctionality boardFunc)
{
if (!endFirstDec && boardFunc.boardActions.actions.Count < 1)
{
AI.playArmies(boardFunc);
AI.generalAbiltiies(mouseState, boardFunc);
AI.attackIfBeneficial(boardFunc);
endFirstDec = true;
}
if (boardFunc.boardActions.actions.Count < 1)
{
if (!endSecondDec)
{
AI.playCardIfThereAreEnoughArmies(boardFunc);
}
endSecondDec = true;
}
if (boardFunc.boardActions.actions.Count < 1)
{
boardFunc.PassTurn();
}
}
public void resetSide(Side side, BoardFunctionality boardFunc)
{
foreach (FunctionalRow row in side.Rows)
{
foreach (Card card in row.cardsInContainer)
{
card.cardProps.exhausted = false;
}
}
foreach (FunctionalRow row in side.Rows)
{
foreach (Card card in row.cardsInContainer)
{
if (card.cardProps.doubleExhausted == true)
{
card.cardProps.exhausted = true;
card.cardProps.doubleExhausted = false;
}
}
}
resetAttributes(boardFunc.friendlySide);
resetAttributes(boardFunc.enemySide);
resetFog(boardFunc.enemySide);
resetFog(boardFunc.friendlySide);
boardFunc.enemySide.Resources = new List <Race>();
boardFunc.friendlySide.Resources = new List <Race>();
side.canPlayArmy = true;
}
public override void abilityImplementation(MouseState mouseState, BoardFunctionality boardFunc)
{
if (returnSelectedCard(mouseState, boardFunc) != null)
{
boardFunc.BoardDamage(INITIALCARD, this, returnSelectedCard(mouseState, boardFunc));
}
}
public void revealBoardForRemainderOfTurn(Card fromCard, Ability ability, BoardFunctionality boardFunc)
{
foreach (FunctionalRow row in boardFunc.enemySide.Rows)
{
row.revealed = true;
}
}
public void attackIfBeneficial(BoardFunctionality boardFunc)
{
if (rowCanBeAttacked(boardFunc.friendlySide.Rows[Side.FieldUnit]))
{
attackRow(boardFunc.enemySide.Rows[Side.FieldUnit], boardFunc);
}
else if (rowCanBeAttacked(boardFunc.friendlySide.Rows[Side.Armies]))
{
attackRow(boardFunc.enemySide.Rows[Side.Armies], boardFunc);
}
else
{
if (isRowRevealed(boardFunc.enemySide.Rows[Side.Armies]) && isRowRevealed(boardFunc.enemySide.Rows[Side.FieldUnit]))
{
foreach (Card card in boardFunc.friendlySide.Rows[Side.FieldUnit].cardsInContainer)
{
if (!card.cardProps.exhausted)
{
boardFunc.LifeDamage(card);
}
}
}
}
/*else
* {
* boardFunc.enemySide.boardFunc.BOARDMESSAGE.addMessage("AI has no attacks this round");
* }*/
}
private void revealBoardIfOptimal(BoardFunctionality boardFunc)
{
if (shouldRevealBoard(boardFunc))
{
//revealBoardWithBestCard(BoardFunctionality boardFunc);
//still need to see if the code in Card.containsReveal works@!~
}
}
public virtual void manueverImplementation(BoardFunctionality boardFunc)
{
boardFunc.cardViewer.NextSelection();
if (!boardFunc.cardViewer.SelectionStillActive())
{
boardFunc.actionConstructor.moveTo(boardFunc.castManuever, boardFunc.friendlySide.Oblivion, INITIALCARD, boardFunc);
}
}
private void updateBoardPositions(BoardFunctionality boardFunc)
{
for (int i = 0; i < Side.MaxRows; i++)
{
setBoardPosition(boardFunc.friendlySide.Rows[i]);
setBoardPosition(boardFunc.enemySide.Rows[i]);
}
}
public void hardResetSelection(BoardFunctionality boardFunc)
{
boardFunc.state = State.Regular;
selection = new List <Action <MouseState> >();
resetSelectedCard(boardFunc);
boardFunc.boardPosLogic.updateBoard(boardFunc);
MouseTransformer.Set(MouseTransformer.State.Reg);
}
private bool noCardsOnBoardAreSelected(BoardFunctionality game)
{
if (game.SELECTEDCARD == null)
{
return(true);
}
return(false);
}
private void updateCastingPosition(BoardFunctionality boardFunc)
{
foreach (Card card in boardFunc.castManuever.cardsInContainer)
{
card.setPos(boardFunc.castManuever.getPosition());
scaleToCast(card);
card.playState = PlayState.Revealed;
}
}
public void resetCardSelectionOnRightClick(MouseState mouseState, BoardFunctionality boardFunc)
{
if (mouseState.RightButton == ButtonState.Pressed)
{
hardResetSelection(boardFunc);
abilityButtons = new List <Button>();
createButtonsOnView = false;
}
}
public override void useAIAbility(AIPlayer player, BoardFunctionality boardFunc, Card targetCard)
{
if (player != null)
{
foreach (Card card in targetCard.correctRow(boardFunc.enemySide).cardsInContainer)
{
card.cardProps.aiCalcDefense -= this.power;
}
}
}
public void drawSpecifiedSpell(Card card, CreateSpell spell, BoardFunctionality boardFunc)
{
Card newCard = boardFunc.cardBuilder.cardConstruct(boardFunc.cardConstructor, spell.identifier);
boardFunc.library = boardFunc.cardConstructor.tempStorage;
newCard.setSupplementalTextures(boardFunc.library);
boardFunc.friendlySide.Deck.cardsInContainer.Insert(0, newCard);
boardFunc.friendlySide.Deck.loadCardImage(boardFunc.library, newCard);
boardFunc.DrawCard(boardFunc.friendlySide);
}
public void resetSelectedCard(BoardFunctionality boardFunc)
{
if (boardFunc.SELECTEDCARD != null)
{
boardFunc.SELECTEDCARD.setRegular();
boardFunc.SELECTEDCARD.resetCardSelector();
}
boardFunc.SELECTEDCARD = null;
}
public override void setCardToView(MouseState mouseState, FunctionalRow row, BoardFunctionality boardFunc, bool friendly)
{
base.setCardToView(mouseState, row, boardFunc, friendly);
foreach (Card card in row.cardsInContainer)
{
if (friendly)
{
fieldLogic(mouseState, row, card, boardFunc);
}
}
}
public void updateAllAssets(BoardFunctionality boardFunc)
{
foreach (Card card in boardFunc.friendlySide.Deck.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.enemySide.Deck.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.friendlySide.Oblivion.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.enemySide.Oblivion.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.friendlySide.Hand.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.enemySide.Hand.cardsInContainer)
{
card.updateGameComponent();
}
foreach (Card card in boardFunc.castManuever.cardsInContainer)
{
card.updateGameComponent();
}
foreach (FunctionalRow row in boardFunc.friendlySide.Rows)
{
foreach (Card card in row.cardsInContainer)
{
card.updateGameComponent();
}
}
foreach (FunctionalRow row in boardFunc.enemySide.Rows)
{
foreach (Card card in row.cardsInContainer)
{
card.updateGameComponent();
}
}
foreach (FunctionalRow row in boardFunc.enemySide.Rows)
{
if (row.playState != PlayState.Hidden)
{
row.revealCardInContainer();
}
}
}
public void updateBoard(BoardFunctionality boardFunc) //after every Action
{
updateHandPositions(boardFunc);
updateBoardPositions(boardFunc);
updateDeckPositions(boardFunc.friendlySide);
updateDeckPositions(boardFunc.enemySide);
boardFunc.assetUpdater.updateAllAssets(boardFunc);
updateCastingPosition(boardFunc);
this.SELECTEDCARD = boardFunc.SELECTEDCARD;
deselectCards(boardFunc);
}
public void spawnSpecifiedUnit(Card card, SpawnCard ability, BoardFunctionality boardFunc)
{
Card newCard = boardFunc.cardBuilder.cardConstruct(boardFunc.cardConstructor, ability.identifier);
boardFunc.library = boardFunc.cardConstructor.tempStorage;
newCard.setSupplementalTextures(boardFunc.library);
newCard.correctRow(boardFunc.friendlySide).cardsInContainer.Add(newCard);
newCard.correctRow(boardFunc.friendlySide).loadCardImage(boardFunc.library, newCard);
newCard.cardProps.exhausted = true;
//newCard.correctRow(friendlySide).loadCardImagesInContainer(library.cardTextureDictionary);
}
public FunctionalRow getCorrectRow(Card card, BoardFunctionality boardFunc)
{
foreach (FunctionalRow row in boardFunc.friendlySide.Rows)
{
if (row.type == card.cardProps.type)
{
return(row);
}
}
return(null);
}
private bool shouldRevealBoard(BoardFunctionality boardFunc)
{
if (getCumulativeAttack(boardFunc.friendlySide.Rows[Side.FieldUnit]) * 1.2 > getCumulativeDefense(boardFunc.friendlySide.Rows[Side.FieldUnit]))
{
if (haveARevealCard(boardFunc))
{
return(true);
}
}
return(false);
}
public Card TargetAnyCard(MouseState mouseState, BoardFunctionality boardFunc, bool pressToTarget)
{
if (TargetCard(mouseState, boardFunc.friendlySide, pressToTarget) != null)
{
return(TargetCard(mouseState, boardFunc.friendlySide, pressToTarget));
}
if (TargetCard(mouseState, boardFunc.enemySide, pressToTarget) != null)
{
return(TargetCard(mouseState, boardFunc.enemySide, pressToTarget));
}
return(null);
}
public override Card returnSelectedCard(MouseState mouseState, BoardFunctionality boardFunc)
{
if (selectAction.TargetEnemyCard(mouseState, boardFunc, true) != null)
{
return(selectAction.TargetEnemyCard(mouseState, boardFunc, true));
}
else
{
return(null);
}
//throw new Exception();
}
