using vnxbqy.UI;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using LitJson;
|
using System;
|
|
//Arena 注册控制代码
|
public class ArenaManagerModel : ILModel<ArenaManagerModel>
|
{
|
private GActorPlayerBase.PlayerInfo info;
|
private float m_LastAttackTime;
|
private int m_ComAtkIndex;
|
private int recordDataMapId;
|
DungeonModel m_DungeonModel;
|
DungeonModel dungeonModel {
|
get {
|
return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
|
}
|
}
|
|
|
/// stage
|
public static readonly Vector3 leftBornPoint = new Vector3(4.9f, 0.2f, 3.5f);
|
static readonly Vector3 rightBornPoint = new Vector3(20f, 0.2f, 18.8f);
|
|
static readonly Vector3 initPoint = new Vector3(30f, 0.2f, 30f);
|
public int[] s_StepTimes = null;
|
|
static ILFightInfo fightInfo;
|
static ILPKStageType pkStageType;
|
public static GA_PlayerClient.PlayerInfo playerInfo;
|
static GA_ILClientPlayer opponentPlayer;
|
static GA_Player mirrorPlayer;
|
public static bool isMirrorFight { get; set; }
|
static uint roundWiner = 0;
|
static ILPKStage currentStage;
|
public DateTime dungeonEndTime;
|
public bool fightStart = false;
|
int[] _skills;
|
|
int RobotIndex = 0;
|
protected override void Init()
|
{
|
//ILClientPlayer 对手
|
ArenaManager.OnILPlayerResult += OnILPlayerResult;
|
ArenaManager.OnILInit += OnILInit;
|
ArenaManager.OnILPlayerInit += OnILPlayerInit;
|
ArenaManager.OnILPlayerReset += OnILPlayerReset;
|
ArenaManager.OnILPlayerDestroy += OnILPlayerDestroy;
|
ArenaManager.OnILPlayerUpdateAI += OnILPlayerUpdateAI;
|
ArenaManager.OnILPlayerUnit += OnILPlayerUnit;
|
ArenaManager.OnILPlayerRequestName += OnILPlayerRequestName;
|
ArenaManager.OnILPlayerHorse += OnILPlayerHorse;
|
ArenaManager.OnILPlayerSelect += OnILPlayerSelect;
|
ArenaManager.OnILPlayerUnSelect += OnILPlayerUnSelect;
|
ArenaManager.OnILPlayerSyncSuitEffect += OnILPlayerSyncSuitEffect;
|
ArenaManager.OnILPlayerClick += OnILPlayerClick;
|
ArenaManager.OnILPlayerSwitchHorse += OnILPlayerSwitchHorse;
|
ArenaManager.OnILPlayerPutonWing += OnILPlayerPutonWing;
|
ArenaManager.OnILPlayerPutonWeapon += OnILPlayerPutonWeapon;
|
ArenaManager.OnILPlayerPutonSecondary += OnILPlayerPutonSecondary;
|
ArenaManager.OnILPlayerPutonClothes += OnILPlayerPutonClothes;
|
ArenaManager.OnILPlayerRefreshLifeBar += OnILPlayerRefreshLifeBar;
|
//Arena Stage控制
|
ArenaManager.OnILStageInitialize += OnILStageInitialize;
|
ArenaManager.OnILStageUnInitialize += OnILStageUnInitialize;
|
ArenaManager.OnILStageLoadFinish += OnILStageLoadFinish;
|
ArenaManager.OnILStageUpdate += OnILStageUpdate;
|
StageLoad.Instance.onStageLoadFinish += OnLoadMapFinish;
|
|
|
//hero behavior 本人
|
HeroBehaviour.OnStartHandupAI += OnILStartHandupAI;
|
HeroBehaviour.OnStopHandupAI += OnILStopHandupAI;
|
HeroBehaviour.onCastSkill += OnILCastSkill;
|
HeroBehaviour.OnUserClickSkill += OnILUserClickSkill;
|
//显示PK UI
|
ArenaManager.OnILPKWinShow += OnILPKWinShow;
|
|
}
|
protected override void UnInit()
|
{
|
//ILClientPlayer
|
ArenaManager.OnILPlayerResult -= OnILPlayerResult;
|
ArenaManager.OnILInit -= OnILInit;
|
ArenaManager.OnILPlayerInit -= OnILPlayerInit;
|
ArenaManager.OnILPlayerReset -= OnILPlayerReset;
|
ArenaManager.OnILPlayerDestroy -= OnILPlayerDestroy;
|
ArenaManager.OnILPlayerUpdateAI -= OnILPlayerUpdateAI;
|
ArenaManager.OnILPlayerUnit -= OnILPlayerUnit;
|
ArenaManager.OnILPlayerRequestName -= OnILPlayerRequestName;
|
ArenaManager.OnILPlayerHorse -= OnILPlayerHorse;
|
ArenaManager.OnILPlayerSelect -= OnILPlayerSelect;
|
ArenaManager.OnILPlayerUnSelect -= OnILPlayerUnSelect;
|
ArenaManager.OnILPlayerSyncSuitEffect -= OnILPlayerSyncSuitEffect;
|
ArenaManager.OnILPlayerClick -= OnILPlayerClick;
|
ArenaManager.OnILPlayerSwitchHorse -= OnILPlayerSwitchHorse;
|
ArenaManager.OnILPlayerPutonWing -= OnILPlayerPutonWing;
|
ArenaManager.OnILPlayerPutonWeapon -= OnILPlayerPutonWeapon;
|
ArenaManager.OnILPlayerPutonSecondary -= OnILPlayerPutonSecondary;
|
ArenaManager.OnILPlayerPutonClothes -= OnILPlayerPutonClothes;
|
ArenaManager.OnILPlayerRefreshLifeBar -= OnILPlayerRefreshLifeBar;
|
//Arena Stage控制
|
ArenaManager.OnILStageInitialize -= OnILStageInitialize;
|
ArenaManager.OnILStageUnInitialize -= OnILStageUnInitialize;
|
ArenaManager.OnILStageLoadFinish -= OnILStageLoadFinish;
|
ArenaManager.OnILStageUpdate -= OnILStageUpdate;
|
StageLoad.Instance.onStageLoadFinish -= OnLoadMapFinish;
|
|
//hero behavior
|
HeroBehaviour.OnStartHandupAI -= OnILStartHandupAI;
|
HeroBehaviour.OnStopHandupAI -= OnILStopHandupAI;
|
HeroBehaviour.onCastSkill -= OnILCastSkill;
|
HeroBehaviour.OnUserClickSkill -= OnILUserClickSkill;
|
|
//显示UI
|
ArenaManager.OnILPKWinShow -= OnILPKWinShow;
|
|
}
|
|
//关闭竞技场后重新打开UI
|
private void OnLoadMapFinish()
|
{
|
var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
|
if (recordDataMapId == ArenaManager.MapID && ArenaModel.Instance.bFirstStageLoadCheck)
|
{
|
WindowCenter.Instance.OpenIL<ArenaWin>();
|
ArenaModel.Instance.bFirstStageLoadCheck = false;
|
}
|
recordDataMapId = dataMapId;
|
}
|
|
//副本结算界面
|
public void UpdateFBEnd()
|
{
|
if (dungeonModel.dungeonResult.isWin == 1)
|
{
|
roundWiner = PlayerDatas.Instance.baseData.PlayerID;
|
}
|
else
|
{
|
roundWiner = ArenaModel.Instance.OPPONENT_PLAYERID;
|
}
|
//ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID,
|
// (byte)(dungeonModel.dungeonResult.isWin == 1 ? 1 : 2));
|
|
if (ArenaManager.IsArenaStage())
|
WindowCenter.Instance.OpenIL<ArenaSettlementWin>();
|
else
|
PopupWindowsProcessor.Instance.Add("ArenaSettlementWin");
|
//更新排名
|
ArenaRankModel.Instance.SetMyRank(ArenaModel.Instance.RankType, dungeonModel.dungeonResult.updOrder);
|
|
}
|
void OnILPKWinShow(bool bShow)
|
{
|
if (bShow)
|
{
|
WindowCenter.Instance.OpenIL<ArenaFightingPKWin>();
|
}
|
else
|
{
|
WindowCenter.Instance.CloseIL<ArenaFightingPKWin>();
|
}
|
}
|
void OnILStartHandupAI()
|
{
|
if (!ArenaManager.isArenaClient)
|
return;
|
//PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();
|
}
|
void OnILStopHandupAI()
|
{
|
if (!ArenaManager.IsArenaClientNotMirrorFight)
|
return;
|
PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();
|
}
|
void OnILCastSkill(int SkillID)
|
{
|
if (!ArenaManager.IsArenaClientNotMirrorFight)
|
return;
|
Skill _skill = PlayerDatas.Instance.hero.SkillMgr.Get(SkillID);
|
if (!_skill.IsValid())
|
return;
|
if (Skill.RefreshCD != null)
|
{
|
_skill.cd = _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA;
|
Skill.RefreshCD(_skill.id, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
|
}
|
}
|
|
void OnILUserClickSkill(int skill)
|
{
|
|
}
|
void OnILPlayerResult(bool winOrLose)
|
{
|
ArenaModel.Instance.WinnerID = winOrLose ? PlayerDatas.Instance.baseData.PlayerID : ArenaModel.Instance.OPPONENT_PLAYERID;
|
}
|
void OnILInit(uint serverInstID, uint clientInstID, GActorPlayerBase.PlayerInfo playerInfo, E_ActorGroup group)
|
{
|
info = playerInfo;
|
ArenaManager.iLClientPlayer.Init(serverInstID, clientInstID, group, null);
|
|
}
|
void OnILPlayerInit(GameNetPackBasic package)
|
{
|
CapsuleCollider _capCollider = ArenaManager.iLClientPlayer.Root.AddMissingComponent<CapsuleCollider>();
|
_capCollider.height = 1.2f;
|
_capCollider.center = new Vector3(0, .6f, 0);
|
_capCollider.radius = .4f;
|
|
Evt_PlayerClick _evtClick = ArenaManager.iLClientPlayer.Root.AddMissingComponent<Evt_PlayerClick>();
|
_evtClick.ownerSID = ArenaManager.iLClientPlayer.ServerInstID;
|
|
// 初始化坐标
|
ArenaManager.iLClientPlayer.AdjustPos(PlayerDatas.Instance.baseData.PosX, PlayerDatas.Instance.baseData.PosY);
|
|
ArenaManager.iLClientPlayer.ActorInfo.moveSpeed = 500f / 150;
|
ArenaManager.iLClientPlayer.ActorInfo.atkSpeed = 1;
|
|
ArenaManager.iLClientPlayer.JobSetup = JobSetupConfig.Get(info.job);
|
GActorPlayerBase.CEquipInfo _itemInfo;
|
if (info.itemDatas != null)
|
{
|
// 因为衣服是所有装备的父节点, 需要预先处理衣服
|
for (int i = 0; i < info.itemDatas.Length; ++i)
|
{
|
_itemInfo = info.itemDatas[i];
|
|
if (_itemInfo.place == (int)RoleEquipType.Clothes)
|
{
|
ArenaManager.iLClientPlayer.SwitchClothes((uint)_itemInfo.id);
|
break;
|
}
|
}
|
}
|
|
// 如果没有任何衣服, 则穿上默认装备
|
if (ArenaManager.iLClientPlayer.ClothesItemID == 0 || ArenaManager.iLClientPlayer.ClothesItemID == uint.MaxValue)
|
{
|
ArenaManager.iLClientPlayer.SwitchClothes(0);
|
}
|
|
if (info.itemDatas != null)
|
{
|
for (int i = 0; i < info.itemDatas.Length; ++i)
|
{
|
_itemInfo = info.itemDatas[i];
|
|
if (_itemInfo.place == (int)RoleEquipType.Weapon)
|
{
|
ArenaManager.iLClientPlayer.SwitchWeapon((uint)_itemInfo.id);
|
}
|
else if (_itemInfo.place == (int)RoleEquipType.Weapon2)
|
{
|
ArenaManager.iLClientPlayer.SwitchSecondary((uint)_itemInfo.id);
|
}
|
else if (_itemInfo.place == (int)RoleEquipType.Wing)
|
{
|
ArenaManager.iLClientPlayer.SwitchWing((uint)_itemInfo.id);
|
}
|
}
|
}
|
|
if (ArenaManager.iLClientPlayer.WeaponItemID == 0 || ArenaManager.iLClientPlayer.WeaponItemID == uint.MaxValue)
|
{
|
ArenaManager.iLClientPlayer.SwitchWeapon(0);
|
}
|
|
ArenaManager.iLClientPlayer.ActorInfo.Job = (byte)ArenaManager.iLClientPlayer.JobSetup.Job;
|
ArenaManager.iLClientPlayer.ActorInfo.PlayerName = info.name;
|
ArenaManager.iLClientPlayer.ActorInfo.MaxHp = info.hp;
|
ArenaManager.iLClientPlayer.ActorInfo.Hp = info.maxHp;
|
ArenaManager.iLClientPlayer.ActorInfo.LV = info.level;
|
int realmLv = 0;
|
if (info.playerID > 10000)
|
{
|
realmLv = ArenaManager.playInfo[1][32];
|
}
|
else
|
{
|
realmLv = ArenaModel.Instance.GetRealm(info.level);
|
}
|
ArenaManager.iLClientPlayer.ActorInfo.realm = (uint)realmLv;
|
|
_skills = ArenaManager.GetJobSkill(ArenaManager.iLClientPlayer.JobSetup.Job, info.level);
|
|
}
|
void OnILPlayerReset()
|
{
|
var _list = GAMgr.Instance.GetTypeList(E_ActorClassType.ILClientPlayer);
|
if (_list != null)
|
{
|
_list[0].ActorInfo.ResetHp((long)_list[0].ActorInfo.MaxHp);
|
_list[0].ActorInfo.serverDie = false;
|
_list[0].IdleImmediate();
|
}
|
|
PlayerDatas.Instance.FightRefreshPlayerHp(PlayerDatas.Instance.extersion.MaxHP);
|
PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)PlayerDatas.Instance.extersion.MaxHP);
|
PlayerDatas.Instance.hero.IdleImmediate();
|
}
|
void OnILPlayerDestroy()
|
{
|
|
}
|
void OnILPlayerUpdateAI()
|
{
|
if (!ArenaManager.IsArenaClientNotMirrorFight)
|
return;
|
if (Application.isEditor)
|
{
|
if(Input.GetKey(KeyCode.F5))
|
{
|
opponentPlayer.ActorInfo.Hp = 0;
|
}
|
|
if (Input.GetKey(KeyCode.F6))
|
{
|
PlayerDatas.Instance.hero.ActorInfo.Hp = 0;
|
}
|
}
|
|
if (!ArenaModel.Instance.bILAI)
|
return;
|
if (dungeonModel.dungeonFightStage != DungeonFightStage.Normal)
|
{
|
dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
|
return;
|
}
|
if (PlayerDatas.Instance.hero == null)
|
return;
|
|
ArenaManager.iLClientPlayer.SelectTarget = PlayerDatas.Instance.hero;
|
if (PlayerDatas.Instance.hero.ActorInfo.RealHp == 0)
|
PlayerDatas.Instance.hero.ActorInfo.serverDie = true;
|
if (ArenaManager.iLClientPlayer.SelectTarget == null || ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.serverDie)
|
{
|
return;
|
}
|
|
// 攻击间隔中
|
if (Time.time - m_LastAttackTime
|
< (1f / ArenaManager.iLClientPlayer.ActorInfo.atkSpeed) * .8f)
|
{
|
return;
|
}
|
|
Skill _skill = ArenaManager.iLClientPlayer.SkillMgr.CurCastSkill;
|
|
// 判断主角当前是否有技能尚未释放完毕
|
if (_skill != null)
|
{
|
if (!_skill.SkillCompelete)
|
{
|
return;
|
}
|
|
if (ArenaManager.iLClientPlayer.SkillMgr.DoingPrepareSkill)
|
{
|
return;
|
}
|
}
|
|
if (RobotIndex >= _skills.Length - 1)
|
RobotIndex = 0;
|
for (int i = RobotIndex; i < _skills.Length; ++i)
|
{
|
_skill = ArenaManager.iLClientPlayer.SkillMgr.Get(_skills[i]);
|
RobotIndex = i + 1;
|
if (_skill.IsValid())
|
{
|
_skill.cd = _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA;
|
//if (Skill.RefreshCD != null)
|
//{
|
// Skill.RefreshCD(_skill.id, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
|
//}
|
break;
|
}
|
else
|
{
|
_skill = null;
|
}
|
}
|
|
if (_skill == null)
|
{
|
if (m_ComAtkIndex > ArenaManager.iLClientPlayer.JobSetup.ComAtkIdList.Length - 1)
|
{
|
m_ComAtkIndex = 0;
|
}
|
int _comSkillId = ArenaManager.iLClientPlayer.JobSetup.ComAtkIdList[m_ComAtkIndex];
|
_skill = ArenaManager.iLClientPlayer.SkillMgr.Get(_comSkillId);
|
m_ComAtkIndex += 1;
|
}
|
|
// 判断技能范围, 不在可释放范围需要移动至目标
|
float _compareDist = _skill.skillInfo.config.AtkDist * .5f;
|
float _compareDistSqrt = _compareDist * _compareDist;
|
|
// 计算当前和目标的距离
|
float _currentDistSqrt = MathUtility.DistanceSqrtXZ(ArenaManager.iLClientPlayer.Pos, ArenaManager.iLClientPlayer.SelectTarget.Pos);
|
// 比较距离
|
if (_currentDistSqrt >= _compareDistSqrt)
|
{
|
// 移动至目标
|
ArenaManager.iLClientPlayer.MoveToTarget(ArenaManager.iLClientPlayer.SelectTarget, _compareDist, true);
|
|
return;
|
}
|
|
Vector3 _forward = MathUtility.ForwardXZ(ArenaManager.iLClientPlayer.SelectTarget.Pos, ArenaManager.iLClientPlayer.Pos);
|
ArenaManager.iLClientPlayer.destForward = ArenaManager.iLClientPlayer.Forward = _forward;
|
|
Vector3 _targetPosition = ArenaManager.iLClientPlayer.Pos + ArenaManager.iLClientPlayer.Forward * (_skill.skillInfo.config.AtkDist * .5f);
|
_targetPosition.y = 0;
|
UnityEngine.AI.NavMeshHit _navMeshHit;
|
if (UnityEngine.AI.NavMesh.Raycast(ArenaManager.iLClientPlayer.Pos, _targetPosition, out _navMeshHit, -1))
|
{
|
_targetPosition = _navMeshHit.position;
|
}
|
_targetPosition.y = ArenaManager.iLClientPlayer.Pos.y;
|
_skill.targetPosition = _targetPosition;
|
|
E_SkillCastType _castType = (E_SkillCastType)(_skill.skillInfo.config.Tag % 10);
|
if (_castType == E_SkillCastType.NeedTarget)
|
{
|
_skill.targetPosition = ArenaManager.iLClientPlayer.SelectTarget.Pos;
|
_skill.mainTarget = ArenaManager.iLClientPlayer.SelectTarget as GActorFight;
|
}
|
|
ArenaManager.iLClientPlayer.SkillMgr.CastSkill(ArenaManager.iLClientPlayer.ServerInstID, _skill.id);
|
|
if (_skill.skillInfo.config.Skillactmark > 0
|
&& _skill.skillInfo.config.Skillactmark < 20)
|
{
|
switch (_skill.skillInfo.config.Skillactmark)
|
{
|
case 10:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack1Hash, 0);
|
break;
|
case 11:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack2Hash, 0);
|
break;
|
case 12:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack3Hash, 0);
|
break;
|
case 13:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack4Hash, 0);
|
break;
|
}
|
|
}
|
else
|
{
|
switch (_skill.skillInfo.config.Skillactmark)
|
{
|
case 21:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill21, 0);
|
break;
|
case 22:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill22, 0);
|
break;
|
case 23:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill23, 0);
|
break;
|
case 24:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill24, 0);
|
break;
|
case 25:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill25, 0);
|
break;
|
case 26:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill26, 0);
|
break;
|
case 27:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill27, 0);
|
break;
|
case 28:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill28, 0);
|
break;
|
case 29:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill29, 0);
|
break;
|
case 99:
|
ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_RollHash, 0);
|
break;
|
}
|
}
|
|
ulong hurtValue = 0;
|
byte attackType = 0;
|
//本人伤害计算
|
AttackHandler.CalculateDamage(ArenaManager.iLClientPlayer, ArenaManager.iLClientPlayer.SelectTarget as GActorFight, _skill, 0, ref hurtValue, ref attackType);
|
|
ulong _hp = ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.Hp;
|
|
if (_hp < hurtValue)
|
{
|
hurtValue = _hp;
|
_hp = 0;
|
}
|
else
|
{
|
_hp = _hp - hurtValue;
|
}
|
|
AttackHandler.HurtObjs _hurtObject = new AttackHandler.HurtObjs
|
{
|
AttackType = attackType,
|
clientInstID = ArenaManager.iLClientPlayer.SelectTarget.ClientInstID,
|
CurHP = _hp,
|
RealHurtHP = hurtValue,
|
HurtHP = hurtValue,
|
ObjID = ArenaManager.iLClientPlayer.SelectTarget.ServerInstID,
|
ObjType = (byte)ArenaManager.iLClientPlayer.SelectTarget.ActorType
|
};
|
|
_skill.hurtClientList.Add(_hurtObject);
|
ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.SyncServerHp = _hp;
|
m_LastAttackTime = Time.time;
|
|
}
|
void OnILPlayerUnit()
|
{
|
|
}
|
void OnILPlayerRequestName()
|
{
|
if (ArenaManager.iLClientPlayer.MovingState == E_MovingState.Ride)
|
{
|
ArenaManager.iLClientPlayer.m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, ArenaManager.iLClientPlayer.MP_Name1, 0, CameraController.Instance.CameraObject);
|
}
|
else
|
{
|
ArenaManager.iLClientPlayer.m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, ArenaManager.iLClientPlayer.MP_Name, 0, CameraController.Instance.CameraObject);
|
}
|
|
ArenaManager.iLClientPlayer.m_HeadUpName.SetPlayerInfo(new HeadUpName.PlayerInfo()
|
{
|
realm = ArenaManager.iLClientPlayer.ActorInfo.realm,
|
title = ArenaManager.iLClientPlayer.ActorInfo.titleID,
|
name = ArenaManager.iLClientPlayer.ActorInfo.PlayerName,
|
alliance = ArenaManager.iLClientPlayer.ActorInfo.familyName,
|
});
|
}
|
void OnILPlayerHorse(byte upOrDown)
|
{
|
|
}
|
|
void OnILPlayerSelect()
|
{
|
if (CanAtked())
|
{
|
SelectionManager.Request(SelectionManager.E_Type.Red, ArenaManager.iLClientPlayer);
|
}
|
else
|
{
|
SelectionManager.Request(SelectionManager.E_Type.Green, ArenaManager.iLClientPlayer);
|
}
|
|
if (GA_Player.s_OnSelected != null)
|
{
|
GA_Player.s_OnSelected(ArenaManager.iLClientPlayer.ServerInstID, true);
|
}
|
}
|
bool CanAtked()
|
{
|
return !ArenaManager.iLClientPlayer.ActorInfo.serverDie;
|
}
|
|
void OnILPlayerUnSelect()
|
{
|
|
}
|
void OnILPlayerSyncSuitEffect(bool onOrOff)
|
{
|
|
}
|
void OnILPlayerClick()
|
{
|
GA_Hero _hero = PlayerDatas.Instance.hero;
|
if (_hero == null)
|
{
|
return;
|
}
|
|
_hero.LockTarget = ArenaManager.iLClientPlayer;
|
_hero.SelectTarget = ArenaManager.iLClientPlayer;
|
}
|
|
void OnILPlayerSwitchHorse(uint horseID, GameObject horse)
|
{
|
|
}
|
void OnILPlayerPutonWing(uint wingItemID, GameObject wing)
|
{
|
SkinnedMeshRenderer _renderer = wing.GetComponentInChildren<SkinnedMeshRenderer>();
|
_renderer.gameObject.SetLayer(LayerUtility.Player, false);
|
}
|
void OnILPlayerPutonWeapon(uint weaponItemID, GameObject weapon)
|
{
|
Renderer _renderer = weapon.GetComponentInChildren<Renderer>();
|
_renderer.gameObject.SetLayer(LayerUtility.Player, false);
|
}
|
void OnILPlayerPutonSecondary(uint secondaryItemID, GameObject secondary)
|
{
|
Renderer _renderer = secondary.GetComponentInChildren<Renderer>();
|
_renderer.gameObject.SetLayer(LayerUtility.Player, false);
|
}
|
void OnILPlayerPutonClothes(uint clothesItemID, GameObject clothed)
|
{
|
clothed.layer = LayerUtility.Player;
|
SkinnedMeshRenderer _renderer = clothed.GetComponentInChildren<SkinnedMeshRenderer>();
|
_renderer.gameObject.SetLayer(LayerUtility.Player, false);
|
}
|
void OnILPlayerRefreshLifeBar(ulong value)
|
{
|
if (ArenaManager.iLClientPlayer.ActorInfo.serverDie)
|
return;
|
GA_Hero _hero = PlayerDatas.Instance.hero;
|
if (_hero != null && _hero.SelectTarget == ArenaManager.iLClientPlayer)
|
{
|
if (GA_Player.s_OnRefreshLife != null)
|
{
|
GA_Player.s_OnRefreshLife(ArenaManager.iLClientPlayer.ServerInstID, ArenaManager.iLClientPlayer.ActorInfo.RealHp, ArenaManager.iLClientPlayer.ActorInfo.RealMaxHp);
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////Arena Stage控制///////////////////////////////////////////////////////////////
|
void OnILStageInitialize()
|
{
|
ArenaModel.Instance.FakeMatchOk();
|
fightInfo = default(ILFightInfo);
|
fightInfo.isOver = false;
|
fightInfo.roundWinnerIds = new List<uint>();
|
currentStage = null;
|
}
|
void OnILStageUnInitialize()
|
{
|
fightInfo = default(ILFightInfo);
|
roundWiner = 0;
|
currentStage = null;
|
ArenaManager.isArenaClient = false;
|
if (opponentPlayer != null)
|
{
|
opponentPlayer.Destroy();
|
opponentPlayer = null;
|
}
|
|
ArenaManager.isArenaPK = false;
|
ArenaManagerModel.Instance.ReleasePlayer();
|
ClientDungeonStageUtility.SetClientDungeon(false, 0);
|
PlayerDatas.Instance.extersion.pkState = 0;
|
ModelCenter.Instance.GetModel<DungeonModel>().ResetBufData();
|
PersonalEnemy.ReleaseAll();
|
PlayerDatas.Instance.baseData.MapID = PlayerDatas.Instance.baseData.mainServerMapIdRecord;
|
}
|
public void OnILStageLoadFinish()
|
{
|
if (!ArenaManager.IsArenaStage())
|
return;
|
ArenaManager.isArenaPK = true;
|
|
ArenaManager.isArenaClient = true;
|
ArenaModel.Instance.IsArenaWork = true;
|
recordDataMapId = ArenaManager.MapID;
|
ArenaModel.Instance.StartInit();
|
pkStageType = ILPKStageType.WaitStart;
|
|
// B2 10 竞技场挑战玩家 通知后端登记挑战目标ID
|
uint PlayerID = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID;
|
if (PlayerID > 10000)
|
isMirrorFight = true;
|
ArenaModel.Instance.SendArenaBattle(PlayerID, 0);
|
|
|
if (opponentPlayer != null)
|
{
|
PersonalEnemy.ReleaseILPlayer(opponentPlayer, false);
|
opponentPlayer = null;
|
}
|
|
|
|
//Debug.Log("s_StepTimes" + s_StepTimes[0] + " " + s_StepTimes[1] + " " + s_StepTimes[2]);
|
//创建对手
|
var job = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].Job;
|
var playerName = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerName;
|
var level = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].LV; //等级
|
var maxHp = ArenaModel.Instance.GetLevel(level, 1); //hp
|
var scoreClass = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].RealmLV; //大境界，
|
|
|
|
if (PlayerID < 10000) //大于10000 真人，小于10000 机器人，读配表
|
{
|
ArenaManager.isArenaRobot = true;
|
//机器人读境界表取等级对应大境界
|
scoreClass = (ushort)ArenaModel.Instance.GetRealmLarge(level);
|
|
playerInfo = GetRobotPlayerInfo(scoreClass, job, playerName, level, (ulong)maxHp);
|
playerInfo.playerID = PlayerID;
|
PersonalEnemy.Create(30000, rightBornPoint, playerInfo,false);
|
PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
|
SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
|
}
|
else
|
{
|
ArenaManager.isArenaRobot = false;
|
//发送命令获得个人详细信息
|
PersonalEnemy.OnMirrorPlayerAppear += OnPlayerAppear;
|
//RoleParticularModel.OnRevPackage += OnRevA705;
|
//ModelCenter.Instance.GetModel<RoleParticularModel>().ViewPlayerCacheData((int)PlayerID, (int)ViewPlayerType.viewPlayerDataArena);
|
}
|
}
|
//private void OnRevA705(int viewType, int playerID, RoleParticularModel.ViewPlayerData data)
|
//{
|
// uint PlayerID = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID;
|
// if (playerID != PlayerID)
|
// return;
|
// RoleParticularModel.OnRevPackage -= OnRevA705;
|
// playerInfo = GetRealPlayerInfo(data.rolePropData);
|
// playerInfo.playerID = PlayerID;
|
// //PersonalEnemy.Create(30000, rightBornPoint, playerInfo,false);
|
// PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
|
// SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
|
// ArenaModel.Instance.CallUpdatePKInfo(1);
|
|
//}
|
|
private void OnPlayerAppear(GA_ILClientPlayer player)
|
{
|
PersonalEnemy.OnILPlayerAppear -= OnPlayerAppear;
|
opponentPlayer = player;
|
opponentPlayer.Pos = rightBornPoint;
|
isMirrorFight = false;
|
dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
|
}
|
|
private void OnPlayerAppear(GA_Player player)
|
{
|
if (pkStageType != ILPKStageType.Fight)
|
{
|
currentStage = new ILWaitStartStage();
|
currentStage.Begin();
|
}
|
playerInfo = new GA_PlayerClient.PlayerInfo()
|
{
|
maxHp = player.ActorInfo.MaxHp,
|
hp = player.ActorInfo.Hp,
|
level = (ushort)player.ActorInfo.LV,
|
job = (byte)player.ActorInfo.Job,
|
face = AvatarHelper.GetAvatarDefaultID(player.ActorInfo.Job),
|
facePic = AvatarHelper.GetAvatarFrameDefaultID(player.ActorInfo.Job),
|
pos = Vector3.zero,
|
name = player.ActorInfo.PlayerName,
|
};
|
|
playerInfo.playerID = player.ActorInfo.sid;
|
ArenaModel.Instance.ArenaPKUpInfoData.MaxProDef = (int)player.ActorInfo.maxProDef;
|
ArenaModel.Instance.ArenaPKUpInfoData.opponentMaxHp = playerInfo.maxHp;
|
ArenaModel.Instance.ArenaPKUpInfoData.opponentShield = (int)player.ActorInfo.curProDef;
|
ArenaModel.Instance.ArenaPKUpInfoData.opponentLevel = player.ActorInfo.LV;
|
ArenaModel.Instance.ArenaPKUpInfoData.realmLV = (int)player.ActorInfo.realm;
|
|
PersonalEnemy.OnMirrorPlayerAppear -= OnPlayerAppear;
|
mirrorPlayer = player;
|
ArenaModel.Instance.CallUpdatePKInfo(1);
|
dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
|
|
}
|
|
public void ReleasePlayer()
|
{
|
if (opponentPlayer != null && !opponentPlayer.ActorInfo.serverDie)
|
{
|
PersonalEnemy.ReleaseILPlayer(opponentPlayer, false);
|
opponentPlayer = null;
|
}
|
}
|
public void GetRobotViewPlayerData(RankPageData m_pageData, out RoleParticularModel.ViewPlayerData m_ViewPlayerData)
|
{
|
m_ViewPlayerData = new RoleParticularModel.ViewPlayerData();
|
m_ViewPlayerData.getTime = DateTime.Now;
|
m_ViewPlayerData.rolePlusData = new RoleParticularModel.RolePlusData();
|
m_ViewPlayerData.rolePlusData = new RoleParticularModel.RolePlusData();
|
|
int level = (int)m_pageData.value2;
|
int job = m_pageData.subType;
|
int realm = ArenaModel.Instance.GetRealm(level);
|
m_ViewPlayerData.rolePropData.Name = ArenaModel.Instance.RobotName;
|
m_ViewPlayerData.rolePropData.LV = level;
|
m_ViewPlayerData.rolePropData.RealmLV = realm;
|
m_ViewPlayerData.rolePropData.MaxHP = ArenaModel.Instance.GetLevel(level, 1); //hp
|
m_ViewPlayerData.rolePropData.FightPower = ArenaModel.Instance.GetLevel(level, 2); //fight
|
m_ViewPlayerData.rolePropData.Job = job;
|
//此处用竞技场机器人配置表
|
int realmlarge = ArenaModel.Instance.GetRealmLarge(level);
|
var config = ArenaRobotConfig.GetRandomRobotConfig(realmlarge);
|
var jsonData = JsonMapper.ToObject(config.equips);
|
|
|
if (jsonData.Keys.Contains(job.ToString()))
|
{
|
var equipJson = jsonData[job.ToString()];
|
m_ViewPlayerData.rolePropData.EquipShowID = new int[equipJson.Count];
|
for (var i = 0; i < equipJson.Count; i++)
|
{
|
m_ViewPlayerData.rolePropData.EquipShowID[i] = (int)equipJson[i];
|
}
|
}
|
|
}
|
//AtkFightPower 挑战方战力，DefFightPower防守方战力
|
float GetFightPowerRate(ulong AtkFightPower, ulong DefFightPower)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue("AtkFightPower", AtkFightPower);
|
Equation.Instance.AddKeyValue("DefFightPower", DefFightPower);
|
var funcConfig = FuncConfigConfig.Get("ArenaLVSet");
|
string formula = funcConfig.Numerical4;
|
return Equation.Instance.Eval<float>(formula);
|
}
|
GA_PlayerClient.PlayerInfo GetRobotPlayerInfo(int scoreClass, int job, string playerName, int level, ulong maxHp)
|
{
|
//此处用竞技场机器人配置表
|
var config = ArenaRobotConfig.GetRandomRobotConfig(scoreClass);
|
var jsonData = JsonMapper.ToObject(config.equips);
|
var equipItems = new List<int>();
|
if (jsonData.Keys.Contains(job.ToString()))
|
{
|
var equipJson = jsonData[job.ToString()];
|
for (var i = 0; i < equipJson.Count; i++)
|
{
|
equipItems.Add((int)equipJson[i]);
|
}
|
}
|
|
var equipInfos = new GA_PlayerClient.CEquipInfo[equipItems.Count];
|
for (int i = 0; i < equipInfos.Length; i++)
|
{
|
var equipInfo = new GA_PlayerClient.CEquipInfo();
|
var itemConfig = ItemConfig.Get(equipItems[i]);
|
equipInfo.id = itemConfig.ID;
|
equipInfo.place = itemConfig.EquipPlace;
|
equipInfos[i] = equipInfo;
|
}
|
|
var playerInfo = new GA_PlayerClient.PlayerInfo()
|
{
|
maxHp = maxHp,
|
hp = maxHp,
|
level = (ushort)level,
|
job = (byte)job,
|
face = AvatarHelper.GetAvatarDefaultID(job),
|
facePic = AvatarHelper.GetAvatarFrameDefaultID(job),
|
pos = Vector3.zero,
|
name = playerName,
|
itemDatas = equipInfos,
|
};
|
|
ulong AtkFightPower = PlayerDatas.Instance.baseData.FightPoint;// 挑战方战力，
|
ulong DefFightPower = (ulong)ArenaModel.Instance.GetLevel(level, 2); //防守方战力
|
//fight rate
|
float rate = GetFightPowerRate(AtkFightPower, DefFightPower);
|
Debug.Log("守护者 GetFightPowerRate:" + rate+ " AtkFightPower:"+ AtkFightPower+ " DefFightPower:"+ DefFightPower);
|
ArenaManager.playInfo[0][0] = (int)(ArenaRobotLVConfig.Get(level).ReMinAtk * rate);
|
ArenaManager.playInfo[0][1] = (int)(ArenaRobotLVConfig.Get(level).ReMaxAtk * rate);
|
ArenaManager.playInfo[0][2] = (int)(ArenaRobotLVConfig.Get(level).ReDef * rate);
|
ArenaManager.playInfo[0][4] = (int)(ArenaRobotLVConfig.Get(level).ReMiss * rate);
|
ArenaManager.playInfo[0][3] = (int)(ArenaRobotLVConfig.Get(level).ReHit * rate);
|
|
return playerInfo;
|
}
|
GA_PlayerClient.PlayerInfo GetRealPlayerInfo(RoleParticularModel.RolePropData propData)
|
{
|
var equipInfos = new GA_PlayerClient.CEquipInfo[propData.EquipShowID.Length];
|
for (int i = 0; i < equipInfos.Length; i++)
|
{
|
var equipInfo = new GA_PlayerClient.CEquipInfo();
|
var itemConfig = ItemConfig.Get(propData.EquipShowID[i]);
|
equipInfo.id = itemConfig.ID;
|
equipInfo.place = itemConfig.EquipPlace;
|
equipInfos[i] = equipInfo;
|
}
|
|
var playerInfo = new GA_PlayerClient.PlayerInfo()
|
{
|
maxHp = (ulong)propData.MaxHP,
|
hp = (ulong)propData.MaxHP,
|
level = (ushort)propData.LV,
|
job = (byte)propData.Job,
|
face = (int)propData.Face,
|
facePic = (int)propData.FacePic,
|
pos = Vector3.zero,
|
name = propData.Name,
|
itemDatas = equipInfos,
|
};
|
ulong AtkFightPower = PlayerDatas.Instance.baseData.FightPoint;// 挑战方战力，
|
ulong DefFightPower = (ulong)propData.FightPower; //防守方战力
|
//fight rate
|
float rate = GetFightPowerRate(AtkFightPower, DefFightPower);
|
Debug.Log("玩家机器人 GetFightPowerRate:" + rate + " AtkFightPower:" + AtkFightPower + " DefFightPower:" + DefFightPower);
|
ArenaManager.playInfo[1][0] = (int)(propData.MinAtk * rate);
|
ArenaManager.playInfo[1][1] = (int)(propData.MaxAtk * rate);
|
ArenaManager.playInfo[1][2] = (int)(propData.Def * rate);
|
ArenaManager.playInfo[1][3] = (int)(propData.Hit * rate);
|
ArenaManager.playInfo[1][4] = (int)(propData.Miss * rate);
|
ArenaManager.playInfo[1][5] = (int)(propData.SkillAtkRate * rate); // 技能攻击比例加成
|
ArenaManager.playInfo[1][6] = (int)(propData.SkillAtkRateReduce * rate); // 技能攻击比例减少
|
ArenaManager.playInfo[1][7] = (int)(propData.LuckyHitRate * rate); // 会心一击几率
|
ArenaManager.playInfo[1][8] = (int)(propData.LuckyHitVal * rate); // 会心一击伤害固定值
|
ArenaManager.playInfo[1][9] = (int)(propData.LuckyHitRateReduce * rate); // 会心一击概率抗性
|
ArenaManager.playInfo[1][10] = (int)(propData.LuckyHitReduce * rate); // 会心一击伤害减免固定值
|
ArenaManager.playInfo[1][11] = (int)(propData.SuperHitRate * rate); // 暴击概率
|
ArenaManager.playInfo[1][12] = (int)(propData.SuperHit * rate); // 暴击伤害固定值
|
ArenaManager.playInfo[1][13] = (int)(propData.SuperHitRateReduce * rate); // 暴击概率抗性
|
ArenaManager.playInfo[1][14] = (int)(propData.SuperHitReduce * rate); // 暴击伤害抗性固定值
|
ArenaManager.playInfo[1][15] = (int)(propData.IceAtk * rate); // 真实伤害 固定值
|
ArenaManager.playInfo[1][16] = (int)(propData.IceDef * rate); // 真实伤害防御 固定值
|
ArenaManager.playInfo[1][17] = (int)(propData.IgnoreDefRate * rate); // 无视防御几率
|
ArenaManager.playInfo[1][18] = (int)(propData.IgnoreDefRateReduce * rate); // 无视防御概率抗性
|
ArenaManager.playInfo[1][19] = (int)(propData.IgnoreDefReducePer * rate); // 无视防御伤害减免
|
ArenaManager.playInfo[1][20] = (int)(propData.DamagePVE * rate); //伤害输出计算固定值PVE
|
ArenaManager.playInfo[1][21] = (int)(propData.DamagePerPVP * rate); // 伤害输出计算百分比PVP
|
ArenaManager.playInfo[1][22] = (int)(propData.DamagePerPVPReduce * rate); //伤害输出计算百分比PVP减少
|
ArenaManager.playInfo[1][23] = (int)(propData.DamagePVP * rate); // PVP固定伤害
|
ArenaManager.playInfo[1][24] = (int)(propData.DamagePVPReduce * rate); // PVP固定减伤
|
ArenaManager.playInfo[1][25] = (int)(propData.FinalHurt * rate); // 最终固定伤害增加
|
ArenaManager.playInfo[1][26] = (int)(propData.FinalHurtReduce * rate); // 最终固定伤害减少
|
ArenaManager.playInfo[1][27] = (int)(propData.FinalHurtPer * rate); // 最终伤害百分比
|
ArenaManager.playInfo[1][28] = (int)(propData.FinalHurtReducePer * rate); // 最终伤害减少百分比
|
ArenaManager.playInfo[1][29] = (int)(propData.OnlyFinalHurt * rate); // 额外输出伤害
|
ArenaManager.playInfo[1][30] = (int)(propData.DamChanceDef * rate); // 20%的概率抵御伤害比率
|
ArenaManager.playInfo[1][31] = (int)(propData.NPCHurtAddPer * rate); // 对怪物伤害加成
|
ArenaManager.playInfo[1][32] = (int)(propData.RealmLV); // 境界
|
|
// ArenaManager.playInfo[1][32] = (int)(propData.AtkBackHPPer * rate); //攻击回复血量固定值
|
// ArenaManager.playInfo[1][33] = (int)(propData.PVPAtkBackHP * rate); //PVP攻击回血
|
// ArenaManager.playInfo[1][34] = (int)(propData.FaintRate * rate); //击晕概率
|
// ArenaManager.playInfo[1][35] = (int)(propData.FaintDefRate * rate); //击晕抵抗概率
|
|
return playerInfo;
|
}
|
private IEnumerator WaitForPlayerCreate()
|
{
|
while (opponentPlayer == null)
|
{
|
yield return null;
|
}
|
|
if (pkStageType != ILPKStageType.Fight)
|
{
|
opponentPlayer.Pos = rightBornPoint;
|
currentStage = new ILWaitStartStage();
|
currentStage.Begin();
|
}
|
}
|
void OnILStageUpdate()
|
{
|
if (currentStage != null)
|
{
|
currentStage.Update();
|
if (currentStage.completed)
|
{
|
currentStage.End();
|
switch (pkStageType)
|
{
|
case ILPKStageType.WaitStart:
|
currentStage = new ILFightStage();
|
break;
|
case ILPKStageType.Fight:
|
currentStage = new ILFightOverStage();
|
break;
|
case ILPKStageType.FightOver:
|
currentStage = null;
|
break;
|
default:
|
break;
|
}
|
|
if (currentStage != null)
|
{
|
currentStage.Begin();
|
}
|
}
|
}
|
}
|
|
public abstract class ILPKStage
|
{
|
public float timer { get; protected set; }
|
public float duration { get; protected set; }
|
public bool completed { get; protected set; }
|
|
public abstract void Begin();
|
public abstract void Update();
|
public abstract void End();
|
}
|
|
public class ILWaitStartStage : ILPKStage
|
{
|
public override void Begin()
|
{
|
pkStageType = ILPKStageType.WaitStart;
|
duration = ArenaManagerModel.Instance.s_StepTimes[1];
|
|
if (opponentPlayer != null)
|
{
|
opponentPlayer.ActorInfo.serverDie = false;
|
opponentPlayer.IdleImmediate();
|
opponentPlayer.Pos = rightBornPoint;
|
}
|
|
PlayerDatas.Instance.baseData.HP = PlayerDatas.Instance.extersion.MaxHP;
|
var maxHp = PlayerDatas.Instance.extersion.MaxHP;
|
PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)maxHp, (long)maxHp);
|
PlayerDatas.Instance.FightRefreshPlayerHp(maxHp);
|
PlayerDatas.Instance.hero.IdleImmediate();
|
PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
|
PlayerDatas.Instance.hero.StopPathFind();
|
|
|
PlayerDatas.Instance.hero.Pos = leftBornPoint;
|
ArenaModel.Instance.FakeWaitFight((int)duration);
|
|
ArenaModel.Instance.CallUpdatePKInfo(1);
|
}
|
|
public override void End()
|
{
|
fightInfo.roundCount++;
|
ArenaModel.Instance.FakeRoundBegin(fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
|
}
|
|
public override void Update()
|
{
|
timer += Time.deltaTime;
|
if (isMirrorFight)
|
completed = timer >= duration;
|
else
|
completed = timer >= duration && opponentPlayer != null;
|
}
|
}
|
public class ILFightOverStage : ILPKStage
|
{
|
public override void Begin()
|
{
|
if (ArenaModel.Instance.WinnerID != PlayerDatas.Instance.baseData.PlayerID)
|
{
|
if (!isMirrorFight)
|
ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID, 2);
|
LocalSave.SetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId, "");
|
}
|
else
|
{
|
if (!isMirrorFight)
|
ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID, 1);
|
string MatchInfoPlayerFightNow = LocalSave.GetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId);
|
if(MatchInfoPlayerFightNow != "")
|
{
|
string inputString = LocalSave.GetString("MatchInfoPlayerFight" + PlayerDatas.Instance.PlayerId);
|
inputString = StringUtility.Contact(inputString, "|", MatchInfoPlayerFightNow);
|
LocalSave.SetString("MatchInfoPlayerFight" + PlayerDatas.Instance.PlayerId, inputString);
|
LocalSave.SetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId,"");
|
}
|
}
|
|
pkStageType = ILPKStageType.FightOver;
|
duration = ArenaManagerModel.Instance.s_StepTimes[2];
|
|
ArenaModel.Instance.FakeDungeonExit((int)duration);
|
}
|
|
public override void End()
|
{
|
if (ArenaManager.isArenaClient)
|
{
|
ArenaModel.Instance.StopClientArena();
|
}
|
WindowCenter.Instance.CloseIL<ArenaSettlementWin>();
|
}
|
|
public override void Update()
|
{
|
timer += Time.deltaTime;
|
completed = timer >= duration;
|
}
|
|
}
|
public class ILFightStage : ILPKStage
|
{
|
bool figthCompleted = false;
|
float restTime = 0.5f;
|
float restTimeTimer = 0f;
|
|
public override void Begin()
|
{
|
pkStageType = ILPKStageType.Fight;
|
duration = ArenaManagerModel.Instance.s_StepTimes[0];
|
roundWiner = 0;
|
figthCompleted = false;
|
restTimeTimer = 0f;
|
|
if (isMirrorFight)
|
{
|
if (mirrorPlayer != null)
|
PlayerDatas.Instance.hero.SelectTarget = mirrorPlayer;
|
}
|
else
|
{
|
opponentPlayer.Pos = rightBornPoint;
|
opponentPlayer.SelectTarget = PlayerDatas.Instance.hero;
|
PlayerDatas.Instance.hero.SelectTarget = opponentPlayer;
|
}
|
ArenaModel.Instance.bILAI = true;
|
PlayerDatas.Instance.hero.Behaviour.StartHandupAI();
|
}
|
|
public override void End()
|
{
|
ArenaManagerModel.Instance.fightStart = false;
|
fightInfo.roundWinnerIds.Add(roundWiner);//记录获胜者的id
|
if (fightInfo.roundCount >= 1)
|
{
|
fightInfo.isOver = true;
|
}
|
|
if (fightInfo.isOver)
|
{
|
if (opponentPlayer != null)
|
{
|
PersonalEnemy.ReleaseILPlayer(opponentPlayer,false);
|
opponentPlayer.Destroy();
|
}
|
}
|
|
ArenaModel.Instance.FakeRoundEnd(fightInfo.isOver, fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
|
}
|
|
public override void Update()
|
{
|
if (!ArenaManagerModel.Instance.fightStart)
|
return;
|
if (PlayerDatas.Instance.hero == null)
|
return;
|
|
timer += Time.deltaTime;
|
|
|
if (isMirrorFight)
|
{
|
if (roundWiner != 0)
|
{
|
figthCompleted = true;
|
ArenaModel.Instance.WinnerID = roundWiner;
|
}
|
}
|
else
|
{
|
if (PlayerDatas.Instance.hero.ActorInfo.Hp <= 0)
|
{
|
figthCompleted = true;
|
roundWiner = ArenaModel.Instance.OPPONENT_PLAYERID;
|
ArenaModel.Instance.WinnerID = ArenaModel.Instance.OPPONENT_PLAYERID;
|
}
|
if (opponentPlayer.ActorInfo.Hp <= 0)
|
{
|
figthCompleted = true;
|
roundWiner = PlayerDatas.Instance.baseData.PlayerID;
|
ArenaModel.Instance.WinnerID = PlayerDatas.Instance.baseData.PlayerID;
|
}
|
}
|
if (!figthCompleted)
|
{
|
var surplus = ArenaManagerModel.Instance.dungeonEndTime - TimeUtility.ServerNow;
|
int EndTime = Mathf.CeilToInt((float)surplus.TotalSeconds);
|
|
if (roundWiner != 0)
|
{
|
figthCompleted = true;
|
}
|
else if (EndTime <= 0)
|
//else if (timer >= duration)
|
{
|
figthCompleted = true;
|
if (!isMirrorFight && opponentPlayer.ActorInfo.RealHp <= 0)
|
{
|
roundWiner = PlayerDatas.Instance.baseData.PlayerID;
|
}
|
else
|
{
|
roundWiner = ArenaModel.Instance.OPPONENT_PLAYERID;
|
}
|
ArenaModel.Instance.WinnerID = roundWiner;
|
}
|
else
|
{
|
figthCompleted = false;
|
}
|
}
|
|
if (figthCompleted)
|
{
|
PlayerDatas.Instance.hero.StopAll();
|
ArenaModel.Instance.bILAI = false;
|
restTimeTimer += Time.deltaTime;
|
completed = restTimeTimer >= restTime;
|
}
|
}
|
|
}
|
|
|
|
public enum ILPKStageType
|
{
|
WaitStart,
|
Fight,
|
FightOver,
|
}
|
|
public struct ILFightInfo
|
{
|
public int myBornPoint;
|
public bool isOver;
|
public int roundCount;
|
public List<uint> roundWinnerIds;
|
}
|
}
|
