public void MinionPlayTest()
{
GameState G = new GameState(DeckChoiceUI.COMBO_DECK, DeckChoiceUI.COMBO_DECK, true, 0);
G.CurrentPower = new PowerCard(G);
// Create two minions, 1/4 and 2/5
// They will end up 1/2 and 2/4 after battle
MinionCard First = new MinionCard(G)
{
OnBoard = true,
CanAttack = true,
Attack = 1,
Health = 4,
Owner = G.PlayerOne,
};
MinionCard Second = new MinionCard(G)
{
OnBoard = true,
CanAttack = true,
Attack = 2,
Health = 5,
Owner = G.PlayerTwo,
};
G.PlayerOne.Board.Add(First);
G.PlayerTwo.Board.Add(Second);
// Tests
Assert.IsTrue(First.IsPlayable(new Move(First.Id, Second.Id)));
G.ProcessMove(new Move(First.Id, Second.Id));
Assert.AreEqual(First.Attack, 1);
Assert.AreEqual(First.Health, 2);
Assert.AreEqual(Second.Attack, 2);
Assert.AreEqual(Second.Health, 4);
}
/// <summary>
/// 去除死去随从
/// </summary>
/// <param name="game"></param>
/// <param name="MeOrYou"></param>
/// <returns></returns>
public List <MinionCard> ClearDead(GameManager game, Boolean MeOrYou)
{
//必须是当前的随从，不能使编号
//如果是沉默状态的随从，无亡语效果！
List <MinionCard> DeadList = new List <MinionCard>();
var CloneMinions = new MinionCard[BattleFieldInfo.MaxMinionCount];
int ALive = 0;
for (int i = 0; i < BattleFieldInfo.MaxMinionCount; i++)
{
if (BattleMinions[i] != null)
{
if (BattleMinions[i].IsLive())
{
CloneMinions[ALive] = BattleMinions[i];
ALive++;
}
else
{
DeadList.Add(BattleMinions[i]);
game.事件池.Add(new Card.CardUtility.全局事件()
{
事件类型 = CardUtility.事件类型列表.死亡,
触发位置 = i + 1,
触发方向 = MeOrYou ? CardUtility.TargetSelectDirectEnum.本方 : CardUtility.TargetSelectDirectEnum.对方,
附加信息 = BattleMinions[i].种族.ToString()
});
}
}
}
BattleMinions = CloneMinions;
return(DeadList);
}
public void CreateMinionCardTest()
{
//Create individual components of a minion card
int id = 1;
string name = "Ghost";
Rarity rarity = Rarity.RARE;
string description = "Is spooky";
int cost = 3;
string imagePath = "ghost";
int health = 3;
int attack = 3;
//Create a minion card
MinionCard testCard = new MinionCard(id, name, rarity, description, cost, imagePath, health, attack);
//Ensure that the spell card was created correctly
Assert.AreEqual(id, testCard.Id);
Assert.AreEqual(name, testCard.Name);
Assert.AreEqual(rarity, testCard.CardRarity);
Assert.AreEqual(description, testCard.Description);
Assert.AreEqual(cost, testCard.Cost);
Assert.AreEqual(imagePath, testCard.ImagePath);
Assert.AreEqual(health, testCard.Health);
Assert.AreEqual(attack, testCard.Attack);
}
public static void RunStatusEffect(MinionCard myMinion, String AddtionInfo)
{
switch (AddtionInfo)
{
case strFreeze:
myMinion.冰冻状态 = CardUtility.EffectTurn.效果命中;
break;
case strSlience:
myMinion.被沉默();
break;
case strAngry:
myMinion.Actual风怒 = true;
break;
case strCharge:
myMinion.Actual冲锋 = true;
if (myMinion.AttactStatus == MinionCard.攻击状态.准备中)
{
myMinion.AttactStatus = MinionCard.攻击状态.可攻击;
}
break;
case strTaunt:
myMinion.Actual嘲讽 = true;
break;
default:
break;
}
}
public void BuildTest()
{
GameState G = new GameState(DeckChoiceUI.COMBO_DECK, DeckChoiceUI.COMBO_DECK, true, 0);
// For a minion
CardBuilder MinionBuilder = new CardBuilder
{
TypeID = CardBuilder.CardType.Minion,
AttackData = 2,
HealthData = 3,
NameData = "MIN1",
DescriptionData = "ABCXYZ",
MinionOnPlayData = (s, m) =>
{
},
MinionEffectData = new EffectData <MinionCard>()
{
{
Effect.CardDrawn, (s, m) =>
{
}
}
},
};
MinionCard Minion = MinionBuilder.Build(G, G.PlayerOne) as MinionCard;
Assert.AreEqual(MinionBuilder.AttackData, Minion.Attack);
Assert.AreEqual(MinionBuilder.HealthData, Minion.Health);
Assert.AreEqual(MinionBuilder.NameData, Minion.Name);
Assert.AreEqual(MinionBuilder.DescriptionData, Minion.Description);
Assert.AreEqual(MinionBuilder.MinionOnPlayData, Minion.OnPlay);
Assert.AreEqual(MinionBuilder.MinionEffectData, Minion.Effects);
}
public string DealMinion(ActionStatus game, MinionCard Minion)
{
var Pos = Minion.战场位置;
if (Pos.本方对方标识)
{
if (game.AllRole.MyPrivateInfo.handCards.Count != SystemManager.MaxHandCardCount)
{
game.AllRole.MyPrivateInfo.handCards.Add(
CardUtility.GetCardInfoBySN(game.AllRole.MyPublicInfo.BattleField.BattleMinions[Pos.位置 - 1].序列号)
);
}
game.AllRole.MyPublicInfo.BattleField.BattleMinions[Pos.位置 - 1] = null;
}
else
{
if (game.AllRole.YourPrivateInfo.handCards.Count != SystemManager.MaxHandCardCount)
{
game.AllRole.YourPrivateInfo.handCards.Add(
CardUtility.GetCardInfoBySN(game.AllRole.YourPublicInfo.BattleField.BattleMinions[Pos.位置 - 1].序列号)
);
}
game.AllRole.YourPublicInfo.BattleField.BattleMinions[Pos.位置 - 1] = null;
}
return(String.Empty);
}
/// <summary>
///
/// </summary>
/// <param name="Minion"></param>
/// <param name="Addition"></param>
public static void RunPointEffect(MinionCard Minion, String Addition)
{
var AttackHealth = Addition.Split("/".ToArray());
if (AttackHealth[0] != strIgnore)
{
if (AttackHealth[0].Length != 1)
{
Minion.实际攻击力 += int.Parse(AttackHealth[0]);
}
else
{
Minion.实际攻击力 = int.Parse(AttackHealth[0]);
}
}
if (AttackHealth[1] != strIgnore)
{
if (AttackHealth[1].Length != 1)
{
Minion.实际生命值 += int.Parse(AttackHealth[1]);
}
else
{
Minion.实际生命值 = int.Parse(AttackHealth[1]);
}
}
}
/// <summary>
/// 去除死去随从
/// </summary>
public List<MinionCard> ClearDead()
{
//必须是当前的随从，不能使编号
//如果是沉默状态的随从，无亡语效果！
List<MinionCard> DeadList = new List<MinionCard>();
var CloneMinions = new MinionCard[BattleFieldInfo.MaxMinionCount];
int ALive = 0;
for (int i = 0; i < BattleFieldInfo.MaxMinionCount; i++)
{
if (BattleMinions[i] != null)
{
if (BattleMinions[i].IsLive())
{
CloneMinions[ALive] = BattleMinions[i];
ALive++;
}
else
{
DeadList.Add(BattleMinions[i]);
}
}
}
BattleMinions = CloneMinions;
return DeadList;
}
private void Card_PointerEntered(object sender, PointerRoutedEventArgs e) //显示卡牌详情
{
if (((sender as Grid).DataContext as Card).CardType == CardTypes.MinionCard)
{
MinionCard card = ((sender as Grid).DataContext as Card).CardData as MinionCard;
DetailImage.Source = new BitmapImage(new Uri(card.ImagePath));
DetailName.Text = card.Name;
DetailCost.Text = card.Cost.ToString();
DetailCategory.Text = card.Category;
DetailDes.Text = card.Description;
DetailAttack.Text = "Attack: " + card.Attack.ToString();
DetailHealth.Text = "Health: " + card.Health.ToString();
}
if (((sender as Grid).DataContext as Card).CardType == CardTypes.SpellCard)
{
SpellCard card = ((sender as Grid).DataContext as Card).CardData as SpellCard;
DetailImage.Source = new BitmapImage(new Uri(card.ImagePath));
DetailName.Text = card.Name;
DetailCost.Text = card.Cost.ToString();
DetailCategory.Text = "";
DetailDes.Text = card.Description;
DetailAttack.Text = "";
DetailHealth.Text = "";
}
DetailRelativePanel.Visibility = Visibility.Visible;
}
/// <summary>
/// 去除死去随从
/// </summary>
public List <MinionCard> ClearDead()
{
//必须是当前的随从，不能使编号
//如果是沉默状态的随从，无亡语效果！
List <MinionCard> DeadList = new List <MinionCard>();
var CloneMinions = new MinionCard[BattleFieldInfo.MaxMinionCount];
int ALive = 0;
for (int i = 0; i < BattleFieldInfo.MaxMinionCount; i++)
{
if (BattleMinions[i] != null)
{
if (BattleMinions[i].IsLive())
{
CloneMinions[ALive] = BattleMinions[i];
ALive++;
}
else
{
DeadList.Add(BattleMinions[i]);
}
}
}
BattleMinions = CloneMinions;
return(DeadList);
}
/// <summary>
/// 卡牌入战场
/// </summary>
/// <param name="Position">从1开始的位置</param>
/// <param name="Minion">随从</param>
/// <remarks>不涉及到战吼等计算</remarks>
public void PutToBattle(int Position, MinionCard Minion)
{
//战场满了
if (MinionCount == MaxMinionCount)
{
return;
}
//无效的位置
if ((Position < 1) || (Position > MinionCount + 1) || Position > MaxMinionCount)
{
return;
}
//插入操作
if (BattleMinions[Position - 1] == null)
{
//添加到最右边
BattleMinions[Position - 1] = Minion;
}
else
{
//Position右边的全体移位，腾出地方
for (int i = MaxMinionCount - 1; i >= Position; i--)
{
BattleMinions[i] = BattleMinions[i - 1];
}
BattleMinions[Position - 1] = Minion;
}
}
// 根据当前卡牌模板复制一张新的卡牌对象
// this 是卡牌模板
// NewMinionCard 是生成的新的卡牌实例
public override Card GetCopy()
{
MinionCard NewMinionCard = new MinionCard();
// 1.将新卡的释放效果链接到模板卡的释放效果
NewMinionCard.SetSpellEffect(SpellEffect);
// 2.创建棋子GameObject并将引用进行设置
NewMinionCard.SetMinionPiece(GetWorldManager().CreatePieceForCard((string)GetParameter("CardID")));
NewMinionCard.GetMinionPiece().GetComponentInChildren <PieceStateController>().SetCard(NewMinionCard);
//NewMinionCard.GetMinionPiece().GetComponentInChildren<PieceStateController>().DisplayPiece();
// 3.创建卡面显示GameObject并设置引用
// ---------------------------------------------
// 获取卡面物体预制体
GameObject MainHandCardBasePrefab = (GameObject)Resources.Load("Prefabs/HandCardBase");
// 实例化卡面物体
NewMinionCard.SetMainHandCardBase(GameObject.Instantiate(MainHandCardBasePrefab));
NewMinionCard.GetMainHandCardBase().GetComponent <HandCardController>().SetCard(NewMinionCard);
// 将卡面物体放置于Canvas下
NewMinionCard.GetMainHandCardBase().transform.SetParent(GameObject.Find("Canvas").gameObject.transform);
// 设置默认位置
NewMinionCard.GetMainHandCardBase().GetComponent <RectTransform>().localPosition = new Vector3(0, 0, 0);
// 将卡面物体的卡牌引用设置为当前卡牌
NewMinionCard.GetMainHandCardBase().GetComponent <HandCardController>().SetCard(NewMinionCard);
// 将卡面物体隐藏
//MainHandCardBase.SetActive(false);
// ---------------------------------------------
return(NewMinionCard);
}
public void IsPlayableTest()
{
GameState G = new GameState(DeckChoiceUI.COMBO_DECK, DeckChoiceUI.COMBO_DECK, true, 0);
// Create a few cards
var First = new SpellCard(G)
{
ManaCost = 0,
IsTargeted = true,
Owner = G.PlayerOne,
};
var Second = new MinionCard(G)
{
Health = 1,
ManaCost = 0,
OnBoard = true,
CanAttack = true,
Owner = G.PlayerOne,
};
G.PlayerOne.Board.Add(Second);
G.PlayerOne.Hand.Add(First);
// This should NOT be playable - invalid target
Assert.IsFalse(First.IsPlayable(new Move(First.Id, 0)));
// This should NOT be playable - invalid target
Assert.IsFalse(Second.IsPlayable(new Move(Second.Id, 0)));
// But this should be
Assert.IsTrue(Second.IsPlayable(new Move(Second.Id, G.PlayerTwo.PlayerCard.Id)));
// Finally, this should be
Assert.IsTrue(First.IsPlayable(new Move(First.Id, Second.Id)));
}
public BattlefieldPage()
{
draggedMinionCard = new MinionCard();
mainBattlefield = new Battlefield();
this.InitializeComponent();
LoadBattlefield();
}
/// <summary>
/// 卡牌入战场
/// </summary>
/// <param name="Position">从1开始的位置</param>
/// <param name="Minion">随从</param>
/// <remarks>不涉及到战吼等计算</remarks>
public void PutToBattle(int Position, MinionCard Minion)
{
//战场满了
if (MinionCount == SystemManager.MaxMinionCount)
{
return;
}
//无效的位置
if ((Position < 1) || (Position > MinionCount + 1) || Position > SystemManager.MaxMinionCount)
{
return;
}
//插入操作
if (BattleMinions[Position - 1] == null)
{
//添加到最右边
BattleMinions[Position - 1] = Minion;
}
else
{
//Position右边的全体移位，腾出地方
for (int i = SystemManager.MaxMinionCount - 1; i >= Position; i--)
{
BattleMinions[i] = BattleMinions[i - 1];
}
BattleMinions[Position - 1] = Minion;
}
for (int i = 0; i < MinionCount; i++)
{
BattleMinions[i].战场位置.位置 = i + 1;
BattleMinions[i].战场位置.本方对方标识 = 本方对方标识;
}
}
// TODO : Board positioning
public void SummonMinion(MinionCard minionCard, int position)
{
Debugger.LogPlayer(this, "summoning " + minionCard.Name + " at position " + position);
if (Minions.Count < 7)
{
// Creating a Minion and its Controller
Minion minion = new Minion(minionCard);
minion.Controller = MinionController.Create(BoardController, minion);
// Adding the Minion to the Player Minion list
Minions.Add(minion);
// Adding the Minion to the BoardController
BoardController.AddMinion(minion, position);
// Firing summoned events
EventManager.Instance.OnMinionSummon(this, minion);
}
else
{
Debugger.LogPlayer(this, "couldn't summon " + minionCard.Name + " because board is full");
}
// Updating the Player glows
UpdateSprites();
}
/// <summary>
/// 符合种族条件
/// </summary>
/// <param name="minion"></param>
/// <param name="SelectOpt"></param>
/// <returns></returns>
public static bool 符合选择条件(MinionCard minion, string strCondition)
{
if (string.IsNullOrEmpty(strCondition) || strCondition == CardUtility.strIgnore)
{
return(true);
}
foreach (var 种族名称 in Enum.GetNames(typeof(CardUtility.种族枚举)))
{
if (种族名称 == strCondition)
{
return(strCondition == minion.种族.ToString());
}
if (("非" + 种族名称) == strCondition)
{
return(strCondition != minion.种族.ToString());
}
}
switch (strCondition.Substring(1, 1))
{
case "+":
return(minion.攻击力 >= int.Parse(strCondition.Substring(0, 1)));
case "-":
return(minion.攻击力 <= int.Parse(strCondition.Substring(0, 1)));
}
return(true);
}
public Minion(MinionCard card)
{
Player = card.Player;
Card = card;
Card.Minion = this;
CurrentAttack = card.CurrentAttack;
BaseAttack = card.BaseAttack;
CurrentHealth = card.CurrentHealth;
MaxHealth = card.CurrentHealth;
BaseHealth = card.BaseHealth;
HasTaunt = card.HasTaunt;
HasCharge = card.HasCharge;
HasPoison = card.HasPoison;
HasWindfury = card.HasWindfury;
HasDivineShield = card.HasDivineShield;
IsElusive = card.IsElusive;
IsForgetful = card.IsForgetful;
IsStealth = card.IsStealth;
SpellPower = card.SpellPower;
CurrentArmor = 0;
Buffs = Card.Buffs;
}
public override void Execute(Action action)
{
Card card;
//THe case of a deal card being send before a creat rune, EX.(A card in the other persons hand)
if (EntityManager.Singelton.GetEntity(cardGuid) != null)
{
CardAvatar ca = (EntityManager.Singelton.GetEntity(cardGuid) as Card).GetCardAvatar();
Debug.Log(ca);
EntityManager.Singelton.RemoveEntity(cardGuid);
if (type == CardType.minion)
{
card = new MinionCard();
MinionCard mc = card as MinionCard;
CardDataLoader.CardData cd = CardDataLoader.Singelton.GetCardData(id);
mc.SetName(cd.cardName);
mc.SetArt(cd.art);
mc.SetBaseAttack(baseAttack);
mc.SetBaseHealth(baseHealth);
mc.SetMana(cost);
mc.SetGuid(cardGuid);
mc.SetDesc(cd.desc);
mc.SetCardAvatar(ca);
EntityManager.Singelton.AddEntity(cardGuid, mc);
ca.Setup(card, cardGuid, controllerGuid);
}
}
else
{
if (type == CardType.minion)
{
MinionCard mc = new MinionCard();
CardDataLoader.CardData cd = CardDataLoader.Singelton.GetCardData(id);
mc.SetCardText(cd.cardText);
mc.SetName(cd.cardName);
mc.SetArt(cd.art);
mc.SetBaseAttack(baseAttack);
mc.SetBaseHealth(baseHealth);
mc.SetMana(cost);
mc.SetGuid(cardGuid);
mc.SetDesc(cd.desc);
EntityManager.Singelton.AddEntity(cardGuid, mc);
}
else if (type == CardType.spell)
{
SpellCard sc = new SpellCard();
CardDataLoader.CardData cd = CardDataLoader.Singelton.GetCardData(id);
sc.SetName(cd.cardName);
sc.SetArt(cd.art);
sc.SetMana(cost);
sc.SetDesc(cd.desc);
sc.SetGuid(cardGuid);
sc.SetCardType((int)type);
EntityManager.Singelton.AddEntity(cardGuid, sc);
}
}
action();
}
/// <summary>
///
/// </summary>
/// <param name="Minion"></param>
/// <param name="Addition"></param>
public static void RunPointEffect(MinionCard Minion, String Addition)
{
var AttackHealth = Addition.Split("/".ToArray());
Minion.实际攻击力 = PointProcess(Minion.实际攻击力, AttackHealth[0]);
Minion.实际生命值 = PointProcess(Minion.实际生命值, AttackHealth[1]);
}
/// <summary>
/// Takes a JSON string as input and uses it to generate a list of cards
/// </summary>
/// <param name="jsonText">The input JSON string</param>
/// <returns>A list of cards generated from the JSON string</returns>
public static List <Card> GenerateCardsFromJSON(string jsonText)
{
//Create an empty list of cards, which will be populated with the generated cards
List <Card> generatedCards = new List <Card>();
//Deserialise the JSON string
Dictionary <string, object> cardData = (Dictionary <string, object>)Json.Deserialize(jsonText);
//Extract spell and minion cards
List <object> spellCards = (List <object>)cardData["spellCards"];
List <object> minionCards = (List <object>)cardData["minionCards"];
//Iterate through every spell card
foreach (object card in spellCards)
{
//Get json data of the card
Dictionary <string, object> currentCardData = (Dictionary <string, object>)card;
//Set individual components of the card
int id = ExtractId(currentCardData);
string name = ExtractName(currentCardData);
Rarity rarity = ExtractRarity(currentCardData);
string description = ExtractDescription(currentCardData);
int cost = ExtractCost(currentCardData);
string imagePath = ExtractImagePath(currentCardData);
List <Effect> effects = ExtractEffects(currentCardData);
//Create a new spellcard from the parsed json data
SpellCard newCard = new SpellCard(id, name, rarity, description, cost, imagePath, effects);
//Add the spell card to the dictionary of all cards
generatedCards.Add(newCard);
}
foreach (object card in minionCards)
{
//Get json data of the card
Dictionary <string, object> currentCardData = (Dictionary <string, object>)card;
//Set individual components of the card
int id = ExtractId(currentCardData);
string name = ExtractName(currentCardData);
Rarity rarity = ExtractRarity(currentCardData);
string description = ExtractDescription(currentCardData);
int cost = ExtractCost(currentCardData);
string imagePath = ExtractImagePath(currentCardData);
int health = ExtractHealth(currentCardData);
int attack = ExtractAttack(currentCardData);
//Create a new spellcard from the parsed json data
MinionCard newCard = new MinionCard(id, name, rarity, description, cost, imagePath, health, attack);
//Add the spell card to the dictionary of all cards
generatedCards.Add(newCard);
}
//Return the list of generated cards
return(generatedCards);
}
public void Clone(MinionCard minion)
{
Name = minion.GetName();
description = minion.GetDescription();
manaCost = minion.GetManaCost();
health = minion.GetHealth();
damage = minion.GetDamage();
armour = minion.GetArmour();
}
/// <summary>
/// InitByMinion
/// </summary>
/// <param name="minion"></param>
public void Init(MinionCard minion)
{
称 = minion.称;
攻击力 = minion.实际攻击值;
生命值 = minion.生命值;
使用成本 = minion.使用成本;
状态列表 = minion.状态;
能否攻击 = minion.能否攻击;
描述 = minion.描述;
}
public void SpawnCard()
{
Player player = heroPanel.GetComponent <Player>();
if (player.CanDrawCard(1) || firstCards)
{
MinionCard minionCard = cardSpawnStrategy.SpawnCard();
InstantiateCard(minionCard);
player.ReduceMana(1f);
}
}
private void SummonMinionFromHandCard(MinionCard summoningMinion) //从手牌中召唤随从
{
mainBattlefield.SummonPlayerMinion(new Minion(summoningMinion));
for (int i = 0; i < summoningMinion.Effects.Count; i++) //战吼效果检查
{
Effect aimEffect = summoningMinion.Effects[i];
if (aimEffect.Category == EffectData.EffectCategory.Battlecry)
{
DealEffect(aimEffect);
}
}
}
private void ShowCardDetail(MinionCard minionCardDetail)
{
if (CardDetailRelativePanel.Visibility == Visibility.Collapsed)
{
ChangeVisibilityByCardDetail();
}
DetailMinionCardAttack.Text = minionCardDetail.Attack.ToString();
DetailMinionCardCost.Text = minionCardDetail.Cost.ToString();
DetailMinionCardHealth.Text = minionCardDetail.Health.ToString();
DetailMinionCardName.Text = minionCardDetail.Name;
DetailMinionCardImage.Source = new BitmapImage(new Uri(minionCardDetail.ImagePath));
}
public MinionCardEditor(string CardSn)
{
InitializeComponent();
if (string.IsNullOrEmpty(CardSn))
{
IsCreateMode = true;
}
else
{
IsCreateMode = false;
minion = (MinionCard)Engine.Utility.CardUtility.GetCardInfoBySN(CardSn);
}
}
private new void Start()
{
base.Start();
currentCard = cardData as MinionCard;
UIGoldCost.text = currentCard.goldCost.ToString();
UIAttackPoints.text = currentCard.attackPoints.ToString();
if (currentCard.Atributtes != 0)
{
UIAttributes.text = currentCard.Atributtes.ToString();
}
}
//右击卡牌事件
private void MinionCardGridViewItem_RightTapped(object sender, RightTappedRoutedEventArgs e)
{
if ((sender as Grid).Name == "")
{
return;
}
NewDeckTip.Visibility = Visibility.Collapsed;
MinionCard addedCard = (sender as Grid).DataContext as MinionCard;
creatingDeck.MinionCard.Add(addedCard);
CardDataManager.AddCardToListView(NewDeckCardListView, addedCard);
return;
}
GivenBoardIsEmpty_WhenSummonMinionActionRequested_ThenCardRemovedFromHandAndManaDecresedAndMinionOboard()
{
var minionCard = new MinionCard(5, 1, 1);
var gameState = GameState.Empty.With(
PlayerGameState.Empty.With(_player, remainingMana: x => 7, hand: x => x.AddCard(minionCard)));
var action = new SummonAction(_player, minionCard);
var newGameState = _testee.ApplyAction(gameState, action);
Assert.IsFalse(newGameState.Of(_player).Hand.Any());
Assert.AreEqual(7 - 5, newGameState.Of(_player).RemainingMana);
Assert.IsTrue(newGameState.Of(_player).Minions.Count() == 1);
}
/// <summary>
/// 去除死去随从
/// </summary>
public void ClearDead()
{
var CloneMinions = new MinionCard[BattleFieldInfo.MaxMinionCount];
int ALive = 0;
for (int i = 0; i < BattleFieldInfo.MaxMinionCount; i++)
{
if (BattleMinions[i] != null && BattleMinions[i].IsLive())
{
CloneMinions[ALive] = BattleMinions[i];
ALive++;
}
}
BattleMinions = CloneMinions;
}
protected override void Context()
{
_card = new MinionCard("M1")
{
PlayerClass = "Warrior",
Name = "Whirlwind",
Faction = FactionTypeOptions.Alliance,
Rarity = RarityTypeOptions.Legendary,
Health = 10,
Attack = 4,
Cost = 9,
Text = "It's just a card"
};
}
public static void RunStatusEffect(MinionCard myMinion, String AddtionInfo)
{
switch (AddtionInfo)
{
case strFreeze:
myMinion.冰冻状态 = CardUtility.EffectTurn.效果命中;
break;
case strSlience:
myMinion.被沉默();
break;
case strAngry:
myMinion.Actual风怒 = true;
break;
case strCharge:
myMinion.Actual冲锋 = true;
if (myMinion.AttactStatus == MinionCard.攻击状态.准备中)
{
myMinion.AttactStatus = MinionCard.攻击状态.可攻击;
}
break;
case strTaunt:
myMinion.Actual嘲讽 = true;
break;
default:
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="Minion"></param>
/// <param name="Addition"></param>
public static void RunPointEffect(MinionCard Minion, String Addition)
{
var AttackHealth = Addition.Split("/".ToArray());
Minion.实际攻击力 = PointProcess(Minion.实际攻击力, AttackHealth[0]);
Minion.实际生命值 = PointProcess(Minion.实际生命值, AttackHealth[1]);
}
/// <summary>
/// 卡牌入战场
/// </summary>
/// <param name="Position">从1开始的位置</param>
/// <param name="Minion">随从</param>
/// <remarks>不涉及到战吼等计算</remarks>
public void PutToBattle(int Position, MinionCard Minion)
{
//战场满了
if (MinionCount == MaxMinionCount) return;
//无效的位置
if ((Position < 1) || (Position > MinionCount + 1) || Position > MaxMinionCount) return;
//插入操作
if (BattleMinions[Position - 1] == null)
{
//添加到最右边
BattleMinions[Position - 1] = Minion;
}
else
{
//Position右边的全体移位，腾出地方
for (int i = MaxMinionCount - 1; i >= Position; i--)
{
BattleMinions[i] = BattleMinions[i - 1];
}
BattleMinions[Position - 1] = Minion;
}
}
//public MinionSlotInputObject MinionSlot { get { return minionSlot; } set { minionSlot = value; } }
public void SummonByMinionCard(MinionCard _minionCard)
{
data.name = _minionCard.Name;
data.maxHealth = _minionCard.Health;
data.health = _minionCard.Health;
data.playerType = _minionCard.PlayerType;
data.damage = _minionCard.PhysicalDamage;
data.armor = _minionCard.PhysicalArmor;
data.resistance = _minionCard.PhysicalResistance;
data.actionPoint = 1;
isDead = false;
data.tags = _minionCard.Tags.ToArray();
data.description = _minionCard.Description;
targetStrategies = new List<TargetStrategy>(_minionCard.TargetStrategies);
if(targetStrategies.Count == 0)
{
targetStrategies.Add(new CloseRangeTargetStrategy());
}
fightBackStrategies = new List<FightBackStrategy>(_minionCard.FightBackStrategy);
if (fightBackStrategies.Count == 0)
{
fightBackStrategies.Add(new NormalFightBackStrategy());
}
foreach (BuffVO tBuffVO in _minionCard.Buffs)
{
Type t = Type.GetType(tBuffVO.BuffName);
if (t == null)
continue;
Buff tBuff = (Buff)Activator.CreateInstance(t);
tBuff.Init(tBuffVO);
AddBuff(tBuff);
}
}
public void SummonMinionUsingMinionCard(MinionCard _minionCard, PositionVO _position)
{
Minion minion = new Minion();
minion.SummonByMinionCard(_minionCard);
AddMinion(minion, _position);
}
/// <summary>
/// 卡牌入战场
/// </summary>
/// <param name="CardSn"></param>
public void AppendToBattle(MinionCard Minion)
{
int Position = MinionCount + 1;
PutToBattle(Position, Minion);
}
