public void StealthTest()
{
THHGame game = GameInitWithoutPlayer <DefaultServant, StealthServant>(29, 1);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[1], 0);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[1], 0);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 1);
Assert.True(game.sortedPlayers[0].field[1].isStealth());
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[0].field[1]);
//game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[1].master);
Assert.AreEqual(3, game.sortedPlayers[0].field[1].getCurrentLife()); //潜行的随从不会被攻击，因此血量不变
game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[0].field[0]);
Assert.AreEqual(6, game.sortedPlayers[1].field[0].getCurrentLife()); //非潜行随从可以被攻击
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdAttack(game, game.sortedPlayers[0].field[1], game.sortedPlayers[1].field[0]);
Assert.False(game.sortedPlayers[0].field[1].isStealth()); //潜行随从攻击后变为非潜行状态
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[0].field[1]);
Assert.AreEqual(1, game.sortedPlayers[0].field[1].getCurrentLife()); //变为非潜行状态后可以被攻击
//game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 1);
//Assert.True(game.sortedPlayers[1].field[1].isStealth());
//game.sortedPlayers[1].cmdTurnEnd(game);
//Assert.AreEqual(29, game.sortedPlayers[0].master.getCurrentLife()); //潜行随从在回合结束时对对方master造成伤害
//Assert.False(game.sortedPlayers[1].field[1].isStealth()); //潜行消失
}
public void startRemoteGame(ClientManager client, GameOption option, THHRoomPlayerInfo[] players)
{
game = new THHGame(option, getManager <CardManager>().GetCardDefines())
{
answers = new GameObject(nameof(AnswerManager)).AddComponent <AnswerManager>(),
triggers = new GameObject(nameof(TriggerManager)).AddComponent <TriggerManager>(),
time = new GameObject(nameof(TimeManager)).AddComponent <TimeManager>(),
logger = new ULogger()
};
(game.answers as AnswerManager).client = client;
foreach (var info in players)
{
checkDeckValid(info.deck);
THHPlayer player = game.createPlayer(info.id, info.name, game.getCardDefine(info.deck[0]) as MasterCardDefine,
info.deck.Skip(1).Select(id => game.getCardDefine(id)));
if (client.id == info.id)
{
displayGameUI(player);
}
}
game.triggers.onEventAfter += onEventAfter;
gameTask = game.run();
}
public void StealthTest()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, new GameOption()
{
shuffle = false
});
game.createPlayer(0, "玩家0", game.getCardDefine <Reimu>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 29)
.Concat(Enumerable.Repeat(game.getCardDefine <StealthServant>(), 1)));
game.createPlayer(1, "玩家1", game.getCardDefine <Reimu>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 29)
.Concat(Enumerable.Repeat(game.getCardDefine <StealthServant>(), 1)));
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[1], 0);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[1], 0);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 1);
Assert.True(game.sortedPlayers[0].field[1].isStealth());
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[0].field[1]);
//game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[1].master);
Assert.AreEqual(7, game.sortedPlayers[1].field[0].getCurrentLife());
game.sortedPlayers[1].cmdAttack(game, game.sortedPlayers[1].field[0], game.sortedPlayers[0].field[0]);
Assert.AreEqual(6, game.sortedPlayers[1].field[0].getCurrentLife());
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdAttack(game, game.sortedPlayers[0].field[1], game.sortedPlayers[1].field[0]);
Assert.False(game.sortedPlayers[0].field[1].isStealth());
}
public IEnumerator humanVillageGuardTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Reimu(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new HumanVillageGuard(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
yield return(new WaitForSeconds(.1f));
Assert.True(game.sortedPlayers[0].field[0].isTaunt());
}
public IEnumerator rifleHunterTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Reimu(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new RifleHunter(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0, game.sortedPlayers[1].master);
yield return(new WaitForSeconds(.1f));
Assert.AreEqual(28, game.sortedPlayers[1].master.getCurrentLife());
}
public IEnumerator winTest()
{
THHGame game = TestGameflow.initStandardGame();
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[0].cmdInitReplace(game);
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
yield return(new WaitForSeconds(.1f));
for (int i = 0; i < 15; i++)
{
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdAttack(game, game.sortedPlayers[0].field[0], game.sortedPlayers[1].master);
yield return(new WaitForSeconds(.1f));
}
THHCard.AttackEventArg attack = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHCard.AttackEventArg) as THHCard.AttackEventArg;
Assert.NotNull(attack);
THHGame.GameEndEventArg gameEnd = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHGame.GameEndEventArg) as THHGame.GameEndEventArg;
Assert.AreEqual(game.sortedPlayers[0], gameEnd.winners[0]);
game.Dispose();
}
public void SkillAndSpellCardTest()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, new GameOption()
{
shuffle = false
});
game.createPlayer(0, "玩家0", game.getCardDefine <TestMaster2>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 28)
.Concat(Enumerable.Repeat(game.getCardDefine <DefaultServant>(), 2)));
game.createPlayer(1, "玩家1", game.getCardDefine <TestMaster2>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 29)
.Concat(Enumerable.Repeat(game.getCardDefine <TestSpellCard>(), 1)));
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
game.sortedPlayers[1].cmdTurnEnd(game);
int gemNum = game.sortedPlayers[0].gem;
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].skill, 0, game.sortedPlayers[1].field[0]);
Assert.True(game.sortedPlayers[0].skill.isUsed()); //技能已使用
Assert.AreEqual(6, game.sortedPlayers[1].field[0].getCurrentLife()); //敌方随从受到伤害
Assert.AreEqual(1, gemNum - game.sortedPlayers[0].gem); //水晶减1
gemNum = game.sortedPlayers[0].gem;
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0, game.sortedPlayers[1].field[0]);
Assert.AreEqual(5, game.sortedPlayers[1].field[0].getCurrentLife());
Assert.AreEqual(1, gemNum - game.sortedPlayers[0].gem); //水晶减1
}
public IEnumerator fatigueTest()
{
THHGame game = TestGameflow.initStandardGame(deckCount: 10);
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[0].cmdInitReplace(game);
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
for (int i = 0; i < 7; i++)
{
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
}
THHPlayer.FatigueEventArg fatigue = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHPlayer.FatigueEventArg) as THHPlayer.FatigueEventArg;
Assert.NotNull(fatigue);
Assert.AreEqual(game.sortedPlayers[0], fatigue.player);
THHCard.DamageEventArg damage = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHCard.DamageEventArg) as THHCard.DamageEventArg;
Assert.NotNull(damage);
Assert.AreEqual(game.sortedPlayers[0].master, damage.cards[0]);
Assert.AreEqual(1, damage.value);
game.Dispose();
}
public static THHGame initStandardGame(string name, int[] playersId, MasterCardDefine[] masters, CardDefine[][] decks, GameOption option)
{
THHGame game = initGameWithoutPlayers(name, option);
if (playersId == null)
{
playersId = new int[] { 1, 2 }
}
;
if (masters == null)
{
masters = Enumerable.Repeat(game.getCardDefine <TestMaster>(), playersId.Length).ToArray();
}
if (decks == null)
{
decks = Enumerable.Repeat(Enumerable.Repeat(game.getCardDefine <TestServant>(), 30).ToArray(), playersId.Length).ToArray();
}
if (option == null)
{
option = GameOption.Default;
}
for (int i = 0; i < playersId.Length; i++)
{
game.createPlayer(playersId[i], "玩家" + playersId[i], masters[i], decks[i]);
}
return(game);
}
public IEnumerator burnTest()
{
THHGame game = TestGameflow.initStandardGame();
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[0].cmdInitReplace(game);
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
for (int i = 0; i < 7; i++)
{
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[1].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
}
THHPlayer.BurnEventArg burn = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHPlayer.BurnEventArg) as THHPlayer.BurnEventArg;
Assert.NotNull(burn);
Assert.AreEqual(game.sortedPlayers[0], burn.player);
Assert.AreEqual(game.sortedPlayers[0].grave[0], burn.card);
game.Dispose();
}
public IEnumerator useTest()
{
THHGame game = TestGameflow.initStandardGame();
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[0].cmdInitReplace(game);
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
yield return(new WaitForSeconds(.1f));
THHPlayer.UseEventArg use = game.triggers.getRecordedEvents().FirstOrDefault(e => e is THHPlayer.UseEventArg) as THHPlayer.UseEventArg;
Assert.NotNull(use);
Assert.AreEqual(game.sortedPlayers[0], use.player);
Assert.AreEqual(game.sortedPlayers[0].field[0], use.card);
Assert.AreEqual(TestServant.ID, use.card.define.id);
Assert.AreEqual(0, use.position);
Assert.AreEqual(0, use.targets.Length);
THHPlayer.SetGemEventArg setGem = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHPlayer.SetGemEventArg) as THHPlayer.SetGemEventArg;
Assert.AreEqual(0, setGem.value);
THHPlayer.MoveEventArg summon = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHPlayer.MoveEventArg) as THHPlayer.MoveEventArg;
Assert.NotNull(summon);
Assert.AreEqual(game.sortedPlayers[0], summon.player);
Assert.AreEqual(TestServant.ID, summon.card.define.id);
Assert.AreEqual(0, summon.position);
game.Dispose();
}
public static void skipTurnUntil(this THHGame game, Func <bool> condition)
{
if (!game.isRunning)
{
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
}
while (!condition())
{
if (game.currentPlayer == game.sortedPlayers[0])
{
game.sortedPlayers[0].cmdTurnEnd(game);
}
if (condition())
{
return;
}
if (game.currentPlayer == game.sortedPlayers[1])
{
game.sortedPlayers[1].cmdTurnEnd(game);
}
}
}
/// <summary>
/// 创建并开始本地游戏
/// </summary>
public void startLocalGame()
{
game = new THHGame(_option, getManager <CardManager>().GetCardDefines())
{
answers = new GameObject(nameof(AnswerManager)).AddComponent <AnswerManager>(),
triggers = new GameObject(nameof(TriggerManager)).AddComponent <TriggerManager>(),
time = new GameObject(nameof(TimeManager)).AddComponent <TimeManager>(),
logger = new UnityLogger()
};
(game.answers as AnswerManager).game = game;
//检查卡组合法性
int[] deck = _deck;
checkDeckValid(deck);
THHPlayer localPlayer = game.createPlayer(1, "本地玩家", game.getCardDefine(deck[0]) as MasterCardDefine,
deck.Skip(1).Select(id => game.getCardDefine(id)));
THHPlayer aiPlayer = game.createPlayer(2, "AI", game.getCardDefine(deck[0]) as MasterCardDefine,
deck.Skip(1).Select(id => game.getCardDefine(id)));
displayGameUI(localPlayer);
//AI玩家用AI
new AI(game, aiPlayer);
game.triggers.onEventAfter += onEventAfter;
gameTask = game.run();
}
public void ElusiveTest()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, new GameOption()
{
shuffle = false
});
THHPlayer defaultPlayer = game.createPlayer(0, "玩家0", game.getCardDefine <TestMaster2>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 28)
.Concat(Enumerable.Repeat(game.getCardDefine <TestSpellCard>(), 2)));
THHPlayer elusivePlayer = game.createPlayer(1, "玩家1", game.getCardDefine <TestMaster2>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 29)
.Concat(Enumerable.Repeat(game.getCardDefine <ElusiveServant>(), 1)));
game.skipTurnUntil(() => defaultPlayer.gem >= game.getCardDefine <DefaultServant>().cost&& game.currentPlayer == defaultPlayer);
defaultPlayer.cmdUse(game, defaultPlayer.hand.First(c => c.define.id == DefaultServant.ID), 0);
game.skipTurnUntil(() => elusivePlayer.gem >= game.getCardDefine <ElusiveServant>().cost&& game.currentPlayer == elusivePlayer);
elusivePlayer.cmdUse(game, elusivePlayer.hand.First(c => c.define.id == ElusiveServant.ID), 0);
game.skipTurnUntil(() => defaultPlayer.gem >= game.getCardDefine <TestSpellCard>().cost&& game.currentPlayer == defaultPlayer);
defaultPlayer.cmdUse(game, defaultPlayer.hand.First(c => c.define.id == TestSpellCard.ID), 0, defaultPlayer.field[0]);
Assert.AreEqual(6, defaultPlayer.field[0].getCurrentLife()); //没有魔免的可以被法术指定
defaultPlayer.cmdUse(game, defaultPlayer.hand.First(c => c.define.id == TestSpellCard.ID), 0, elusivePlayer.field[0]);
Assert.AreEqual(3, elusivePlayer.field[0].getCurrentLife()); //魔免无法被法术指定
game.skipTurnUntil(() => elusivePlayer.gem >= game.getCardDefine <TestDamageSkill>().cost&& game.currentPlayer == elusivePlayer);
elusivePlayer.cmdUse(game, elusivePlayer.skill, 0, defaultPlayer.field[0]);
Assert.AreEqual(5, defaultPlayer.field[0].getCurrentLife());//没有魔免的可以被技能指定
elusivePlayer.cmdTurnEnd(game);
game.skipTurnUntil(() => elusivePlayer.gem >= game.getCardDefine <TestDamageSkill>().cost&& game.currentPlayer == elusivePlayer);
elusivePlayer.cmdUse(game, elusivePlayer.skill, 0, elusivePlayer.field[0]);
Assert.AreEqual(3, elusivePlayer.field[0].getCurrentLife());//魔免无法被技能指定
game.Dispose();
}
public void removeBuffWhenInjureTest()
{
THHGame game = new THHGame()
{
logger = new UnityLogger()
};
Card card = new Card(0);
card.setLife(5);
card.setCurrentLife(5);
TestBuff buff = new TestBuff(new LifeModifier(3, true));
card.addBuff(game, buff);
Assert.AreEqual(3, card.getLife(game));
Assert.AreEqual(3, card.getCurrentLife(game));
card.removeBuff(game, buff);
Assert.AreEqual(5, card.getLife(game));
Assert.AreEqual(5, card.getCurrentLife(game));
card.addBuff(game, buff);
Assert.AreEqual(3, card.getLife(game));
Assert.AreEqual(3, card.getCurrentLife(game));
//不满血
card.setCurrentLife(1);
card.removeBuff(game, buff);
Assert.AreEqual(5, card.getLife(game));
Assert.AreEqual(1, card.getCurrentLife(game));
}
public void PatchouliMegaReaverTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Patchouli(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new MegaReaver(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
int preHand = game.sortedPlayers[1].hand.count;
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
if (preHand <= 3)
{
Assert.AreEqual(0, game.sortedPlayers[1].hand.count);
}
else
{
Assert.AreEqual(3, preHand - game.sortedPlayers[1].hand.count);
}
}
public void PatchouliSylphyHornTest()
{
TouhouCardEngine.CardDefine[][] decks = new TouhouCardEngine.CardDefine[][]
{
Enumerable.Repeat(new RashFairy(), 30).ToArray(),
Enumerable.Repeat(new AgniShine(), 30).ToArray()
};
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Patchouli(), 2).ToArray(),
decks,
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
}
public void PatchouliBestMagicTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Patchouli(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new BestMagic(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
int preGem = game.sortedPlayers[1].gem;
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
Assert.AreEqual(1, preGem - game.sortedPlayers[1].gem);
}
public void PatchouliAgniShineTest()
{
TouhouCardEngine.CardDefine[][] decks = new TouhouCardEngine.CardDefine[][]
{
Enumerable.Repeat(new RashFairy(), 30).ToArray(),
Enumerable.Repeat(new AgniShine(), 30).ToArray()
};
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Patchouli(), 2).ToArray(),
decks,
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
THHCard.DamageEventArg damage = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHCard.DamageEventArg) as THHCard.DamageEventArg;
Assert.AreEqual(0, game.sortedPlayers[0].field.count);
Assert.AreEqual(4, damage.value);
}
public void PatchouliSkillTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Patchouli(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new RashFairy(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
int preHand = game.sortedPlayers[1].hand.count;
int preDeck = game.sortedPlayers[1].deck.count;
int preLife = game.sortedPlayers[1].master.getCurrentLife();
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].skill, 0, game.sortedPlayers[1].master);
Assert.AreEqual(1, game.sortedPlayers[1].hand.count - preHand);
Assert.AreEqual(-1, game.sortedPlayers[1].deck.count - preDeck);
Assert.AreEqual(-2, game.sortedPlayers[1].master.getCurrentLife() - preLife);
}
public void sanaeSkillTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Sanae(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new RashFairy(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdAttack(game, game.sortedPlayers[0].field[0], game.sortedPlayers[1].master);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].skill, 0, game.sortedPlayers[1].master);
THHCard.HealEventArg heal = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHCard.HealEventArg) as THHCard.HealEventArg;
Assert.AreEqual(1, heal.cards.Length);
Assert.AreEqual(2, heal.value);
Assert.AreEqual(1, heal.infoDic[game.sortedPlayers[1].master].healedValue);
}
public void missingSpecterTest()
{
THHGame game = TestGameflow.initStandardGame(null, new int[] { 0, 1 },
Enumerable.Repeat(new Reimu(), 2).ToArray(),
Enumerable.Repeat(Enumerable.Repeat(new MissingSpecter(), 30).ToArray(), 2).ToArray(),
new GameOption()
{
});
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0);
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
game.sortedPlayers[1].cmdTurnEnd(game);
game.sortedPlayers[0].cmdAttack(game, game.sortedPlayers[0].field[0], game.sortedPlayers[1].field[0]);
Assert.AreEqual(1, game.sortedPlayers[0].field.count);
Assert.AreEqual(1, game.sortedPlayers[1].field.count);
}
public void flameFairyTest()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, new GameOption()
{
shuffle = false
}); //首先，上来先新建一个不带玩家的游戏
game.createPlayer(0, "玩家0", game.getCardDefine <Reimu>(), Enumerable.Repeat(game.getCardDefine <FlameFairy>() as CardDefine, 30)); //创建两个玩家，给他们设置初始英雄，套牌
game.createPlayer(1, "玩家1", game.getCardDefine <Reimu>(), Enumerable.Repeat(game.getCardDefine <FlameFairy>() as CardDefine, 30));
game.run(); //运行游戏
//炎之妖精 战吼：对一个随机敌方随从造成1点伤害
//那么我们要测试这个战吼内容
game.skipTurnWhen(() => game.sortedPlayers[0].gem < 1);
game.sortedPlayers[0].cmdUse(game, game.sortedPlayers[0].hand[0], 0); //第一个行动的玩家使用手上的第一张牌，反正满手都是炎之妖精随便用
Assert.IsInstanceOf <FlameFairy>(game.sortedPlayers[0].field[0].define); //预期场上拍了一个炎之妖精
//不过因为对方场上没有随从，所以啥事也没发生。
game.sortedPlayers[0].cmdTurnEnd(game); //第一个行动的玩家回合结束
game.sortedPlayers[1].cmdUse(game, game.sortedPlayers[1].hand[0], 0);
Assert.IsInstanceOf <FlameFairy>(game.sortedPlayers[1].field[0].define); //第二个行动的玩家拍一个炎之妖精，这个时候应该触发战吼的
Assert.AreEqual(0, game.sortedPlayers[0].field.count); //对面的妖精应该被打死了
var damage = game.triggers.getRecordedEvents().LastOrDefault(e => e is THHCard.DamageEventArg) as THHCard.DamageEventArg; //这会产生一个伤害事件
Assert.AreEqual(1, damage.value); //伤害值为1
//大概就是这样了，稍微测试一下保证每一张卡都在正常工作吧，能减少很多bug。
//出了个随从重名的小问题，测试结果看看Log还是挺正常的，那就没有问题了。
//做这个测试是为了防止以后对系统的改动导致已经做好的卡失效，这样能防止很多bug。
}
public static void skipTurnUntil(this THHGame game, Func <bool> condition)
{
if (!game.isRunning)
{
game.run();
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
}
int count = 0;
while (!condition())
{
if (game.currentPlayer == game.sortedPlayers[0])
{
game.sortedPlayers[0].cmdTurnEnd(game);
}
if (condition())
{
return;
}
if (game.currentPlayer == game.sortedPlayers[1])
{
game.sortedPlayers[1].cmdTurnEnd(game);
}
count++;
if (count > 1000)
{
throw new StackOverflowException();
}
}
}
public static void skipTurnWhen(this THHGame game, Func <bool> condition)
{
if (!game.isRunning)
{
game.run();
}
if (!game.triggers.getRecordedEvents().Any(e => e is THHGame.StartEventArg))
{
game.sortedPlayers[0].cmdInitReplace(game);
game.sortedPlayers[1].cmdInitReplace(game);
}
while (condition())
{
if (game.currentPlayer == game.sortedPlayers[0])
{
game.sortedPlayers[0].cmdTurnEnd(game);
}
if (!condition())
{
return;
}
if (game.currentPlayer == game.sortedPlayers[1])
{
game.sortedPlayers[1].cmdTurnEnd(game);
}
}
}
/// <summary>
/// 创建并开始本地游戏
/// </summary>
public void startLocalGame()
{
_ui.Game.GameResultDialog.hide();
if (_useTimeAsRandomSeed)
{
_option.randomSeed = (int)DateTime.Now.ToBinary();
}
game = new THHGame(_option, getManager <CardManager>().GetCardDefines())
{
answers = new GameObject(nameof(AnswerManager)).AddComponent <AnswerManager>(),
triggers = new GameObject(nameof(TriggerManager)).AddComponent <TriggerManager>(),
time = new GameObject(nameof(TimeManager)).AddComponent <TimeManager>(),
logger = new UnityLogger()
};
(game.answers as AnswerManager).game = game;
//检查卡组合法性
int[] deck = _deck;
checkDeckValid(deck);
CardDefine playerMaster = game.getCardDefine(deck[0]);
CardDefine[] playerDeck = deck.Skip(1).Select(id => game.getCardDefine(id)).ToArray();
THHPlayer localPlayer = game.createPlayer(1, "本地玩家", playerMaster as MasterCardDefine,
playerDeck);
THHPlayer aiPlayer = game.createPlayer(2, "AI", playerMaster as MasterCardDefine,
deck.Skip(1).Select(id => game.getCardDefine(id)));
displayGameUI(localPlayer);
//AI玩家用AI
new AI(game, aiPlayer);
gameTask = game.run();
}
/// <summary>
/// 从player[0]开始经过x回合
/// </summary>
/// <param name="game"></param>
/// <param name="x"></param>
public void AfterXRound(THHGame game, int x)
{
for (int i = 0; i < x; i++)
{
game.sortedPlayers[0].cmdTurnEnd(game);
game.sortedPlayers[1].cmdTurnEnd(game);
}
}
static async Task effect(THHGame game, Card card)
{
for (int i = 0; i < 2; i++)
{
await card.getOwner().createToken(game, game.getCardDefine <LavaElement>());
}
await Patchouli.tryMix(game, card);
}
static async Task effect(THHGame game, Card card)
{
await game.getAllServants().silence(game);
await card.getOwner().createToken(game, game.getCardDefine <FloodElement>());
await Patchouli.tryMix(game, card);
}
float calcFreezeValue(THHGame game, THHPlayer player, THHPlayer opponent, Card target)
{
if (target == opponent.master || opponent.field.Contains(target))
{
return(target.getAttack(game));
}
return(0);
}
