public void AddRange(Player player, IEnumerable<Card> cardCollection, DeckPosition deckPosition)
{
switch (deckPosition)
{
case DeckPosition.Top:
_Cards.InsertRange(0, cardCollection.Reverse());
break;
case DeckPosition.Bottom:
_Cards.AddRange(cardCollection);
break;
}
this.Sort();
if (cardCollection.Count() > 0)
{
if (_AsynchronousChanging)
{
if (_AsynchronousPileChangedEventArgs == null)
_AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
else
_AsynchronousPileChangedEventArgs.AddedCards.AddRange(cardCollection);
}
else if (PileChanged != null)
{
lock (PileChanged)
{
PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
PileChanged(this, pcea);
}
}
}
}
public CardReceivedEventArgs(Player fromPlayer, Card card, DeckLocation location, DeckPosition position)
{
this.FromPlayer = fromPlayer;
this.Card = card;
this.Location = location;
this.Position = position;
}
private void NextCard_Click(object sender, EventArgs e)
{
DeckPosition deckPos = (DeckPosition)Convert.ToInt32((sender as Button).Tag);
drill.NextCard(deckPos);
wordTextBox.Text = drill.CurrentWord();
}
private int GetIndexFromPosition(DeckPosition pos)
{
int newPositionIndex = 0;
switch (pos)
{
case DeckPosition.Top:
newPositionIndex = LastIndex;
break;
case DeckPosition.Middle:
newPositionIndex = UnityEngine.Random.Range(0, LastIndex);
break;
case DeckPosition.Bottom:
newPositionIndex = 0;
break;
}
if (_cards.Count == 0)
{
newPositionIndex = 0;
}
return(newPositionIndex);
}
private int GetIndexFromPosition(DeckPosition position)
{
int newPositionIndex = 0;
// Index is zero on an empty deck, though this will have to be interpreted
if (_cards.Count == 0)
{
newPositionIndex = 0;
}
// Index is last in deck "on the top"
if (position == DeckPosition.Top)
{
newPositionIndex = LastIndex;
}
// randomizes index if drawing from deck "body"
else if (position == DeckPosition.Middle)
{
newPositionIndex = UnityEngine.Random.Range(0, LastIndex);
}
// Index is 0 "on the bottom"
else if (position == DeckPosition.Bottom)
{
newPositionIndex = 0;
}
return(newPositionIndex);
}
private int GetIndexFromPosition(DeckPosition position)
{
int newPositionIndex = 0;
//if our deck is empty, index should always be 0
if (_cards.Count == 0)
{
newPositionIndex = 0;
}
//get end index if it's on 'front the top'
if (position == DeckPosition.Top)
{
newPositionIndex = LastIndex;
}
//randomize if drawing from the middle
else if (position == DeckPosition.Middle)
{
newPositionIndex = UnityEngine.Random.Range(0, LastIndex);
}
//get 0 index if it's 'from the bottom'
else if (position == DeckPosition.Bottom)
{
newPositionIndex = 0;
}
return(newPositionIndex);
}
public CardGainEventArgs(Game game, Card card, DeckLocation location, DeckPosition position, Boolean bought)
{
this.Game = game;
this.Card = card;
this.Location = location;
this.Position = position;
this.Bought = bought;
}
public CardsAddedToDeckEventArgs(Card card, DeckPosition deckPosition)
{
this.Cards = new CardCollection()
{
card
};
this.DeckPosition = deckPosition;
}
// adds cards to the deck from a given list
public void Add(List <T> cards, DeckPosition position = DeckPosition.Top)
{
int itemCount = cards.Count;
for (int i = 0; i < itemCount; i++)
{
Add(cards[i], position);
}
}
public T Draw(DeckPosition position = DeckPosition.Top)
{
if (IsEmpty)
{
//Debug.LogWarning("Deck: Cannot draw new item - deck is empty!");
return(null);
}
int targetIndex = GetIndexFromPosition(position);
T cardToRemove = _cards[targetIndex];
Remove(targetIndex);
return(cardToRemove);
}
public void Add(T card, DeckPosition position = DeckPosition.Top)
{
if (card == null)
{
return;
}
int targetIndex = GetIndexFromPosition(position);
if (targetIndex == LastIndex)
{
cards.Add(card);
}
else
{
cards.Insert(targetIndex, card);
}
CardAdded?.Invoke(card);
}
internal CardCollection Retrieve(Player player, DeckPosition position, Predicate <Card> match, int count)
{
CardCollection matching = _Cards.FindAll(match);
if (count >= 0 && count < matching.Count)
{
if (position == DeckPosition.Bottom)
{
matching.RemoveRange(0, matching.Count - count);
}
else
{
matching.RemoveRange(count, matching.Count - count);
}
if (matching.Count != count)
{
throw new Exception("Incorrect number of cards drawn!");
}
}
_Cards.RemoveAll(c => matching.Contains(c));
if (matching.Count > 0)
{
if (_AsynchronousChanging)
{
if (_AsynchronousPileChangedEventArgs == null)
{
_AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Removed, matching);
}
else
{
_AsynchronousPileChangedEventArgs.AddedCards.AddRange(matching);
}
}
else if (PileChanged != null)
{
PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Removed, matching);
PileChanged(this, pcea);
}
}
return(matching);
}
public void Add(T card, DeckPosition position = DeckPosition.Top)
{
//bodyguard
if (card == null)
{
return;
}
int targetIndex = GetIndexFromPosition(position);
// to add it to 'Top' we actually want to add it at the end, by default Inset() moves the current index upwards
if (targetIndex == LastIndex)
{
_cards.Add(card);
}
else
{
_cards.Insert(targetIndex, card);
}
CardAdded?.Invoke(card);
}
//Deck Position Code
private int GetIndexFromPosition(DeckPosition position)
{
int newPositionIndex = 0;
if (cards.Count == 0)
{
newPositionIndex = 0;
}
if (position == DeckPosition.Top)
{
newPositionIndex = LastIndex;
}
else if (position == DeckPosition.Middle)
{
newPositionIndex = UnityEngine.Random.Range(0, LastIndex);
}
else if (position == DeckPosition.Bottom)
{
newPositionIndex = 0;
}
return(newPositionIndex);
}
public void AddRange(Player player, IEnumerable <Card> cardCollection, DeckPosition deckPosition)
{
switch (deckPosition)
{
case DeckPosition.Top:
_Cards.InsertRange(0, cardCollection.Reverse());
break;
case DeckPosition.Bottom:
_Cards.AddRange(cardCollection);
break;
}
this.Sort();
if (cardCollection.Count() > 0)
{
if (_AsynchronousChanging)
{
if (_AsynchronousPileChangedEventArgs == null)
{
_AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
}
else
{
_AsynchronousPileChangedEventArgs.AddedCards.AddRange(cardCollection);
}
}
else if (PileChanged != null)
{
lock (PileChanged)
{
PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
PileChanged(this, pcea);
}
}
}
}
/// <summary>
/// Tries to gain the specified card into the location and position of the deck specified
/// </summary>
/// <param name="card">The card to gain from the supply</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <param name="isBought">Indicating whether or not the card was bought</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
private Boolean Gain(Card card, DeckLocation location, DeckPosition position, Boolean isBought)
{
if (card == null)
return false;
Boolean cancelled = false;
Boolean lostTrackOf = false;
if (CurrentTurn != null)
CurrentTurn.Gained(card);
CardGainInto(card, location, position, isBought, false, false);
if (CardGained != null)
{
// This is a little bit wacky, but we're going to set up an event listener INSIDE this method that listens to both
// the Discard Pile and the Draw Pile for changes. We need to do this in order to capture any "Lost Track" updates
// that might happen from one card covering up another card (e.g. this card being gained) and causing the game state
// to "Lose Track" of the card being gained in this method.
_LostTrackStack[card] = false;
Pile.PileChangedEventHandler pceh = new Pile.PileChangedEventHandler(DiscardPile_PileChanged_CaptureLostTrack);
this.DiscardPile.PileChanged += pceh;
List<Object> handledBy = new List<Object>();
CardGainEventArgs cgea = null;
Boolean actionPerformed = false;
do
{
actionPerformed = false;
cgea = new CardGainEventArgs(_Game, card, location, position, isBought);
cgea.HandledBy.AddRange(handledBy);
cgea.Cancelled = cancelled;
cgea.IsLostTrackOf = lostTrackOf;
CardGained(this, cgea);
handledBy = cgea.HandledBy;
cancelled |= cgea.Cancelled;
lostTrackOf |= cgea.IsLostTrackOf || _LostTrackStack[card];
location = cgea.Location;
position = cgea.Position;
IEnumerator<Player> enumerator = this._Game.GetPlayersStartingWithEnumerator(this);
while (enumerator.MoveNext())
{
Boolean isAnyRequired = false;
List<String> options = new List<String>();
IEnumerable<Type> cardTypes = cgea.Actions.Keys;
foreach (Type key in cardTypes)
{
if (enumerator.Current == cgea.Actions[key].Player)
{
options.Add(cgea.Actions[key].Text);
isAnyRequired |= cgea.Actions[key].IsRequired;
}
}
if (options.Count > 0)
{
Choice choice = new Choice(String.Format("{0} gained {1}", this == enumerator.Current ? "You" : this.ToString(), card), null, new CardCollection() { card }, options, this, cgea, false, isAnyRequired ? 1 : 0, 1);
ChoiceResult result = enumerator.Current.MakeChoice(choice);
if (result.Options.Count > 0)
{
options.Sort();
cgea.Actions.First(kvp => kvp.Value.Text == result.Options[0]).Value.Method(enumerator.Current, ref cgea);
actionPerformed = true;
}
if (enumerator.Current == this && (cgea.Location != location || cgea.Position != position))
CardGainInto(card, cgea.Location, cgea.Position, cgea.Bought, cgea.Cancelled, cgea.IsLostTrackOf);
cancelled |= cgea.Cancelled;
lostTrackOf |= cgea.IsLostTrackOf || _LostTrackStack[card];
location = cgea.Location;
position = cgea.Position;
}
}
} while (CardGained != null && actionPerformed);
if (pceh != null)
this.DiscardPile.PileChanged -= pceh;
_LostTrackStack.Remove(card);
}
CardGainFinish(card, location, position, isBought, cancelled, lostTrackOf);
return true;
}
/// <summary>
/// Tries to gain the specified cardType from the specified supply into the location and position of the deck specified
/// </summary>
/// <param name="supply">The supply pile to gain from</param>
/// <param name="cardType">The card type we're trying to gain</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
public Boolean Gain(Supply supply, Type cardType, DeckLocation location, DeckPosition position)
{
return Gain(supply, cardType, location, position, false);
}
/// <summary>
/// Tries to gain from the specified supply into the location and position of the deck specified
/// </summary>
/// <param name="supply">The supply pile to gain from</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
public Boolean Gain(Supply supply, DeckLocation location, DeckPosition position)
{
return Gain(supply, supply.TopCard == null ? null : supply.TopCard.CardType, location, position, false);
}
private CardGainEventArgs CardGainCheckAllowed(Card card, DeckLocation location, DeckPosition position, Boolean isBought)
{
Boolean cancelled = false;
CardGainEventArgs cgea = new CardGainEventArgs(_Game, card, location, position, isBought);
if (CardGaining != null)
{
do
{
cgea = new CardGainEventArgs(_Game, card, location, position, isBought);
cgea.Cancelled = cancelled;
CardGaining(this, cgea);
Boolean isAnyRequired = false;
List<String> options = new List<String>();
IEnumerable<Type> cardTypes = cgea.Actions.Keys;
foreach (Type key in cardTypes)
{
options.Add(cgea.Actions[key].Text);
isAnyRequired |= cgea.Actions[key].IsRequired;
}
if (options.Count > 0)
{
options.Sort();
Choice choice = new Choice(String.Format("You are gaining {0}", card), null, new CardCollection() { card }, options, this, cgea, false, isAnyRequired ? 1 : 0, 1);
ChoiceResult result = this.MakeChoice(choice);
if (result.Options.Count > 0)
cgea.Actions.First(kvp => kvp.Value.Text == result.Options[0]).Value.Method(this, ref cgea);
}
cancelled = cgea.Cancelled;
location = cgea.Location;
position = cgea.Position;
} while (CardGaining != null && cgea.HandledBy.Count > 0);
}
return cgea;
}
public void AddCardsInto(Type deckType, IEnumerable<Card> cards, DeckPosition position)
{
if (cards.Count() == 0)
return;
foreach (Card card in cards)
{
card.ModifiedBy = null;
card.AddedTo(deckType, this);
}
PlayerMats.Add(this, deckType, cards);
}
public void AddCardsInto(DeckLocation location, IEnumerable<Card> cards, DeckPosition position)
{
if (this.Phase != PhaseEnum.Endgame)
{
foreach (Card card in cards)
card.AddedTo(location, this);
}
DeckPosition realPosition = ResolveDeckPosition(location, position);
switch (location)
{
case DeckLocation.Hand:
foreach (Card card in cards)
card.ModifiedBy = null;
_Hand.AddRange(this, cards, realPosition);
break;
case DeckLocation.Revealed:
foreach (Card card in cards)
card.ModifiedBy = null;
_Revealed.AddRange(this, cards, realPosition);
break;
case DeckLocation.Discard:
foreach (Card card in cards)
card.ModifiedBy = null;
_DiscardPile.AddRange(this, cards, realPosition);
break;
case DeckLocation.Deck:
foreach (Card card in cards)
card.ModifiedBy = null;
_DrawPile.AddRange(this, cards, realPosition);
break;
case DeckLocation.InPlay:
_InPlay.AddRange(this, cards, realPosition);
break;
case DeckLocation.SetAside:
_SetAside.AddRange(this, cards, realPosition);
break;
case DeckLocation.Private:
foreach (Card card in cards)
card.ModifiedBy = null;
_Private.AddRange(this, cards, realPosition);
break;
}
}
internal CardCollection Retrieve(Player player, DeckPosition position, Predicate<Card> match, int count)
{
CardCollection matching = _Cards.FindAll(match);
if (count >= 0 && count < matching.Count)
{
if (position == DeckPosition.Bottom)
matching.RemoveRange(0, matching.Count - count);
else
matching.RemoveRange(count, matching.Count - count);
if (matching.Count != count)
throw new Exception("Incorrect number of cards drawn!");
}
_Cards.RemoveAll(c => matching.Contains(c));
if (matching.Count > 0)
{
if (_AsynchronousChanging)
{
if (_AsynchronousPileChangedEventArgs == null)
_AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Removed, matching);
else
_AsynchronousPileChangedEventArgs.AddedCards.AddRange(matching);
}
else if (PileChanged != null)
{
PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Removed, matching);
PileChanged(this, pcea);
}
}
return matching;
}
/// <summary>
/// Retrieve current card for specified deck.
/// </summary>
/// <param name="deckPosition"></param>
/// <returns></returns>
public Card CurrentCard(DeckPosition deckPosition)
{
return(Decks[deckPosition].CurrentCard());
}
public CardsAddedToDeckEventArgs(IEnumerable<Card> cards, DeckPosition deckPosition)
{
this.Cards = new CardCollection(cards);
this.DeckPosition = deckPosition;
}
public CardsAddedToDeckEventArgs(Card card, DeckPosition deckPosition)
{
this.Cards = new CardCollection() { card };
this.DeckPosition = deckPosition;
}
public CardGainEventArgs(Game game, Card card, DeckLocation location, DeckPosition position, Boolean bought)
{
this.Game = game;
this.Card = card;
this.Location = location;
this.Position = position;
this.Bought = bought;
}
public CardReceivedEventArgs(Player fromPlayer, Card card, DeckLocation location, DeckPosition position)
{
this.FromPlayer = fromPlayer;
this.Card = card;
this.Location = location;
this.Position = position;
}
public CardsDrawnEventArgs(IEnumerable<Card> cards, DeckPosition fromDeckPosition, int numberToDraw)
{
this.Cards.AddRange(cards);
this.FromDeckPosition = fromDeckPosition;
this.NumberToDraw = numberToDraw;
}
private void CardGainFinish(Card card, DeckLocation location, DeckPosition position, Boolean isBought, Boolean isCancelled, Boolean isLostTrackOf)
{
if (CardGainFinished != null)
{
CardGainEventArgs cgea = new CardGainEventArgs(_Game, card, location, position, isBought);
cgea.Cancelled = isCancelled;
cgea.IsLostTrackOf = isLostTrackOf;
CardGainFinished(this, cgea);
}
}
public DeckPosition ResolveDeckPosition(DeckLocation location, DeckPosition position)
{
switch (location)
{
case DeckLocation.Hand:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.Revealed:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.Discard:
return position == DeckPosition.Automatic ? DeckPosition.Top : position;
case DeckLocation.Deck:
return position == DeckPosition.Automatic ? DeckPosition.Top : position;
case DeckLocation.InPlay:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.SetAside:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.PlayerMat:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.Private:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
case DeckLocation.InPlayAndSetAside:
return position == DeckPosition.Automatic ? DeckPosition.Bottom : position;
}
return position;
}
/// <summary>
/// Retrieve prev card for specified deck.
/// </summary>
/// <param name="deckPos"></param>
/// <returns></returns>
public Card PrevCard(DeckPosition deckPosition)
{
return(Decks[deckPosition].PrevCard());
}
public void AddCardInto(DeckLocation location, Card card, DeckPosition position)
{
AddCardsInto(location, new CardCollection() { card }, position);
}
/// <summary>
/// Retrieve next card for specified deck.
/// </summary>
/// <param name="deckPos"></param>
/// <returns></returns>
public Card NextCard(DeckPosition deckPosition)
{
return(Decks[deckPosition].NextCard());
}
public void AddCardInto(Type deckType, Card card, DeckPosition position)
{
AddCardsInto(deckType, new CardCollection() { card }, position);
}
public void AddCardToDeck(Card card, DeckPosition deckPosition)
{
AddCardInto(DeckLocation.Deck, card, deckPosition);
if (CardsAddedToDeck != null)
{
CardsAddedToDeckEventArgs catdea = new CardsAddedToDeckEventArgs(card, deckPosition);
CardsAddedToDeck(this, catdea);
}
}
internal CardCollection RetrieveCardsFrom(DeckLocation location, DeckPosition position, Predicate<Card> match, int count)
{
CardCollection cards;
switch (location)
{
case DeckLocation.Hand:
cards = _Hand.Retrieve(this, position, match, count);
break;
case DeckLocation.Revealed:
cards = _Revealed.Retrieve(this, position, match, count);
break;
case DeckLocation.Discard:
cards = _DiscardPile.Retrieve(this, position, match, count);
break;
case DeckLocation.Deck:
cards = _DrawPile.Retrieve(this, position, match, count);
if (cards.Count < count && _DrawPile.Count == 0 && _DiscardPile.Count > 0)
this.ShuffleForDrawing();
cards.AddRange(_DrawPile.Retrieve(this, position, match, count < 0 ? count : count - cards.Count));
break;
case DeckLocation.InPlay:
cards = _InPlay.Retrieve(this, position, match, count);
break;
case DeckLocation.SetAside:
cards = _SetAside.Retrieve(this, position, match, count);
break;
case DeckLocation.Private:
cards = _Private.Retrieve(this, position, match, count);
break;
case DeckLocation.InPlayAndSetAside:
cards = _InPlay.Retrieve(this, position, match, count);
cards.AddRange(_SetAside.Retrieve(this, position, match, count < 0 ? count : count - cards.Count));
break;
default:
cards = new CardCollection();
break;
}
cards.RemovedFrom(location, this);
return cards;
}
public CardsAddedToDeckEventArgs(CardCollection cards, DeckPosition deckPosition)
{
this.Cards = cards;
this.DeckPosition = deckPosition;
}
/// <summary>
/// Tries to gain the specified card from the trash specified into the location and position of the deck specified
/// </summary>
/// <param name="trash">The trash pile to look through</param>
/// <param name="card">The card to gain from the trash</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
public Boolean Gain(Trash trash, Card card, DeckLocation location, DeckPosition position)
{
if (trash.Contains(card))
{
CardGainEventArgs cgea = CardGainCheckAllowed(card, location, position, false);
if (!cgea.Cancelled)
return this.Gain(trash.Retrieve(this, card), cgea.Location, cgea.Position, cgea.Bought);
else
{
CardGainFinish(card, cgea.Location, cgea.Position, cgea.Bought, cgea.Cancelled, cgea.IsLostTrackOf);
return true;
}
}
return false;
}
//Draws next item (top of deck). default to top
public T Draw(DeckPosition position = DeckPosition.Top)
{
if (IsEmpty)
{
Debug.LogWarning("Deck: Cannot draw new item - deck is empty!");
return(default);
/// <summary>
/// Tries to gain the number of cards specified from the specified supply into the location and position of the deck specified
/// </summary>
/// <param name="supply">The supply pile to gain from</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <param name="count">How many cards to gain</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
public Boolean Gain(Supply supply, DeckLocation location, DeckPosition position, int count)
{
Boolean success = true;
for (int i = 0; i < count; i++)
success &= this.Gain(supply, supply.TopCard == null ? null : supply.TopCard.CardType, location, position, false);
return success;
}
public CardsAddedToDeckEventArgs(CardCollection cards, DeckPosition deckPosition)
{
this.Cards = cards;
this.DeckPosition = deckPosition;
}
/// <summary>
/// Tries to gain the specified cardType from the specified supply into the location and position of the deck specified
/// </summary>
/// <param name="supply">The supply pile to gain from</param>
/// <param name="cardType">The card type we're trying to gain</param>
/// <param name="location">The deck the card should go into</param>
/// <param name="position">The position into the deck the card should go</param>
/// <param name="isBought">Indicating whether or not the card was bought</param>
/// <returns>True if the card was actually gained, False otherwise</returns>
public Boolean Gain(Supply supply, Type cardType, DeckLocation location, DeckPosition position, Boolean isBought)
{
if (supply.CanGain(cardType))
{
Card supplyCard = supply[cardType].First();
CardGainEventArgs cgea = CardGainCheckAllowed(supplyCard, location, position, isBought);
if (!cgea.Cancelled)
return this.Gain(supply.Take(cardType), cgea.Location, cgea.Position, cgea.Bought);
else
{
CardGainFinish(supplyCard, cgea.Location, cgea.Position, cgea.Bought, cgea.Cancelled, cgea.IsLostTrackOf);
return false;
}
}
return false;
}
public CardsAddedToDeckEventArgs(IEnumerable <Card> cards, DeckPosition deckPosition)
{
this.Cards = new CardCollection(cards);
this.DeckPosition = deckPosition;
}
private void CardGainInto(Card card, DeckLocation location, DeckPosition position, Boolean isBought, Boolean isCancelled, Boolean isLostTrackOf)
{
if (this.DiscardPile.Contains(card))
this.RetrieveCardFrom(DeckLocation.Discard, card);
card.Gaining(this, ref location, ref position);
this.AddCardInto(location, card, position);
card.Gained(this);
if (CardGainedInto != null)
{
CardGainEventArgs cgea = new CardGainEventArgs(_Game, card, location, position, isBought);
cgea.Cancelled = isCancelled;
cgea.IsLostTrackOf = isLostTrackOf;
CardGainedInto(this, cgea);
}
}
// retrieves an item while removing it from the deck
public T Draw(DeckPosition position = DeckPosition.Top)
{
if (IsEmpty)
{
// draw fail feedback
return(default);
public void Receive(Player fromPlayer, Card card, DeckLocation location, DeckPosition position)
{
if (CurrentTurn != null)
CurrentTurn.Received(card);
this.AddCardInto(location, card, position);
card.ReceivedBy(this);
if (CardReceived != null)
{
CardReceivedEventArgs crea = new CardReceivedEventArgs(fromPlayer, card, location, position);
CardReceived(this, crea);
}
}
internal virtual void Gaining(Player player, ref DeckLocation location, ref DeckPosition position)
{
Receiving(player, ref location, ref position);
}
public CardCollection DrawFrom(DeckPosition deckPosition, int number, Object destination)
{
CardCollection cards = new CardCollection();
if (number <= 0)
return cards;
CardCollection cardsFirst = _DrawPile.Retrieve(this, deckPosition, c => true, number);
cards.AddRange(cardsFirst);
cards.RemovedFrom(DeckLocation.Deck, this);
if (_AsynchronousDrawing)
{
if (_AsynchronousCardsDrawnEventArgs == null)
_AsynchronousCardsDrawnEventArgs = new CardsDrawnEventArgs(cardsFirst, deckPosition, number);
else
_AsynchronousCardsDrawnEventArgs.Cards.AddRange(cardsFirst);
}
else if (CardsDrawn != null)
{
CardsDrawnEventArgs cdea = new CardsDrawnEventArgs(cardsFirst, deckPosition, number);
CardsDrawn(this, cdea);
}
if (destination is Type)
this.AddCardsInto((Type)destination, cardsFirst);
else if (destination is DeckLocation)
this.AddCardsInto((DeckLocation)destination, cardsFirst);
else
throw new Exception(String.Format("Destination of {0} ({1}) is not supported", destination, destination.GetType()));
if (cardsFirst.Count < number && _DrawPile.Count == 0 && _DiscardPile.Count > 0)
{
this.ShuffleForDrawing();
CardCollection cardsSecond = _DrawPile.Retrieve(this, deckPosition, c => true, number < 0 ? number : number - cards.Count);
cards.AddRange(cardsSecond);
cardsSecond.RemovedFrom(DeckLocation.Deck, this);
if (_AsynchronousDrawing)
{
if (_AsynchronousCardsDrawnEventArgs == null)
_AsynchronousCardsDrawnEventArgs = new CardsDrawnEventArgs(cardsSecond, deckPosition, number);
else
_AsynchronousCardsDrawnEventArgs.Cards.AddRange(cardsSecond);
}
else if (CardsDrawn != null)
{
CardsDrawnEventArgs cdea = new CardsDrawnEventArgs(cardsSecond, deckPosition, number);
CardsDrawn(this, cdea);
}
if (destination is Type)
this.AddCardsInto((Type)destination, cardsSecond);
else if (destination is DeckLocation)
this.AddCardsInto((DeckLocation)destination, cardsSecond);
else
throw new Exception(String.Format("Destination of {0} ({1}) is not supported", destination, destination.GetType()));
}
return cards;
}
internal virtual void Receiving(Player player, ref DeckLocation location, ref DeckPosition position)
{
}
public void AddCardsToDeck(IEnumerable<Card> cards, DeckPosition deckPosition)
{
AddCardsInto(DeckLocation.Deck, cards, deckPosition);
if (CardsAddedToDeck != null)
{
CardsAddedToDeckEventArgs catdea = new CardsAddedToDeckEventArgs(cards, deckPosition);
CardsAddedToDeck(this, catdea);
}
}
public CardsDrawnEventArgs(IEnumerable <Card> cards, DeckPosition fromDeckPosition, int numberToDraw)
{
this.Cards.AddRange(cards);
this.FromDeckPosition = fromDeckPosition;
this.NumberToDraw = numberToDraw;
}