public void AddSituationalModifiers(Deck deck, Mechanics.Action action, Character user, Position posTarget, Character charTarget)
{
foreach (var tag in action.Tags)
{
switch (tag)
{
case Mechanics.Action.AbilityType.Attack:
if (IsFlanking(user, charTarget))
{
var flank = new Card("Flanking", Card.CardType.Hit);
deck.AddCards(flank, 2); //TODO: magic number
}
var userOn = map.GetTile(user.Pos);
userOn.AddSituationalModifiers(deck, action, user, posTarget, charTarget, false);
var targetOn = map.GetTile(charTarget.Pos);
targetOn.AddSituationalModifiers(deck, action, user, posTarget, charTarget, true);
//cramped fighting
var freeSquares = GetEmptyAdjacentSquares(user.Pos).Count;
if (freeSquares < 4 && !user.Gear.Contains("Cruel Knife"))
{
//TODO: better gear system
var cramped = new Card("Cramped", Card.CardType.Miss);
deck.AddCards(cramped, 1);
}
break;
default:
break;
}
}
}
public void TestCombiningCards()
{
Deck deck = new Deck();
Card hit = new Card("Hit", Card.CardType.Hit);
Card armor = Card.CreateReplacementCard("Glacing Blow", Card.CardType.Armor, hit);
int numHits = 5;
int armorCoverage = 3;
deck.AddCards(hit, numHits);
deck.AddCards(armor, armorCoverage);
deck.Consolidate();
Assert.AreEqual(numHits, deck.Cards.Count);
Assert.AreEqual(armorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Armor));
Assert.AreEqual(numHits - armorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Hit));
numHits = 3;
armorCoverage = 10;
deck = new Deck();
deck.AddCards(hit, numHits);
deck.AddCards(armor, armorCoverage);
deck.Consolidate();
Assert.AreEqual(numHits, deck.Cards.Count);
Assert.AreEqual(numHits, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Armor));
Assert.AreEqual(0, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Hit));
}
public Deck GetDeckFor(DungeonMaster DM, Character user, Position posTarget,
Character charTarget)
{
Deck deck = new Deck();
foreach (var ingredient in DeckRecipe)
{
var source = ingredient.Key;
int num = ResolveSource(source, DM, user, posTarget, charTarget);
var card = ingredient.Value;
deck.AddCards(card, num);
}
user.AddModifiers(deck, DM, user, charTarget, this, false);
if (charTarget != null)
{
charTarget.AddModifiers(deck, DM, user, null, this, true);
}
DM.AddSituationalModifiers(deck, this, user, posTarget, charTarget);
deck.Consolidate();
return(deck);
}
public void NewGame()
{
overlay.Hide();
resources.Reset();
weeks.Reset();
mana.Reset();
factions.Reset();
library.Reset();
rent.Reset();
events.Reset();
hand.Reset();
library.AddCards(CardDataFactory.OpeningHand);
knowledgePile.Shuffle();
events.AddCards(CardEventFactory.EventDeck);
eventsPile.Shuffle();
DrawEvent();
DrawHand();
gameState = GameState.PLAY;
}
public void AddDodgeCards(Deck deck, DungeonMaster DM, Character attacker, Action action)
{
//TODO: no magic numbers
var defense = new Card("Defense", Card.CardType.Miss);
deck.AddCards(defense, 2);
//TODO: pass to condition and query
var dodging = Conditions.FirstOrDefault(c => c.Name == "Dodging");
if (dodging != null)
{
var dodge = new Card("Dodge", Card.CardType.Miss);
deck.AddCards(dodge, dodging.Value);
}
}
public void GIVEN_a_deck_with_unordered_cards_WHEN_sort_is_called_THEN_deck_is_sorted_in_order()
{
// Arrange
var fakePack = new FakePack();
var deck = new Deck <IFakeCard>(fakePack);
deck.OpenDeck();
var card1 = deck.Deal();
var card2 = deck.Deal();
var card3 = deck.Deal();
deck.AddCards(new List <IFakeCard> {
card2, card1, card3
});
// Act
deck.Sort();
var firstCard = deck.Deal();
var secondCard = deck.Deal();
var thirdCard = deck.Deal();
var fourthCard = deck.Deal();
// Assert
Assert.AreEqual(1, firstCard.Number);
Assert.AreEqual(2, secondCard.Number);
Assert.AreEqual(3, thirdCard.Number);
Assert.AreEqual(4, fourthCard.Number);
}
private void Awake()
{
deckMain = new Deck();
deckNextYear = new Deck();
cardsInHand = new Deck();
deckMain.AddCards(deckStart);
}
public double[] CalculateFlopEquity()
{
for (int n = 0; n < values.Length; n++)
{
values[n] = 0.0;
}
double[] percentages = new double[values.Length];
int suitCounts = 21845;
//check flush possibility
for (int n = 0; n < 3; n++)
{
suitCounts += 1 << (board.Cards.GetCard(n).Suit * 4);
}
deck.RemoveCards(board.Cards.GetRange(0, 3));
for (int c1 = 0; c1 < deck.NumCards; c1++)
{
suitCounts += 1 << (deck.Cards.GetCard(c1).Suit * 4);
for (int c2 = c1 + 1; c2 < deck.NumCards; c2++)
{
suitCounts += 1 << (deck.Cards.GetCard(c2).Suit * 4);
Board b = new Board(board.Cards.GetCard(0), board.Cards.GetCard(1), board.Cards.GetCard(2),
deck.Cards.GetCard(c1), deck.Cards.GetCard(c2));
evaluator(b, suitCounts);
suitCounts -= 1 << (deck.Cards.GetCard(c2).Suit * 4);
}
suitCounts -= 1 << (deck.Cards.GetCard(c1).Suit * 4);
}
deck.AddCards(board.Cards.GetRange(0, 3));
double totalValue = 0;
for (int n = 0; n < values.Length; n++)
{
totalValue += values[n];
}
for (int n = 0; n < values.Length; n++)
{
percentages[n] = values[n] / totalValue;
}
return(percentages);
}
public void TestDeckConstructor()
{
Deck deck = new Deck();
Card card = new Card(Card.Value.Two, Card.Suit.Clubs);
deck.AddCards();
Assert.Equal(52, deck.DeckOfCards.Count);
Assert.Equal(card, deck.DeckOfCards.First());
}
public void TestTopCard()
{
Deck deck = new Deck();
deck.AddCards();
var firstCard = deck.DeckOfCards[0];
var dealedCard = deck.DealTopCard();
Assert.Equal(dealedCard, firstCard);
}
public void AddModifiers(Deck deck, DungeonMaster DM, Character user, Character target, Action action, bool isTarget)
{
foreach (var tag in action.Tags)
{
switch (tag)
{
case Mechanics.Action.AbilityType.Attack:
if (isTarget)
{
AddDodgeCards(deck, DM, user, action);
AddArmorCards(deck, DM, user, action);
//add dodge
}
else
{
//check for buffs to attack
var empowered = Conditions.FirstOrDefault(c => c.Name == "Empowered");
if (empowered != null)
{
deck.AddCards(new Card("Empowered", Card.CardType.Hit), empowered.Value);
}
var exertion = Conditions.FirstOrDefault(c => c.Name == "Exertion");
if (exertion != null)
{
deck.AddCards(new Card("Exertion", Card.CardType.Hit), exertion.Value);
}
if (target != null)
{
if (HasTrait("Thirst for Magic"))
{
deck.AddCards(new Card("Thirst", Card.CardType.Hit), target.Mana.Value);
}
}
}
break;
default:
break;
}
}
}
public void AddArmorCards(Deck deck, DungeonMaster DM, Character attacker, Action action)
{
var hit = new Card("Hit", Card.CardType.Hit);
var armor = Card.CreateReplacementCard("Glancing Blow", Card.CardType.Armor, hit);
deck.AddCards(armor, ArmorCoverage); //armor card causes hit to be redirected to character for resolution?
if (HasTrait("Split"))
{
var split = Card.CreateReplacementCard("Split", Card.CardType.Armor, hit);
deck.AddCards(split, 1); //TODO: magic number
}
if (HasTrait("Made of Flame"))
{
var burn = Card.CreateReplacementCard("Burn", Card.CardType.Armor, hit);
deck.AddCards(burn, 3); //TODO: magic number
}
}
public void TestDeckShuffle()
{
Deck deck = new Deck();
deck.AddCards();
Card card = new Card(Card.Value.Two, Card.Suit.Clubs);
Assert.Equal(card, deck.DeckOfCards.First());
deck.Shuffle <Card>(deck.DeckOfCards);
Assert.NotEqual(card, deck.DeckOfCards.First());
}
public void TestDealTop()
{
Deck deck = new Deck();
Card card = new Card(Card.Value.Two, Card.Suit.Clubs);
deck.DeckOfCards.Add(card);
Assert.Equal(card, deck.DealTopCard());
deck.AddCards();
deck.DealTopCard();
Assert.Equal(51, deck.DeckOfCards.Count);
}
//This method empties the discard pile and reshuffles it for the deck
private void EmptyDiscard()
{
//keep the top card for the discard pile
Card topCard = discard.Pop();
//take all the cards in discard and add them to the deck
while (discard.Count > 0)
{
deck.AddCards(discard.Pop(), 1);
}
deck.ShuffleDeck();
//Bring the top card back to the discard pile
Discard(topCard);
}
public void ShouldAddCardsFromAnotherDeck()
{
var extraCards = new List <ICard>
{
new GenericCard(new GenericCardInfo {
Name = "test5", Type = TestCardType.GenericType1
}),
new GenericCard(new GenericCardInfo {
Name = "test6", Type = TestCardType.GenericType2
})
};
var otherDeck = new Deck(extraCards);
_deck.AddCards(otherDeck);
Assert.AreEqual(6, _deck.Count());
Assert.AreEqual(2, otherDeck.Count());
Assert.IsNotNull(_deck.FindCard("test1"));
Assert.IsNotNull(_deck.FindCard("test2"));
Assert.IsNotNull(_deck.FindCard("test3"));
Assert.IsNotNull(_deck.FindCard("test4"));
Assert.IsNotNull(_deck.FindCard("test5"));
Assert.IsNotNull(_deck.FindCard("test6"));
}
public void GIVEN_an_unopened_deck_WHEN_add_cards_is_called_with_collection_containing_a_different_type_of_card_THEN_out_of_cards_exception_is_thrown()
{
// Arrange
var fakePack = new FakePack();
var deck = new Deck <IFakeCard>(fakePack);
var cards = new List <IFakeCard>
{
new FakeCard(1, null),
};
// Act
deck.AddCards(cards);
}
private void SaveDeck()
{
if (isInBattle)
{
MapMgr.Instance.MyMapPlayer.Data.CardList.Clear();
for (int i = 0; i < tempDeck.Count; i++)
{
MapMgr.Instance.MyMapPlayer.Data.CardList.Add(tempDeck[i]);
}
}
else
{
Deck.Clear();
Deck.AddCards(tempDeck);
}
}
public void AddCardsTest()
{
try
{
Error.ErrorReporter.IsUnitTesting = true;
Deck a = new Deck(true, 1);
a.AddCards(true);
Card b = new Card(1);
int i = 1;
int NumberOfCurrentCard = 0;
while (i != 55)
{
int ii = 0;
while (ii != a.GetSize())
{
if (a.Cards[ii].WhatCard == b.WhatCard)
{
NumberOfCurrentCard++;
}
ii++;
}
if (NumberOfCurrentCard != 2)
{
Assert.Fail("Not all of the cards were properly added");
}
else
{
NumberOfCurrentCard = 0;
}
b.WhatCard = i;
i++;
}
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
void Reload()
{
if (m_reloadTimer <= 0)
{
m_discard.AddCards(m_hand.GetAllCards());
m_audioHandler.PlaySound("Draw");
m_reloadTimer = m_reloadTime;
m_reloadText.SetActive(true);
for (int i = 0; i < m_handSize; i++)
{
if (!m_deck.HasCards())
{
m_audioHandler.PlaySound("Shuffle");
m_deck.AddCards(m_discard.PopAllCards());
}
m_hand.AddCard(m_deck.PopRandomCard());
}
m_hand.selectedIndex = 0;
}
}
public void GIVEN_a_deck_WHEN_add_cards_is_called_with_collection_THEN_cards_are_added()
{
// Arrange
var fakePack = new FakePack();
var deck = new Deck <IFakeCard>(fakePack);
deck.OpenDeck();
var cards = new List <IFakeCard>
{
new FakeCard(1, null),
};
// Act
deck.AddCards(cards);
var result = deck.CardCount;
// Assert
Assert.AreEqual(5, result);
}
public void ChooseOption(Encounter encounter, int option)
{
var optionChosen = encounter.Options[option];
switch (optionChosen["Outcome"] as string)
{
case "SkillCheck":
var recipie = optionChosen["SkillCheck"]["Cards"];
Deck deck = new Deck();
var originalDeck = deck.Clone() as Deck;
foreach (var ingredient in recipie)
{
var name = ingredient["Name"] as string;
var source = ingredient["Number"] as string;
int number = ResolveSource(source);
var card = new Card(name, Card.CardType.Encounter);
deck.AddCards(card, number);
}
var outcome = deck.Draw();
var result = optionChosen["SkillCheck"]["Result"][outcome.Name];
if (OnCardDrawn != null)
{
OnCardDrawn(this, new CardDrawnEventArgs(originalDeck, outcome));
}
ApplyEncounterEffect(result["Effect"] as string);
if (OnEncounterOutcome != null)
{
OnEncounterOutcome(this, result["Prompt"]);
}
//TODO: apply effects
break;
default:
break;
}
}
public Card PickCard(int playerId, int cardIdx)
{
if (turn.CurrentPlayerId != playerId)
{
return(null);
}
Player player = GetPlayer(playerId);
List <Card> cards = turn.GetChooseableCards();
Card card = cards[cardIdx];
// We remove the card from the list
cards.RemoveAt(cardIdx);
// We add them back to the common deck
commonDeck.AddCards(cards);
// We add the card to the player hand
player.hand.AddCard(card);
return(card);
}
public override List <Result> UseAbility(Battle battle, Unit caster, object targetInfo, int?fated_outcome = null)
{
Vector3Int offset = (Vector3Int)targetInfo;
Vector3Int targetPos = caster.Position + (Vector3Int)targetInfo;
List <Result> results = new List <Result>();
Unit hitUnit;
Block hitBlock;
if (offset.magnitude > 6)
{
results.Add(new Result(Result.ResultType.InvalidAction, "too far", "out of range", null));
return(results);
}
caster.HasActed = true;
caster.Stamina.Current -= 3;
for (int i = battle.map.Shape[2] - 1; i >= 0; i--) //start at highest z-level and go down
{
Vector3Int hitPos = new Vector3Int(targetPos.x, targetPos.y, i);
hitBlock = battle.map.BlockAt(hitPos);
if (hitBlock.Conductive)
{
List <Vector3Int> adjacent = Map.GetAdjacent(hitPos);
foreach (var adj in adjacent)
{
var secondaryBlock = battle.map.BlockAt(adj);
if (secondaryBlock.Conductive)
{
results.AddRange(secondaryBlock.StruckByLightning());
var secondaryUnit = battle.units.FirstOrDefault(u => u.Position == adj);
if (secondaryUnit != null)
{
Deck outcome = new Deck();
Card struck = new Card(Card.CardType.Hit, secondaryUnit.Name + " struck by lightning");
outcome.AddCards(struck, secondaryUnit.Position.z);
Card dodge = new Card(Card.CardType.Miss, secondaryUnit.Name + " dodges the lightning");
outcome.AddCards(dodge, secondaryUnit.Stamina.Current);
var drawn = outcome.Draw(fated_outcome);
switch (drawn.Type)
{
case Card.CardType.Hit:
Result hitResult = new Result(Result.ResultType.Deck, "hit", drawn.Description, null);
hitResult.OutcomeDeck = outcome;
secondaryUnit.TakeDamage(3);
results.Add(hitResult);
break;
case Card.CardType.Armor:
break;
case Card.CardType.Miss:
Result missResult = new Result(Result.ResultType.Deck, "miss", drawn.Description, null);
missResult.OutcomeDeck = outcome;
results.Add(missResult);
break;
default:
break;
}
}
}
}
}
if (hitBlock.Solid)
{
results.Add(new Result(Result.ResultType.Generic, "lightning",
"Lightning bolt strikes " + hitBlock.Name + " at " + hitPos, null));
return(results);
}
results.AddRange(hitBlock.StruckByLightning());
hitUnit = battle.units.FirstOrDefault(u => u.Position == hitPos);
if (hitUnit != null)
{
//struck by lightning
Deck outcome = new Deck();
Card struck = new Card(Card.CardType.Hit, hitUnit.Name + " struck by lightning");
outcome.AddCards(struck, hitUnit.Position.z);
Card dodge = new Card(Card.CardType.Miss, hitUnit.Name + " dodges the lightning");
outcome.AddCards(dodge, hitUnit.Stamina.Current);
var drawn = outcome.Draw(fated_outcome);
switch (drawn.Type)
{
case Card.CardType.Hit:
Result hitResult = new Result(Result.ResultType.Deck, "hit", drawn.Description, null);
hitResult.OutcomeDeck = outcome;
hitUnit.TakeDamage(7);
results.Add(hitResult);
break;
case Card.CardType.Armor:
break;
case Card.CardType.Miss:
Result missResult = new Result(Result.ResultType.Deck, "miss", drawn.Description, null);
missResult.OutcomeDeck = outcome;
results.Add(missResult);
break;
default:
break;
}
return(results);
}
}
throw new NotImplementedException(); //should never be here, will always hit something
}
