void SmallBattleResponse(BaseHttpRequest request, BaseResponse response)
{
ComLoading.Close();
FBReword = null;
if (response != null && response.status != BaseResponse.ERROR)
{
BattleResponse r = response as BattleResponse;
FBReword = r.data;
cityFloorManager.ShowReward(FBReword, GoNextFloor);
//如果是新手引导点击的
if (IsGuideClick)
{
Core.Data.guideManger.DelayAutoRun(1.8f);
}
}
else
{
isCanClick = true;
if (response.errorCode == 4002)
{
JCRestoreEnergyMsg.OpenUI(110015, 110016);
}
else
{
ErrorDeal(response.errorCode);
}
}
//UIMiniPlayerController.Instance.freshPlayerInfoView ();
//DBUIController.mDBUIInstance.RefreshUserInfo ();
}
public void InitData()
{
BattleSequence thisBattle = Core.Data.temper.warBattle;
if (thisBattle != null)
{
if (thisBattle.gambleResult != null)
{
gambleItemData = thisBattle.gambleResult;
if (gambleItemData.winFlag == true)
{
this.ShowWin();
}
else
{
this.ShowLose();
}
if (gambleItemData.type == 1)
{
curResultType = resultWinType.isComboType;
}
else
{
curResultType = resultWinType.isSkillType;
}
this.TypeShowLabel(gambleItemData.winFlag);
}
}
}
public void ExcuteAction(BattleInfoSet ParaBattleInfoSet, BattleSequence ParaBattleSequence)
{
// 调用武器或者技能的执行方法实际执行该行动
if (ParaBattleInfoSet == null)
{
Debug.Log("ParaBattleInfoSet");
}
RelativeBattleOperation.ExcuteBattleOperation(ExcuteUnit, ParaBattleInfoSet, ParaBattleSequence);
}
// 将所有玩家的所有行动加载到战斗序列当中
public void FetchActionFromBattleInfoSet(BattleSequence ParaBattleSequence)
{
for (int i = 0; i < PlayerNum; i++)
{
PlayerBattleInfoSet CurrentPlayerBattleInfoSet = PlayerBattleInfoSetOfPlayID[PlayerIDOfIndex[i]];
CurrentPlayerBattleInfoSet.FetchActionFromPlayerBattleInfoSet(ParaBattleSequence);
}
}
public void FetchActionFromPlayerBattleInfoSet(BattleSequence ParaBattleSequence)
{
for (int i = 0; i < UnitTypeNum; i++)
{
for (int j = 0; j < ActionsOfUnitName[UnitNameOfIndex[i]].Count; j++)
{
ParaBattleSequence.InsertAction(ActionsOfUnitName[UnitNameOfIndex[i]][j]);
//Debug.Log(ActionsOfUnitName[UnitNameOfIndex[i]][j].GetActionName() + "==" + ActionsOfUnitName[UnitNameOfIndex[i]][j].GetExcuteUnit().GetUnitOwner());
}
}
}
public void ShowReward(BattleSequence data, System.Action callBack)
{
UIFloorReward fr = FhjLoadPrefab.GetPrefabClass <UIFloorReward>();
if (fr != null)
{
Transform t = fr.transform;
t.parent = transform;
t.localPosition = Vector3.back;
t.localRotation = Quaternion.identity;
t.localScale = Vector3.one;
fr.Close = callBack;
fr.ShowReward(data);
}
}
private void addCoinOrExp(BaseHttpRequest request, BattleSequence reward)
{
if (reward != null)
{
if (reward.sync != null)
{
if (!Core.Data.guideManger.isGuiding)
{
RTData.curCoin = reward.sync.coin;
RTData.curExp = reward.sync.ep;
RTData.curStone = reward.sync.stone;
RTData.curVipLevel = reward.sync.vip;
}
else
{
//新手引导是假数据不要同步
RTData.curCoin += (reward.reward.bco + reward.reward.eco);
RTData.curExp += (reward.reward.bep + reward.reward.eep);
}
}
//可能会导致升等级
if (RTData.curLevel < reward.sync.lv)
{
HttpRequest req = request as HttpRequest;
BattleParam sendData = req.ParamMem as BattleParam;
//如果是小关卡,打完以后直接升级,如果是BOSS关卡,升级处理将留到战斗播放完毕
if (sendData != null)
{
if (Core.Data.dungeonsManager.getFloorData(sendData.doorId).isBoss == 0)
{
RTData.curLevel = reward.sync.lv;
}
else
{
Core.Data.temper.AfterBattleLv = reward.sync.lv;
}
upgrade = true;
}
}
else if (RTData.curLevel == reward.sync.lv)
{
//.. seems to do nothing
}
}
}
public void SetData(BattleSequence data, int index)
{
ItemOfReward[] rewards = null;
if (data.reward != null)
{
rewards = data.reward.p;
}
if (rewards != null)
{
RewardCount = rewards.Length;
for (int i = 0; i < rewards.Length; i++)
{
Core.Data.itemManager.AddRewardToBag(rewards[i]);
list_cells[i].InitUI(rewards[i]);
}
}
Lab_Title.text = Core.Data.stringManager.getString(9080).Replace("{}", (index + 1).ToString());
Lab_AddExp.text = "+" + data.reward.bep.ToString();
Lab_AddCoin.text = "+" + data.reward.bco.ToString();
}
public virtual void ExcuteBattleOperation(Unit ExecuteUnit, BattleInfoSet ParaBattleInfoSet, BattleSequence ParaBattleSequence)
{
}
public virtual void ExcuteEffect(Unit SourceUnit, GameObject SourcePiece, GameObject SourceCheckerBoard, Unit TargetUnit, GameObject TargetPiece, GameObject TargetCheckerBoard, BattleInfoSet ParaBattleInfoSet = null, BattleSequence ParaBattleSequence = null)
{
}
void InitUI()
{
m_btnBack.TextID = 5195;
m_btnReplay.TextID = 5194;
m_txtSpecial.text = "";
// m_txtTip.text = "";
BattleSequence battle = Core.Data.temper.warBattle;
List <GPSRewardData> list = new List <GPSRewardData> ();
for (int i = 0; i < m_gridEnermy.transform.childCount; i++)
{
Transform tf = m_gridEnermy.transform.GetChild(i);
tf.parent = null;
Destroy(tf.gameObject);
}
for (int i = 0; i < m_gridReward.transform.childCount; i++)
{
Transform tf = m_gridReward.transform.GetChild(i);
tf.parent = null;
Destroy(tf.gameObject);
}
if (battle.reward != null && battle.reward.p != null)
{
battle.reward.p = AnalysisReward(battle.reward.p);
for (int i = 0; i < battle.reward.p.Length; i++)
{
GPSRewardData rd = new GPSRewardData();
rd.reward = battle.reward.p [i];
rd.IsSpecial = false;
list.Add(rd);
}
}
if (battle.radarReward != null && battle.radarReward.p != null)
{
for (int i = 0; i < battle.radarReward.p.Length; i++)
{
GPSRewardData rd = new GPSRewardData();
rd.reward = battle.radarReward.p [i];
rd.IsSpecial = true;
list.Add(rd);
}
}
if (m_prefabReward == null)
{
m_prefabReward = PrefabLoader.loadFromPack("ZQ/GPSRewardItem");
}
if (m_prefabEmermy == null)
{
m_prefabEmermy = PrefabLoader.loadFromPack("ZQ/GPSEnermyItem");
}
for (int i = 0; i < list.Count; i++)
{
GameObject objRwd = Instantiate(m_prefabReward) as GameObject;
RED.AddChild(objRwd, m_gridReward.gameObject);
GPSRewardItem item = objRwd.GetComponent <GPSRewardItem>();
item.SetGPSRewardData(list [i]);
}
List <int> enermys = BanBattleManager.Instance.GetDeadEnmeyList();
if (enermys != null)
{
for (int i = 0; i < enermys.Count; i++)
{
Monster mon = new Monster();
mon.config = Core.Data.monManager.getMonsterByNum(enermys [i]);
GameObject objEmy = Instantiate(m_prefabEmermy) as GameObject;
RED.AddChild(objEmy, m_gridEnermy.gameObject);
GPSEnermyItem item = objEmy.GetComponent <GPSEnermyItem> ();
item.SetEnermyData(mon);
}
}
m_gridEnermy.Reposition();
m_gridReward.Reposition();
if (battle.radarReward != null && battle.radarReward.p != null)
{
string strName = "";
for (int i = 0; i < Core.Data.gpsWarManager.curRoom.members.Length; i++)
{
if (Core.Data.gpsWarManager.curRoom.members [i].memberId == battle.radarReward.user_id)
{
strName = Core.Data.gpsWarManager.curRoom.members [i].memberName;
break;
}
}
string strText = Core.Data.stringManager.getString(5196);
strText = string.Format(strText, strName);
m_txtSpecial.text = strText;
}
Vector3 tpos = Vector3.up * enermys.Count * 100;
tpos.y -= 330;
SpringPanel.Begin(m_gridEnermy.transform.parent.gameObject, tpos, 5.0f);
// tpos = Vector3.up * list.Count * 100;
// tpos.y -= 330;
// SpringPanel.Begin(m_gridReward.transform.parent.gameObject, tpos, 5.0f);
}
public override void ExcuteEffect(Unit SourceUnit, GameObject SourcePiece, GameObject SourceCheckerBoard, Unit TargetUnit, GameObject TargetPiece, GameObject TargetCheckerBoard, BattleInfoSet ParaBattleInfoSet = null, BattleSequence ParaBattleSequence = null)
{
GameObject CurrentPiece = null;
if ((int)GetParameter("TargetSelect") == 0)
{
if (SourcePiece != null)
{
CurrentPiece = SourcePiece;
}
else if (SourceUnit != null)
{
CurrentPiece = SourceUnit.GetLocatePiece();
}
else
{
Debug.Log("No valid Source.");
return;
}
}
else
{
if (TargetPiece != null)
{
CurrentPiece = TargetPiece;
}
else if (TargetUnit != null)
{
CurrentPiece = TargetUnit.GetLocatePiece();
}
else
{
Debug.Log("No valid Target.");
return;
}
}
int ActualSearchUnitNum = 0;
int PieceAliveUnitNum = CurrentPiece.GetComponent <PieceStateController>().GetAliveUnitNum();
int SearchUnitMaxNum = (int)GetParameter("SearchUnitMaxNum");
float SearchDimension = (float)GetParameter("SearchDimension");
// 计算实际需要搜索的单位数
if (SearchUnitMaxNum == -1)
{
// 如果上限为-1则完全根据搜索尺寸进行单位实际搜索数目计算
if (SearchDimension == -1)
{
// 如果搜索尺寸为-1则实际搜索单位数目为该棋子内所有存活单位数目
ActualSearchUnitNum = PieceAliveUnitNum;
}
else
{
// 计算实际搜索单位数目
ActualSearchUnitNum = CalculateSearchUnitNum();
}
}
else
{
// 如果上限不为1则先计算搜索结果再与上限比较大小
if ((float)GetParameter("SearchDimension") == -1)
{
// 如果搜索尺寸为-1则实际搜索单位数目为该棋子内所有存活单位数目
ActualSearchUnitNum = (PieceAliveUnitNum < SearchUnitMaxNum) ? PieceAliveUnitNum : SearchUnitMaxNum;
}
else
{
int TmpUnitNum = CalculateSearchUnitNum();
ActualSearchUnitNum = (PieceAliveUnitNum < TmpUnitNum) ? PieceAliveUnitNum : TmpUnitNum;
ActualSearchUnitNum = (ActualSearchUnitNum < SearchUnitMaxNum) ? ActualSearchUnitNum : SearchUnitMaxNum;
}
}
// 使用效果链接的单位筛选器从操作棋子中选择 SearchUnitNum 数量的单位
List <Unit> SearchUnitList = EffectUnitSelector.ExecuteSelection(CurrentPiece.GetComponent <PieceStateController>().GetAllAlivePieceUnit(), (int)GetParameter("SearchUnitNum"));
// 对每个搜索结果中的棋子执行搜索结果单位效果
for (int i = 0; i < SearchUnitList.Count; i++)
{
ResultUnitEffect.ExcuteEffect(SourceUnit, SourcePiece, SourceCheckerBoard, SearchUnitList[i], TargetPiece, TargetCheckerBoard, ParaBattleInfoSet, ParaBattleSequence);
}
}
public virtual void ExcuteEffect(Unit DamageSource, Unit DamageTarget, BattleInfoSet ParaBattleInfoSet = null, BattleSequence ParaBattleSequence = null)
{
Debug.Log("ExcuteEffect");
}
public override void ExcuteEffect(Unit DamageSource, Unit DamageTarget, BattleInfoSet ParaBattleInfoSet = null, BattleSequence ParaBattleSequence = null)
{
int PlayerID = -1;
if ((int)GetParameter("TargetPlayer") == 0)
{
PlayerID = DamageSource.GetUnitOwner();
}
else
{
PlayerID = DamageTarget.GetUnitOwner();
}
int PlayerCurrentMineral = GetResourceManager().GetPlayerMineral(PlayerID);
int PlayerCurrentGas = GetResourceManager().GetPlayerGas(PlayerID);
int SourcePieceMineralCost = DamageSource.GetLocatePiece().GetComponentInChildren <PieceInfoController>().GetPieceCostMineral();
int SourcePieceGasCost = DamageSource.GetLocatePiece().GetComponentInChildren <PieceInfoController>().GetPieceCostGas();
int TargetPieceMineralCost = DamageTarget.GetLocatePiece().GetComponentInChildren <PieceInfoController>().GetPieceCostMineral();
int TargetPieceGasCost = DamageTarget.GetLocatePiece().GetComponentInChildren <PieceInfoController>().GetPieceCostGas();
PlayerCurrentMineral += (int)((float)GetParameter("SourcePiecePercentage") * SourcePieceMineralCost + (float)GetParameter("TargetPiecePercentage") * TargetPieceMineralCost + (int)GetParameter("DeltaMineral"));
PlayerCurrentGas += (int)((float)GetParameter("SourcePiecePercentage") * SourcePieceGasCost + (float)GetParameter("TargetPiecePercentage") * TargetPieceGasCost + (int)GetParameter("DeltaGas"));
// 更新玩家资源
GetResourceManager().SetPlayerMineral(PlayerID, PlayerCurrentMineral);
GetResourceManager().SetPlayerGas(PlayerID, PlayerCurrentGas);
// 更新玩家卡牌
// 修改玩家手牌区卡牌
for (int i = 0; i < PlayerCardListOfType["PlayerAddHandCard"].Count; i++)
{
Debug.Log("give me a hand card.");
GetCardManager().PlayerGetAHandCard(PlayerID, GetCardManager().CreateACard(PlayerCardListOfType["PlayerAddHandCard"][i], PlayerID));
}
// 修改玩家牌堆区卡牌
for (int i = 0; i < PlayerCardListOfType["PlayerAddDeckCard"].Count; i++)
{
GetCardManager().PlayerGetADeckCard(PlayerID, GetCardManager().CreateACard(PlayerCardListOfType["PlayerAddDeckCard"][i], PlayerID));
}
// 修改玩家坟场区卡牌
for (int i = 0; i < PlayerCardListOfType["PlayerAddGraveCard"].Count; i++)
{
GetCardManager().PlayerGetAGraveCard(PlayerID, GetCardManager().CreateACard(PlayerCardListOfType["PlayerAddGraveCard"][i], PlayerID));
}
}
// 效果执行
public override void ExcuteEffect(Unit DamageSource, Unit DamageTarget, BattleInfoSet ParaBattleInfoSet = null, BattleSequence ParaBattleSequence = null)
{
Debug.Log("ExcuteDealDamage");
float tmp = (float)ParameterOfName["DamageAmount"].GetParameter();
int DamageAmount = (int)tmp;
DamageTarget.ReceiveDamage(DamageSource, DamageAmount);
}
public void ShowReward(BattleSequence data)
{
//StartCoroutine(PlaySoundFx());
m_rewardData = data;
if (data != null)
{
Init(data.reward.bep, data.reward.bco);
if (data.reward.eco > 0)
{
NGUITools.SetActive(coinPos, true);
//_name.text = coin.text;
_name.text = Core.Data.stringManager.getString(9060) + data.reward.eco.ToString(); // yangchenguang 修改 额外奖励修改成具体奖励数
FinishedIndex = 3;
}
else if (data.reward.eep > 0)
{
NGUITools.SetActive(expPos, true);
_name.text = Core.Data.stringManager.getString(9060) + data.reward.eep.ToString();
FinishedIndex = 1;
}
else if (data.reward.p == null || data.reward.p.Length < 1)
{
NGUITools.SetActive(nothingPos, true);
_name.text = nothing.text;
FinishedIndex = 0;
}
else
{
FinishedIndex = 2;
// _name.text = other.text;
ItemOfReward item = data.reward.p[0];
NGUITools.SetActive(otherPos, true);
att.enabled = false;
switch (item.getCurType())
{
case ConfigDataType.Monster:
att.enabled = true;
Monster m = item.toMonster(Core.Data.monManager);
if (m != null)
{
att.spriteName = "Attribute_" + ((int)m.RTData.Attribute).ToString();
border.spriteName = "Attribute_Border_" + ((int)m.RTData.m_nAttr).ToString();
_name.text = m.config.name;
AtlasMgr.mInstance.SetHeadSprite(spr_head, item.pid.ToString());
}
break;
case ConfigDataType.Equip:
spr_head.atlas = AtlasMgr.mInstance.equipAtlas;
_name.text = Core.Data.EquipManager.getEquipConfig(item.pid).name;
spr_head.spriteName = item.pid.ToString();
break;
case ConfigDataType.Frag:
spr_head.atlas = AtlasMgr.mInstance.itemAtlas;
Soul soul = Core.Data.soulManager.GetSoulByID(item.ppid);
if (soul != null)
{
_name.text = soul.m_config.name;
}
NGUITools.SetActive(att.gameObject, false);
spr_head.spriteName = item.pid.ToString();
break;
default:
/*道具*/
spr_head.atlas = AtlasMgr.mInstance.itemAtlas;
_name.text = Core.Data.itemManager.getItemData(item.pid).name;
NGUITools.SetActive(att.gameObject, false);
spr_head.spriteName = item.pid.ToString();
break;
}
spr_head.MakePixelPerfect();
}
}
Invoke("PlayEffect", 1f);
}
public void AttackTarget(GameObject AttackTargetPiece)
{
//GameObject LocateChessBoard = this.GetComponent<PieceStateController>().LocateChessboard;
//===========================================================================================
// 获取进攻协战棋子组和防御协战棋子组
List <GameObject> AssistAttackPieces = GetAttackPieces();
List <GameObject> AssistDefendPieces = GetDefendPieces(AttackTargetPiece);
List <GameObject> AllAttackPieces = new List <GameObject>();
List <GameObject> AllDefendPieces = new List <GameObject>();
AllAttackPieces.Add(this.transform.parent.gameObject);
AllDefendPieces.Add(AttackTargetPiece);
for (int i = 0; i < AssistAttackPieces.Count; i++)
{
AllAttackPieces.Add(AssistAttackPieces[i]);
}
for (int i = 0; i < AssistDefendPieces.Count; i++)
{
AllDefendPieces.Add(AssistDefendPieces[i]);
}
BattleInfoSet CurrentBattleInfoSet = new BattleInfoSet();
// 获取进攻方所有棋子的所有参战单位
GetBattleUnits(AllAttackPieces, AllDefendPieces, CurrentBattleInfoSet);
// 获取防御方所有棋子的所有参战单位
GetBattleUnits(AllDefendPieces, AllAttackPieces, CurrentBattleInfoSet);
CurrentBattleInfoSet.InitializeCumulativeCooldownTime();
//CurrentBattleInfoSet.DubugDisplay();
BattleSequence CurrentBattleSequence = new BattleSequence();
// 设置战斗执行器的相关参数
CurrentBattleSequence.SetMainAttackPiece(this.transform.parent.gameObject);
CurrentBattleSequence.SetMainDefendPiece(AttackTargetPiece);
CurrentBattleSequence.SetRelativeBattleInfoSet(CurrentBattleInfoSet);
CurrentBattleInfoSet.FetchActionFromBattleInfoSet(CurrentBattleSequence);
// CurrentBattleSequence.DisplayAllActionInList();
CurrentBattleSequence.BattleExcute();
//===========================================================================================
//// 0.获取进攻方和防御方的棋子状态机引用
//PieceStateController DefenderPieceStateController = AttackTargetPiece.GetComponentInChildren<PieceStateController>();
//PieceStateController AttackerPieceStateController = this.GetComponent<PieceStateController>();
//
//// 1.获取进攻方和防御方参与战斗的单位
//float DefenderPieceSize = DefenderPieceStateController.GetPieceSize();
//float AttackerPieceSize = AttackerPieceStateController.GetPieceSize();
//
////Debug.Log("DefenderPieceSize:" + DefenderPieceSize);
////Debug.Log("AttackerPieceSize:" + AttackerPieceSize);
//
//float DefenderUnitSize = DefenderPieceStateController.GetUnitSize();
//float AttackerUnitSize = AttackerPieceStateController.GetUnitSize();
//
//float DefenderPieceRange = 5.0f;
//float AttackerPieceRange = 6.0f;
//
//float DefenderMobilityFactor = DefenderPieceStateController.GetPieceMobilityFactor();
//float AttackerMobilityFactor = AttackerPieceStateController.GetPieceMobilityFactor();
//
//int DefenderBattleUnitNum = CalculateBattleUnitNum(AttackerPieceSize, DefenderUnitSize, DefenderPieceRange, DefenderMobilityFactor);
//int AttackerBattleUnitNum = CalculateBattleUnitNum(DefenderPieceSize, AttackerUnitSize, AttackerPieceRange, AttackerMobilityFactor);
//
////Debug.Log("DefenderBattleUnitNum:" + DefenderBattleUnitNum);
////Debug.Log("AttackerBattleUnitNum:" + AttackerBattleUnitNum);
//
//// 2.生成参战单位数组
//List<Unit> DefenderUnitArray = new List<Unit>();
//List<Unit> AttackerUnitArray = new List<Unit>();
//
//DefenderUnitArray = DefenderPieceStateController.GetRandomBattleUnitArray(DefenderBattleUnitNum);
//AttackerUnitArray = AttackerPieceStateController.GetRandomBattleUnitArray(AttackerBattleUnitNum);
//
////Debug.Log(DefenderUnitArray.Count);
////Debug.Log(AttackerUnitArray.Count);
//
//// 3.根据射程计算并标记可攻击单位
//SetUnitsAttackableOff(DefenderUnitArray);
//SetUnitsAttackableOff(AttackerUnitArray);
//if (DefenderPieceRange > AttackerPieceRange)
//{
// float RangeDifference = DefenderPieceRange - AttackerPieceRange;
//
// DefenderUnitArray = SetUnitsAttackableOn(DefenderUnitArray, (int)(DefenderUnitArray.Count * CalculateAttackablePercentage(RangeDifference)));
// AttackerUnitArray = SetUnitsAttackableOn(AttackerUnitArray, AttackerUnitArray.Count);
//}
//else if(DefenderPieceRange < AttackerPieceRange)
//{
// float RangeDifference = AttackerPieceRange - DefenderPieceRange;
//
// Debug.Log("Percantage:" + AttackerUnitArray.Count * CalculateAttackablePercentage(RangeDifference));
//
// DefenderUnitArray = SetUnitsAttackableOn(DefenderUnitArray, DefenderUnitArray.Count);
// AttackerUnitArray = SetUnitsAttackableOn(AttackerUnitArray, (int)(AttackerUnitArray.Count * CalculateAttackablePercentage(RangeDifference)));
//}
//else
//{
// DefenderUnitArray = SetUnitsAttackableOn(DefenderUnitArray, DefenderUnitArray.Count);
// AttackerUnitArray = SetUnitsAttackableOn(AttackerUnitArray, AttackerUnitArray.Count);
//}
//
//// 4.进行回合制单位攻击演算
//DebugDisplay(DefenderUnitArray);
//DebugDisplay(AttackerUnitArray);
//
//float DefenderWeaponInterval = 0.8f;
//float AttackerWeaponInterval = 0.9f;
//
//int DefenderAttackCount = 0;
//int AttackerAttackCount = 0;
//
//
//if(DefenderWeaponInterval == AttackerWeaponInterval)
//{
// // 如果攻击间隔相等则随机决定先手
// int TmpInt = Random.Range(1, 2);
// if(TmpInt == 1)
// {
// DefenderWeaponInterval -= 0.01f;
// }
// else
// {
// AttackerWeaponInterval -= 0.01f;
// }
//}
//
//float DefenderAttackRemain = DefenderWeaponInterval;
//float AttackerAttackRemain = AttackerWeaponInterval;
//
//float MinimumInterval = 0.0f;
//
//if(DefenderWeaponInterval < AttackerWeaponInterval)
//{
// MinimumInterval = DefenderWeaponInterval;
// DefenderAttackRemain -= DefenderWeaponInterval;
// AttackerAttackRemain -= DefenderWeaponInterval;
//}
//else
//{
// MinimumInterval = AttackerWeaponInterval;
// DefenderAttackRemain -= AttackerWeaponInterval;
// AttackerAttackRemain -= AttackerWeaponInterval;
//}
//
//int DefenderAttackSum = DefenderUnitArray.Count;
//int AttackerAttackSum = AttackerUnitArray.Count;
//
//int DealerAttackDiff = 0;
//int ReceiverAttackDiff = 0;
//
//while (DefenderAttackCount < DefenderAttackSum || AttackerAttackCount < AttackerAttackSum)
//{
// if(GetAliveUnitNum(DefenderUnitArray) == 0 || GetAliveUnitNum(AttackerUnitArray) == 0)
// {
// break;
// }
//
// DealerAttackDiff = 0;
// ReceiverAttackDiff = 0;
//
// if (DefenderAttackRemain <= 0.0f && AttackerAttackRemain > 0.0f)
// {
//
// // 防御方的一个攻击次数最少的单位攻击随机的进攻方单位
// ExcuteOneAttack(DefenderUnitArray, AttackerUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 AttackerAttackSum 需要-1
// DefenderAttackSum -= DealerAttackDiff;
// AttackerAttackSum -= ReceiverAttackDiff;
//
// DefenderAttackCount++;
// DefenderAttackRemain = DefenderWeaponInterval;
//
//
// if (AttackerAttackRemain <= MinimumInterval)
// {
// DefenderAttackRemain -= AttackerAttackRemain;
// AttackerAttackRemain = 0.0f;
// }
// else
// {
// AttackerAttackRemain -= MinimumInterval;
// DefenderAttackRemain -= MinimumInterval;
// }
// }
// else if(AttackerAttackRemain <= 0.0f && DefenderAttackRemain > 0.0f)
// {
// // 进攻方的一个攻击次数最少的单位攻击随机的防守方单位
// ExcuteOneAttack(AttackerUnitArray, DefenderUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 DefenderAttackSum 需要-1
// DefenderAttackSum -= ReceiverAttackDiff;
// AttackerAttackSum -= DealerAttackDiff;
//
// AttackerAttackCount++;
// AttackerAttackRemain = AttackerWeaponInterval;
//
// if(DefenderAttackRemain <= MinimumInterval)
// {
// AttackerAttackRemain -= DefenderAttackRemain;
// DefenderAttackRemain = 0.0f;
// }
// else
// {
// AttackerAttackRemain -= MinimumInterval;
// DefenderAttackRemain -= MinimumInterval;
// }
// }
// else if(DefenderAttackRemain <= 0.0f && AttackerAttackRemain <= 0.0f)
// {
// if(DefenderWeaponInterval > AttackerWeaponInterval)
// {
// // 进攻方的一个攻击次数最少的单位攻击随机的防守方单位
// ExcuteOneAttack(AttackerUnitArray, DefenderUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 DefenderAttackSum 需要-1
// DefenderAttackSum -= ReceiverAttackDiff;
// AttackerAttackSum -= DealerAttackDiff;
//
// AttackerAttackCount++;
//
// if (DefenderAttackCount >= DefenderAttackSum && AttackerAttackCount >= AttackerAttackSum) break;
// if (GetAliveUnitNum(DefenderUnitArray) == 0 || GetAliveUnitNum(AttackerUnitArray) == 0) break;
//
// // 防御方的一个攻击次数最少的单位攻击随机的进攻方单位
// ExcuteOneAttack(DefenderUnitArray, AttackerUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 AttackerAttackSum 需要-1
// DefenderAttackSum -= DealerAttackDiff;
// AttackerAttackSum -= ReceiverAttackDiff;
//
// DefenderAttackCount++;
// }
// else
// {
// // 防御方的一个攻击次数最少的单位攻击随机的进攻方单位
// ExcuteOneAttack(DefenderUnitArray, AttackerUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 AttackerAttackSum 需要-1
// DefenderAttackSum -= DealerAttackDiff;
// AttackerAttackSum -= ReceiverAttackDiff;
//
// DefenderAttackCount++;
//
// if (DefenderAttackCount >= DefenderAttackSum && AttackerAttackCount >= AttackerAttackSum) break;
// if (GetAliveUnitNum(DefenderUnitArray) == 0 || GetAliveUnitNum(AttackerUnitArray) == 0) break;
//
// // 进攻方的一个攻击次数最少的单位攻击随机的防守方单位
// ExcuteOneAttack(AttackerUnitArray, DefenderUnitArray, out DealerAttackDiff, out ReceiverAttackDiff);
// // 如果死亡的单位是一个未攻击过的单位则 DefenderAttackSum 需要-1
// DefenderAttackSum -= ReceiverAttackDiff;
// AttackerAttackSum -= DealerAttackDiff;
//
// AttackerAttackCount++;
// }
//
//
// AttackerAttackRemain = AttackerWeaponInterval;
// DefenderAttackRemain = DefenderWeaponInterval;
//
// }
//}
//DisplayUnitHealth(AttackerUnitArray);
// 5.根据战斗结果更新状态
//LocateChessBoard.GetComponent<ChessBoardStateController>().PieceDie(AttackTargetPiece.transform.parent.gameObject);
//Destroy(AttackTargetPiece.transform.parent.gameObject);
}
public override void ExcuteBattleOperation(Unit ExecuteUnit, BattleInfoSet ParaBattleInfoSet, BattleSequence ParaBattleSequence)
{
// 先锁定若干攻击单位
for (int i = 0; i < TargetNum; i++)
{
// 将武器使用单位传入根据单位所有者来寻找敌对单位
// 将武器本身引用传入是要根据武器的目标筛选标旗来选择合适的攻击单位类型
if (ParaBattleInfoSet == null)
{
Debug.Log("ParaBattleInfoSet");
}
if (ExecuteUnit == null)
{
Debug.Log("ExecuteUnit");
}
List <UnitTypeInfo> EnemyUnitTypeList = ParaBattleInfoSet.FindAvaliableEnemyUnitTypes(ExecuteUnit, this);
if (EnemyUnitTypeList == null)
{
Debug.Log("EnemyUnitTypeList");
}
if (EnemyUnitTypeList.Count > 0)
{
// 使用武器的单位类型选择器先选择一个单位类型
UnitTypeInfo TargetUnitType = WeaponTargetUnitTypeSelector.ExecuteSingleSelection(EnemyUnitTypeList);
// 再使用武器的单位选择器选择一个攻击目标单位
Unit TargetUnit = WeaponTargetUnitSelector.ExecuteSingleSelection(TargetUnitType.GetContainUnit());
// 再对攻击单位执行若干次武器开火效果
for (int j = 0; j < MultipleAttacks; j++)
{
Debug.Log(ExecuteUnit.GetUnitOwner() + " attack " + TargetUnit.GetUnitOwner());
WeaponEffect.ExcuteEffect(ExecuteUnit, TargetUnit, ParaBattleInfoSet, ParaBattleSequence);
}
}
else
{
//此时没有敌方单位可以被攻击了
}
}
// 可以再添加先进行多重攻击再进行多目标锁定的攻击模式
}
