public static void Run()
{
do
{
var rnd = new Random();
Game game = new Game(new GameConfig
{
Player1HeroClass = (CardClass)rnd.Next(2, 11),
Player2HeroClass = (CardClass)rnd.Next(2, 11),
History = true,
Logging = true,
FillDecks = true,
SkipMulligan = true,
Shuffle = false,
});
game.StartGame();
do
{
Game clone = game.Clone(history: true);
List <PlayerTask> options = game.CurrentPlayer.Options();
PlayerTask option = options[rnd.Next(options.Count)];
game.Process(option);
StateTransition(clone, game.PowerHistory);
InequalityFlags flag = Equals(game, clone);
if (CheckFlag(flag))
{
;
}
} while (game.State != State.COMPLETE);
} while (true);
}
public static void EqualTest()
{
var rnd = new Random();
Game game = new Game(new GameConfig
{
Player1HeroClass = (CardClass)rnd.Next(2, 11),
Player2HeroClass = (CardClass)rnd.Next(2, 11),
History = false,
Logging = false,
FillDecks = true,
SkipMulligan = true,
Shuffle = false,
});
game.StartGame();
Game clone;
do
{
List <PlayerTask> options = game.CurrentPlayer.Options();
PlayerTask option = options[rnd.Next(options.Count)];
game.Process(option);
clone = game.Clone();
InequalityFlags flag = Equals(game, clone);
if (CheckFlag(flag))
{
throw new Exception(flag.ToString());
}
} while (game.State != State.COMPLETE);
}
private static InequalityFlags Equals(Playable a, Playable b)
{
InequalityFlags flag = InequalityFlags.Playable;
flag |= Equals(a.ActivatedTrigger, b.ActivatedTrigger);
if (CheckFlag(flag))
{
return(flag);
}
List <Enchantment> aEnchantments = a.AppliedEnchantments;
List <Enchantment> bEnchantments = b.AppliedEnchantments;
if (aEnchantments is null)
{
if (!(bEnchantments is null))
{
return(flag | InequalityFlags.Enchantments);
}
}
else
{
if (bEnchantments is null)
{
return(flag | InequalityFlags.Enchantments);
}
if (aEnchantments.Count != bEnchantments.Count)
{
return(flag | InequalityFlags.Enchantments);
}
for (int i = 0; i < aEnchantments.Count; i++)
{
if (!Equals(aEnchantments[i], bEnchantments[i]))
{
return(flag | InequalityFlags.Enchantments);
}
}
}
if (!(a.IsExhausted == b.IsExhausted &&
a.ZonePosition == b.ZonePosition &&
a.Cost == b.Cost))
{
// Playable attribute mismatch
return(flag | InequalityFlags.Attributes);
}
flag |= Equals((Entity)a, b);
if ((flag & InequalityFlags.None) != InequalityFlags.None)
{
return(flag);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Entity a, Entity b)
{
InequalityFlags flag = InequalityFlags.Entity;
if (!Equals(a.NativeTags, b.NativeTags))
{
return(flag | InequalityFlags.Tags);
}
if (a.AuraEffects != b.AuraEffects)
{
return(flag | InequalityFlags.AuraEffects);
}
if (a.OrderOfPlay != b.OrderOfPlay)
{
return(flag | InequalityFlags.Attributes);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Weapon a, Weapon b)
{
InequalityFlags flag = InequalityFlags.Weapon;
if (a is null)
{
return(b is null ? InequalityFlags.None : flag);
}
if (b is null)
{
return(flag);
}
flag |= Equals((Playable)a, b);
if (CheckFlag(flag))
{
return(flag);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Controller a, Controller b)
{
InequalityFlags flag = InequalityFlags.None;
//if (!Equals(a.NativeTags, b.NativeTags)) return InequalityFlags.Tags;
if (a.ControllerAuraEffects != b.ControllerAuraEffects)
{
return(InequalityFlags.AuraEffects);
}
flag |= Equals(a.Hero, b.Hero);
if (CheckFlag(flag))
{
return(flag);
}
flag |= Equals(a.HandZone, b.HandZone);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.Hand);
}
flag |= Equals(a.BoardZone, b.BoardZone);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.Board);
}
flag |= Equals(a.SecretZone, b.SecretZone);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.Secrets);
}
flag |= Equals(a.DeckZone, b.DeckZone);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.Deck);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals <T>(Zone <T> a, Zone <T> b) where T : IPlayable
{
if (a.Count != b.Count)
{
return(InequalityFlags.Attributes);
}
InequalityFlags flag = InequalityFlags.None;
ReadOnlySpan <T> aSpan = a.GetSpan();
ReadOnlySpan <T> bSpan = b.GetSpan();
for (int i = 0; i < aSpan.Length; i++)
{
flag |= Equals(aSpan[i], bSpan[i]);
if (CheckFlag(flag))
{
return(flag);
}
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Game a, Game b)
{
InequalityFlags flag = InequalityFlags.Game;
if (!Equals(a.NativeTags, b.NativeTags))
{
return(flag | InequalityFlags.Tags);
}
flag |= Equals(a.CurrentPlayer, b.CurrentPlayer);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.CurrentPlayer);
}
flag |= Equals(a.CurrentOpponent, b.CurrentOpponent);
if (CheckFlag(flag))
{
return(flag | InequalityFlags.CurrentOpponent);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Character a, Character b)
{
InequalityFlags flag = InequalityFlags.Character;
if (!(a.AttackDamage != b.AttackDamage ||
a.BaseHealth != b.BaseHealth ||
a.Damage != b.Damage ||
a.NumAttacksThisTurn != b.NumAttacksThisTurn ||
a.HasStealth != b.HasStealth ||
a.IsImmune != b.IsImmune ||
a.HasTaunt != b.HasTaunt ||
a.CantBeTargetedBySpells != b.CantBeTargetedBySpells))
{
return(flag | InequalityFlags.Attributes);
}
flag |= Equals((Playable)a, b);
if (CheckFlag(flag))
{
return(flag);
}
return(InequalityFlags.None);
}
private static InequalityFlags Equals(Hero a, Hero b)
{
InequalityFlags flag = InequalityFlags.Hero;
if (a.Auras.Count != b.Auras.Count)
{
return(flag | InequalityFlags.Attributes);
}
for (int i = 0; i < a.Auras.Count; i++)
{
if (!Equals(a.Auras[i], b.Auras[i]))
{
return(flag | InequalityFlags.Attributes);
}
}
flag |= Equals(a.HeroPower, b.HeroPower);
if (CheckFlag(flag))
{
return(flag);
}
flag |= Equals(a.Weapon, b.Weapon);
if (CheckFlag(flag))
{
return(flag);
}
flag |= Equals((Character)a, b);
if (CheckFlag(flag))
{
return(flag);
}
return(InequalityFlags.None);
}
private static bool CheckFlag(InequalityFlags flag)
{
return((flag & InequalityFlags.None) != InequalityFlags.None);
}
