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(); }