VDH
1336 lines
37 KiB
C#
1336 lines
37 KiB
C#
|
|
using BrewMonster;
|
|
using BrewMonster.Managers;
|
|
using BrewMonster.Network;
|
|
using BrewMonster.Scripts.Managers;
|
|
using CSNetwork;
|
|
using CSNetwork.GPDataType;
|
|
using PerfectWorld.Scripts;
|
|
using PerfectWorld.Scripts.Managers;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
|
|
public static class AP
|
|
{
|
|
// AP events (from EC_PlayerWrapper.h anonymous enum)
|
|
public const int AP_EVENT_CANNOTMOVE = 0;
|
|
public const int AP_EVENT_MOVEFINISHED = 1;
|
|
public const int AP_EVENT_TRACEOK = 2;
|
|
public const int AP_EVENT_STARTSKILL = 3;
|
|
public const int AP_EVENT_STOPSKILL = 4;
|
|
public const int AP_EVENT_STARTUSEITEM = 5;
|
|
public const int AP_EVENT_STOPUSEITEM = 6;
|
|
public const int AP_EVENT_PICKUPOK = 7;
|
|
public const int AP_EVENT_CANNOTPICKUP = 8;
|
|
public const int AP_EVENT_STARTMELEE = 9;
|
|
public const int AP_EVENT_STOPMELEE = 10;
|
|
public const int AP_EVENT_COMBOCONTINUE = 11;
|
|
public const int AP_EVENT_COMBOFINISH = 12;
|
|
public const int AP_EVENT_MELEEOUTOFRANGE = 13;
|
|
|
|
// NOTE: C# doesn't have free functions; keep names, put into static class.
|
|
public static void AP_ActionEvent(int iEvent, int iParam = 0)
|
|
{
|
|
if (!CECAutoPolicy.GetInstance().IsAutoPolicyEnabled())
|
|
return;
|
|
|
|
var pWrapper = CECAutoPolicy.GetInstance().GetPlayerWrapper();
|
|
pWrapper?.OnActionEvent(iEvent, iParam);
|
|
}
|
|
|
|
public static string AP_GetActionName(int iAction)
|
|
{
|
|
return iAction switch
|
|
{
|
|
CECPlayerWrapper.ACTION_IDLE => "ACTION_IDLE",
|
|
CECPlayerWrapper.ACTION_MOVE => "ACTION_MOVE",
|
|
CECPlayerWrapper.ACTION_CASTSKILL => "ACTION_CASTSKILL",
|
|
CECPlayerWrapper.ACTION_USEITEM => "ACTION_USEITEM",
|
|
CECPlayerWrapper.ACTION_PICKUP => "ACTION_PICKUP",
|
|
CECPlayerWrapper.ACTION_COMBOSKILL => "ACTION_COMBOSKILL",
|
|
CECPlayerWrapper.ACTION_MELEE => "ACTION_MELEE",
|
|
_ => "Unknown",
|
|
};
|
|
}
|
|
|
|
public static string AP_GetEventName(int iEvent)
|
|
{
|
|
return iEvent switch
|
|
{
|
|
AP_EVENT_CANNOTMOVE => "AP_EVENT_CANNOTMOVE",
|
|
AP_EVENT_MOVEFINISHED => "AP_EVENT_MOVEFINISHED",
|
|
AP_EVENT_TRACEOK => "AP_EVENT_TRACEOK",
|
|
AP_EVENT_STARTSKILL => "AP_EVENT_STARTSKILL",
|
|
AP_EVENT_STOPSKILL => "AP_EVENT_STOPSKILL",
|
|
AP_EVENT_STARTUSEITEM => "AP_EVENT_STARTUSEITEM",
|
|
AP_EVENT_STOPUSEITEM => "AP_EVENT_STOPUSEITEM",
|
|
AP_EVENT_PICKUPOK => "AP_EVENT_PICKUPOK",
|
|
AP_EVENT_CANNOTPICKUP => "AP_EVENT_CANNOTPICKUP",
|
|
AP_EVENT_STARTMELEE => "AP_EVENT_STARTMELEE",
|
|
AP_EVENT_STOPMELEE => "AP_EVENT_STOPMELEE",
|
|
AP_EVENT_COMBOCONTINUE => "AP_EVENT_COMBOCONTINUE",
|
|
AP_EVENT_COMBOFINISH => "AP_EVENT_COMBOFINISH",
|
|
AP_EVENT_MELEEOUTOFRANGE => "AP_EVENT_MELEEOUTOFRANGE",
|
|
_ => "Unknown",
|
|
};
|
|
}
|
|
}
|
|
|
|
public class CECPlayerWrapper
|
|
{
|
|
// Actions (from EC_PlayerWrapper.h enum)
|
|
public const int ACTION_IDLE = 0;
|
|
public const int ACTION_MOVE = 1;
|
|
public const int ACTION_CASTSKILL = 2;
|
|
public const int ACTION_USEITEM = 3;
|
|
public const int ACTION_PICKUP = 4;
|
|
public const int ACTION_COMBOSKILL = 5;
|
|
public const int ACTION_MELEE = 6;
|
|
|
|
private const int MAX_ATTACK_ERROR = 3;
|
|
private const int INVALIDOBJ_TIMEOUT = 30000;
|
|
private const float MATTER_SEARCH_RANGE = 60.0f;
|
|
|
|
public struct DelayTask
|
|
{
|
|
public int iType;
|
|
public int iParam1;
|
|
public int iParam2;
|
|
|
|
public DelayTask(int _)
|
|
{
|
|
iType = ACTION_IDLE;
|
|
iParam1 = 0;
|
|
iParam2 = 0;
|
|
}
|
|
}
|
|
|
|
// ===== Base Action =====
|
|
public abstract class Action
|
|
{
|
|
protected readonly int type;
|
|
protected readonly CECPlayerWrapper host;
|
|
|
|
protected Action(CECPlayerWrapper pHost, int t)
|
|
{
|
|
host = pHost;
|
|
type = t;
|
|
}
|
|
|
|
public virtual bool StartAction() => true;
|
|
public virtual void EndAction() { }
|
|
|
|
// return true => action finished
|
|
public virtual bool Tick(uint dwDeltaTime) => false;
|
|
|
|
public virtual void OnEvent(int iEvent, int iParam) { }
|
|
|
|
public virtual bool CanBreak() => true;
|
|
|
|
public bool HaveNextAction() => host.m_Actions.Count > 0;
|
|
|
|
public int GetType() => type;
|
|
}
|
|
|
|
public delegate void ActionEventDelegate(int iEvent, int iParam);
|
|
|
|
// ===== Dependencies (keep original names/types; implement in your project) =====
|
|
protected CECHostPlayer m_pHost;
|
|
|
|
// ===== Runtime state =====
|
|
protected readonly LinkedList<Action> m_Actions = new();
|
|
protected Action m_pCurAction;
|
|
|
|
protected A3DVECTOR3 m_vOrigPos;
|
|
|
|
protected bool m_bForceAttack;
|
|
protected int m_iAttackErrCnt;
|
|
protected int m_iPickupErrCnt;
|
|
|
|
// invalid objects timeout map
|
|
protected readonly Dictionary<int, int> m_InvalidObj = new();
|
|
|
|
// monsters attacking me
|
|
protected readonly HashSet<int> m_MonsterAttackMe = new();
|
|
|
|
protected DelayTask m_DelayTask = new DelayTask(0);
|
|
|
|
// Keep accessors like C++ (AutoPolicy.Render reads these directly in C++)
|
|
public CECHostPlayer GetHostPlayer() => m_pHost;
|
|
|
|
public CECPlayerWrapper(CECHostPlayer pHost)
|
|
{
|
|
m_pHost = pHost;
|
|
m_pCurAction = null;
|
|
m_iAttackErrCnt = 0;
|
|
m_iPickupErrCnt = 0;
|
|
m_bForceAttack = false;
|
|
m_vOrigPos = m_pHost.GetPos();
|
|
}
|
|
|
|
public virtual void Tick(uint dwDeltaTime)
|
|
{
|
|
if (m_pCurAction != null)
|
|
{
|
|
if (m_pCurAction.Tick(dwDeltaTime))
|
|
{
|
|
EndCurAction();
|
|
StartAction();
|
|
}
|
|
}
|
|
|
|
if (m_DelayTask.iType != ACTION_IDLE)
|
|
ProcessDelayTask();
|
|
|
|
// decrement invalid timeouts
|
|
if (m_InvalidObj.Count > 0)
|
|
{
|
|
var toRemove = new List<int>();
|
|
foreach (var kv in m_InvalidObj)
|
|
{
|
|
int t = kv.Value - (int)dwDeltaTime;
|
|
if (t <= 0) toRemove.Add(kv.Key);
|
|
else m_InvalidObj[kv.Key] = t;
|
|
}
|
|
for (int i = 0; i < toRemove.Count; i++)
|
|
m_InvalidObj.Remove(toRemove[i]);
|
|
}
|
|
}
|
|
|
|
public void StopPolicy()
|
|
{
|
|
CECAutoPolicy.GetInstance().StopPolicy();
|
|
}
|
|
|
|
public void OnStopPolicy()
|
|
{
|
|
ClearAction();
|
|
m_bForceAttack = false;
|
|
m_iAttackErrCnt = 0;
|
|
m_iPickupErrCnt = 0;
|
|
m_InvalidObj.Clear();
|
|
m_MonsterAttackMe.Clear();
|
|
}
|
|
|
|
public bool HaveAction()
|
|
{
|
|
return m_pCurAction != null || m_Actions.Count > 0;
|
|
}
|
|
|
|
public bool AddIdleAction(int iTime)
|
|
{
|
|
AddAction(new IdleAction(this, iTime));
|
|
return StartAction();
|
|
}
|
|
|
|
protected bool AddAction(Action pAction)
|
|
{
|
|
if (pAction == null) return false;
|
|
if (m_pCurAction != null && m_pCurAction.GetType() == pAction.GetType())
|
|
return false;
|
|
|
|
for (var node = m_Actions.First; node != null; node = node.Next)
|
|
{
|
|
if (node.Value.GetType() == pAction.GetType())
|
|
return false;
|
|
}
|
|
|
|
m_Actions.AddLast(pAction);
|
|
return true;
|
|
}
|
|
|
|
protected bool StartAction()
|
|
{
|
|
if (m_pCurAction != null)
|
|
return true;
|
|
|
|
bool ret = false;
|
|
|
|
while (m_Actions.Count > 0)
|
|
{
|
|
m_pCurAction = m_Actions.First.Value;
|
|
m_Actions.RemoveFirst();
|
|
|
|
ret = m_pCurAction.StartAction();
|
|
if (ret) break;
|
|
|
|
EndCurAction(); // if StartAction failed, kill and try next
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
protected bool EndCurAction()
|
|
{
|
|
if (m_pCurAction == null)
|
|
return false;
|
|
|
|
m_pCurAction.EndAction();
|
|
m_pCurAction = null;
|
|
return true;
|
|
}
|
|
|
|
public void ClearAction()
|
|
{
|
|
if (m_pCurAction != null)
|
|
EndCurAction();
|
|
|
|
m_Actions.Clear();
|
|
}
|
|
|
|
private bool AddOneAction(int iActionType, int iParam = 0)
|
|
{
|
|
switch (iActionType)
|
|
{
|
|
case ACTION_MOVE: AddAction(new MoveAction(this)); break;
|
|
case ACTION_CASTSKILL: AddAction(new CastSkillAction(this)); break;
|
|
case ACTION_USEITEM: AddAction(new UseItemAction(this)); break;
|
|
case ACTION_PICKUP: AddAction(new PickupAction(this, iParam)); break;
|
|
case ACTION_COMBOSKILL: AddAction(new ComboSkillAction(this)); break;
|
|
case ACTION_MELEE: AddAction(new MeleeAction(this)); break;
|
|
default: throw new ArgumentOutOfRangeException(nameof(iActionType));
|
|
}
|
|
|
|
return StartAction();
|
|
}
|
|
|
|
// ===== Inventory helpers =====
|
|
public int GetItemIndex(int iPack, int tid)
|
|
{
|
|
if (iPack >= (int)InventoryType.IVTRTYPE_PACK && iPack <= (int)InventoryType.IVTRTYPE_TASKPACK)
|
|
{
|
|
var pPack = m_pHost.GetPack(iPack);
|
|
return pPack.FindItem(tid);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public int GetItemCount(int iPack, int tid)
|
|
{
|
|
if (iPack >= (int)InventoryType.IVTRTYPE_PACK && iPack <= (int)InventoryType.IVTRTYPE_TASKPACK)
|
|
{
|
|
var pPack = m_pHost.GetPack(iPack);
|
|
return pPack.GetItemTotalNum(tid);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public A3DVECTOR3 GetPos()
|
|
{
|
|
return m_pHost.GetPos();
|
|
}
|
|
|
|
public void MoveTo(float x, float z)
|
|
{
|
|
var pGameUI = EC_Game.GetGameRun().GetUIManager().GetInGameUIMan();
|
|
//pGameUI?.AutoMoveStart((int)x, (int)z, false);
|
|
AddOneAction(ACTION_MOVE);
|
|
}
|
|
|
|
public void CancelAction()
|
|
{
|
|
EC_ManMessage.PostMessage(EC_MsgDef.MSG_HST_PRESSCANCEL, MANAGER_INDEX.MAN_PLAYER, 0);
|
|
}
|
|
|
|
public A3DVECTOR3 GetOrigPos()
|
|
{
|
|
return m_vOrigPos;
|
|
}
|
|
|
|
public void SetOrigPos(A3DVECTOR3 vPos)
|
|
{
|
|
m_vOrigPos = vPos;
|
|
}
|
|
|
|
// ===== Target search =====
|
|
private sealed class ObjectSorter : IComparer<CECObject>
|
|
{
|
|
private readonly CECPlayerWrapper _host;
|
|
|
|
public ObjectSorter(CECPlayerWrapper host)
|
|
{
|
|
_host = host;
|
|
}
|
|
|
|
public int Compare(CECObject p1, CECObject p2)
|
|
{
|
|
float f1 = GetDistToHost(p1);
|
|
float f2 = GetDistToHost(p2);
|
|
|
|
float df = Math.Abs(f1 - f2);
|
|
if (df > 0.00001f)
|
|
return f1 < f2 ? -1 : 1;
|
|
|
|
if (p1.GetClassID() == p2.GetClassID())
|
|
{
|
|
// pointer compare equivalent
|
|
int h1 = RuntimeHelpers.GetHashCode(p1);
|
|
int h2 = RuntimeHelpers.GetHashCode(p2);
|
|
return h1.CompareTo(h2);
|
|
}
|
|
|
|
// C++: return p1->IsMatter(); => matter first if same dist but different class
|
|
return p1.IsMatter() ? -1 : 1;
|
|
}
|
|
|
|
private float GetDistToHost(CECObject p)
|
|
{
|
|
if (p == null) return 0.0f;
|
|
|
|
if (p.IsMonsterNPC())
|
|
{
|
|
var pNPC = p as CECNPC;
|
|
return pNPC != null ? pNPC.GetDistToHost() : 0.0f;
|
|
}
|
|
/* else if (p.IsMatter())
|
|
{
|
|
var pMatter = p as CECMatter;
|
|
return pMatter != null ? pMatter.GetDistToHost() : 0.0f;
|
|
}*/
|
|
else
|
|
{
|
|
return 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool SearchTarget(ref int id, ref int tid)
|
|
{
|
|
int iTarget = 0;
|
|
int iTargetTempl = 0;
|
|
|
|
var pNPCMan = EC_ManMessageMono.Instance.CECNPCMan;
|
|
var pMatterMan = EC_ManMessageMono.Instance.EC_ManMatter;
|
|
|
|
m_iAttackErrCnt = 0;
|
|
|
|
// Prefer monsters attacking me
|
|
if (m_MonsterAttackMe.Count > 0)
|
|
{
|
|
float fMinDist = 999999.0f;
|
|
int chosen = 0;
|
|
|
|
foreach (var mid in m_MonsterAttackMe)
|
|
{
|
|
var pNPC = pNPCMan.GetNPC(mid);
|
|
if (pNPC == null)
|
|
continue;
|
|
|
|
#if UNITY_5_3_OR_NEWER
|
|
float fDist = (m_pHost.GetPos() - pNPC.GetPos()).Magnitude();
|
|
#else
|
|
float fDist = A3DVECTOR3.Magnitude(m_pHost.GetPos() - pNPC.GetPos());
|
|
#endif
|
|
if (fDist < fMinDist)
|
|
{
|
|
fMinDist = fDist;
|
|
iTarget = mid;
|
|
iTargetTempl = pNPC.GetTemplateID();
|
|
chosen = mid;
|
|
}
|
|
}
|
|
|
|
if (iTarget != 0)
|
|
{
|
|
m_MonsterAttackMe.Remove(chosen);
|
|
id = iTarget;
|
|
tid = iTargetTempl;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Collect candidates (monsters + matters)
|
|
var targets = new List<CECObject>();
|
|
|
|
var monsters = new List<CECNPC>();
|
|
pNPCMan.TabSelectCandidates(0, monsters);
|
|
for (int i = 0; i < monsters.Count; i++)
|
|
targets.Add(monsters[i]);
|
|
|
|
var matters = new List<CECMatter>();
|
|
//pMatterMan.FindMattersInRange(MATTER_SEARCH_RANGE, true, matters);
|
|
for (int i = 0; i < matters.Count; i++)
|
|
targets.Add(matters[i]);
|
|
|
|
if (targets.Count > 0)
|
|
{
|
|
targets.Sort(new ObjectSorter(this));
|
|
|
|
for (int i = 0; i < targets.Count; i++)
|
|
{
|
|
var obj = targets[i];
|
|
if (obj.IsMonsterNPC())
|
|
{
|
|
var pNPC = obj as CECNPC;
|
|
if (pNPC != null && NpcCanAttack(pNPC.GetNPCID()))
|
|
{
|
|
iTarget = pNPC.GetNPCID();
|
|
iTargetTempl = pNPC.GetTemplateID();
|
|
break;
|
|
}
|
|
}
|
|
else if (obj.IsMatter())
|
|
{
|
|
var pMatter = obj as CECMatter;
|
|
if (pMatter != null && MatterCanPickup(pMatter.GetMatterID(), pMatter.GetTemplateID()))
|
|
{
|
|
iTarget = pMatter.GetMatterID();
|
|
iTargetTempl = pMatter.GetTemplateID();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iTarget != 0 && iTargetTempl != 0)
|
|
{
|
|
id = iTarget;
|
|
tid = iTargetTempl;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
id = 0;
|
|
tid = 0;
|
|
return false;
|
|
}
|
|
|
|
public int GetSelectedTarget()
|
|
{
|
|
return m_pHost.GetSelectedTarget();
|
|
}
|
|
|
|
public void SelectTarget(int iTarget)
|
|
{
|
|
m_iAttackErrCnt = 0;
|
|
m_pHost.SelectTarget(iTarget);
|
|
}
|
|
|
|
public void Unselect()
|
|
{
|
|
m_iAttackErrCnt = 0;
|
|
m_pHost.SelectTarget(0);
|
|
}
|
|
|
|
public bool NpcCanAttack(int nid)
|
|
{
|
|
if (m_pHost.AttackableJudge(nid, false) != 1)
|
|
return false;
|
|
|
|
if (m_InvalidObj.ContainsKey(nid))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool NormalAttack()
|
|
{
|
|
bool bRet = m_pHost.CmdNormalAttack(false, false, 0, m_bForceAttack ? 1 : -1);
|
|
if (bRet)
|
|
{
|
|
AddAttackError();
|
|
AddOneAction(ACTION_MELEE);
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
// NOTE: header calls this bQueue; cpp uses bDelay. Here keep signature like header.
|
|
public bool CastComboSkill(int group_id, bool bIgnoreAtkLoop, bool bQueue = false)
|
|
{
|
|
if (bQueue)
|
|
{
|
|
DoDelayTask(ACTION_COMBOSKILL, group_id, bIgnoreAtkLoop ? 1 : 0);
|
|
return true;
|
|
}
|
|
|
|
AddOneAction(ACTION_COMBOSKILL, group_id);
|
|
|
|
bool bRet = m_pHost.ApplyComboSkill(group_id, bIgnoreAtkLoop, m_bForceAttack ? 1 : -1);
|
|
if (!bRet && m_iAttackErrCnt++ >= 3)
|
|
{
|
|
m_iAttackErrCnt = 0;
|
|
m_pHost.ClearComboSkill();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool CastSkill(int skill_id, bool bQueue = false)
|
|
{
|
|
if (bQueue)
|
|
{
|
|
DoDelayTask(ACTION_CASTSKILL, skill_id);
|
|
return true;
|
|
}
|
|
|
|
bool bRet = m_pHost.ApplySkillShortcut(skill_id, false, 0, m_bForceAttack ? 1 : -1);
|
|
if (bRet)
|
|
{
|
|
AddAttackError();
|
|
AddOneAction(ACTION_CASTSKILL);
|
|
|
|
// self-cast: no trace needed
|
|
if (m_pHost.GetPrepSkill() != null)
|
|
AP.AP_ActionEvent(AP.AP_EVENT_TRACEOK);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/* public void UseItem(int iSlot)
|
|
{
|
|
bool bRet = m_pHost.UseItemInPack(EC_GPDataType.IVTRTYPE_PACK, iSlot);
|
|
if (bRet) AddOneAction(ACTION_USEITEM);
|
|
}*/
|
|
|
|
public bool MatterCanPickup(int mid, int tid)
|
|
{
|
|
int iPickMode = CECAutoPolicy.GetInstance().GetConfigData().iAutoPickMode;
|
|
if (iPickMode == 0 || (iPickMode == 2 && !GPDataTypeHelper.ISMONEYTID(tid)))
|
|
return false;
|
|
|
|
if (!m_pHost.CanTakeItem(tid, 1))
|
|
return false;
|
|
|
|
if (m_InvalidObj.ContainsKey(mid))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Pickup(int mid)
|
|
{
|
|
bool bRet = m_pHost.PickupObject(mid, false);
|
|
|
|
if (m_iPickupErrCnt++ >= 3)
|
|
{
|
|
m_iPickupErrCnt = 0;
|
|
m_InvalidObj[mid] = INVALIDOBJ_TIMEOUT;
|
|
}
|
|
|
|
if (bRet)
|
|
AddOneAction(ACTION_PICKUP, mid);
|
|
}
|
|
|
|
public bool IsPlayerInSlice(int idPlayer)
|
|
{
|
|
var pPlayerMan = EC_ManMessageMono.Instance.EC_ManPlayer;
|
|
var pPlayer = pPlayerMan.GetPlayer(idPlayer);
|
|
return pPlayer != null && !pPlayer.IsDead();
|
|
}
|
|
|
|
/* public int GetWeaponEndurance()
|
|
{
|
|
var pWeapon = m_pHost.GetEquipment().GetItem((int)IndexOfIteminEquipmentInventory.EQUIPIVTR_WEAPON) as CECIvtrWeapon;
|
|
if (pWeapon != null)
|
|
{
|
|
if (pWeapon.IsRangeWeapon())
|
|
{
|
|
var pArrow = m_pHost.GetEquipment().GetItem(EC_GPDataType.EQUIPIVTR_PROJECTILE) as CECIvtrArrow;
|
|
if (pArrow == null || pArrow.GetCount() == 0)
|
|
return 0;
|
|
}
|
|
|
|
return pWeapon.GetCurEndurance();
|
|
}
|
|
|
|
return 0;
|
|
}*/
|
|
|
|
public bool IsDead() => m_pHost.IsDead();
|
|
|
|
/* public bool IsRevivedByOther()
|
|
{
|
|
return m_pHost.GetReviveLostExp() >= 0.0f;
|
|
}
|
|
|
|
public void AcceptRevive()
|
|
{
|
|
UnityGameSession.c2s_CmdRevivalAgree();
|
|
}*/
|
|
|
|
/* public bool ReviveByItem()
|
|
{
|
|
if (m_pHost.GetCoolTime((int)CoolTimeIndex.GP_CT_SOUL_STONE) == 0)
|
|
{
|
|
UnityGameSession.c2s_CmdReviveItem();
|
|
return true;
|
|
}
|
|
return false;
|
|
}*/
|
|
|
|
public void ReviveInTown()
|
|
{
|
|
UnityGameSession.c2s_CmdReviveVillage();
|
|
}
|
|
|
|
public void SetForceAttack(bool bFlag)
|
|
{
|
|
m_bForceAttack = bFlag;
|
|
}
|
|
|
|
/* public bool IsInSanctuary()
|
|
{
|
|
return m_pHost.IsInSanctuary();
|
|
}*/
|
|
|
|
public bool IsMonsterAttackMe()
|
|
{
|
|
return m_MonsterAttackMe.Count > 0;
|
|
}
|
|
|
|
public A3DVECTOR3 GetObjectPos(int object_id)
|
|
{
|
|
if (GPDataTypeHelper.ISPLAYERID(object_id))
|
|
{
|
|
var pMan = EC_ManMessageMono.Instance.EC_ManPlayer;
|
|
var pPlayer = pMan.GetElsePlayer(object_id);
|
|
return pPlayer != null ? pPlayer.GetPos() : new A3DVECTOR3(0, 0, 0);
|
|
}
|
|
else if (GPDataTypeHelper.ISNPCID(object_id))
|
|
{
|
|
var pMan = EC_ManMessageMono.Instance.CECNPCMan;
|
|
var pNPC = pMan.GetNPC(object_id);
|
|
return pNPC != null ? pNPC.GetPos() : new A3DVECTOR3(0, 0, 0);
|
|
}
|
|
else if (GPDataTypeHelper.ISMATTERID(object_id))
|
|
{
|
|
var pMan = EC_ManMessageMono.Instance.EC_ManMatter;
|
|
var pMatter = pMan.GetMatter(object_id);
|
|
return pMatter != null ? pMatter.GetPos() : new A3DVECTOR3(0, 0, 0);
|
|
}
|
|
|
|
return new A3DVECTOR3(0, 0, 0);
|
|
}
|
|
|
|
public void SetInvalidObject(int object_id)
|
|
{
|
|
m_InvalidObj[object_id] = INVALIDOBJ_TIMEOUT;
|
|
}
|
|
|
|
public void OnObjectDisappear(int object_id)
|
|
{
|
|
m_InvalidObj.Remove(object_id);
|
|
m_MonsterAttackMe.Remove(object_id);
|
|
}
|
|
|
|
public void OnMonsterAttackMe(int monster_id)
|
|
{
|
|
if (GetSelectedTarget() != monster_id)
|
|
{
|
|
m_MonsterAttackMe.Add(monster_id);
|
|
m_InvalidObj.Remove(monster_id);
|
|
}
|
|
}
|
|
|
|
public void AddAttackError()
|
|
{
|
|
if (m_iAttackErrCnt++ >= MAX_ATTACK_ERROR)
|
|
{
|
|
m_iAttackErrCnt = 0;
|
|
m_InvalidObj[GetSelectedTarget()] = INVALIDOBJ_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
public void ResetAttackError()
|
|
{
|
|
m_iAttackErrCnt = 0;
|
|
}
|
|
|
|
public void ResetPickupError()
|
|
{
|
|
m_iPickupErrCnt = 0;
|
|
}
|
|
|
|
public int GetAttackError() => m_iAttackErrCnt;
|
|
public int GetPickupError() => m_iPickupErrCnt;
|
|
|
|
public void OnActionEvent(int iEvent, int iParam)
|
|
{
|
|
m_pCurAction?.OnEvent(iEvent, iParam);
|
|
}
|
|
|
|
private void DoDelayTask(int iType, int iParam1 = 0, int iParam2 = 0)
|
|
{
|
|
m_DelayTask.iType = iType;
|
|
m_DelayTask.iParam1 = iParam1;
|
|
m_DelayTask.iParam2 = iParam2;
|
|
|
|
if (m_pHost.IsMeleeing() || m_pHost.IsPlayerMoving())
|
|
CancelAction();
|
|
}
|
|
|
|
private void ProcessDelayTask()
|
|
{
|
|
if (m_pCurAction != null && !m_pCurAction.CanBreak())
|
|
return;
|
|
|
|
ClearAction();
|
|
m_iAttackErrCnt = 0;
|
|
m_iPickupErrCnt = 0;
|
|
|
|
switch (m_DelayTask.iType)
|
|
{
|
|
case ACTION_CASTSKILL:
|
|
CastSkill(m_DelayTask.iParam1);
|
|
break;
|
|
|
|
case ACTION_COMBOSKILL:
|
|
CastComboSkill(m_DelayTask.iParam1, m_DelayTask.iParam2 == 1);
|
|
break;
|
|
|
|
default:
|
|
throw new InvalidOperationException("Unknown delay task type");
|
|
}
|
|
|
|
m_DelayTask.iType = ACTION_IDLE;
|
|
m_DelayTask.iParam1 = 0;
|
|
m_DelayTask.iParam2 = 0;
|
|
}
|
|
|
|
// =========================================================
|
|
// Action implementations (converted 1:1)
|
|
// =========================================================
|
|
|
|
private sealed class IdleAction : Action
|
|
{
|
|
private int m_iTime;
|
|
|
|
public IdleAction(CECPlayerWrapper pPlayer, int iTime)
|
|
: base(pPlayer, ACTION_IDLE)
|
|
{
|
|
m_iTime = iTime;
|
|
}
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
if (HaveNextAction())
|
|
return true;
|
|
|
|
if (m_iTime > 0)
|
|
{
|
|
m_iTime -= (int)dwDeltaTime;
|
|
return m_iTime <= 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private sealed class MoveAction : Action
|
|
{
|
|
private bool m_bFinish;
|
|
private int m_iTimeOut;
|
|
|
|
public MoveAction(CECPlayerWrapper pPlayer)
|
|
: base(pPlayer, ACTION_MOVE)
|
|
{
|
|
m_bFinish = false;
|
|
m_iTimeOut = 30000;
|
|
}
|
|
|
|
public override bool CanBreak() => false;
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_CANNOTMOVE || iEvent == AP.AP_EVENT_MOVEFINISHED)
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
|
|
private sealed class CastSkillAction : Action
|
|
{
|
|
private const int TRACE = 0;
|
|
private const int SPELL = 1;
|
|
|
|
private int m_iStep;
|
|
private bool m_bFinish;
|
|
private int m_iTimeOut;
|
|
private bool m_bSuccess;
|
|
|
|
public CastSkillAction(CECPlayerWrapper pPlayer)
|
|
: base(pPlayer, ACTION_CASTSKILL)
|
|
{
|
|
m_iStep = TRACE;
|
|
m_iTimeOut = 30000;
|
|
m_bSuccess = false;
|
|
m_bFinish = false;
|
|
}
|
|
|
|
public override void EndAction()
|
|
{
|
|
if (m_bSuccess)
|
|
host.ResetAttackError();
|
|
}
|
|
|
|
public override bool CanBreak()
|
|
{
|
|
return m_iStep == TRACE && !host.GetHostPlayer().IsPlayerMoving();
|
|
}
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (m_iStep == TRACE)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_TRACEOK)
|
|
{
|
|
m_iStep = SPELL;
|
|
m_iTimeOut = 2000;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MOVEFINISHED)
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
else if (m_iStep == SPELL)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_STARTSKILL)
|
|
{
|
|
m_iTimeOut = iParam * 2;
|
|
m_bSuccess = true;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STOPSKILL)
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class UseItemAction : Action
|
|
{
|
|
private bool m_bFinish;
|
|
private int m_iTimeOut;
|
|
|
|
public UseItemAction(CECPlayerWrapper pPlayer)
|
|
: base(pPlayer, ACTION_USEITEM)
|
|
{
|
|
m_bFinish = false;
|
|
m_iTimeOut = 2000;
|
|
}
|
|
|
|
public override bool CanBreak() => false;
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_STARTUSEITEM)
|
|
{
|
|
m_iTimeOut = iParam * 2;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STOPUSEITEM)
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class PickupAction : Action
|
|
{
|
|
private const int TRACE = 0;
|
|
private const int PICKUP = 1;
|
|
|
|
private int m_iStep;
|
|
private bool m_bFinish;
|
|
private int m_iTimeOut;
|
|
private bool m_bSuccess;
|
|
private readonly int m_iMatterID;
|
|
|
|
public PickupAction(CECPlayerWrapper pPlayer, int iMatterID)
|
|
: base(pPlayer, ACTION_PICKUP)
|
|
{
|
|
m_iMatterID = iMatterID;
|
|
m_iTimeOut = 30000;
|
|
m_iStep = TRACE;
|
|
m_bSuccess = false;
|
|
m_bFinish = false;
|
|
}
|
|
|
|
public override void EndAction()
|
|
{
|
|
if (m_bSuccess)
|
|
host.ResetPickupError();
|
|
}
|
|
|
|
public override bool CanBreak()
|
|
{
|
|
return m_iStep == TRACE && !host.GetHostPlayer().IsPlayerMoving();
|
|
}
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (m_iStep == TRACE)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_TRACEOK)
|
|
{
|
|
m_iStep = PICKUP;
|
|
m_iTimeOut = 2000;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MOVEFINISHED)
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
else if (m_iStep == PICKUP)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_PICKUPOK)
|
|
{
|
|
m_bFinish = true;
|
|
m_bSuccess = true;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_CANNOTPICKUP)
|
|
{
|
|
m_bFinish = true;
|
|
host.SetInvalidObject(m_iMatterID);
|
|
host.ResetPickupError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class MeleeAction : Action
|
|
{
|
|
private const int TRACE = 0;
|
|
private const int MELEE = 1;
|
|
|
|
private bool m_bFinish;
|
|
private int m_iStep;
|
|
private int m_iTimeOut;
|
|
private bool m_bMeleeing;
|
|
private bool m_bLastMeleeStopped;
|
|
|
|
public MeleeAction(CECPlayerWrapper pPlayer)
|
|
: base(pPlayer, ACTION_MELEE)
|
|
{
|
|
m_iStep = TRACE;
|
|
m_iTimeOut = 30000;
|
|
m_bMeleeing = false;
|
|
m_bFinish = false;
|
|
m_bLastMeleeStopped = true;
|
|
}
|
|
|
|
public override bool CanBreak()
|
|
{
|
|
return m_iStep == TRACE && !host.GetHostPlayer().IsPlayerMoving();
|
|
}
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
if (!m_bMeleeing)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_TRACEOK)
|
|
{
|
|
if (m_iStep == TRACE)
|
|
{
|
|
m_iStep = MELEE;
|
|
m_iTimeOut = 2000;
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MOVEFINISHED)
|
|
{
|
|
if (m_iStep == TRACE)
|
|
m_bFinish = true;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STARTMELEE)
|
|
{
|
|
if (m_iStep == MELEE)
|
|
{
|
|
m_bMeleeing = true;
|
|
m_iTimeOut = 10000;
|
|
host.ResetAttackError();
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STOPMELEE)
|
|
{
|
|
if (!m_bLastMeleeStopped)
|
|
{
|
|
m_bMeleeing = false;
|
|
m_bLastMeleeStopped = true;
|
|
return;
|
|
}
|
|
|
|
if (m_iStep == MELEE && m_bMeleeing)
|
|
{
|
|
m_bMeleeing = false;
|
|
m_bFinish = true;
|
|
host.ResetAttackError();
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MELEEOUTOFRANGE)
|
|
{
|
|
if (!m_bLastMeleeStopped)
|
|
{
|
|
m_bLastMeleeStopped = true;
|
|
return;
|
|
}
|
|
|
|
if (m_iStep == MELEE)
|
|
{
|
|
m_iStep = TRACE;
|
|
m_iTimeOut = 30000;
|
|
m_bLastMeleeStopped = (iParam == 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class ComboSkillAction : Action
|
|
{
|
|
private const int TRACE = 0;
|
|
private const int SPELL = 1;
|
|
private const int MELEE = 2;
|
|
|
|
private int m_iState;
|
|
private int m_iTimeOut;
|
|
private bool m_bFinish;
|
|
private bool m_bMeleeing;
|
|
private bool m_bCasting;
|
|
private bool m_bDelayContinue;
|
|
private bool m_bSelfSkillFlag;
|
|
private bool m_bSending;
|
|
private bool m_bLastMeleeStopped;
|
|
|
|
public ComboSkillAction(CECPlayerWrapper pPlayer)
|
|
: base(pPlayer, ACTION_COMBOSKILL)
|
|
{
|
|
m_iState = TRACE;
|
|
m_iTimeOut = 30000;
|
|
m_bMeleeing = false;
|
|
m_bDelayContinue = false;
|
|
m_bCasting = false;
|
|
m_bSelfSkillFlag = false;
|
|
m_bSending = false;
|
|
m_bFinish = false;
|
|
m_bLastMeleeStopped = true;
|
|
}
|
|
|
|
public override bool CanBreak()
|
|
{
|
|
return !m_bSending && !m_bCasting && !m_bMeleeing && !host.GetHostPlayer().IsPlayerMoving();
|
|
}
|
|
|
|
public override bool Tick(uint dwDeltaTime)
|
|
{
|
|
var pCombo = host.GetHostPlayer().GetComboSkill();
|
|
if (pCombo == null && !m_bMeleeing)
|
|
return true;
|
|
|
|
if (pCombo != null && !pCombo.IsIgnoreAtkLoop() &&
|
|
pCombo.GetTarget() != host.GetSelectedTarget() &&
|
|
!m_bCasting && !m_bMeleeing)
|
|
return true;
|
|
|
|
if (!m_bMeleeing)
|
|
{
|
|
m_iTimeOut -= (int)dwDeltaTime;
|
|
if (m_iTimeOut <= 0)
|
|
return true;
|
|
|
|
return m_bFinish;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void OnEvent(int iEvent, int iParam)
|
|
{
|
|
if (iEvent == AP.AP_EVENT_COMBOCONTINUE)
|
|
{
|
|
if (m_iState == MELEE)
|
|
{
|
|
m_bDelayContinue = true;
|
|
m_bSelfSkillFlag = (iParam == 1);
|
|
}
|
|
else
|
|
{
|
|
if (iParam == 1)
|
|
{
|
|
m_iState = SPELL;
|
|
m_iTimeOut = 2000;
|
|
m_bSending = true;
|
|
}
|
|
else
|
|
{
|
|
m_iState = TRACE;
|
|
m_iTimeOut = 30000;
|
|
}
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_TRACEOK)
|
|
{
|
|
if (m_iState == TRACE)
|
|
{
|
|
m_iState = (iParam == 0) ? MELEE : SPELL;
|
|
m_iTimeOut = 2000;
|
|
m_bSending = true;
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MOVEFINISHED)
|
|
{
|
|
if (m_iState == TRACE)
|
|
m_bFinish = true;
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STARTMELEE)
|
|
{
|
|
if (m_iState == MELEE)
|
|
{
|
|
m_iTimeOut = 10000;
|
|
m_bMeleeing = true;
|
|
m_bSending = false;
|
|
host.ResetAttackError();
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STOPMELEE)
|
|
{
|
|
if (!m_bLastMeleeStopped)
|
|
{
|
|
m_bMeleeing = false;
|
|
m_bLastMeleeStopped = true;
|
|
return;
|
|
}
|
|
|
|
if (m_iState == MELEE && m_bMeleeing)
|
|
{
|
|
m_bMeleeing = false;
|
|
host.ResetAttackError();
|
|
|
|
var pCombo = host.GetHostPlayer().GetComboSkill();
|
|
if (pCombo != null && pCombo.IsStop())
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
else
|
|
{
|
|
m_iTimeOut = 10000;
|
|
|
|
if (m_bDelayContinue)
|
|
{
|
|
m_bDelayContinue = false;
|
|
|
|
if (m_bSelfSkillFlag)
|
|
{
|
|
m_iState = SPELL;
|
|
m_iTimeOut = 2000;
|
|
m_bSending = true;
|
|
}
|
|
else
|
|
{
|
|
m_iState = TRACE;
|
|
m_iTimeOut = 30000;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_MELEEOUTOFRANGE)
|
|
{
|
|
if (!m_bLastMeleeStopped)
|
|
{
|
|
m_bLastMeleeStopped = true;
|
|
return;
|
|
}
|
|
|
|
if (m_iState == MELEE)
|
|
{
|
|
m_iState = TRACE;
|
|
m_iTimeOut = 30000;
|
|
m_bLastMeleeStopped = (iParam == 1);
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STARTSKILL)
|
|
{
|
|
if (m_iState == SPELL)
|
|
{
|
|
m_iTimeOut = iParam * 2;
|
|
m_bCasting = true;
|
|
m_bSending = false;
|
|
host.ResetAttackError();
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_STOPSKILL)
|
|
{
|
|
if (m_iState == SPELL && m_bCasting)
|
|
{
|
|
m_bCasting = false;
|
|
host.ResetAttackError();
|
|
|
|
var pCombo = host.GetHostPlayer().GetComboSkill();
|
|
if (pCombo != null && pCombo.IsStop())
|
|
m_bFinish = true;
|
|
else
|
|
m_iTimeOut = 10000;
|
|
}
|
|
}
|
|
else if (iEvent == AP.AP_EVENT_COMBOFINISH)
|
|
{
|
|
m_bFinish = true;
|
|
}
|
|
}
|
|
}
|
|
public enum AP_EVENT
|
|
{
|
|
AP_EVENT_CANNOTMOVE, // ²»ÄÜÒƶ¯
|
|
AP_EVENT_MOVEFINISHED, // Òƶ¯½áÊø
|
|
AP_EVENT_TRACEOK, // ×·×ٳɹ¦
|
|
AP_EVENT_STARTSKILL, // ¼¼ÄÜ¿ªÊ¼
|
|
AP_EVENT_STOPSKILL, // ¼¼ÄÜÍ£Ö¹
|
|
AP_EVENT_STARTUSEITEM, // ʹÓÃÎïÆ·¿ªÊ¼
|
|
AP_EVENT_STOPUSEITEM, // ʹÓÃÎïÆ·½áÊø
|
|
AP_EVENT_PICKUPOK, // ³É¹¦¼ñÈ¡ÎïÆ·
|
|
AP_EVENT_CANNOTPICKUP, // ËûÈËÎïÆ·£¬²»ÄܼñÈ¡
|
|
AP_EVENT_STARTMELEE, // ¿ªÊ¼ÆÕ¹¥
|
|
AP_EVENT_STOPMELEE, // ½áÊøÆÕ¹¥
|
|
AP_EVENT_COMBOCONTINUE, // ×éºÏ¼¼Íƽø
|
|
AP_EVENT_COMBOFINISH, // ×éºÏ¼¼ÖÕÖ¹£¬Ó¦¶Ô×îºóÒ»¸ö¼¼ÄÜûÓзųöµÄÇé¿ö
|
|
AP_EVENT_MELEEOUTOFRANGE, // ÆÕ¹¥³¬³ö¾àÀë
|
|
};
|
|
}
|