public static bool SummonFirst2DeathMech(GameEvent gameEvent)
{
List <Card> summons = new List <Card>();
foreach (var id in gameEvent.player.deathMinionCollection)
{
if (summons.Count >= (gameEvent.hostCard.isGold ? 4 : 2))
{
break;
}
Card card = CardBuilder.GetCard(id);
if (card.IsMinionType(MinionType.Mechs))
{
summons.Add(card.NewCard());
}
}
var byCard = gameEvent.hostCard;
foreach (var card in summons)
{
gameEvent.player.board.SummonMinionByMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = card,
player = gameEvent.player
}, byCard);
byCard = card;
}
return(true);
}
public void TransformMinionsToBetter()
{
if (player.leftCoins >= Const.coinCostToBuyMinion)
{
List <KeyValuePair <Card, Card> > cards = new List <KeyValuePair <Card, Card> >();
foreach (Card item in player.battlePile)
{
Card targetCard = cardPile.RandomlyGetBestCard(card => (
card.star <= player.star &&
CheckDuplicate(card) &&
CheckTransform(item.GetPositionTag(), card.GetPositionTag())) ? GetFit(card): -1);
if (targetCard != null && GetFit(targetCard) > GetFit(item))
{
cards.Add(new KeyValuePair <Card, Card>(item, targetCard));
}
}
if (cards.Count != 0)
{
KeyValuePair <Card, Card> cardPair = cards.GetOneRandomly();
int tmpID = cardPair.Key.id;
cardPair.Key.TransformToNewCardWithEffectsForBoss(cardPair.Value.NewCard());
cardPile.ReduceCard(CardBuilder.GetCard(cardPair.Value.id), 1);
player.leftCoins -= Const.coinCostToBuyMinion;
if (cardPair.Key.GetPositionTag() >= 3)
{
cardPair.Key.RemoveKeyWord(Keyword.Taunt);
}
Debug.Log(player.hero.name + "购买了权值为" + GetFit(cardPair.Key) + "的" + cardPair.Key.name + "替换了权值为" + GetFit(CardBuilder.GetCard(tmpID)) + "的" + CardBuilder.GetCard(tmpID).name);
}
}
}
public static bool SummonAllDeadTauntMinion(GameEvent gameEvent)
{
List<Card> summons = new List<Card>();
foreach (var id in gameEvent.player.deathMinionCollection)
{
if (summons.Count >= 7) break;
Card card = CardBuilder.GetCard(id);
if (card.HasKeyword(Keyword.Taunt))
{
summons.Add(card.NewCard());
}
}
var byCard = gameEvent.hostCard;
foreach (var card in summons)
{
gameEvent.player.board.SummonMinionByMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = card,
player = gameEvent.player
}, byCard);
byCard = card;
}
return true;
}
public static bool Gain1Or2HealthForEachHealthYourHEroLost(GameEvent gameEvent)
{
int maxHealth = CardBuilder.GetCard(gameEvent.player.hero.id).health + gameEvent.player.hero.GetExtraBody().y;
gameEvent.hostCard.effectsStay.Add(new BodyPlusEffect(0,
(gameEvent.hostCard.isGold ? 2 : 1) * (maxHealth - gameEvent.player.hero.GetMinionBody().y)));
return(true);
}
public static void UnlockCard(int card)
{
if (CardBuilder.GetCard(card).Lock)
{
CardBuilder.GetCard(card).Lock = false;
SaveLockCard();
}
}
public void InitCardPile(CardPile cardPile)
{
RemoveAll();
CardBuilder.GetCard(0);
foreach (var item in cardPile.cardPile)
{
this.cardPile.Add(item.Key, item.Value);
}
InitSpecialCards();
}
public void ReduceCard(Card card, int num)
{
if (cardPile.ContainsKey(CardBuilder.GetCard(card.id)))
{
cardPile[CardBuilder.GetCard(card.id)] -= num;
if (cardPile[CardBuilder.GetCard(card.id)] <= 0)
{
cardPile.Remove(CardBuilder.GetCard(card.id));
}
}
}
public int GetFit(Card card)
{
Card tmpCard = CardBuilder.GetCard(card.id);
if (fitMap.ContainsKey(tmpCard))
{
return(fitMap[tmpCard]);
}
else
{
return(-10);
}
}
//工具方法
public void AddCard(Card card, int num = 1)
{
if (cardPile.ContainsKey(CardBuilder.GetCard(card.id)))
{
cardPile[CardBuilder.GetCard(card.id)] += num;
}
else
{
cardPile.Add(CardBuilder.GetCard(card.id), num);
}
//foreach (var item in cardPile)
//{
// Debug.Log(item.Key.name + " " + item.Value);
//}
}
/// <summary>
/// 初始化一个包含所有牌的牌池
/// </summary>
public void InitCardPileFully()
{
RemoveAll();
CardBuilder.GetCard(0);
for (int i = 0; i <= 5; i++)
{
baseCardPileOfDifferentLevel[i] = new Map <Card, int>();
foreach (var item in CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.star == i + 1))
{
baseCardPileOfDifferentLevel[i].Add(item, Const.numOfMinionsInCardPile[i]);
}
AddMap(baseCardPileOfDifferentLevel[i]);
}
InitSpecialCards();
}
private void CalculateTags(List <Card> cardList)
{
tags = new Map <string, int>();
keywords = new Map <Keyword, int>();
minionTypes = new Map <MinionType, int>();
proxys = new Map <ProxyEnum, int>();
foreach (Card card in cardList)
{
if (card.IsMinionType(MinionType.Mechs) || card.tag.Contains("机械流"))
{
AddToMap(tags, "机械流", 1);
AddToMap(minionTypes, MinionType.Mechs, 1);
}
if (card.IsMinionType(MinionType.Murlocs) || card.tag.Contains("鱼人流"))
{
AddToMap(tags, "鱼人流", 1);
AddToMap(minionTypes, MinionType.Murlocs, 1);
}
if (card.IsMinionType(MinionType.Demons) || card.tag.Contains("恶魔流"))
{
AddToMap(tags, "恶魔流", 1);
AddToMap(minionTypes, MinionType.Demons, 1);
}
if (card.IsMinionType(MinionType.Beasts) || card.tag.Contains("野兽流"))
{
AddToMap(tags, "野兽流", 1);
AddToMap(minionTypes, MinionType.Beasts, 1);
}
if (card.HasKeyword(Keyword.DivineShield) || card.tag.Contains("圣盾流"))
{
AddToMap(tags, "圣盾流", 1);
AddToMap(keywords, Keyword.DivineShield, 1);
}
if (CardBuilder.GetCard(card.id).GetProxys(ProxyEnum.Deathrattle) != null || card.tag.Contains("亡语流"))
{
AddToMap(tags, "亡语流", 1);
AddToMap(proxys, ProxyEnum.Deathrattle, 1);
}
if (card.IsMinionType(MinionType.Dragons))
{
AddToMap(minionTypes, MinionType.Dragons, 1);
}
if (card.tag.Contains("手牌"))
{
AddToMap(tags, "手牌", 1);
}
}
}
public static bool RandomlyAddMinionOnSaleToYouHand(GameEvent gameEvent)
{
BattlePile <Card> cards = gameEvent.player.board.players[1].battlePile;
if (cards.Count != 0)
{
Card card = cards.GetOneRandomly();
if (card != null && gameEvent.player.handPile.Count < Const.numOfHandPile)
{
gameEvent.player.board.AddToHandPile(card);
gameEvent.player.board.players[1].RemoveMinionFromBattlePile(card);
}
}
gameEvent.player.hero.cost = CardBuilder.GetCard(gameEvent.player.hero.id).cost;
return(true);
}
public void CalculateFitMap()
{
fitMap = new Map <Card, int>();
foreach (var item in cardPile.cardPile)
{
if (!IsRecruitFieldEffect(item.Key))
{
fitMap.Add(item.Key, CalculateFit(item.Key));
}
}
foreach (var item in player.battlePile)
{
if (!fitMap.ContainsKey(CardBuilder.GetCard(item.id)))
{
fitMap.Add(CardBuilder.GetCard(item.id), CalculateFit(CardBuilder.GetCard(item.id)));
}
}
}
public static bool FillHealthWhenReborn(GameEvent gameEvent)
{
if (gameEvent.targetCard == gameEvent.hostCard)
{
return(false);
}
if (gameEvent.player != gameEvent.player.board.GetPlayer(gameEvent.targetCard))
{
return(false);
}
int healthMax = CardBuilder.GetCard(gameEvent.targetCard.id).health;
int healthToRestore = healthMax - gameEvent.targetCard.health;
if (healthToRestore > 0)
{
gameEvent.targetCard.health += healthToRestore;
return(true);
}
return(false);
}
public void CalculateTags() //当前思路识别,导向对应抓牌思路
{
tags = new Map <string, int>();
keywords = new Map <Keyword, int>();
minionTypes = new Map <MinionType, int>();
proxys = new Map <ProxyEnum, int>();
foreach (Card card in player.battlePile)
{
if (card.IsMinionType(MinionType.Mechs) || card.tag.Contains("机械流"))
{
AddToMap(tags, "机械流", 2);
AddToMap(minionTypes, MinionType.Mechs, 1);
}
if (card.IsMinionType(MinionType.Murlocs) || card.tag.Contains("鱼人流"))
{
AddToMap(tags, "鱼人流", 2);
AddToMap(minionTypes, MinionType.Murlocs, 1);
}
if (card.IsMinionType(MinionType.Demons) || card.tag.Contains("恶魔流"))
{
AddToMap(tags, "恶魔流", 2);
AddToMap(minionTypes, MinionType.Demons, 1);
}
if (card.IsMinionType(MinionType.Beasts) || card.tag.Contains("野兽流"))
{
AddToMap(tags, "野兽流", 2);
AddToMap(minionTypes, MinionType.Beasts, 1);
}
if (card.HasKeyword(Keyword.DivineShield) || card.tag.Contains("圣盾流"))
{
AddToMap(tags, "圣盾流", 3);
AddToMap(keywords, Keyword.DivineShield, 1);
}
if (CardBuilder.GetCard(card.id).GetProxys(ProxyEnum.Deathrattle) != null || card.tag.Contains("亡语流"))
{
AddToMap(tags, "亡语流", 3);
AddToMap(proxys, ProxyEnum.Deathrattle, 1);
}
}
InitTag();
}
public void RandomlyTransformMinionsToGold()
{
if (player.leftCoins >= Const.coinCostToBuyMinion * 2 - 1 && random.Next(10) > 5)
{
List <Card> cards = new List <Card>();
foreach (Card item in player.battlePile)
{
if (!item.isGold)
{
cards.Add(item);
}
}
if (cards.Count != 0)
{
Card cardToTransform = cards.GetOneRandomly();
Debug.Log(player.hero.name + "将" + cardToTransform.name + "三连升级了!");
cardToTransform.TransformToNewCardWithEffectsForBoss(CardBuilder.GetCard(cardToTransform.goldVersion).NewCard());
player.leftCoins -= Const.coinCostToBuyMinion * 2 - 1;
}
}
}
public void SetByCard(Card card)
{
if (card.cardType != CardType.Hero)
{
return;
}
setedCard = card;
Vector2Int body = card.GetMinionBody();
SetHeroBody(body.x, body.y);
SetHeroFace(GameAnimationSetting.instance.Images.GetSpriteByString(card.image));
Vector2Int extraBody = card.GetExtraBody();
if (card.health < CardBuilder.GetCard(card.id).health)
{
SetHealthColor(Color.red);
}
else if (extraBody.y > 0)
{
SetHealthColor(Color.green);
}
else
{
SetHealthColor(Color.white);
}
if (card.HasKeyword(Keyword.Immune))
{
免疫.gameObject.SetActive(true);
}
else
{
免疫.gameObject.SetActive(false);
}
}
public static bool SummonDeadBeast(GameEvent gameEvent)
{
List <Card> summons = new List <Card>();
List <Card> tmp = new List <Card>();
foreach (var id in gameEvent.player.deathMinionCollection)
{
Card card = CardBuilder.GetCard(id);
if (card.IsMinionType(MinionType.Beasts))
{
tmp.Add(card);
}
}
tmp.Shuffle();
if (tmp.Count > 0)
{
summons.Add(tmp.GetOneRandomly());
if (gameEvent.hostCard.isGold)
{
summons.Add(tmp.GetOneRandomly());
}
}
var byCard = gameEvent.hostCard;
foreach (var card in summons)
{
gameEvent.player.board.SummonMinionByMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = card.NewCard(),
player = gameEvent.player
}, byCard);
byCard = card;
}
return(true);
}
public void SetByCard(Card card)
{
Init();
LockThis(false);
setedCard = card;
foreach (var trans in keywords)
{
trans.gameObject.SetActive(false);
}
foreach (var keyword in card.GetAllKeywords())
{
string keywordName = BIFStaticTool.GetEnumDescriptionSaved(keyword);
foreach (var trans in keywords)
{
if (keywordName == trans.name)
{
trans.gameObject.SetActive(true);
}
}
}
var map = BIFStaticTool.GetEnumNameAndDescriptionSaved <ProxyEnum>();
List <string> effects = new List <string>()
{
"闪电", "亡语", "光环"
};
foreach (var pair in map)
{
if (effects.Count == 0)
{
break;
}
string description = pair.Value.Value;
if (effects.Contains(description) && card.GetProxys(pair.Key) != null)
{
effects.Remove(description);
if (description == "闪电")
{
闪电.gameObject.SetActive(true);
}
else if (description == "亡语")
{
亡语.gameObject.SetActive(true);
}
else if (description == "光环")
{
光环.gameObject.SetActive(true);
}
}
}
if (card.isGold)
{
嘲讽.sprite = 金色嘲讽;
}
else
{
嘲讽.sprite = 普通嘲讽;
}
金色边框.gameObject.SetActive(card.isGold);
string name = BIFStaticTool.GetEnumDescriptionSaved(card.type);
foreach (var spec in family)
{
if (name == spec.name)
{
spec.gameObject.SetActive(true);
}
else
{
spec.gameObject.SetActive(false);
}
}
main.sprite = GameAnimationSetting.instance.Images.GetSpriteByString(card.image);
#region set text and its color
if (card.cardType != CardType.Spell)
{
Vector2Int body = card.GetMinionBody();
body.x = Math.Max(0, body.x);
attackText.text = body.x.ToString();
healthText.text = body.y.ToString();
Vector2Int extraBody = card.GetExtraBody();
if (card.health < CardBuilder.GetCard(card.id).health)
{
SetHealthColor(Color.red);
}
else if (extraBody.y > 0)
{
SetHealthColor(Color.green);
}
else
{
SetHealthColor(Color.white);
}
if (extraBody.x > 0)
{
SetAttackColor(Color.green);
}
else
{
SetAttackColor(Color.white);
}
}
if (card.cardType == CardType.Spell || card.cost > 0)
{
CostText.text = card.cost.ToString();
Cost.gameObject.SetActive(true);
}
else
{
Cost.gameObject.SetActive(false);
}
if (card.cardType == CardType.Spell)
{
attack.gameObject.SetActive(false);
health.gameObject.SetActive(false);
}
else
{
attack.gameObject.SetActive(true);
health.gameObject.SetActive(true);
}
#endregion
if (潜行.gameObject.activeSelf)
{
//BIFStaticTool.SetAlphaRecursively(Content.gameObject, 0.5f);
//BIFStaticTool.SetColorRecursively(Content.gameObject, new Color(1f, 1f, 1f, 0.5f));
BIFStaticTool.SetColorRecursively(Content.gameObject, new Color(0.5f, 0.5f, 0.5f, 1f));
}
else
{
//BIFStaticTool.SetAlphaRecursively(Content.gameObject, 1f);
BIFStaticTool.SetColorRecursively(Content.gameObject, new Color(1f, 1f, 1f, 1f));
}
}
public static void Init()
{
CardBuilder.GetCard(0);
CardPile cardPile = new CardPile();
cardPile.InitCardPileFully();
/*
* string minionTypeCountString = cardPile.cardPile
* .GroupBy(pair => pair.Key.type)
* .Select(x => (card: x.First().Key, count: x.Sum(pair => pair.Value)))
* .Select(x => (x.card.type, count: x.count / Const.numOfMinionsInCardPile[x.card.star - 1]))
* .Select(pair => (type: BIF.BIFStaticTool.GetEnumDescriptionSaved(pair.type), pair.count))
* .Where(pair => !string.IsNullOrEmpty(pair.type))
* .Map(pair => pair.type + ":" + pair.count)
* .Join(" ");
* Debug.Log(minionTypeCountString);
*/
schools = new List <School>
{
new School()
{
name = "中立",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("中立"))
},
new School()
{
name = "野兽",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("野兽"))
},
new School()
{
name = "恶魔",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("恶魔"))
},
new School()
{
name = "机械",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("机械"))
},
new School()
{
name = "鱼人",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("鱼人"))
},
new School()
{
name = "巨龙",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("龙"))
},
new School()
{
name = "嘲讽",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("嘲讽"))
},
new School()
{
name = "圣盾",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("圣盾"))
},
new School()
{
name = "战吼",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("战吼"))
},
new School()
{
name = "亡语",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("亡语"))
},
new School()
{
name = "混沌",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("混合") || card.tag.Contains("奇异") || card.tag.Contains("青玉"))
},
//schools.Add(new School()
//{
// name = "奇异",
// cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("奇异"))
//});
//schools.Add(new School()
//{
// name = "召唤",
// cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("召唤"))
//});
new School()
{
name = "手牌",
cards = CardBuilder.AllCards.FilterValue(card => !card.isToken && !card.isGold).Filter(card => card.tag.Contains("手牌"))
}
};
//foreach (var item in schools)
//{
// Debug.Log(item.name + " " + item.cards.Count);
//}
for (int i = 1; i <= 6; i++)
{
for (int j = 0; j < Const.typeOfMinionsInCardPile[i - 1] - 3; j++)
{
starList.Add(i);
}
}
starList.Shuffle();
for (int i = 1; i <= 3; i++)
{
List <int> tmpStarList = new List <int>();
for (int j = 1; j <= 6; j++)
{
tmpStarList.Add(j);
}
tmpStarList.Shuffle();
foreach (var item in tmpStarList)
{
starList.Add(item);
}
}
}
private void OnGUI()
{
if (CardBuilder.AllCards != null && Application.isPlaying)
{
EditorGUILayout.HelpBox("在对战中点击卡牌生成卡牌\n在对战前点击宝藏获得宝藏", MessageType.Info);
if (GUILayout.Button("增加十块钱"))
{
AddCoins();
}
if (GUILayout.Button("解锁所有英雄"))
{
UnlockAllHero(true);
}
if (GUILayout.Button("锁定所有英雄"))
{
UnlockAllHero(false);
}
if (GUILayout.Button("解锁所有卡牌"))
{
LockAllCard(true);
}
if (GUILayout.Button("锁定所有卡牌"))
{
LockAllCard(false);
}
if (GUILayout.Button("直接获胜"))
{
AutoWin();
}
if (GUILayout.Button("直接失败"))
{
AutoLose();
}
EditorGUILayout.Space();
selectedType = (SelectedType)EditorGUILayout.EnumPopup(new GUIContent("分类依据："), selectedType);
PlayerPrefs.SetInt("selectedType", (int)selectedType);
if (selectedType == SelectedType.Tag)
{
List <string> tags = new HashSet <string>(CardBuilder.AllCards.Values.SelectMany(card => card.tag))
.OrderBy(x => x).ToList();
if (string.IsNullOrEmpty(tagValue))
{
tagValue = tags.GetOne();
}
GUILayout.BeginHorizontal();
GUILayout.Label("选择tag:");
if (EditorGUILayout.DropdownButton(new GUIContent(tagValue), FocusType.Keyboard))
{
GenericMenu genericMenu = new GenericMenu();
foreach (var tag in tags)
{
genericMenu.AddItem(new GUIContent(tag), tag.Equals(tagValue), value => {
tagValue = value.ToString();
}, tag);
}
genericMenu.ShowAsContext();
}
GUILayout.EndHorizontal();
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
CardBuilder.AllCards.FilterValue(card => card.tag.Contains(tagValue) && card.isGold == false)
.OrderByDescending(card => card.star)
.Map(card => {
if (GUILayout.Button(card.name + "******".Substring(0, card.star)))
{
CreateNewCard(card);
SaveLastCard(card.id);
}
});
GUILayout.EndScrollView();
}
else if (selectedType == SelectedType.MinionType)
{
minionType = (MinionType)EditorGUILayout.EnumPopup(new GUIContent("种族："), minionType);
PlayerPrefs.SetInt("minionType", (int)minionType);
isToken = EditorGUILayout.Toggle(new GUIContent("Token?"), isToken);
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
CardBuilder.AllCards.FilterValue(card => card.IsMinionType(minionType) && card.isToken == isToken && card.isGold == false)
.OrderByDescending(card => card.star)
.Map(card => {
if (GUILayout.Button(card.name + "******".Substring(0, card.star)))
{
CreateNewCard(card);
SaveLastCard(card.id);
}
});
GUILayout.EndScrollView();
}
else if (selectedType == SelectedType.Keyword)
{
keywordValue = (Keyword)EditorGUILayout.EnumPopup(new GUIContent("关键字："), keywordValue);
PlayerPrefs.SetInt("keywordValue", (int)keywordValue);
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
CardBuilder.AllCards.FilterValue(card => card.HasKeyword(keywordValue) && card.isGold == false)
.OrderByDescending(card => card.star)
.Map(card => {
if (GUILayout.Button(card.name + "******".Substring(0, card.star)))
{
CreateNewCard(card);
SaveLastCard(card.id);
}
});
GUILayout.EndScrollView();
}
List <int> cards = GetAllLastCard();
if (cards.Count != 0)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("最近使用过", MessageType.Info);
foreach (var id in cards)
{
var card = CardBuilder.GetCard(id);
if (GUILayout.Button(card.name + "******".Substring(0, card.star)))
{
CreateNewCard(card);
}
}
}
}
else
{
EditorGUILayout.HelpBox("请启动游戏", MessageType.Info);
}
}
