public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
var target = TargetsOpponent ? opponent : caster;
var cards = new List <Card>();
for (int i = 0; i < Amount; i++)
{
if (target.Deck.Cards.Count > 0)
{
cards.Add(target.Deck.Cards.Pop());
}
}
if (cards.Count == 0)
{
return;
}
var message = new PickFromListMessage(cards, 1).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
foreach (var id in response.Cards)
{
var card = cards.First(x => x.Id.Equals(id));
target.Deck.Cards.Push(card);
}
}
protected override void Activate(Player owner, Player opponent, int damageTaken, GameField game)
{
var availablePokemons = new List <PokemonCard>(owner.BenchedPokemon.ValidPokemonCards);
availablePokemons.Add(owner.ActivePokemonCard);
var sourcePokemons = availablePokemons.Where(x => x.DamageCounters > 0).OfType <Card>().ToList();
var pickFirstMessage = new PickFromListMessage(sourcePokemons, 1).ToNetworkMessage(owner.Id);
var selectedSource = (PokemonCard)game.Cards[owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(pickFirstMessage).Cards.First()];
var availableTargets = availablePokemons.Where(x => (x.Hp - x.DamageCounters) > Amount).OfType <Card>().ToList();
availableTargets.Remove(selectedSource);
PokemonCard target;
if (availableTargets.Count == 1)
{
target = (PokemonCard)availableTargets.First();
}
else
{
var pickTargetMessage = new PickFromListMessage(availableTargets, 1).ToNetworkMessage(owner.Id);
target = (PokemonCard)game.Cards[owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(pickTargetMessage).Cards.First()];
}
selectedSource.Heal(Amount, game);
target.DealDamage(Amount, game, PokemonOwner, false);
}
protected override void Activate(Player owner, Player opponent, int damageTaken, GameField game)
{
if (game.AskYesNo(owner, "Look at the top card of opponents deck?"))
{
owner.RevealCard(opponent.Deck.Cards.Peek());
}
else if (game.AskYesNo(owner, "Look at the top card of your deck?"))
{
owner.RevealCard(owner.Deck.Cards.Peek());
}
else if (game.AskYesNo(owner, "Look at a random card from opponents hand?"))
{
owner.RevealCard(opponent.Hand[new Random().Next(0, opponent.Hand.Count)]);
}
else if (game.AskYesNo(owner, "Look at a prize card from opponent?"))
{
var message = new PickFromListMessage(opponent.PrizeCards, 1).ToNetworkMessage(game.Id);
var response = opponent.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.FirstOrDefault();
owner.RevealCard(game.Cards[response]);
}
else if (game.AskYesNo(owner, "Look at one of your prize cards?"))
{
var message = new PickFromListMessage(owner.PrizeCards, 1).ToNetworkMessage(game.Id);
var response = opponent.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.FirstOrDefault();
owner.RevealCard(game.Cards[response]);
}
}
protected override void Activate(Player owner, Player opponent, int damageTaken, GameField game)
{
IEnumerable <Card> energyCards;
Player activator = GetActivator(game.ActivePlayer);
if (energyType != EnergyTypes.All)
{
energyCards = activator.Hand.OfType <EnergyCard>().Where(card => energyType == card.EnergyType);
}
else
{
energyCards = activator.Hand.OfType <EnergyCard>();
}
var message = new PickFromListMessage(energyCards.ToList(), 1).ToNetworkMessage(owner.Id);
var response = owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
var energyCard = game.Cards[response.Cards.First()];
var selectPokemonMessage = new SelectFromYourPokemonMessage(energyType).ToNetworkMessage(owner.Id);
response = owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(selectPokemonMessage);
var selectedId = response.Cards.First();
var pokemon = owner.ActivePokemonCard.Id.Equals(selectedId) ? owner.ActivePokemonCard : owner.BenchedPokemon.ValidPokemonCards.First(x => x.Id.Equals(selectedId));
pokemon.AttachEnergy((EnergyCard)energyCard, game);
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
if (MayAbility && !game.AskYesNo(caster, "Discard attached energy?"))
{
return;
}
if (!CoinflipConditional.IsOk(game, caster))
{
return;
}
if (Targeting.GetPossibleTargetsFromMode(TargetingMode, game, caster, opponent, caster.ActivePokemonCard, OnlyWithNameLike).All(x => x.AttachedEnergy.Count == 0))
{
return;
}
int cardsDiscarded = 0;
while (true)
{
PokemonCard target = Targeting.AskForTargetFromTargetingMode(TargetingMode, game, caster, opponent, caster.ActivePokemonCard, string.Empty, OnlyWithNameLike);
if (target.AttachedEnergy.Count == 0)
{
continue;
}
if (Amount == -1 || target.AttachedEnergy.Count <= Amount)
{
while (target.AttachedEnergy.Count > 0)
{
target.DiscardEnergyCard(target.AttachedEnergy[0], game);
cardsDiscarded++;
}
target.AttachedEnergy.Clear();
}
else
{
var message = new PickFromListMessage(target.AttachedEnergy.OfType <Card>().ToList(), Amount);
var ids = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message.ToNetworkMessage(game.Id)).Cards;
var cards = target.AttachedEnergy.Where(x => ids.Contains(x.Id)).ToList();
foreach (var card in cards)
{
target.DiscardEnergyCard(card, game);
cardsDiscarded++;
}
}
break;
}
if (targetingMode == TargetingMode.Self || targetingMode == TargetingMode.YourActive || targetingMode == TargetingMode.YourBench || targetingMode == TargetingMode.YourPokemon)
{
game.LastDiscard = cardsDiscarded;
}
}
public void PickFromListMessage()
{
var message = new PickFromListMessage(new List <Card> {
new EnergyCard()
{
EnergyType = EnergyTypes.Water, Amount = 1
}
}, 1);
Assert.NotNull(SerializeAndBack(message));
}
public static void DiscardAttachedEnergy(PokemonCard pokemon, int amount, GameField game)
{
var message = new PickFromListMessage(pokemon.AttachedEnergy.OfType <Card>().ToList(), amount);
var response = pokemon.Owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message.ToNetworkMessage(pokemon.Owner.Id));
foreach (var id in response.Cards)
{
var energyCard = pokemon.AttachedEnergy.First(x => x.Id.Equals(id));
pokemon.DiscardEnergyCard(energyCard, game);
}
}
public override Damage GetDamage(Player owner, Player opponent, GameField game)
{
var heads = game.FlipCoins(owner.ActivePokemonCard.AttachedEnergy.Count(e => OnlyThisType == EnergyTypes.All || e.EnergyType == OnlyThisType));
if (DiscardForeachHead && heads > 0)
{
var message = new PickFromListMessage(owner.ActivePokemonCard.AttachedEnergy.OfType <Card>().ToList(), heads).ToNetworkMessage(owner.Id);
var response = owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
opponent.ActivePokemonCard.DiscardEnergyCard((EnergyCard)game.Cards[response.Cards.First()], game);
}
return(Damage + (heads * ExtraBaseDamage));
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
var choices = caster.ActivePokemonCard.AttachedEnergy.Where(x => x.EnergyType == EnergyType).OfType <Card>().ToList();
var message = new PickFromListMessage(choices, 0, choices.Count).ToNetworkMessage(game.Id);
var resoponse = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
foreach (var card in resoponse.Cards.Select(id => game.Cards[id]))
{
caster.ActivePokemonCard.DiscardEnergyCard((EnergyCard)card, game);
}
for (int i = 0; i < resoponse.Cards.Count; i++)
{
var card = opponent.Deck.Cards.Pop();
opponent.DiscardPile.Add(card);
}
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
int amount = FlipCoinsForAmount != -1 ? game.FlipCoins(FlipCoinsForAmount) : Amount;
if (amount == 0)
{
return;
}
List <Card> choices = CardUtil.GetCardsOfType(caster.DiscardPile, CardType, EnergyType);
var message = new PickFromListMessage(choices, 0, amount).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards;
var cards = new List <Card>();
foreach (var id in response)
{
var card = game.Cards[id];
caster.DiscardPile.Remove(card);
if (shuffleIntoDeck)
{
cards.Add(card);
caster.Deck.Cards.Push(card);
}
else
{
caster.Hand.Add(card);
game.SendEventToPlayers(new DrawCardsEvent()
{
Player = caster.Id, Cards = new List <Card>()
{
card
}
});
}
}
if (shuffleIntoDeck)
{
opponent.RevealCards(cards);
caster.Deck.Shuffle();
}
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
foreach (var pokemon in opponent.GetAllPokemonCards())
{
if (pokemon.AttachedEnergy.Count == 1)
{
pokemon.DiscardEnergyCard(pokemon.AttachedEnergy[0], game);
}
else
{
var message = new PickFromListMessage(pokemon.AttachedEnergy.OfType <Card>().ToList(), 1)
{
Info = "Pick 1 Energy to discard from " + pokemon.Name
};
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message.ToNetworkMessage(game.Id));
pokemon.DiscardEnergyCard((EnergyCard)game.Cards[response.Cards[0]], game);
}
}
}
public void PickFromListMessageDeserialize()
{
var player = new Player();
var message = new PickFromListMessage(new List <Card> {
new EnergyCard()
{
EnergyType = EnergyTypes.Water, Amount = 1
}, new EnergyCard()
{
EnergyType = EnergyTypes.Water, Amount = 1
}
}, 1, 1);
var result = SerializeAndBack(message);
Assert.Equal(1, result.MinCount);
Assert.Equal(1, result.MaxCount);
Assert.Equal(2, result.PossibleChoices.Count);
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
while (true)
{
PokemonCard target = Targeting.AskForTargetFromTargetingMode(TargetingMode, game, caster, opponent, caster.ActivePokemonCard);
if (target == null)
{
return;
}
if (target.AttachedEnergy.Count < amountToDiscard)
{
continue;
}
if (target.AttachedEnergy.Count == AmountToDiscard)
{
for (int i = 0; i < AmountToDiscard; i++)
{
target.DiscardEnergyCard(target.AttachedEnergy[0], game);
}
target.AttachedEnergy.Clear();
}
else
{
var message = new PickFromListMessage(target.AttachedEnergy.OfType <Card>().ToList(), AmountToDiscard).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
foreach (var id in response.Cards)
{
var card = (EnergyCard)game.Cards[id];
target.DiscardEnergyCard(card, game);
}
}
target.Heal(AmountToHeal, game);
break;
}
}
public override void ProcessEffects(GameField game, Player owner, Player opponent)
{
if (!opponent.ActivePokemonCard.AttachedEnergy.Any())
{
return;
}
else if (opponent.ActivePokemonCard.AttachedEnergy.Count == 1)
{
var energyCard = opponent.ActivePokemonCard.AttachedEnergy[0];
opponent.ActivePokemonCard.DiscardEnergyCard(energyCard, game);
return;
}
var message = new PickFromListMessage(opponent.ActivePokemonCard.AttachedEnergy.OfType <Card>().ToList(), 1).ToNetworkMessage(owner.Id);
var response = owner.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message);
opponent.ActivePokemonCard.DiscardEnergyCard((EnergyCard)game.Cards[response.Cards.First()], game);
base.ProcessEffects(game, owner, opponent);
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
if (CoinFlip && game.FlipCoins(1) == 0)
{
return;
}
var target = TargetsOpponent ? opponent : caster;
List <Card> choices = CardUtil.GetCardsOfType(target.DiscardPile, CardType);
var message = new PickFromListMessage(choices, Amount).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards;
foreach (var id in response)
{
var card = game.Cards[id];
target.Deck.Cards.Push(card);
target.DiscardPile.Remove(card);
}
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
var source = Targeting.AskForTargetFromTargetingMode(SourceTargetingMode, game, caster, opponent, pokemonSource, "Select Pokémon to Move energy from");
var availableEnergy = source.AttachedEnergy.Where(e => EnergyType == EnergyTypes.All || e.EnergyType == EnergyType).ToList();
if (availableEnergy.Count > AmountToMove)
{
var pickEnergyMessage = new PickFromListMessage(availableEnergy.OfType <Card>().ToList(), AmountToMove).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(pickEnergyMessage);
availableEnergy.Clear();
foreach (var id in response.Cards)
{
availableEnergy.Add((EnergyCard)game.Cards[id]);
}
}
var newTarget = Targeting.AskForTargetFromTargetingMode(NewTargetingMode, game, caster, opponent, pokemonSource, "Select Pokémon to Move energy from");
if (newTarget == null)
{
foreach (var energy in availableEnergy)
{
source.DiscardEnergyCard(energy, game);
}
}
else
{
foreach (var energy in availableEnergy)
{
source.AttachedEnergy.Remove(energy);
game.SendEventToPlayers(new AttachedEnergyDiscardedEvent()
{
DiscardedCard = energy, FromPokemonId = source.Id
});
newTarget.AttachEnergy(energy, game);
}
}
}
public void Init(PickFromListMessage pickFromListMessage)
{
InitForCards(pickFromListMessage.PossibleChoices, pickFromListMessage.MinCount, pickFromListMessage.MaxCount);
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
PokemonCard source;
while (true)
{
source = Targeting.AskForTargetFromTargetingMode(Source, game, caster, opponent, pokemonSource, "Select a pokemon to move energy from");
if (FromAnother && source == pokemonSource)
{
continue;
}
break;
}
if (source == null)
{
return;
}
var availableEnergyCards = source.AttachedEnergy
.Where(energy => !OnlyBasic || (OnlyBasic && energy.IsBasic))
.Where(energy => EnergyType == EnergyTypes.All || EnergyType == EnergyTypes.None || energy.EnergyType == EnergyType)
.ToList();
PokemonCard target;
bool first = true;
if (availableEnergyCards.Count <= Amount)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
while (source.AttachedEnergy.Count > 0)
{
var energyCard = source.AttachedEnergy[0];
source.AttachedEnergy.RemoveAt(0);
game.SendEventToPlayers(new AttachedEnergyDiscardedEvent {
DiscardedCard = energyCard, FromPokemonId = source.Id
});
if (DifferentTargetForEachCard && !first)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
}
target.AttachedEnergy.Add(energyCard);
game.SendEventToPlayers(new EnergyCardsAttachedEvent {
EnergyCard = energyCard, AttachedTo = target
});
first = false;
}
return;
}
var message = new PickFromListMessage(availableEnergyCards.OfType <Card>().ToList(), 1, Amount);
var ids = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message.ToNetworkMessage(game.Id)).Cards;
var cards = source.AttachedEnergy.Where(x => ids.Contains(x.Id)).ToList();
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
foreach (var card in cards)
{
if (DifferentTargetForEachCard && !first)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
}
source.AttachedEnergy.Remove(card);
game.SendEventToPlayers(new AttachedEnergyDiscardedEvent {
DiscardedCard = card, FromPokemonId = source.Id
});
target.AttachedEnergy.Add(card);
game.SendEventToPlayers(new EnergyCardsAttachedEvent {
EnergyCard = card, AttachedTo = target
});
first = false;
}
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
Player target;
if (AskYesNoToTargetOpponent && game.AskYesNo(caster, "Put Pokémon from opponents discard onto their bench?"))
{
target = opponent;
}
else
{
target = caster;
}
if (TargetsOpponent)
{
target = opponent;
}
var pokemons = target.DiscardPile.OfType <PokemonCard>().Where(pokemon => pokemon.Stage == 0).OfType <Card>().ToList();
if (pokemons.Count == 0 || target.BenchedPokemon.Count == GameField.BenchMaxSize)
{
return;
}
var message = new PickFromListMessage(pokemons, 1).ToNetworkMessage(game.Id);
var response = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.First();
var card = game.Cards[response];
var pokemonCard = (PokemonCard)card;
int index = target.BenchedPokemon.GetNextFreeIndex();
target.BenchedPokemon.Add(pokemonCard);
target.DiscardPile.Remove(card);
if (WithRemainingHealth > 0 && WithRemainingHealth < 1)
{
var health = (int)Math.Ceiling(pokemonCard.Hp * WithRemainingHealth);
if (health.ToString().Last() == '5')
{
health += 5;
}
pokemonCard.DamageCounters = health;
}
else if (WithRemainingHealth > 1)
{
pokemonCard.DamageCounters = pokemonCard.Hp - (int)WithRemainingHealth;
}
else
{
pokemonCard.DamageCounters = 0;
}
game.SendEventToPlayers(new PokemonAddedToBenchEvent()
{
Pokemon = pokemonCard, Player = target.Id, Index = index
});
}
