public void MajordomoExecutus_BRM_027()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player2HeroClass = CardClass.PRIEST,
FillDecks = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
var testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Majordomo Executus"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, testCard));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
var spell = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Shadow Word: Death"));
game.Process(PlayCardTask.SpellTarget(game.CurrentPlayer, spell, testCard));
Assert.AreEqual(8, game.CurrentOpponent.Hero.Health);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
Assert.AreEqual(22, game.CurrentOpponent.Hero.Health);
}
public void TauntTest()
{
var game = new Game(new GameConfig {
StartPlayer = 1, Player1HeroClass = CardClass.ROGUE, Player2HeroClass = CardClass.WARLOCK, FillDecks = true, FillDecksPredictably = true
});
game.StartGame();
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
Assert.True(game.CurrentPlayer.Hero.IsValidAttackTarget(game.CurrentOpponent.Hero));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
IPlayable taunt = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Voidwalker"));
game.Process(PlayCardTask.Any(game.CurrentPlayer, taunt));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.True(((ICharacter)taunt).HasTaunt);
Assert.False(game.CurrentPlayer.Hero.IsValidAttackTarget(game.CurrentOpponent.Hero));
Assert.True(game.CurrentPlayer.Hero.IsValidAttackTarget(taunt as ICharacter));
}
public void MoltenGiant_EX1_620()
{
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.Player2.BaseMana = 10;
IPlayable testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Molten Giant"));
Assert.Equal(30, game.CurrentPlayer.Hero.Health);
Assert.Equal(20, testCard.Cost);
game.Process(HeroPowerTask.Any(game.CurrentPlayer, game.CurrentPlayer.Hero));
Assert.Equal(29, game.CurrentPlayer.Hero.Health);
Assert.Equal(19, testCard.Cost);
Game clone = game.Clone();
Assert.Equal(19, clone.CurrentPlayer.HandZone.Last().Cost);
}
public void VolcanicDrake_BRM_025()
{
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("Volcanic Drake"));
var minion = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion));
Assert.AreEqual(1, testCard.Enchants.Count);
Assert.AreEqual(6, testCard.Cost);
game.Process(HeroPowerTask.Any(game.CurrentPlayer, minion));
Assert.AreEqual(5, testCard.Cost);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.AreEqual(6, testCard.Cost);
}
/// <summary>
/// Plays current player's Hero Power.
/// </summary>
public static void PlayHeroPower(this Game game, IPlayable target = null, int chooseOne = 0, bool asZeroCost = false, bool autoRefresh = false)
{
game.Process(HeroPowerTask.Any(game.CurrentPlayer, target, chooseOne, asZeroCost));
if (autoRefresh)
{
game.CurrentPlayer.Hero.HeroPower.IsExhausted = false;
}
}
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 SummonFailTest()
{
var game = new Game(new GameConfig {
StartPlayer = 1, Player1HeroClass = CardClass.PALADIN, Player2HeroClass = CardClass.MAGE, FillDecks = true, FillDecksPredictably = true
});
game.StartGame();
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.Equal(6, game.CurrentPlayer.BoardZone.Count);
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
Assert.Equal(7, game.CurrentPlayer.BoardZone.Count);
game.Process(HeroPowerTask.Any(game.CurrentPlayer));
Assert.Equal(7, game.CurrentPlayer.BoardZone.Count);
}
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;
}
}
/// <summary>
/// Plays current player's Hero Power.
/// </summary>
public static void PlayHeroPower(this Game game, IPlayable target = null, int chooseOne = 0, bool asZeroCost = false, bool autoRefresh = false)
{
if (target != null && !(target is ICharacter))
{
throw new ArgumentException($"Can't target non-charater entity {target}");
}
var option = HeroPowerTask.Any(game.CurrentPlayer, (ICharacter)target, chooseOne, asZeroCost);
if (!game.Process(option))
{
throw new Exception($"{option} is not a valid task.");
}
if (autoRefresh)
{
game.CurrentPlayer.Hero.HeroPower.IsExhausted = false;
}
}
public static void CardsTest()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.WARLOCK,
Player1Deck = new List <Card>()
{
Cards.FromName("Bloodreaver Gul'dan")
},
Player2HeroClass = CardClass.MAGE,
Shuffle = false,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer, game.CurrentOpponent.Hero));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer, game.CurrentOpponent.Hero));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(PlayCardTask.Any(game.CurrentPlayer, "Bloodreaver Gul'dan"));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(HeroPowerTask.Any(game.CurrentPlayer, game.CurrentOpponent.Hero));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
ShowLog(game, LogLevel.VERBOSE);
//Console.WriteLine(game.CurrentPlayer.BoardZone.FullPrint());
//Console.WriteLine(game.CurrentPlayer.HandZone.FullPrint());
//Console.WriteLine(game.CurrentPlayer.DeckZone.FullPrint());
}
public void DragonsBreath_BRM_003()
{
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("Dragon's Breath"));
var minion = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion));
Assert.AreEqual(1, testCard.Enchants.Count);
Assert.AreEqual(5, testCard.Cost);
game.Process(HeroPowerTask.Any(game.CurrentPlayer, minion));
Assert.AreEqual(4, testCard.Cost);
game.Process(PlayCardTask.SpellTarget(game.CurrentPlayer, testCard, game.CurrentOpponent.Hero));
Assert.AreEqual(26, game.CurrentOpponent.Hero.Health);
}
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);
}
/// <summary>
/// Plays current player's Hero Power.
/// </summary>
public static void PlayHeroPower(this Game game, IPlayable target = null, int chooseOne = 0, bool asZeroCost = false)
{
game.Process(HeroPowerTask.Any(game.CurrentPlayer, target, chooseOne, asZeroCost));
}
