/// <summary>
/// 当所有信息齐后进行
/// </summary>
void RealFunction()
{
//如果当前怪兽的状态是里侧表示，则进行反转召唤
if (calledMonster.GetCardGameState() == CardGameState.Back)
{
callMonsterType = CallMonsterType.Flip;
calledMonster.SetCardGameState(cardGameState);
calledMonster.SetChangeAttackOrDefenseNumber(0);
calledMonster.GetDuelCardScript().SetOwner(ownerPlayer);
CheckCardCanChainLaunch();
return;
}
int monsterLevel = calledMonster.GetLevel();
//先判断是否可以直接进行召唤
if (monsterLevel <= DuelRuleManager.GetCallMonsterWithoutSacrificeLevelUpperLimit())
{
int index = CallMonster();
calledMonster.GetDuelCardScript().SetOwner(ownerPlayer);
ownerPlayer.GetOpponentPlayer().CallMonsterNotify(calledMonster.GetID(), CallType.Normal, CardGameState.Hand, cardGameState, index);
CheckCardCanChainLaunch();
}
else//使用祭品召唤
{
if (ownerPlayer.GetCanBeSacrificeMonsterNumber() >= calledMonster.NeedSacrificeMonsterNumer())
{
callMonsterType = CallMonsterType.Sacrifice;
TrySacrificeCall();
}
}
}
/// <summary>
/// 召唤怪兽
/// </summary>
int CallMonster()
{
int index = 0;
for (; index < DuelRuleManager.GetMonsterAreaNumber(); index++)
{
if (ownerPlayer.GetMonsterCardArea()[index] == null)
{
ownerPlayer.GetMonsterCardArea()[index] = calledMonster;
break;
}
}
callMonsterType = CallMonsterType.Normal;
calledMonster.AddContent("monsterCardAreaIndex", index);
if (calledMonster.GetCardGameState() == CardGameState.Tomb)
{
calledMonster.GetDuelCardScript().GetOwner().GetTombCards().Remove(calledMonster);
}
else if (calledMonster.GetCardGameState() == CardGameState.Hand)
{
calledMonster.GetDuelCardScript().GetOwner().GetHandCards().Remove(calledMonster);
}
calledMonster.SetCardGameState(cardGameState, index);
ownerPlayer.SetNormalCallNumber(ownerPlayer.GetNormalCallNumber() - 1);
return(index);
}
protected override void BeforeProcessFunction()
{
if (!launchEffectCard.IsInArea())
{
int index = 0;
for (; index < DuelRuleManager.GetMagicTrapAreaNumber(); index++)
{
if (ownerPlayer.GetMagicTrapCardArea()[index] == null)
{
ownerPlayer.GetMagicTrapCardArea()[index] = launchEffectCard;
break;
}
}
launchEffectCard.AddContent("magicTrapCardAreaIndex", index);
if (launchEffectCard.GetCardGameState() == CardGameState.Hand)
{
ownerPlayer.GetHandCards().Remove(launchEffectCard);
}
launchEffectCard.SetCardGameState(CardGameState.Front, index);
}
else
{
launchEffectCard.SetCardGameState(CardGameState.Front);
}
launchEffectCard.BeforeLaunchEffect(CostFinish);
}
/// <summary>
/// 决斗开始时抽卡
/// </summary>
public void DrawAtFirst()
{
for (int i = 0; i < DuelRuleManager.GetDrawNumberOnStartDuel(); i++)
{
Draw();
}
}
public void SetLife(int newLife)
{
life = newLife;
life = life > 0 ? life : 0;
lifeScrollBar.size = (float)life / DuelRuleManager.GetPlayerStartLife();
lifeNumberText.text = life + "/" + DuelRuleManager.GetPlayerStartLife();
duelScene.CheckWinByLife();
}
/// <summary>
/// 开始结束流程事件
/// </summary>
void BeginEndPhaseTypeEvent()
{
//在回合结束后检查手牌是否超过规定的最大数量，超过的话丢弃多余数量
if (duelScene.GetCurrentPlayer().GetHandCards().Count > DuelRuleManager.GetHandCardNumberUpperLimit())
{
GameManager.ShowMessage("当前手牌数量大于规定数量！");
beInterrupted = true;
int number = duelScene.GetCurrentPlayer().GetHandCards().Count - DuelRuleManager.GetHandCardNumberUpperLimit();
DiscardHandCardEffectProcess discardHandCardEffectProcess = new DiscardHandCardEffectProcess(null, number, null, duelScene.GetCurrentPlayer());
duelScene.GetCurrentPlayer().AddEffectProcess(discardHandCardEffectProcess);
}
finishAction += duelScene.ChangeCurrentPlayer;
}
/// <summary>
/// 清除指定卡组错误
/// </summary>
/// <param name="cardGroupName"></param>
public static void ClearCardGroupError(string cardGroupName)
{
UserCardGroup userCardGroup = gameManagerInstance.GetUserData().GetCardGroupByName(cardGroupName);
//检测卡牌的数量
for (int i = userCardGroup.mainCardList.Count - 1; i >= 0; i--)
{
if (userCardGroup.GetMainCardCount() > DuelRuleManager.GetMainCardGroupNumberUpperLimit())
{
userCardGroup.mainCardList.RemoveAt(i);
}
else
{
break;
}
}
//检测是否存在未知卡牌
for (int i = userCardGroup.mainCardList.Count - 1; i >= 0; i--)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(userCardGroup.mainCardList[i].cardNo))
{
userCardGroup.mainCardList.RemoveAt(i);
}
}
for (int i = userCardGroup.extraCardList.Count - 1; i >= 0; i--)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(userCardGroup.extraCardList[i].cardNo))
{
userCardGroup.extraCardList.RemoveAt(i);
}
}
for (int i = userCardGroup.deputyCardList.Count - 1; i >= 0; i--)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(userCardGroup.deputyCardList[i].cardNo))
{
userCardGroup.deputyCardList.RemoveAt(i);
}
}
//检测同名卡牌的数量
foreach (var item in userCardGroup.mainCardList)
{
if (item.number > DuelRuleManager.GetSameCardNumberUpperLimit())
{
item.number = DuelRuleManager.GetSameCardNumberUpperLimit();
}
}
//检测禁卡的限制
gameManagerInstance.SaveUserData();
}
/// <summary>
/// 检测卡组是否合法
/// </summary>
/// <param name="cardGroupName"></param>
/// <returns></returns>
public static bool CheckCardGroupLegal(string cardGroupName)
{
UserCardGroup userCardGroup = gameManagerInstance.GetUserData().GetCardGroupByName(cardGroupName);
//检测卡牌的数量
if (userCardGroup.mainCardList.Count > DuelRuleManager.GetMainCardGroupNumberUpperLimit())
{
ShowMessage($"卡组：{cardGroupName}不合法。原因：卡牌的数量超过限制！");
return(false);
}
//检测是否存在未知卡牌
foreach (var item in userCardGroup.mainCardList)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(item.cardNo))
{
ShowMessage($"卡组：{cardGroupName}不合法。原因：主卡组存在未知卡牌{item.cardNo}！");
return(false);
}
}
foreach (var item in userCardGroup.extraCardList)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(item.cardNo))
{
ShowMessage($"卡组：{cardGroupName}不合法。原因：额外卡组存在未知卡牌{item.cardNo}！");
return(false);
}
}
foreach (var item in userCardGroup.deputyCardList)
{
if (!gameManagerInstance.GetAllCardInfoList().ContainsKey(item.cardNo))
{
ShowMessage($"卡组：{cardGroupName}不合法。原因：副卡组存在未知卡牌{item.cardNo}！");
return(false);
}
}
//检测同名卡牌的数量
foreach (var item in userCardGroup.mainCardList)
{
if (item.number > DuelRuleManager.GetSameCardNumberUpperLimit())
{
ShowMessage($"卡组：{cardGroupName}不合法。原因：同名卡牌{item.cardNo}超过上限！");
return(false);
}
}
//检测禁卡的限制
return(true);
}
/// <summary>
/// 召唤需要的祭品数量
/// </summary>
/// <returns></returns>
public int NeedSacrificeMonsterNumer()
{
if (GetLevel() > DuelRuleManager.GetCallMonsterWithoutSacrificeLevelUpperLimit())
{
if (GetLevel() > DuelRuleManager.GetCallMonsterWithOneSacrificeLevelUpperLimit())
{
return(2);
}
else
{
return(1);
}
}
return(0);
}
/// <summary>
/// 判断是否可以通常召唤
/// </summary>
/// <returns></returns>
public bool CanNormalCall()
{
if (ownerPlayer.IsMyTurn() &&
card.GetCardGameState() == CardGameState.Hand &&
card.GetCardType() == CardType.Monster &&
(duelScene.GetCurrentPhaseType() == PhaseType.Main ||
duelScene.GetCurrentPhaseType() == PhaseType.Second) &&
ownerPlayer.GetCurrentEffectProcess() == null &&
ownerPlayer.GetCanCallNumber() > 0)
{
if (card.GetLevel() <= DuelRuleManager.GetCallMonsterWithoutSacrificeLevelUpperLimit())
{
return(!ownerPlayer.MonsterAreaIsFull());
}
}
return(false);
}
protected override void BeforeProcessFunction()
{
int index = 0;
for (; index < DuelRuleManager.GetMagicTrapAreaNumber(); index++)
{
if (ownerPlayer.GetMagicTrapCardArea()[index] == null)
{
ownerPlayer.GetMagicTrapCardArea()[index] = backPlaceCard;
break;
}
}
backPlaceCard.AddContent("magicTrapCardAreaIndex", index);
backPlaceCard.SetCardGameState(CardGameState.Back, index);
ownerPlayer.GetHandCards().Remove(backPlaceCard);
AfterFinishProcessFunction();
}
public override void InitBeforDuel()
{
lifeScrollBar = GameObject.Find("opponentLifeScrollbar").GetComponent <Scrollbar>();
lifeNumberText = GameObject.Find("opponentLifeNumberText").GetComponent <Text>();
life = DuelRuleManager.GetPlayerStartLife();
List <CardBase> myCards = duelCardGroup.GetCards();
for (int i = 0; i < myCards.Count; i++)
{
GameObject go = GameObject.Instantiate(duelScene.cardPre, duelScene.duelBackImage.transform);
go.GetComponent <DuelCardScript>().SetCard(myCards[i]);
go.GetComponent <DuelCardScript>().SetOwner(this);
myCards[i].SetCardObject(go);
myCards[i].SetCardGameState(CardGameState.Group);
}
}
/// <summary>
/// 初始化数据
/// </summary>
public void InitData()
{
if (initDataFinish)
{
Debug.LogError("游戏中数据仅初始化一次！");
return;
}
string cardBackPath = rootPath + "/Texture/CardBack.jpg";
WWW www = new WWW(cardBackPath);
Texture2D texture = new Texture2D(177, 254);
www.LoadImageIntoTexture(texture);
cardBackImage = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.zero);
string cardOperationButtonPrefabPath = "Prefab/CardOperationButtonPre";
cardOperationButtonPrefab = Resources.Load <GameObject>(cardOperationButtonPrefabPath);
DuelRuleManager.InitDuelRule();
LoadUserData();
LoadAllCardData();
}
public void SetAttackNumber()
{
SetAttackNumber(DuelRuleManager.GetMonsterAttackNumberEveryTurn());
}
/// <summary>
/// 开始回合
/// </summary>
public void StartTurn()
{
normalCallNumber = DuelRuleManager.GetNormalCallMonsterNumber();
duelScene.EnterPhaseType(PhaseType.Draw);
}
public void SetChangeAttackOrDefenseNumber()
{
SetChangeAttackOrDefenseNumber(DuelRuleManager.GetMonsterChangeAttackOrDefenseNumberEveryTurn());
}
/// <summary>
/// 向指定卡组添加卡牌
/// </summary>
/// <param name="cardGroupType"></param>
/// <param name="card"></param>
public bool AddCardToCardGroup(CardGroupType cardGroupType, CardBase card)
{
if (cardGroup == null)
{
Debug.LogError("在向卡组中添加卡牌时没有找到卡组：" + currentCardGroupName);
return(false);
}
int cardNumberLimit = DuelRuleManager.GetSameCardNumberUpperLimit();
List <UserCardData> typrCardGroup = null;
switch (cardGroupType)
{
case CardGroupType.Unknown:
Debug.LogError("未知卡组类型！");
return(false);
case CardGroupType.Main:
typrCardGroup = cardGroup.mainCardList;
break;
case CardGroupType.Extra:
typrCardGroup = cardGroup.extraCardList;
break;
case CardGroupType.Deputy:
typrCardGroup = cardGroup.deputyCardList;
break;
default:
break;
}
UserCardData userCardData = null;
foreach (var item in typrCardGroup)
{
if (item.cardNo == card.GetCardNo())
{
userCardData = item;
}
}
if (userCardData == null)
{
userCardData = new UserCardData();
userCardData.cardNo = card.GetCardNo();
userCardData.number = 1;
typrCardGroup.Add(userCardData);
}
else
{
if (userCardData.number >= cardNumberLimit)
{
GameManager.ShowMessage("卡组中" + card.GetName() + "数量超过最大值！");
return(false);
}
else
{
userCardData.number++;
}
}
switch (cardGroupType)
{
case CardGroupType.Unknown:
break;
case CardGroupType.Main:
ResetMainCardGroup();
break;
case CardGroupType.Extra:
ResetExtraCardGroup();
break;
case CardGroupType.Deputy:
ResetDeputyCardGroup();
break;
default:
break;
}
return(true);
}
/// <summary>
/// 电脑思考行动，暂时制作简单处理。
/// </summary>
public override void ThinkAction()
{
//不是自己回合不进行操作
if (duelScene.GetCurrentPlayer() != this)
{
return;
}
//受效果处理时进行根据效果类型做特殊操作
if (currentEffectProcess != null)
{
if (currentEffectProcess is DiscardHandCardEffectProcess)
{
(currentEffectProcess as DiscardHandCardEffectProcess).DiscardOneHandCard(null, FindWorstCardInHand());
}
if (currentEffectProcess is ChooseCardEffectProcess)
{
ChooseCardEffectProcess chooseCardEffectProcess = currentEffectProcess as ChooseCardEffectProcess;
chooseCardEffectProcess.ChooseCardCallBack(chooseCardEffectProcess.GetLaunchEffectCard(), FindCanBeChooseCardFromList(chooseCardEffectProcess.GetCanChooseCardList()));
}
return;
}
if (duelScene.GetCurrentPhaseType() == PhaseType.Draw)
{
duelScene.EnterPhaseType(PhaseType.Prepare);
return;
}
else if (duelScene.GetCurrentPhaseType() == PhaseType.Prepare)
{
duelScene.EnterPhaseType(PhaseType.Main);
return;
}
//在主要流程中
else if (duelScene.GetCurrentPhaseType() == PhaseType.Main)
{
//先召唤怪兽
if (GameManager.GetSingleInstance().GetUserData().opponentCanCallMonster&& CanCallMonster())
{
foreach (var item in handCards)
{
DuelCardScript duelCardScript = item.GetDuelCardScript();
if (duelCardScript.CanCall())
{
int sacrificeMonsterNumer = item.NeedSacrificeMonsterNumer();
if (sacrificeMonsterNumer > 0)
{
List <CardBase> sacrificeCards = new List <CardBase>();//祭品列表
for (int i = 0; i < DuelRuleManager.GetMonsterAreaNumber(); i++)
{
if (monsterCardArea[i] != null)
{
sacrificeCards.Add(monsterCardArea[i]);
sacrificeMonsterNumer -= monsterCardArea[i].GetCanBeSacrificedNumber();
if (sacrificeMonsterNumer <= 0)
{
break;
}
}
}
CardGameState nextCardGameState = ThinkCallMonsterCardGameState(item);
CallMonsterEffectProcess callMonsterEffectProcess = new CallMonsterEffectProcess(item, nextCardGameState, sacrificeCards, this);
AddEffectProcess(callMonsterEffectProcess);
}
else
{
CardGameState nextCardGameState = ThinkCallMonsterCardGameState(item);
CallMonsterEffectProcess callMonsterEffectProcess = new CallMonsterEffectProcess(item, nextCardGameState, this);
AddEffectProcess(callMonsterEffectProcess);
}
return;
}
}
}
//然后使用魔法卡
else if (GameManager.GetSingleInstance().GetUserData().opponentCanLaunchEffect&& CanLanuchMagicCard())
{
foreach (var item in magicTrapCardArea)
{
if (item != null && item.CanLaunchEffect())
{
LaunchEffect(item);
return;
}
}
foreach (var item in GetHandCards())
{
if (item.CanLaunchEffect())
{
LaunchEffect(item);
return;
}
}
}
//最后进入战斗流程
else if (GameManager.GetSingleInstance().GetUserData().opponentCanAttack&& CanEnterBattlePhaseType())
{
Battle();
return;
}
}
else if (duelScene.GetCurrentPhaseType() == PhaseType.Battle)
{
//先判断是否存在可以进行攻击的怪兽，并选出攻击力最大的怪兽先进行攻击
int canAttackMonsterIndex = -1;
int maxAttackValue = 0;
for (int i = 0; i < DuelRuleManager.GetMonsterAreaNumber(); i++)
{
if (monsterCardArea[i] != null && monsterCardArea[i].CanAttack() && monsterCardArea[i].GetAttackValue() > maxAttackValue)
{
canAttackMonsterIndex = i;
maxAttackValue = monsterCardArea[i].GetAttackValue();
}
}
//没有的话进入第二主要回合或回合结束
if (canAttackMonsterIndex == -1)
{
duelScene.EnterPhaseType(PhaseType.Second);
return;
}
else
{
CardBase canAttackMonster = monsterCardArea[canAttackMonsterIndex];
//如果对方没有可以受攻击的怪兽时，进行直接攻击
if (!GetOpponentPlayer().HaveBeAttackedMonster() &&
GetCanDirectAttack() &&
GetOpponentPlayer().CanBeDirectAttacked() &&
canAttackMonster.CanDirectAttack())
{
AttackEffectProcess attackEffectProcess = new AttackEffectProcess(canAttackMonster, null, this);
AddEffectProcess(attackEffectProcess);
return;
}
//如果当前怪兽攻击力，比对方场上表侧表示的怪兽最小的攻击力或守备力大的话进行攻击
//如果对方存在里侧表示的怪兽时进行攻击
//以上皆不满足的话退出战斗流程
foreach (var item in GetOpponentPlayer().GetMonsterCardArea())
{
bool attackThisMonster = false;
if (item != null && item.CanBeAttacked())
{
if (item.GetCardGameState() == CardGameState.FrontAttack)
{
if (maxAttackValue >= item.GetAttackValue())
{
attackThisMonster = true;
}
}
else if (item.GetCardGameState() == CardGameState.FrontDefense)
{
if (maxAttackValue >= item.GetDefenseValue())
{
attackThisMonster = true;
}
}
else if (item.GetCardGameState() == CardGameState.Back)
{
attackThisMonster = true;
}
}
if (attackThisMonster)
{
AttackEffectProcess attackEffectProcess = new AttackEffectProcess(canAttackMonster, item, this);
AddEffectProcess(attackEffectProcess);
return;
}
}
return;
}
}
else if (duelScene.GetCurrentPhaseType() == PhaseType.End)
{
}
if (duelScene.GetCurrentPhaseType() == PhaseType.Main ||
duelScene.GetCurrentPhaseType() == PhaseType.Battle ||
duelScene.GetCurrentPhaseType() == PhaseType.Second)
{
EndTurn();
}
}
