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();
}
protected void Update()
{
if (player == null)
{
return;
}
if (canControl)
{
TurnEndButton.interactable = true;
TurnEndButton.GetComponent <Image>().color = Color.white;
}
else
{
TurnEndButton.interactable = false;
TurnEndButton.GetComponent <Image>().color = Color.gray;
}
THHPlayer opponent = game.getOpponent(player);
if (opponent == null)
{
return;
}
}
public void update(THHPlayer player, TouhouCardEngine.Card card, CardSkinData skin)
{
this.card = card;
Table table = GetComponentInParent <Table>();
if (skin != null)
{
Image.sprite = skin.image;
}
AttackText.text = card.getAttack().ToString();
HpText.text = card.getCurrentLife().ToString();
if (table.selectableTargets != null && table.selectableTargets.Contains(this))
{
HighlightController = Highlight.Yellow;
}
else if (table.player == player && table.game.currentPlayer == player && card.canAttack(table.game))
{
HighlightController = Highlight.Green;
}
else
{
HighlightController = Highlight.None;
}
getChild("Root").getChild("Taunt").gameObject.SetActive(card.isTaunt());
getChild("Root").getChild("Shield").gameObject.SetActive(card.isShield());
}
/// <summary>
/// 显示游戏UI，并指定本地玩家
/// </summary>
/// <param name="localPlayer"></param>
private void displayGameUI(THHPlayer localPlayer)
{
//本地玩家用UI
_ui.display(_ui.Game);
getManager <TableManager>().setGame(game, localPlayer);
_ui.Game.Table.setGame(game, localPlayer);
}
public void update(THHPlayer player)
{
if (player.deck.count == 0)
{
//我没有卡牌了！
}
}
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(game)); //没有魔免的可以被法术指定
defaultPlayer.cmdUse(game, defaultPlayer.hand.First(c => c.define.id == TestSpellCard.ID), 0, elusivePlayer.field[0]);
Assert.AreEqual(3, elusivePlayer.field[0].getCurrentLife(game)); //魔免无法被法术指定
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(game));//没有魔免的可以被技能指定
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));//魔免无法被技能指定
game.Dispose();
}
public static void createGame(out THHGame game, out THHPlayer you, out THHPlayer oppo, params KeyValuePair <int, int>[] yourDeck)
{
createGame(out game, out you, out oppo, new GameOption()
{
shuffle = false
}, yourDeck);
}
/// <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();
}
public void freezeTest()
{
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, 30));
THHPlayer elusivePlayer = game.createPlayer(1, "玩家1", game.getCardDefine <TestMaster2>(), Enumerable.Repeat(game.getCardDefine <DefaultServant>() as CardDefine, 28)
.Concat(Enumerable.Repeat(game.getCardDefine <TestFreeze>(), 2)));
game.skipTurnUntil(() => defaultPlayer.gem >= game.getCardDefine <DefaultServant>().cost&& game.currentPlayer == defaultPlayer);
defaultPlayer.cmdUse(game, defaultPlayer.hand.First(c => c.define.id == DefaultServant.ID), 0);
//玩家0拍白板一张
game.skipTurnUntil(() => elusivePlayer.gem >= game.getCardDefine <TestFreeze>().cost&& game.currentPlayer == elusivePlayer);
elusivePlayer.cmdUse(game, elusivePlayer.hand.First(c => c.define.id == TestFreeze.ID), 0, defaultPlayer.field);
//玩家1释放冰环
game.skipTurnUntil(() => defaultPlayer.gem >= game.getCardDefine <DefaultServant>().cost&& game.currentPlayer == defaultPlayer);
defaultPlayer.cmdAttack(game, defaultPlayer.field[0], elusivePlayer.master); //被冻结的随从无法攻击
defaultPlayer.cmdTurnEnd(game); //回合结束，随从解冻
elusivePlayer.cmdTurnEnd(game);
game.skipTurnUntil(() => defaultPlayer.gem >= game.getCardDefine <DefaultServant>().cost&& game.currentPlayer == defaultPlayer);
defaultPlayer.cmdAttack(game, defaultPlayer.field[0], elusivePlayer.master);//已解除冰冻的随从可以攻击
Assert.AreEqual(29, elusivePlayer.master.getCurrentLife(game));
game.Dispose();
}
public IEnumerator calcActionsTest_Turn1()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, GameOption.Default);
THHPlayer player = game.createPlayer(1, "玩家1", game.getCardDefine <TestMaster>(), Enumerable.Repeat(game.getCardDefine <TestServant>(), 30));
game.createPlayer(2, "玩家2", game.getCardDefine <TestMaster>(), Enumerable.Repeat(game.getCardDefine <TestServant>(), 30));
game.logger.log("Force Init");
AI ai = new AI(game, player, false);
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[0].cmdInitReplace(game);
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(.1f));
if (game.sortedPlayers[0] != player)
{
game.sortedPlayers[0].cmdTurnEnd(game);
yield return(new WaitForSeconds(.1f));
}
var actions = ai.calcActions(game, player);
Assert.AreEqual(player.hand.count, actions.Count);
UseResponse use = actions.Keys.First() as UseResponse;
Assert.NotNull(use);
}
public void update(Table table, THHPlayer self, THHPlayer player, TouhouCardEngine.Card card, CardSkinData skin)
{
this.card = card;
Image.sprite = skin.image;
CostText.text = card.getCost().ToString();
if (card.isUsed())
{
IsUsedController = IsUsed.True;
}
else
{
IsUsedController = IsUsed.False;
}
if (player == self &&
card.isUsable(table.game, player, out _) &&//技能是可用的
table.selectableTargets == null //没有在选择目标
)
{
IsUsableController = IsUsable.True;
asButton.interactable = true;
}
else
{
IsUsableController = IsUsable.False;
asButton.interactable = false;
}
}
/// <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 override bool update(Table table)
{
table.SelfMaster.update(table, table.player, table.player.master, table.getSkin(table.player.master));
THHPlayer opponent = table.game.getOpponent(table.player);
table.EnemyMaster.update(table, opponent, opponent.master, table.getSkin(opponent.master));
return(true);
}
float calcFreezeValue(THHGame game, THHPlayer player, THHPlayer opponent, Card target)
{
if (target == opponent.master || opponent.field.Contains(target))
{
return(target.getAttack(game));
}
return(0);
}
public AI(THHGame game, THHPlayer player, bool autoRun = true)
{
this.game = game;
this.player = player;
if (autoRun)
{
run(game);
}
}
static async Task effect(THHGame game, Card card)
{
THHPlayer opponent = game.getOpponent(card.getOwner());
for (int i = 0; i < opponent.field.count; i++)
{
await card.getOwner().createToken(game, game.getCardDefine <DustElement>());
}
await Patchouli.tryMix(game, card);
}
public override bool update(TableManager table, THHGame.InitEventArg eventArg)
{
table.setMaster(table.ui.SelfMaster, table.player.master);
table.setSkill(table.ui.SelfSkill, table.player.skill);
THHPlayer opponent = table.game.getOpponent(table.player);
table.setMaster(table.ui.EnemyMaster, opponent.master);
table.setSkill(table.ui.EnemySkill, opponent.skill);
return(true);
}
public void setGame(THHGame game, THHPlayer player)
{
InitReplaceDialog.hide();
TurnTipImage.hide();
SelfHandList.clearItems();
SelfFieldList.clearItems();
EnemyFieldList.clearItems();
EnemyHandList.clearItems();
AttackArrowImage.hide();
Fatigue.hide();
}
/// <summary>
/// 设置游戏对象和玩家并初始化UI
/// </summary>
/// <param name="game"></param>
/// <param name="player"></param>
public void setGame(THHGame game, THHPlayer player)
{
ui.onClickNoWhere.set(onClickNoWhere);
ui.InitReplaceDialog.hide();
ui.TurnTipImage.hide();
initMaster(ui.SelfMaster);
ui.SelfGem.Text.text = "0";
ui.SelfSkill.asButton.onClick.set(onClickSkill);
ui.SelfSkill.onDrag.set(onDragSkill);
ui.SelfSkill.onDragEnd.set(onDragSkillEnd);
ui.SelfItem.hide();
ui.SelfHandList.clearItems();
ui.SelfHandList.asButton.onClick.set(() =>
{
if (ui.SelfHandList.isExpanded)
{
ui.SelfHandList.shrink();
}
else
{
ui.SelfHandList.expand();
}
});
ui.SelfFieldList.clearItems();
ui.TurnEndButton.onClick.set(onTurnEndButtonClick);
ui.TipText.hide();
initMaster(ui.EnemyMaster);
ui.EnemyGem.Text.text = "0";
ui.EnemyItem.hide();
ui.EnemyFieldList.clearItems();
ui.EnemyHandList.clearItems();
ui.AttackArrowImage.hide();
ui.Fatigue.hide();
ui.Discover.ButtonButtonBlack.asButton.onClick.set(onDiscoverHideButtonClick);
ui.Discover.hide();
_animationQueue.Clear();
if (game != null)
{
game.triggers.onEventBefore -= onEventBefore;
game.triggers.onEventAfter -= onEventAfter;
game.answers.onRequest -= onRequest;
game.answers.onResponse -= onResponse;
}
this.game = game;
if (game != null)
{
game.triggers.onEventBefore += onEventBefore;
game.triggers.onEventAfter += onEventAfter;
game.answers.onRequest += onRequest;
game.answers.onResponse += onResponse;
}
this.player = player;
}
float calcRandomDamageValue(THHGame game, THHPlayer player, THHPlayer opponent, IEnumerable <Card> targets, int damage)
{
float value = 0;
foreach (var target in targets)
{
value += calcDamageValue(game, player, opponent, target, damage);
}
value /= targets.Count();
return(value);
}
static async Task effect(THHGame game, Card card)
{
THHPlayer opponent = game.getOpponent(card.getOwner());
if (opponent.field.count > 0)
{
return;
}
await opponent.field.randomTake(game, 1).damage(game, card, 2);
await Patchouli.tryMix(game, card);
}
public Response calcNextAction(THHGame game, THHPlayer player)
{
var actions = calcActions(game, player);
if (actions.Count > 0)
{
return(actions.OrderByDescending(p => p.Value).First().Key);
}
else
{
return(new TurnEndResponse());
}
}
float calcDamageValue(THHGame game, THHPlayer player, THHPlayer opponent, Card target, int damage)
{
float value = 0;
if (target == opponent.master)
{
value = target.getCurrentLife(game) > damage ? damage : float.MaxValue;
}
else if (opponent.field.Contains(target))
{
value = target.getCurrentLife(game) > damage?target.getAttack(game) * damage : target.getAttack(game) * target.getCurrentLife(game) + 1;
}
return(value);
}
public void setGame(THHGame game, THHPlayer player)
{
InitReplaceDialog.hide();
TurnTipImage.hide();
SelfHandList.clearItems();
SelfFieldList.clearItems();
EnemyFieldList.clearItems();
EnemyHandList.clearItems();
AttackArrowImage.hide();
Fatigue.hide();
_animationQueue.Clear();
if (game != null)
{
game.triggers.onEventBefore -= onEventBefore;
game.triggers.onEventAfter -= onEventAfter;
}
this.game = game;
if (game != null)
{
game.triggers.onEventBefore += onEventBefore;
game.triggers.onEventAfter += onEventAfter;
}
if (player != null)
{
SelfSkill.asButton.onClick.RemoveAllListeners();
TurnEndButton.onClick.RemoveAllListeners();
}
this.player = player;
if (player != null)
{
SelfSkill.asButton.onClick.AddListener(() =>
{
if (selectableTargets != null)
{
return;
}
player.cmdUse(game, SelfSkill.card, 0);
});
TurnEndButton.onClick.AddListener(() =>
{
player.cmdTurnEnd(game);
//SelfHandList.stopPlacing(true);
resetUse(true, true);
selectableTargets = null;
});
}
}
float calcBuffValue(THHGame game, THHPlayer player, THHPlayer opponent, Card target, int attack, int life)
{
float value = 0;
if (target == player.master)
{
value = attack * target.getCurrentLife(game) + life;
}
else if (player.field.Contains(target))
{
value = calcServantValue(game, player, opponent, target.getAttack(game) + attack, target.getCurrentLife(game) + life)
- calcServantValue(game, player, opponent, target.getAttack(game), target.getLife(game));
}
return(value);
}
public IEnumerator run_InitReplaceTest()
{
THHGame game = TestGameflow.initGameWithoutPlayers(null, GameOption.Default);
THHPlayer player = game.createPlayer(1, "玩家1", game.getCardDefine <TestMaster>(), Enumerable.Repeat(game.getCardDefine <TestServant>(), 30));
game.createPlayer(2, "玩家2", game.getCardDefine <TestMaster>(), Enumerable.Repeat(game.getCardDefine <TestServant>(), 30));
AI ai = new AI(game, player);
_ = game.run();
yield return(new WaitForSeconds(.1f));
game.players[1].cmdInitReplace(game);
yield return(new WaitForSeconds(1f));
Assert.True(game.triggers.getRecordedEvents().Any(e => e is THHGame.StartEventArg));
}
public static async Task tryMix(THHGame game, Card card)
{
THHPlayer player = card.getOwner();
var mixableCards = player.hand.Where(c => getMixCards(game, card.define, c.define).Length > 0).ToArray();//检查手牌中有没有可以融合的牌
if (mixableCards.Length > 0)
{
var mixCard = await player.discover(game, mixableCards, -1, "选择一张卡片进行元素融合");
var mixedResults = getMixCards(game, card.define, mixCard.define).Select(define => game.createCard(define)).ToArray();
var mixedResult = await player.discover(game, mixedResults, -1, "选择一张融合元素法术加入你的手牌");
await player.discard(game, mixCard);
await player.tryAddCardToHand(game, mixedResult);
}
}
public static string replace(string desc, THHGame game, THHPlayer player, TouhouCardEngine.Card card)
{
string result = Regex.Replace(desc, @"{(?<obj>\w+):(?<name>.+)}", m =>
{
string obj = m.Groups["obj"].Value;
string name = m.Groups["name"].Value;
if (obj == "card")
{
return(card.getProp(game, name).ToString());
}
else
{
return("???");
}
});
return(result);
}
static async Task effect(THHGame game, Card card)
{
THHPlayer player = card.getOwner();
THHPlayer opponent = game.getOpponent(player);
await opponent.field.damage(game, card, player.getSpellDamage(game, 2));
foreach (Card target in opponent.field)
{
if (target.isDead(game))
{
if (player.field.count > 0)
{
await player.field.random(game).addBuff(game, new GeneratedBuff(ID, new AttackModifier(1), new LifeModifier(1)));
}
}
}
await Patchouli.tryMix(game, card);
}
public void update(Table table, THHPlayer player, TouhouCardEngine.Card card, CardSkinData skin)
{
this.card = card;
Image.sprite = skin.image;
HpText.text = card.getCurrentLife().ToString();
//if (card.getCurrentLife() == card.getLife())
// HpText.color = Color.white;
//else
// HpText.color = Color.red;
if (card.getAttack() > 0)
{
AttackText.text = card.getAttack().ToString();
AttackText.enabled = true;
}
else
{
AttackText.enabled = false;
}
if (card.getArmor() > 0)
{
ArmorText.text = card.getArmor().ToString();
ArmorText.enabled = true;
}
else
{
ArmorText.enabled = false;
}
if (table.selectableTargets != null && table.selectableTargets.Contains(this))
{
HighlightController = Highlight.Yellow;
}
else if (table.player == player && table.game.currentPlayer == player && card.canAttack(table.game, player))
{
HighlightController = Highlight.Green;
}
else
{
HighlightController = Highlight.None;
}
}
