public void GrimPatron_BRM_019()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player2HeroClass = CardClass.MAGE,
FillDecks = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
var testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Grim Patron"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, testCard));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
var minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
var minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Reckless Rocketeer"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(MinionAttackTask.Any(game.CurrentPlayer, minion1, testCard));
Assert.AreEqual(2, game.CurrentOpponent.Board.Count);
game.Process(MinionAttackTask.Any(game.CurrentPlayer, minion2, testCard));
Assert.AreEqual(1, game.CurrentOpponent.Board.Count);
}
public void SecretActivation()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.HUNTER,
Player2HeroClass = CardClass.ROGUE,
FillDecks = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
var minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Knife Juggler"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
var testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Snake Trap"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, testCard));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
var minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(MinionAttackTask.Any(game.CurrentPlayer, minion2, minion1));
Assert.Equal(game.CurrentOpponent.Hero.Health > 27 ? 2 : 1, ((Minion)minion1).Health);
}
public void SolemnVigil_BRM_001()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.PALADIN,
Player2HeroClass = CardClass.PALADIN,
FillDecks = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
var testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Solemn Vigil"));
var minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
Assert.AreEqual(1, testCard.Enchants.Count);
Assert.AreEqual(5, testCard.Cost);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
var minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.AreEqual(5, testCard.Cost);
Assert.AreEqual(6, game.CurrentPlayer.Hand.Count);
game.Process(MinionAttackTask.Any(game.CurrentPlayer, minion1, minion2));
Assert.AreEqual(3, testCard.Cost);
game.Process(PlayCardTask.Spell(game.CurrentPlayer, testCard));
Assert.AreEqual(7, game.CurrentPlayer.Hand.Count);
}
public static List <PlayerTask> OptionsOnlyMinionAttacksAndHeroAttacks(Game game1, int playerid)
{
List <PlayerTask> result = new List <PlayerTask>();
result.Add(EndTurnTask.Any(game1.ControllerById(playerid)));
foreach (Minion minion in game1.ControllerById(playerid).BoardZone)
{
if (!minion.CanAttack)
{
continue;
}
IEnumerable <ICharacter> targets = minion.ValidAttackTargets;
foreach (ICharacter target in targets)
{
result.Add(MinionAttackTask.Any(game1.ControllerById(playerid), minion, target));
}
}
if (game1.CurrentPlayer.Hero.CanAttack)
{
IEnumerable <ICharacter> targets = game1.CurrentPlayer.Hero.ValidAttackTargets;
foreach (ICharacter target in targets)
{
result.Add(HeroAttackTask.Any(game1.ControllerById(playerid), target));
}
}
return(result);
}
public static PlayerTask KettleOptionToPlayerTask(Game Game, int sendOptionId, int sendOptionMainOption, int sendOptionTarget, int sendOptionPosition, int sendOptionSubOption)
{
SabberStoneCore.Kettle.PowerAllOptions allOptions = Game.AllOptionsMap[sendOptionId];
Console.WriteLine(allOptions.Print());
List <PlayerTask> tasks = allOptions.PlayerTaskList;
SabberStoneCore.Kettle.PowerOption powerOption = allOptions.PowerOptionList[sendOptionMainOption];
OptionType optionType = powerOption.OptionType;
PlayerTask task = null;
switch (optionType)
{
case OptionType.END_TURN:
task = EndTurnTask.Any(Game.CurrentPlayer);
break;
case OptionType.POWER:
SabberStoneCore.Kettle.PowerSubOption mainOption = powerOption.MainOption;
IPlayable source = Game.IdEntityDic[mainOption.EntityId];
IPlayable target = sendOptionTarget > 0 ? Game.IdEntityDic[sendOptionTarget] : null;
List <SabberStoneCore.Kettle.PowerSubOption> subObtions = powerOption.SubOptions;
if (source.Zone?.Type == Zone.PLAY)
{
task = MinionAttackTask.Any(Game.CurrentPlayer, source, target);
}
else
{
switch (source.Card.Type)
{
case CardType.HERO:
task = HeroAttackTask.Any(Game.CurrentPlayer, target);
break;
case CardType.HERO_POWER:
task = HeroPowerTask.Any(Game.CurrentPlayer, target);
break;
default:
task = PlayCardTask.Any(Game.CurrentPlayer, source, target, sendOptionPosition,
sendOptionSubOption);
break;
}
}
break;
case OptionType.PASS:
break;
default:
throw new NotImplementedException();
}
return(task);
}
public static PlayerTask CreatePlayerTaskOption(Game game, PowerOption powerOption, int sendOptionTarget, int sendOptionPosition, int sendOptionSubOption)
{
//var allOptions = _game.AllOptionsMap[sendOptionId];
//var tasks = allOptions.PlayerTaskList;
//var powerOption = allOptions.PowerOptionList[sendOptionMainOption];
var optionType = powerOption.OptionType;
PlayerTask task = null;
switch (optionType)
{
case OptionType.END_TURN:
task = EndTurnTask.Any(game.CurrentPlayer);
break;
case OptionType.POWER:
var mainOption = powerOption.MainOption;
var source = game.IdEntityDic[mainOption.EntityId];
var target = sendOptionTarget > 0 ? (ICharacter)game.IdEntityDic[sendOptionTarget] : null;
var subObtions = powerOption.SubOptions;
if (source.Zone?.Type == Zone.PLAY)
{
task = MinionAttackTask.Any(game.CurrentPlayer, source, target);
}
else
{
switch (source.Card.Type)
{
case CardType.HERO:
task = target != null
? (PlayerTask)HeroAttackTask.Any(game.CurrentPlayer, target)
: PlayCardTask.Any(game.CurrentPlayer, source);
break;
case CardType.HERO_POWER:
task = HeroPowerTask.Any(game.CurrentPlayer, target);
break;
default:
task = PlayCardTask.Any(game.CurrentPlayer, source, target, sendOptionPosition, sendOptionSubOption);
break;
}
}
break;
case OptionType.PASS:
break;
default:
throw new NotImplementedException();
}
//Log.Info($"{task?.FullPrint()}");
return(task);
}
public void CloneAura2()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player1Deck = new List <Card>
{
Cards.FromName("Sorcerer's Apprentice"),
Cards.FromName("Counterspell")
},
Player2HeroClass = CardClass.MAGE,
Player2Deck = new List <Card>
{
Cards.FromName("Sorcerer's Apprentice"),
Cards.FromName("Counterspell"),
Cards.FromName("Vaporize")
},
Shuffle = false,
FillDecks = false,
History = false,
});
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
game.StartGame();
game.Process(PlayCardTask.Any(game.CurrentPlayer, "Sorcerer's Apprentice"));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(PlayCardTask.Any(game.CurrentPlayer, "Sorcerer's Apprentice"));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.Equal(2, game.Auras.Count);
Assert.Equal(2, game.CurrentPlayer.HandZone[0].Cost);
Assert.Equal(2, game.CurrentOpponent.HandZone[0].Cost);
Assert.Equal(2, game.CurrentOpponent.HandZone[1].Cost);
Game clone = game.Clone();
Assert.Equal(2, clone.Auras.Count);
Assert.Equal(2, clone.CurrentPlayer.HandZone[0].Cost);
Assert.Equal(2, clone.CurrentOpponent.HandZone[0].Cost);
Assert.Equal(2, clone.CurrentOpponent.HandZone[1].Cost);
clone.Process(MinionAttackTask.Any(clone.CurrentPlayer, clone.CurrentPlayer.BoardZone[0],
clone.CurrentOpponent.BoardZone[0]));
Assert.Empty(clone.Auras);
Assert.Equal(3, clone.CurrentPlayer.HandZone[0].Cost);
Assert.Equal(3, clone.CurrentOpponent.HandZone[0].Cost);
Assert.Equal(3, clone.CurrentOpponent.HandZone[1].Cost);
}
public static void AuraTimingTest()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.PALADIN,
Player2HeroClass = CardClass.HUNTER,
Player1Deck = new List <Card>
{
Cards.FromName("Stormwind Champion")
},
Player2Deck = new List <Card>
{
Cards.FromName("Fiery Bat")
},
FillDecks = false,
Shuffle = false
});
game.Player1.BaseMana = 10;
game.StartGame();
game.Process(PlayCardTask.Any(game.CurrentPlayer, "Stormwind Champion"));
game.CurrentPlayer.BoardZone[0].Damage = 4;
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
Assert.Equal(2, game.CurrentPlayer.BoardZone[1].Health);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(PlayCardTask.Any(game.CurrentPlayer, "Fiery Bat"));
game.CurrentPlayer.BoardZone[0].IsExhausted = false;
while (true)
{
Game clone = game.Clone();
Assert.Equal(2, clone.CurrentOpponent.BoardZone[1].Health);
clone.Process(MinionAttackTask.Any(clone.CurrentPlayer, clone.CurrentPlayer.BoardZone[0],
clone.CurrentOpponent.BoardZone[0]));
if (clone.CurrentOpponent.Hero.Damage == 7)
{
continue;
}
Assert.Equal(1, clone.CurrentOpponent.BoardZone.Count);
Assert.Equal(1, clone.CurrentOpponent.BoardZone[0].AttackDamage);
Assert.Equal(1, clone.CurrentOpponent.BoardZone[0].Health);
break;
}
}
public void SecretActivation()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.HUNTER,
Player2HeroClass = CardClass.ROGUE,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
IPlayable minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Knife Juggler"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
IPlayable testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Snake Trap")); // Spawns 3
game.Process(PlayCardTask.Spell(game.CurrentPlayer, testCard));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
IPlayable minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(MinionAttackTask.Any(game.CurrentPlayer, minion2, minion1));
Assert.Equal(4, game.CurrentOpponent.BoardZone.Count);
if (game.CurrentPlayer.BoardZone.Count == 0)
{
// Minion was destroyed, so it's moved to graveyard with tags reset.
Assert.Equal(1, game.CurrentPlayer.GraveyardZone.Count);
Assert.Equal(game.CurrentOpponent.Hero.BaseHealth, game.CurrentOpponent.Hero.Health);
Assert.Equal(game.CurrentPlayer.Hero.BaseHealth - 2, game.CurrentPlayer.Hero.Health);
}
else
{
// Minion was NOT destroyed, so it continued it's attack.
Assert.Equal(0, game.CurrentPlayer.GraveyardZone.Count);
Assert.Equal(game.CurrentOpponent.Hero.BaseHealth - 1, game.CurrentOpponent.Hero.Health);
Assert.Equal(game.CurrentPlayer.Hero.BaseHealth - 3, game.CurrentPlayer.Hero.Health);
}
}
public void SecretOrderOfPlay()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player1Deck = new List <Card>()
{
Cards.FromName("Vaporize"),
Cards.FromName("Ice Barrier"),
Cards.FromName("Stonetusk Boar")
},
Player2HeroClass = CardClass.HUNTER,
Player2Deck = new List <Card>()
{
Cards.FromName("Stonetusk Boar"),
Cards.FromName("Freezing Trap"),
Cards.FromName("Explosive Trap")
},
Shuffle = false,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
game.Process(PlayCardTask.Spell(game.CurrentPlayer, "Vaporize"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, "Ice Barrier"));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, "Stonetusk Boar"));
game.Process(MinionAttackTask.Any(game.CurrentPlayer, game.CurrentPlayer.BoardZone[0], game.CurrentOpponent.Hero));
Assert.Equal(8, game.CurrentOpponent.Hero.Armor);
game.Process(PlayCardTask.Spell(game.CurrentPlayer, "Freezing Trap"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, "Explosive Trap"));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, "Stonetusk Boar"));
game.Process(MinionAttackTask.Any(game.CurrentPlayer, game.CurrentPlayer.BoardZone[0], game.CurrentOpponent.Hero));
Assert.Equal(30, game.CurrentOpponent.Hero.Health);
}
public void LifestealAuchenaiTest()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.PRIEST,
Player2HeroClass = CardClass.PRIEST,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.ProcessCard("Auchenai Soulpriest", asZeroCost: true);
Minion lifestealAttacker = game.ProcessCard <Minion>("Acolyte of Agony", asZeroCost: true);
lifestealAttacker.HasCharge = true;
game.Process(MinionAttackTask.Any(game.CurrentPlayer, lifestealAttacker, game.CurrentOpponent.Hero));
Assert.Equal(3, game.CurrentPlayer.Hero.Damage);
}
public static PlayerTask GetPlayerTask(Option option, Game g)
{
const bool SkipPrePhase = true;
Controller c = g.CurrentPlayer;
switch (option.Type)
{
case Choose:
return(ChooseTask.Pick(c, option.Choice));
case Concede:
return(ConcedeTask.Any(c));
case EndTurn:
return(EndTurnTask.Any(c));
case HeroAttack:
return(HeroAttackTask.Any(c, GetOpponentTarget(option.TargetPosition), SkipPrePhase));
case Option.Types.PlayerTaskType.HeroPower:
return(HeroPowerTask.Any(c, GetTarget(option.TargetPosition), option.SubOption, SkipPrePhase));
case MinionAttack:
return(MinionAttackTask.Any(c, c.BoardZone[option.SourcePosition - 1], GetOpponentTarget(option.TargetPosition), SkipPrePhase));
case PlayCard:
IPlayable source = c.HandZone[option.SourcePosition];
if (source.Card.Type == CardType.MINION)
{
return(PlayCardTask.Any(c, source, null, option.TargetPosition - 1, option.SubOption, SkipPrePhase));
}
else
{
return(PlayCardTask.Any(c, source, GetTarget(option.TargetPosition),
0, option.SubOption, SkipPrePhase));
}
default:
throw new ArgumentOutOfRangeException();
}
ICharacter GetOpponentTarget(int position)
{
if (position == Option.OP_HERO_POSITION)
{
return(c.Opponent.Hero);
}
return(c.Opponent.BoardZone[position - 9]);
}
ICharacter GetTarget(int position)
{
if (position == -1)
{
return(null);
}
if (position >= Option.OP_HERO_POSITION)
{
return(GetOpponentTarget(position));
}
if (position == Option.HERO_POSITION)
{
return(c.Hero);
}
return(c.BoardZone[position - 1]);
}
}
public PlayerTask ProcessPowerOptionsData(int sendOptionId, int sendOptionMainOption, int sendOptionTarget, int sendOptionPosition, int sendOptionSubOption)
{
var allOptions = _game.AllOptionsMap[sendOptionId];
var tasks = allOptions.PlayerTaskList;
var powerOption = allOptions.PowerOptionList[sendOptionMainOption];
var optionType = powerOption.OptionType;
PlayerTask task = null;
switch (optionType)
{
case OptionType.END_TURN:
task = EndTurnTask.Any(_game.CurrentPlayer);
break;
case OptionType.POWER:
var mainOption = powerOption.MainOption;
var source = _game.IdEntityDic[mainOption.EntityId];
var target = sendOptionTarget > 0 ? (ICharacter)_game.IdEntityDic[sendOptionTarget] : null;
var subObtions = powerOption.SubOptions;
if (source.Zone?.Type == Zone.PLAY)
{
task = MinionAttackTask.Any(_game.CurrentPlayer, source, target);
}
else
{
switch (source.Card.Type)
{
case CardType.HERO:
if (target != null)
{
task = HeroAttackTask.Any(_game.CurrentPlayer, target);
}
else
{
task = PlayCardTask.Any(_game.CurrentPlayer, source);
}
break;
case CardType.HERO_POWER:
task = HeroPowerTask.Any(_game.CurrentPlayer, target);
break;
default:
task = PlayCardTask.Any(_game.CurrentPlayer, source, target, sendOptionPosition,
sendOptionSubOption);
break;
}
}
break;
case OptionType.PASS:
break;
default:
throw new NotImplementedException();
}
return(task);
}
/// <summary>
/// Returns a set of all options this player can perform execute at the moment.
/// From this set one option is picked and executed by the game.
/// </summary>
/// <param name="playCards"></param>
/// <returns></returns>
public List <PlayerTask> Options(bool playCards = true)
{
var result = new List <PlayerTask>();
if (this != Game.CurrentPlayer)
{
return(result);
}
if (Choice != null)
{
switch (Choice.ChoiceType)
{
case ChoiceType.GENERAL:
Choice.Choices.ToList().ForEach(p => result.Add(ChooseTask.Pick(this, p)));
return(result);
case ChoiceType.MULLIGAN:
IEnumerable <IEnumerable <int> > choices = Util.GetPowerSet(Choice.Choices);
choices.ToList().ForEach(p => result.Add(ChooseTask.Mulligan(this, p.ToList())));
return(result);
default:
throw new NotImplementedException();
}
}
// no options till mulligan is done for both players
if (Game.Step != Step.MAIN_ACTION)
{
return(result);
}
// add end turn task ...
result.Add(EndTurnTask.Any(this));
if (playCards)
{
foreach (IPlayable playableCard in HandZone)
{
var minion = playableCard as Minion;
if (!playableCard.IsPlayableByPlayer)
{
continue;
}
List <IPlayable> playables = playableCard.ChooseOne && !Game.CurrentPlayer.ChooseBoth
? playableCard.ChooseOnePlayables.ToList()
: new List <IPlayable> {
playableCard
};
foreach (IPlayable t in playables)
{
if (!t.IsPlayableByCardReq)
{
continue;
}
var targets = t.ValidPlayTargets.ToList();
var subResult = new List <PlayCardTask>();
if (!targets.Any())
{
subResult.Add(PlayCardTask.Any(this, playableCard, null, -1,
playables.Count == 1 ? 0 : playables.IndexOf(t) + 1));
}
subResult.AddRange(
targets.Select(
target =>
PlayCardTask.Any(this, playableCard, target, -1,
playables.Count == 1 ? 0 : playables.IndexOf(t) + 1)));
if (minion != null)
{
var tempSubResult = new List <PlayCardTask>();
int positions = BoardZone.Count + 1;
for (int j = 0; j < positions; j++)
{
subResult.ForEach(p =>
{
PlayCardTask task = p.Copy();
task.ZonePosition = j;
tempSubResult.Add(task);
});
}
subResult = tempSubResult;
}
result.AddRange(subResult);
}
}
}
foreach (Minion minion in BoardZone)
{
if (!minion.CanAttack)
{
continue;
}
IEnumerable <ICharacter> targets = minion.ValidAttackTargets;
targets.ToList().ForEach(p => result.Add(MinionAttackTask.Any(this, minion, p)));
}
if (Hero.CanAttack)
{
IEnumerable <ICharacter> targets = Hero.ValidAttackTargets;
targets.ToList().ForEach(p => result.Add(HeroAttackTask.Any(this, p)));
}
if (Hero.Power.IsPlayable)
{
var targets = Hero.Power.GetValidPlayTargets().ToList();
if (targets.Any())
{
targets.ToList().ForEach(p => result.Add(HeroPowerTask.Any(this, p)));
}
else
{
result.Add(HeroPowerTask.Any(this));
}
}
return(result);
}
public void IceBlock_EX1_295()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player2HeroClass = CardClass.MAGE,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player1.Hero.Health = 2;
game.Player2.BaseMana = 10;
IPlayable spell = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Ice Block"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell));
Assert.Equal(1, game.CurrentPlayer.SecretZone.Count);
//Assert.Equal(1, game.CurrentOpponent.Board.Triggers.Count);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
// play 2 charge minions
IPlayable minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
IPlayable minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
IPlayable minion3 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Bluegill Warrior"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion3));
Assert.Equal(3, game.CurrentPlayer.BoardZone.Count);
// minion 1 attacks hero that should NOT proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion1, game.CurrentOpponent.Hero));
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
Assert.Equal(1, game.CurrentOpponent.SecretZone.Count);
// adding one armor for next attack
game.Player1.Hero.Armor = 1;
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
// minion 2 attacks hero that should proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion2, game.CurrentOpponent.Hero));
Assert.Equal(0, game.CurrentOpponent.Hero.Armor);
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
Assert.Equal(1, game.CurrentOpponent.SecretZone.Count);
// adding one armor for next attack
game.Player1.Hero.Armor = 1;
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
// minion 3 attacks hero that should proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion3, game.CurrentOpponent.Hero));
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
Assert.Equal(0, game.CurrentOpponent.SecretZone.Count);
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
// minion 2 now kills opponent
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion3, game.CurrentOpponent.Hero));
Assert.True(game.CurrentOpponent.Hero.IsDead);
}
public override PlayerTask GetMove(POGame game)
{
if (SelectHeroPower)
{
SelectHeroPower = false;
List <IPlayable> choices = game.CurrentPlayer.Choice.Choices.Select(id => game.getGame().IdEntityDic[id]).ToList();
string selected = HeroPowerPriorities.choose(choices.Select(c => c.Card.Name).Distinct().ToList());
return(ChooseTask.Pick(game.CurrentPlayer, choices.First(c => c.Card.Name == selected).Id));
}
int mana = game.CurrentPlayer.BaseMana + game.CurrentPlayer.TemporaryMana - game.CurrentPlayer.UsedMana;
List <PlayerTask> options = game.CurrentPlayer.Options();
List <PlayerTask> heroPowers = options.Where(t => t.PlayerTaskType == PlayerTaskType.HERO_POWER).ToList();
List <PlayerTask> playCards = options.Where(t => t.PlayerTaskType == PlayerTaskType.PLAY_CARD && t.Source.Card.Cost <= mana).ToList();
List <Minion> ourMinionsReady = game.Minions.Where(m => m.Controller.Id == game.CurrentPlayer.Id && m.CanAttack).ToList();
if (game.CurrentPlayer.MulliganState == Mulligan.INPUT)
{
// mulligan
List <IPlayable> choices = game.CurrentPlayer.Choice.Choices.Select(id => game.getGame().IdEntityDic[id]).ToList();
choices = choices.Where(c => c.Cost <= 3 && c.Card.Name != "Patches the Pirate").ToList();
return(ChooseTask.Mulligan(game.CurrentPlayer, choices.Select(c => c.Id).ToList()));
}
else if (playCards.Count != 0)
{
// play card
List <string> cardNames = playCards.Select(c => c.Source.Card.Name).Distinct().ToList();
string selectedCard;
if (game.CurrentPlayer.Hero.Weapon != null)
{
// we have a weapon
selectedCard = CardPrioritiesWithWeapon.choose(cardNames);
}
else
{
// we don't have a weapon
selectedCard = CardPrioritiesNoWeapon.choose(cardNames);
}
if (selectedCard == "Sir Finley Mrrgglton")
{
SelectHeroPower = true;
}
return(playCards.First(t => t.Source.Card.Name == selectedCard));
}
else if (game.CurrentPlayer.Hero.CanAttack)
{
// hero attack
List <Minion> enemyMinions = game.Minions.Where(m => m.Controller.Id == game.CurrentOpponent.Id).ToList();
List <Minion> enemyTaunts = enemyMinions.Where(m => m.HasTaunt == true).ToList();
if (enemyTaunts.Count != 0)
{
return(HeroAttackTask.Any(game.CurrentPlayer, enemyTaunts[0]));
}
else
{
return(HeroAttackTask.Any(game.CurrentPlayer, game.CurrentOpponent.Hero));
}
}
else if (ourMinionsReady.Count != 0)
{
// minion attack
List <Minion> enemyMinions = game.Minions.Where(m => m.Controller.Id == game.CurrentOpponent.Id).ToList();
List <Minion> enemyTaunts = enemyMinions.Where(m => m.HasTaunt == true).ToList();
if (enemyTaunts.Count != 0)
{
int tauntHealth = enemyTaunts[0].Health;
int tauntAttack = enemyTaunts[0].AttackDamage;
// perfectTraders: survive the attack, kill the Taunt and don't have more overkill/wasted damage than 2
List <Minion> perfectTraders = ourMinionsReady.Where(m => m.Health > tauntAttack && m.AttackDamage >= tauntHealth && m.AttackDamage <= (tauntHealth + 2)).ToList();
// almost perfect Traders: survive the attack and kill the Taunt
List <Minion> almostPerfectTraders = ourMinionsReady.Where(m => m.Health > tauntAttack && m.AttackDamage >= tauntHealth).ToList();
// goodTraders: kill Taunt
List <Minion> goodTraders = ourMinionsReady.Where(m => m.AttackDamage > tauntHealth).ToList();
// survivingTraders: survive an attack but don't necessarily kill the taunt
List <Minion> survivingTraders = ourMinionsReady.Where(m => m.Health > tauntAttack).ToList();
// trade perfect
if (perfectTraders.Count != 0)
{
perfectTraders = perfectTraders.OrderBy(m => m.Health + m.AttackDamage).ToList();
return(MinionAttackTask.Any(game.CurrentPlayer, perfectTraders[0], enemyTaunts[0]));
}
// trade almost perfect
else if (almostPerfectTraders.Count != 0)
{
almostPerfectTraders = almostPerfectTraders.OrderBy(m => m.Health + m.AttackDamage).ToList();
return(MinionAttackTask.Any(game.CurrentPlayer, almostPerfectTraders[0], enemyTaunts[0]));
}
// trade good
else if (goodTraders.Count != 0)
{
// sort good traders and choose weakest to not waste potential
goodTraders = goodTraders.OrderBy(m => m.Health + m.AttackDamage).ToList();
return(MinionAttackTask.Any(game.CurrentPlayer, goodTraders[0], enemyTaunts[0]));
}
// trade so that minions survive
else if (survivingTraders.Count != 0)
{
return(MinionAttackTask.Any(game.CurrentPlayer, survivingTraders[0], enemyTaunts[0]));
}
// trade random
else
{
return(MinionAttackTask.Any(game.CurrentPlayer, ourMinionsReady[0], enemyTaunts[0]));
}
}
else
{
return(MinionAttackTask.Any(game.CurrentPlayer, ourMinionsReady[0], game.CurrentOpponent.Hero));
}
}
else if (mana >= 2 && heroPowers.Count != 0)
{
// hero power
if (game.CurrentPlayer.Hero.HeroPower.Card.Name == "Lesser Heal" || game.CurrentPlayer.Hero.HeroPower.Card.Name == "Fireblast")
{
return(options[0]); // end turn, because we don't know how to set the target
}
else
{
return(heroPowers[0]); // use hero power
}
}
else
{
// fallback: end turn
return(options[0]);
}
}
