VDH
1247 lines
46 KiB
C#
1247 lines
46 KiB
C#
using BrewMonster;
|
|
using BrewMonster.Network;
|
|
using CSNetwork;
|
|
using CSNetwork.Common;
|
|
using CSNetwork.GPDataType;
|
|
using CSNetwork.Protocols;
|
|
using CSNetwork.Protocols.RPCData;
|
|
using PerfectWorld.Scripts.Managers;
|
|
using PerfectWorld.Scripts.Player;
|
|
using PerfectWorld.Scripts.Task;
|
|
using System;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using TMPro;
|
|
using Unity.VisualScripting;
|
|
using UnityEditor.Experimental.GraphView;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.SceneManagement;
|
|
using UnityEngine.UI;
|
|
using Scene = UnityEngine.SceneManagement.Scene;
|
|
|
|
public class CECHostPlayer : CECPlayer
|
|
{
|
|
[SerializeField] private TextMeshPro txtName;
|
|
[SerializeField] private CharacterController controller;
|
|
|
|
[SerializeField] private Joystick joystick;
|
|
[SerializeField] private Button btnJump;
|
|
[SerializeField] private Button btnRun;
|
|
[SerializeField] private Transform parentModel;
|
|
|
|
PlayerStateMachine _playerStateMachine;
|
|
PlayerMoveState _moveState;
|
|
PlayerIdleState _idleState;
|
|
public CECHostMove m_MoveCtrl;
|
|
|
|
CECHPWorkMan m_pWorkMan; // Host work manager
|
|
uint m_dwLIES; // Logic-influence extend states
|
|
FACTION_FORTRESS_ENTER m_fortressEnter; // ½øÈë»ùµØÐÅÏ¢
|
|
PVPINFO m_pvp; // pvp information
|
|
bool m_bInSanctuary = false; // true, player is in sanctuary
|
|
int m_idFaction = 0; // ID of player's faction
|
|
public bool m_bPrepareFight = false; // true, prepare to fight
|
|
int m_iJumpCount = 0;
|
|
bool m_bJumpInWater = false;
|
|
public A3DVECTOR3 m_vVelocity; // Velocity
|
|
|
|
float playerSpeed = 5.0f;
|
|
float jumpHeight = 1.5f;
|
|
float gravityValue = -9.81f;
|
|
StateAnim stateAnim = StateAnim.Idle;
|
|
Vector3 playerVelocity;
|
|
bool isGrounded = false;
|
|
bool isRun = false;
|
|
Vector3 m_vLastSevPos;
|
|
public CDR_INFO m_CDRInfo;
|
|
public GNDINFO m_GndInfo;
|
|
public float m_fVertSpeed = 0f;
|
|
|
|
// ====== Ground cast config ======
|
|
[Header("Ground Cast")]
|
|
[Tooltip("Khoảng thêm ngoài skinWidth để SphereCast xuống (m ngắn)")]
|
|
[SerializeField] private float extraGroundDistance = 0.05f;
|
|
[Tooltip("Bớt bán kính một chút để tránh tự va vào capsule (epsilon)")]
|
|
[SerializeField] private float radiusEpsilon = 0.005f;
|
|
[Tooltip("Layer mặt đất")]
|
|
[SerializeField] private LayerMask groundMask;
|
|
[Tooltip("Layer mặt đất")]
|
|
[SerializeField] private float slopeToleranceDeg = 2f;
|
|
|
|
// cache tùy chọn (không bắt buộc)
|
|
float ccRadius, ccSkin;
|
|
RaycastHit lastGroundHit;
|
|
Camera mainCam;
|
|
|
|
private void Awake()
|
|
{
|
|
base.Awake();
|
|
_moveState = new PlayerMoveState(this);
|
|
_idleState = new PlayerIdleState(this);
|
|
_playerStateMachine = new PlayerStateMachine();
|
|
m_MoveCtrl = new CECHostMove(this);
|
|
|
|
// Cache: không bắt buộc, nhưng gọn tay và ít gọi property lặp.
|
|
if (controller != null)
|
|
{
|
|
ccRadius = controller.radius;
|
|
ccSkin = controller.skinWidth;
|
|
}
|
|
}
|
|
|
|
|
|
public void SetModelHostPlayer()
|
|
{
|
|
_pPlayerModel = NPCManager.Instance.GetModelPlayer();
|
|
Scene scene = SceneManager.GetSceneByName("WorldRender");
|
|
SceneManager.MoveGameObjectToScene(_pPlayerModel, scene);
|
|
_pPlayerModel.transform.SetParent(parentModel);
|
|
_pPlayerModel.transform.localPosition = Vector3.zero;
|
|
_pPlayerModel.SetActive(true);
|
|
}
|
|
private void Start()
|
|
{
|
|
mainCam = Camera.main;
|
|
if (mainCam == null)
|
|
{
|
|
mainCam = FindFirstObjectByType<Camera>();
|
|
}
|
|
_playerStateMachine.InitState(_idleState);
|
|
// btnJump.onClick.AddListener(HandleJump);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
//Debug.Log($"(ulong)Time.deltaTime * 1000 {(ulong)(Time.deltaTime * 1000)}");
|
|
m_MoveCtrl.Tick((ulong)(Time.deltaTime * 1000));
|
|
// Nếu có thay đổi runtime, có thể lấy lại mỗi vài giây/Start nếu bạn thích:
|
|
// ccRadius = controller.radius; ccSkin = controller.skinWidth;
|
|
|
|
_playerStateMachine.UpdateState();
|
|
|
|
if (Input.GetMouseButtonDown(1) && mainCam != null)
|
|
{
|
|
int idTraceTarget = 0, idSelTarget = 0;
|
|
bool bForceAttack = false;
|
|
int iTraceReason = CECHPWorkTrace.Trace_reason.TRACE_NONE;
|
|
bool bWikiMonster = false;
|
|
|
|
Ray ray = mainCam.ScreenPointToRay(Input.mousePosition);
|
|
RaycastHit hit;
|
|
|
|
if (Physics.Raycast(ray, out hit))
|
|
{
|
|
CECObject clickedObject = hit.collider.gameObject.GetComponent<CECObject>();
|
|
|
|
if (clickedObject != null)
|
|
{
|
|
int idObject = CECObject.GetObjectID(clickedObject);
|
|
if (idObject != 0)
|
|
{
|
|
CECNPC pNPC = EC_ManMessageMono.Instance._CECNPCMan.GetNPC(idObject);
|
|
if (pNPC != null)
|
|
{
|
|
if (!pNPC.IsDead())
|
|
{
|
|
idTraceTarget = idObject;
|
|
}
|
|
if (idTraceTarget != 0)
|
|
{
|
|
if (AttackableJudge(idObject, bForceAttack) == 1)
|
|
iTraceReason = CECHPWorkTrace.Trace_reason.TRACE_ATTACK;
|
|
else if (pNPC.IsServerNPC())
|
|
{
|
|
if (!IsInBattle() || InSameBattleCamp(pNPC))
|
|
iTraceReason = CECHPWorkTrace.Trace_reason.TRACE_TALK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idTraceTarget != 0)
|
|
{
|
|
//if (m_pWorkMan.IsSitting())
|
|
//{
|
|
// g_pGame.GetGameSession().c2s_CmdStandUp();
|
|
// return;
|
|
//}
|
|
// Trace a object
|
|
if (iTraceReason == CECHPWorkTrace.Trace_reason.TRACE_ATTACK)
|
|
{
|
|
//if (!CanDo(CANDO_MELEE))
|
|
// return;
|
|
Debug.LogError("Attack");
|
|
NormalAttackObject(idTraceTarget, bForceAttack);
|
|
}
|
|
//else
|
|
//{
|
|
// if (!CanDo(CANDO_MOVETO))
|
|
// return;
|
|
|
|
// if (iTraceReason == CECHPWorkTrace::TRACE_PICKUP)
|
|
// {
|
|
// PickupObject(idTraceTarget, false);
|
|
// }
|
|
// else if (iTraceReason == CECHPWorkTrace::TRACE_GATHER)
|
|
// {
|
|
// PickupObject(idTraceTarget, true);
|
|
// }
|
|
// else if (CECHPWork * pWork = m_pWorkMan.GetWork(CECHPWork::WORK_TRACEOBJECT))
|
|
// {
|
|
// CECHPWorkTrace* pWorkTrace = dynamic_cast<CECHPWorkTrace*>(pWork);
|
|
// pWorkTrace.SetTraceTarget(pWorkTrace.CreatTraceTarget(idTraceTarget, iTraceReason, bForceAttack));
|
|
// }
|
|
// else if (m_pWorkMan.CanStartWork(CECHPWork::WORK_TRACEOBJECT) && !bWikiMonster)
|
|
// {
|
|
// CECHPWorkTrace* pWork = (CECHPWorkTrace*)m_pWorkMan.CreateWork(CECHPWork::WORK_TRACEOBJECT);
|
|
// pWork.SetTraceTarget(pWork.CreatTraceTarget(idTraceTarget, iTraceReason, bForceAttack));
|
|
// m_pWorkMan.StartWork_p1(pWork);
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
public void StopMovement()
|
|
{
|
|
m_MoveCtrl.SendStopMoveCmd(transform.position, 5f, (int)GPMoveMode.GP_MOVE_WALK);
|
|
}
|
|
public void HandleMovement()
|
|
{
|
|
// 1) Kiểm tra grounded bằng SphereCast ngắn dựa trên radius + skinWidth
|
|
isGrounded = GroundCheck(out lastGroundHit);
|
|
|
|
// 2) Input tạm thời: giữ nguyên như bạn
|
|
if (UnityEngine.Input.GetKeyDown(KeyCode.LeftShift)) SetStatusRun(true);
|
|
if (UnityEngine.Input.GetKeyUp(KeyCode.LeftShift)) SetStatusRun(false);
|
|
if (UnityEngine.Input.GetKeyDown(KeyCode.Space)) HandleJump();
|
|
|
|
// 3) Trọng lực / sticky
|
|
if (isGrounded && playerVelocity.y < 0f)
|
|
{
|
|
// Đè nhẹ để bám đất (tránh nhấp-nháy)
|
|
playerVelocity.y = -2f;
|
|
}
|
|
else
|
|
{
|
|
playerVelocity.y += gravityValue * Time.deltaTime;
|
|
}
|
|
|
|
// 4) Chuyển động phẳng
|
|
float x = joystick.Horizontal;
|
|
float z = joystick.Vertical;
|
|
|
|
Vector3 move = new Vector3(x, 0, z);
|
|
move = Vector3.ClampMagnitude(move, 1f);
|
|
|
|
if (move != Vector3.zero)
|
|
{
|
|
transform.forward = move;
|
|
m_MoveCtrl.GroundMove(Time.deltaTime);
|
|
m_MoveCtrl.SendMoveCmd(transform.position, controller.velocity, (int)GPMoveMode.GP_MOVE_RUN);
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
Vector3 finalMove = (move * playerSpeed) + (playerVelocity.y * Vector3.up);
|
|
controller.Move(finalMove * Time.deltaTime);
|
|
}
|
|
private void JoystickRelease(JoystickRealeaseEvent joystickRealeaseEvent)
|
|
{
|
|
_playerStateMachine.ChangeState(_idleState);
|
|
}
|
|
|
|
private bool GroundCheck(out RaycastHit hit)
|
|
{
|
|
float radius = controller.radius;
|
|
float skin = controller.skinWidth;
|
|
float height = controller.height;
|
|
|
|
// Tâm capsule theo world
|
|
Vector3 cWorld = transform.TransformPoint(controller.center);
|
|
float hemi = Mathf.Max(0f, (height * 0.5f) - radius);
|
|
|
|
// Hai điểm top/bottom của capsule nhân vật (đang đứng)
|
|
Vector3 pTop = cWorld + Vector3.up * hemi;
|
|
Vector3 pBottom = cWorld - Vector3.up * hemi;
|
|
|
|
// Ta tạo một "đoạn capsule ngắn" gần đáy để sweep xuống
|
|
// Nhấc đoạn bắt đầu lên 1 chút để không bắt đầu trong trạng thái giao nhau
|
|
Vector3 startBottom = pBottom + Vector3.up * (skin + 0.01f);
|
|
Vector3 startTop = startBottom + Vector3.up * (radius * 2f - 0.02f); // chiều cao đoạn ngắn ~2*radius
|
|
|
|
float castRadius = Mathf.Max(0f, radius - radiusEpsilon);
|
|
float castDistance = skin + extraGroundDistance; // quãng sweep ngắn
|
|
|
|
bool hitSomething = Physics.CapsuleCast(
|
|
startTop, startBottom, castRadius,
|
|
Vector3.down, out hit, castDistance,
|
|
groundMask, QueryTriggerInteraction.Ignore
|
|
);
|
|
|
|
if (!hitSomething) return false;
|
|
|
|
// Lọc theo slope limit
|
|
float maxSlope = controller.slopeLimit + slopeToleranceDeg;
|
|
float slope = Vector3.Angle(hit.normal, Vector3.up);
|
|
if (slope > maxSlope) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private void HandleJump()
|
|
{
|
|
if (isGrounded)
|
|
{
|
|
playerVelocity.y = Mathf.Sqrt(jumpHeight * -2f * gravityValue);
|
|
}
|
|
}
|
|
public void ProcessMessage(in ECMSG Msg)
|
|
{
|
|
Debug.LogWarning("HoangDev : ProcessMessageProcessMessageProcessMessage");
|
|
var msg = (int)Msg.dwMsg;
|
|
switch (msg)
|
|
{
|
|
case int value when value == EC_MsgDef.MSG_HST_CORRECTPOS: OnMsgHstCorrectPos(Msg); break;
|
|
case int value when value == EC_MsgDef.MSG_HST_GOTO: OnMsgHstGoto(Msg); break;
|
|
case int value when value == EC_MsgDef.MSG_HST_IVTRINFO:
|
|
{
|
|
OnMsgHstIvtrInfo(Msg);
|
|
break;
|
|
}
|
|
case int value when value == EC_MsgDef.MSG_HST_OWNITEMINFO:
|
|
{
|
|
OnMsgHstOwnItemInfo(Msg);
|
|
break;
|
|
}
|
|
case int value when value == EC_MsgDef.MSG_HST_TASKDATA:
|
|
{
|
|
OnMsgHstTaskData(Msg);
|
|
//Debug.LogError("[Dat]- OnMsgHstTaskData");
|
|
break;
|
|
}
|
|
case int value when value == EC_MsgDef.MSG_HST_ITEMOPERATION:
|
|
OnMsgHstItemOperation(Msg);
|
|
break;
|
|
case int value when value == EC_MsgDef.MSG_HST_PICKUPITEM:
|
|
OnMsgHstPickupItem(Msg);
|
|
break;
|
|
case int value when value == EC_MsgDef.MSG_HST_ATKRESULT: OnMsgHstAttackResult(Msg); break;
|
|
//case int value when value == EC_MsgDef.MSG_HST_ATTACKED: OnMsgHstAttacked(Msg); break;
|
|
case int value when value == EC_MsgDef.MSG_HST_HURTRESULT: OnMsgHstHurtResult(Msg); break;
|
|
}
|
|
}
|
|
public void OnMsgHstAttackResult(ECMSG Msg)
|
|
{
|
|
|
|
cmd_host_attack_result pCmd = (cmd_host_attack_result)Msg.dwParam1;
|
|
|
|
int iAttackTime = 0;
|
|
PlayAttackEffect(pCmd.idTarget, 0, 0, pCmd.iDamage, (uint)pCmd.attack_flag, pCmd.attack_speed * 50, ref iAttackTime);
|
|
TurnFaceTo(pCmd.idTarget);
|
|
|
|
if (iAttackTime != 0)
|
|
{
|
|
if (m_pWorkMan.GetRunningWork(CECHPWork.Host_work_ID.WORK_HACKOBJECT) is CECHPWorkMelee pCurWork)
|
|
{
|
|
pCurWork.SetIdleTime(iAttackTime);
|
|
}
|
|
}
|
|
}
|
|
public void PlayAttackEffect(int idTarget, int idSkill, int skillLevel, int nDamage,
|
|
uint dwModifier, int nAttackSpeed, ref int piAttackTime/* NULL */, int nSection = 0)
|
|
{
|
|
/* if (!IsAllResReady())
|
|
return;
|
|
|
|
if (idSkill == 0)
|
|
{
|
|
int idWeapon = IsShapeChanged() ? 0 : GetWeaponID();
|
|
|
|
int nTimeFly = 10;
|
|
if (idWeapon != 0)
|
|
{
|
|
// ¿´¿´ÊDz»ÊÇÔ¶³ÌÎäÆ÷
|
|
DATA_TYPE dt = default;
|
|
WEAPON_ESSENCE? pWeapon = (WEAPON_ESSENCE)ElementDataManProvider.GetElementDataMan().get_data_ptr((uint)idWeapon, ID_SPACE.ID_SPACE_ESSENCE, ref dt);
|
|
|
|
if (dt == DATA_TYPE.DT_WEAPON_ESSENCE && pWeapon != null && pWeapon.Value.require_projectile != 0)
|
|
{
|
|
nTimeFly = 700;
|
|
|
|
if (m_aEquips[(int)IndexOfIteminEquipmentInventory.EQUIPIVTR_PROJECTILE] != 0)
|
|
idWeapon = m_aEquips[(int)IndexOfIteminEquipmentInventory.EQUIPIVTR_PROJECTILE];
|
|
}
|
|
}
|
|
|
|
if (g_pGame->GetGameRun()->GetWorld()->GetAttacksMan()->FindAttackByAttacker(GetPlayerInfo().cid))
|
|
{
|
|
// signal early attack event
|
|
ClearComActFlagAllRankNodes(true);
|
|
}
|
|
|
|
// melee attack
|
|
CECAttackEvent* pAttack = g_pGame->GetGameRun()->GetWorld()->GetAttacksMan()->AddMeleeAttack(
|
|
GetPlayerInfo().cid, idTarget, idWeapon, dwModifier, nDamage, nTimeFly);
|
|
|
|
if (pAttack)
|
|
{
|
|
if (!IsDead() && (dwModifier & CECAttackEvent::MOD_RETORT) == 0
|
|
&& (dwModifier & CECAttackEvent::MOD_ATTACK_AURA) == 0
|
|
&& PlayAttackAction(nAttackSpeed, piAttackTime, &pAttack->m_bSignaled)
|
|
&& (dwModifier & CECAttackEvent::MOD_BEAT_BACK) == 0)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
pAttack->m_bSignaled = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (skillLevel == 0)
|
|
{
|
|
if (m_pCurSkill)
|
|
skillLevel = m_pCurSkill->GetSkillLevel();
|
|
else
|
|
skillLevel = 1;
|
|
}
|
|
|
|
CECAttackEvent* pAttack = NULL;
|
|
|
|
// first try to find if there is already a skill attack event in attackman
|
|
CECAttackerEvents attackerEvents = g_pGame->GetGameRun()->GetWorld()->GetAttacksMan()->FindAttackByAttacker(GetPlayerInfo().cid);
|
|
if (attackerEvents)
|
|
{
|
|
if (CECAttackEvent * pAttack = attackerEvents.Find(idSkill, nSection))
|
|
{
|
|
// Ãæ¹¥»÷µÄ·ÇµÚÒ»´ÎÉ˺¦ÏûÏ¢
|
|
pAttack->AddTarget(idTarget, dwModifier, nDamage);
|
|
goto EXIT;
|
|
}
|
|
else
|
|
{
|
|
attackerEvents.Signal();
|
|
}
|
|
}
|
|
if (GNET::ElementSkill::IsGoblinSkill(idSkill) &&
|
|
GNET::ElementSkill::GetType(idSkill) == 2)
|
|
{
|
|
pAttack = g_pGame->GetGameRun()->GetWorld()->GetAttacksMan()->AddSkillAttack(
|
|
GetPlayerInfo().cid, GetPlayerInfo().cid, idTarget, GetWeaponID(), idSkill, skillLevel, dwModifier, nDamage);
|
|
}
|
|
else
|
|
{
|
|
// begin a skill attack
|
|
pAttack = g_pGame->GetGameRun()->GetWorld()->GetAttacksMan()->AddSkillAttack(
|
|
GetPlayerInfo().cid, m_idCurSkillTarget, idTarget, GetWeaponID(), idSkill, skillLevel, dwModifier, nDamage);
|
|
}
|
|
|
|
if (pAttack)
|
|
{
|
|
pAttack->SetSkillSection(nSection);
|
|
if (!IsDead() && (dwModifier & CECAttackEvent::MOD_RETORT) == 0
|
|
&& (dwModifier & CECAttackEvent::MOD_ATTACK_AURA) == 0
|
|
&& PlaySkillAttackAction(idSkill, nAttackSpeed, NULL, nSection, &pAttack->m_bSignaled)
|
|
&& (dwModifier & CECAttackEvent::MOD_BEAT_BACK) == 0)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
pAttack->m_bSignaled = true;
|
|
}
|
|
}
|
|
|
|
EXIT:
|
|
// For skill attacking, time is always set to 0
|
|
if (piAttackTime)
|
|
*piAttackTime = 0;
|
|
}*/
|
|
}
|
|
private void OnMsgHstHurtResult(ECMSG Msg)
|
|
{
|
|
/* BMLogger.LogError("HoangDev : OnMsgHstHurtResult");
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
if (cmd == CommandID.BE_HURT)
|
|
{
|
|
cmd_be_hurt pCmd = (cmd_be_hurt)Msg.dwParam1;
|
|
if (pCmd.damage != 0)
|
|
Damaged(pCmd->damage);
|
|
}
|
|
else if (cmd == CommandID.HURT_RESULT)
|
|
{
|
|
cmd_hurt_result pCmd = (cmd_hurt_result)Msg.dwParam1;
|
|
if (pCmd.target_id == m_PlayerInfo.cid)
|
|
return; // Host himself will receive BE_HURT, so ignore this.
|
|
|
|
if (UnityGameSession.Instance.GameSession.ISPLAYERID(pCmd.target_id))
|
|
{
|
|
CECElsePlayer pTarget = m_pPlayerMan.GetElsePlayer(pCmd.target_id);
|
|
if (pTarget)
|
|
pTarget->Damaged(pCmd->damage);
|
|
}
|
|
else if (UnityGameSession.Instance.GameSession.ISNPCID(pCmd.target_id))
|
|
{
|
|
CECNPC pTarget = EC_ManMessageMono.Instance._CECNPCMan.GetNPC(pCmd.target_id);
|
|
if (pTarget)
|
|
pTarget.Damaged(pCmd.damage);
|
|
}
|
|
}*/
|
|
}
|
|
public void OnMsgHstPickupItem(in ECMSG Msg)
|
|
{
|
|
var data = Msg.dwParam1 as byte[];
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
switch (cmd)
|
|
{
|
|
case CommandID.PICKUP_ITEM:
|
|
{
|
|
// Parse the pickup item data from the server response
|
|
if (data != null && data.Length >= 16)
|
|
{
|
|
int tid = BitConverter.ToInt32(data, 0);
|
|
int expire_date = BitConverter.ToInt32(data, 4);
|
|
uint iAmount = BitConverter.ToUInt32(data, 8);
|
|
uint iSlotAmount = BitConverter.ToUInt32(data, 12);
|
|
byte byPackage = data[16];
|
|
byte bySlot = data[17];
|
|
|
|
Debug.Log($"[Inventory] PICKUP_ITEM: tid={tid}, expire_date={expire_date}, iAmount={iAmount}, iSlotAmount={iSlotAmount}, byPackage={byPackage}, bySlot={bySlot}");
|
|
|
|
// Notify pickupItem script about successful pickup
|
|
pickupItem pickupScript = UnityEngine.Object.FindFirstObjectByType<pickupItem>();
|
|
if (pickupScript != null)
|
|
{
|
|
pickupScript.OnPickupSuccess(tid);
|
|
}
|
|
|
|
// Create new inventory item data
|
|
var newItem = new InventoryItemData
|
|
{
|
|
Package = byPackage,
|
|
Slot = bySlot,
|
|
TemplateId = tid,
|
|
ExpireDate = expire_date,
|
|
State = 0,
|
|
Count = (int)iAmount,
|
|
Crc = 0,
|
|
Content = null
|
|
};
|
|
|
|
// Add item to inventory
|
|
EC_Inventory.SetItem(byPackage, bySlot, newItem);
|
|
|
|
Debug.Log($"[Inventory] Successfully added item {tid} to package {byPackage}, slot {bySlot} with count {iAmount}");
|
|
|
|
// Trigger UI refresh if an EC_InventoryUI is present in scene
|
|
var ui = GameObject.FindFirstObjectByType<EC_InventoryUI>();
|
|
if (ui != null)
|
|
{
|
|
ui.RefreshAll();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("[Inventory] PICKUP_ITEM: Invalid data length");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
public void OnMsgHstItemOperation(ECMSG Msg)
|
|
{
|
|
var data = Msg.dwParam1 as byte[];
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
switch (cmd)
|
|
{
|
|
case CommandID.PLAYER_DROP_ITEM:
|
|
{
|
|
// Parse the drop item data from the server response
|
|
if (data != null && data.Length >= 6)
|
|
{
|
|
byte byPackage = data[0];
|
|
byte bySlot = data[1];
|
|
int count = BitConverter.ToInt32(data, 2);
|
|
int tid = BitConverter.ToInt32(data, 6);
|
|
byte reason = data[10];
|
|
|
|
Debug.Log($"[Inventory] PLAYER_DROP_ITEM: package={byPackage}, slot={bySlot}, count={count}, tid={tid}, reason={reason}");
|
|
|
|
// Update the inventory by removing the item
|
|
bool success = EC_Inventory.RemoveItem(byPackage, bySlot, count);
|
|
|
|
if (success)
|
|
{
|
|
Debug.Log($"[Inventory] Successfully removed {count} items from package {byPackage}, slot {bySlot}");
|
|
|
|
// Trigger UI refresh if an EC_InventoryUI is present in scene
|
|
var ui = GameObject.FindFirstObjectByType<EC_InventoryUI>();
|
|
if (ui != null)
|
|
{
|
|
ui.RefreshAll();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[Inventory] Failed to remove items from package {byPackage}, slot {bySlot}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("[Inventory] PLAYER_DROP_ITEM: Invalid data length");
|
|
}
|
|
break;
|
|
}
|
|
case CommandID.EQUIP_ITEM:
|
|
{
|
|
byte index_inv = data[0];
|
|
byte index_equip = data[1];
|
|
// Update client-side data: move item between PACK_INVENTORY and PACK_EQUIPMENT
|
|
var invItem = EC_Inventory.GetItem(EC_Inventory.PACK_INVENTORY, index_inv, true);
|
|
var equipItem = EC_Inventory.GetItem(EC_Inventory.PACK_EQUIPMENT, index_equip, true);
|
|
if (invItem != null)
|
|
{
|
|
invItem.Package = EC_Inventory.PACK_EQUIPMENT;
|
|
invItem.Slot = index_equip;
|
|
EC_Inventory.SetItem(EC_Inventory.PACK_EQUIPMENT, index_equip, invItem);
|
|
}
|
|
if (equipItem != null)
|
|
{
|
|
equipItem.Package = EC_Inventory.PACK_INVENTORY;
|
|
equipItem.Slot = index_inv;
|
|
EC_Inventory.SetItem(EC_Inventory.PACK_INVENTORY, index_inv, equipItem);
|
|
}
|
|
|
|
// Trigger UI refresh if an EC_InventoryUI is present in scene
|
|
var ui = GameObject.FindObjectOfType<EC_InventoryUI>();
|
|
if (ui != null)
|
|
{
|
|
ui.RefreshAll();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
public void OnMsgHstOwnItemInfo(ECMSG Msg)
|
|
{
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
switch (cmd)
|
|
{
|
|
case CommandID.OWN_ITEM_INFO:
|
|
{
|
|
Debug.Log("[Inventory] OWN_ITEM_INFO received");
|
|
var data = Msg.dwParam1 as byte[];
|
|
int hostId = Convert.ToInt32(Msg.dwParam3);
|
|
PerfectWorld.Scripts.Managers.EC_Inventory.LogInventoryPacket("OWN_ITEM_INFO", data, hostId);
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
public void OnMsgHstIvtrInfo(ECMSG Msg)
|
|
{
|
|
var data = Msg.dwParam1 as byte[];
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
int hostId = Convert.ToInt32(Msg.dwParam3);
|
|
|
|
switch (cmd)
|
|
{
|
|
case CommandID.OWN_IVTR_DATA:
|
|
{
|
|
Debug.Log("[Inventory] OWN_IVTR_DATA received");
|
|
PerfectWorld.Scripts.Managers.EC_Inventory.LogInventoryPacket("OWN_IVTR_DATA", data, hostId);
|
|
break;
|
|
}
|
|
case CommandID.OWN_IVTR_DETAIL_DATA:
|
|
{
|
|
Debug.Log("[Inventory] OWN_IVTR_DETAIL_DATA received");
|
|
PerfectWorld.Scripts.Managers.EC_Inventory.LogInventoryPacket("OWN_IVTR_DETAIL_DATA", data, hostId);
|
|
// Parse and store
|
|
if (data != null && data.Length >= 6)
|
|
{
|
|
byte byPackage = data[0];
|
|
byte ivtrSize = data[1];
|
|
if (PerfectWorld.Scripts.Managers.EC_IvtrItem.TryParseInventoryDetail(data, out var pkg, out var size, out var items))
|
|
{
|
|
PerfectWorld.Scripts.Managers.EC_Inventory.UpdatePack(pkg, size, items);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
public void OnMsgHstCorrectPos(in ECMSG Msg)
|
|
{
|
|
Debug.LogWarning("HoangDev : OnMsgHstCorrectPos");
|
|
byte[] buf = (byte[])Msg.dwParam1; // chỗ bạn lưu pDataBuf
|
|
GCHandle handle = GCHandle.Alloc(buf, GCHandleType.Pinned);
|
|
cmd_host_correct_pos pCmd = (cmd_host_correct_pos)Marshal.PtrToStructure(
|
|
handle.AddrOfPinnedObject(), typeof(cmd_host_correct_pos));
|
|
handle.Free();
|
|
Debug.LogWarning("HoangDev :pCmd.pos " + pCmd.pos);
|
|
SetPos(pCmd.pos);
|
|
}
|
|
public void OnMsgHstGoto(in ECMSG Msg)
|
|
{
|
|
Debug.Log("HoangDev :OnMsgHstGoto");
|
|
cmd_notify_hostpos pCmd = (cmd_notify_hostpos)Msg.dwParam1;
|
|
|
|
}
|
|
|
|
public void SetPos(Vector3 pos)
|
|
{
|
|
transform.position = pos;
|
|
}
|
|
public void SetStatusRun(bool value)
|
|
{
|
|
if (!isGrounded)
|
|
{
|
|
Debug.LogError("Player not in ground");
|
|
return;
|
|
}
|
|
isRun = value;
|
|
}
|
|
public void InitCharacter(cmd_self_info_1 role)
|
|
{
|
|
string roleName = "(Error decoding name)";
|
|
//if (role.name != null && role.name.ByteArray != null)
|
|
//{
|
|
// roleName = Encoding.UTF8.GetString(role.name.ByteArray, 0, role.name.Length);
|
|
//}
|
|
SetPlayerInfor(new INFO(role.cid, role.crc_e, role.crc_c));
|
|
Vector3 pos = new Vector3(role.pos.x, role.pos.y, role.pos.z);
|
|
if (txtName != null) txtName.text = roleName;
|
|
transform.position = pos;
|
|
SetModelHostPlayer();
|
|
Debug.LogError("Pos Character = " + pos);
|
|
joystick = FindAnyObjectByType<Joystick>();
|
|
EventBus.Subscribe<JoystickRealeaseEvent>(JoystickRelease);
|
|
EventBus.Subscribe<JoystickPressEvent>(JoystickStartDrag);
|
|
if (TryGetComponent<PlayerVisual>(out var visual))
|
|
{
|
|
visual.InitHostPlayerEventDoneHandler();
|
|
}
|
|
|
|
// Create work manager
|
|
m_pWorkMan = new CECHPWorkMan(this);
|
|
if (m_pWorkMan == null)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void JoystickStartDrag(JoystickPressEvent joystickPressEvent)
|
|
{
|
|
_playerStateMachine.ChangeState(_moveState);
|
|
}
|
|
private void OnDestroy()
|
|
{
|
|
EventBus.Unsubscribe<JoystickRealeaseEvent>(JoystickRelease);
|
|
EventBus.Unsubscribe<JoystickPressEvent>(JoystickStartDrag);
|
|
}
|
|
public void InitCharacter(info_player_1 role)
|
|
{
|
|
string roleName = "(Error decoding name)";
|
|
//if (role.name != null && role.name.ByteArray != null)
|
|
//{
|
|
// roleName = Encoding.UTF8.GetString(role.name.ByteArray, 0, role.name.Length);
|
|
//}
|
|
Vector3 pos = new Vector3(role.pos.x, role.pos.y, role.pos.z);
|
|
if (txtName != null) txtName.text = roleName;
|
|
transform.position = pos;
|
|
SetModelHostPlayer();
|
|
Debug.LogError("Pos Character = " + pos);
|
|
}
|
|
|
|
#region Task
|
|
public void OnMsgHstTaskData(ECMSG Msg)
|
|
{
|
|
int cmd = Convert.ToInt32(Msg.dwParam2);
|
|
if (cmd == CommandID.TASK_DATA)
|
|
{
|
|
Debug.Log("[Dat]- OnMsgHstTaskData- TASK_DATA");
|
|
//a_LogOutput(1, "[Dat]- EC_HostMsg- OnMsgHstTaskData- TASK_DATA");
|
|
//cmd_task_data* pCmd = (cmd_task_data*)Msg.dwParam1;
|
|
//ASSERT(pCmd);
|
|
|
|
//int iActiveListSize = (int)pCmd.active_list_size;
|
|
//BYTE* pData = (BYTE*)pCmd + sizeof(size_t);
|
|
//void* pActiveListbuf = pData;
|
|
//pData += iActiveListSize;
|
|
|
|
//int iFinishedListSize = *(int*)pData;
|
|
//pData += sizeof(int);
|
|
//void* pFinishedListBuf = pData;
|
|
//pData += iFinishedListSize;
|
|
|
|
//int iFinishTimeListSize = *(int*)pData;
|
|
//pData += sizeof(int);
|
|
//void* pFinishTimeListBuf = pData;
|
|
//pData += iFinishTimeListSize;
|
|
|
|
//int iFinishedCountListSize = *(int*)pData;
|
|
//pData += sizeof(int);
|
|
//void* pFinishedCountListBuf = pData;
|
|
//pData += iFinishedCountListSize;
|
|
|
|
//int iStorageTasksListSize = *(int*)pData;
|
|
//pData += sizeof(int);
|
|
//void* pStorageTaskListBuf = pData;
|
|
//pData += iStorageTasksListSize;
|
|
|
|
//A3DRELEASE(m_pTaskInterface);
|
|
|
|
//todo
|
|
//var m_pTaskInterface = new CECTaskInterface(this);
|
|
|
|
//if (!m_pTaskInterface.Init(null, 0, null, 0,
|
|
// null, 0, null, 0, null, 0))
|
|
//{
|
|
// //a_LogOutput(1, "CECHostPlayer::OnMsgHstTaskData, failed to initialize task interface");
|
|
// return;
|
|
//}
|
|
|
|
//m_pTaskInterface.CheckPQEnterWorldInit();
|
|
|
|
//// check if player has equipped goblin
|
|
//if (m_pEquipPack.GetItem(EQUIPIVTR_GOBLIN) != NULL)
|
|
//{
|
|
// CECIvtrGoblin* pIvtrGoblin = (CECIvtrGoblin*)m_pEquipPack.GetItem(EQUIPIVTR_GOBLIN);
|
|
// m_pGoblin = new CECHostGoblin();
|
|
// m_pGoblin.Init(pIvtrGoblin.GetTemplateID(), pIvtrGoblin, this);
|
|
//}
|
|
|
|
//// Note: this command now is also used as the end flag of responding
|
|
//// for GET_ALL_DATA request
|
|
//g_pGame.GetGameSession().LoadConfigData();
|
|
|
|
//// ¸ù¾Ý×°±¸°ü¹ü¸üÐÂ×°±¸¼¼Äܵ½¼¼ÄÜÁбí
|
|
//if (UpdateEquipSkills())
|
|
// UpdateEquipSkillCoolDown();
|
|
}
|
|
else if (cmd == CommandID.TASK_VAR_DATA)
|
|
{
|
|
//cmd_task_var_data* pCmd = (cmd_task_var_data*)Msg.dwParam1;
|
|
//ASSERT(pCmd);
|
|
//if (m_pTaskInterface)
|
|
// OnServerNotify(m_pTaskInterface, pCmd.data, pCmd.size);
|
|
//else
|
|
// ASSERT(m_pTaskInterface);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
private bool NormalAttackObject(int idTarget, bool bForceAttack, bool bMoreClose = false)
|
|
{
|
|
if (idTarget == 0 || idTarget == m_PlayerInfo.cid)
|
|
{
|
|
// We should have check target isn't dead
|
|
return false;
|
|
}
|
|
//if (!EC_Game.GetGameRun().GetWorld().GetObject(idTarget, 1))
|
|
// return false;
|
|
bool bStartNewWork = false;
|
|
|
|
bool bUseAutoPF = false;
|
|
//CECPlayerWrapper* pWrapper = CECAutoPolicy::GetInstance().GetPlayerWrapper();
|
|
//if (CECAutoPolicy::GetInstance().IsAutoPolicyEnabled() && pWrapper.GetAttackError() >= 2)
|
|
bUseAutoPF = true;
|
|
|
|
CECHPWorkTrace pWorkTrace = null;
|
|
CECHPWork pWork = null;
|
|
if ((pWork = m_pWorkMan.GetWork(CECHPWork.Host_work_ID.WORK_TRACEOBJECT)) != null)
|
|
{
|
|
pWorkTrace = pWork as CECHPWorkTrace;
|
|
}
|
|
else if ((pWork = m_pWorkMan.GetWork(CECHPWork.Host_work_ID.WORK_HACKOBJECT)) != null)
|
|
{
|
|
if ((pWork as CECHPWorkMelee).GetTarget() == idTarget)
|
|
return false; // Host is attacking the target
|
|
|
|
pWorkTrace = (CECHPWorkTrace)m_pWorkMan.CreateWork(CECHPWork.Host_work_ID.WORK_TRACEOBJECT);
|
|
bStartNewWork = true;
|
|
}
|
|
else if (m_pWorkMan.CanStartWork(CECHPWork.Host_work_ID.WORK_TRACEOBJECT))
|
|
{
|
|
pWorkTrace = (CECHPWorkTrace)m_pWorkMan.CreateWork(CECHPWork.Host_work_ID.WORK_TRACEOBJECT);
|
|
bStartNewWork = true;
|
|
}
|
|
|
|
if (pWorkTrace != null)
|
|
{
|
|
pWorkTrace.SetTraceTarget(pWorkTrace.CreatTraceTarget(idTarget, CECHPWorkTrace.Trace_reason.TRACE_ATTACK, bForceAttack), bUseAutoPF);
|
|
pWorkTrace.SetMoveCloseFlag(bMoreClose);
|
|
|
|
if (bStartNewWork)
|
|
m_pWorkMan.StartWork_p1(pWorkTrace);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int AttackableJudge(int idTarget, bool bForceAttack)
|
|
{
|
|
if (CannotAttack())
|
|
return 0;
|
|
|
|
//if (CDlgAutoHelp::IsAutoHelp())
|
|
// return 0;
|
|
|
|
if (idTarget == 0 || idTarget == m_PlayerInfo.cid)
|
|
return -1;
|
|
|
|
CECObject pObject = EC_ManMessageMono.Instance.GetObject(idTarget, 1);
|
|
if (!pObject)
|
|
return -1;
|
|
|
|
// If target is pet, it's attacked possibility depends on it's monster
|
|
if (GPDataTypeHelper.ISNPCID(idTarget))
|
|
{
|
|
CECNPC pNPC = (CECNPC)pObject;
|
|
int idMaster = pNPC.GetMasterID();
|
|
if (idMaster != 0)
|
|
{
|
|
// master¿ÉÄÜÊÇhostplayer
|
|
if (idMaster == m_PlayerInfo.cid)
|
|
return 0;
|
|
|
|
//// Follow pet cannot be attacked
|
|
//if (pNPC.IsPetNPC() && ((CECPet)pNPC).IsFollowPet())
|
|
// return 0;
|
|
|
|
idTarget = idMaster;
|
|
pObject = EC_ManMessageMono.Instance.GetObject(idTarget, 1);
|
|
if (!pObject)
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int iRet = 0;
|
|
|
|
if (GPDataTypeHelper.ISNPCID(idTarget))
|
|
{
|
|
CECNPC pNPC = (CECNPC)pObject;
|
|
|
|
// If this npc is host's pet, cannot be attacked
|
|
//if (pNPC.GetMasterID() == m_PlayerInfo.cid)
|
|
// return 0;
|
|
|
|
// If it's a pet and can not be attacked, pet can be attacked only if it's a fighting pet
|
|
//if (pNPC.IsPetNPC() && !((CECPet)pNPC).CanBeAttacked())
|
|
// return 0;
|
|
|
|
if (IsInBattle()) // Host is in battle
|
|
{
|
|
if (InSameBattleCamp(pNPC))
|
|
iRet = 0;
|
|
else
|
|
{
|
|
if (pNPC.IsMonsterNPC())
|
|
iRet = 1;
|
|
else if (pNPC.IsServerNPC() && (IsInFortress() || pNPC.GetRoleInBattle() == 8)) // ¶Ô·þÎñÐÍNPCµÄ¹¥»÷£¬°ïÅÉ»ùµØ»ò³Çսʱ¿ÉÓÃ
|
|
iRet = 1;
|
|
else
|
|
iRet = 0;
|
|
}
|
|
}
|
|
else if (pNPC.IsServerNPC())
|
|
{
|
|
// In sanctuary we cannot attack NPCs
|
|
if (!IsPVPOpen() || m_bInSanctuary || !bForceAttack)
|
|
iRet = 0;
|
|
else
|
|
iRet = 1;
|
|
}
|
|
else // Is monster
|
|
{
|
|
iRet = 1;
|
|
}
|
|
if (iRet == 1 && pNPC.GetOwnerFaction() > 0)
|
|
{
|
|
// Õë¶Ô°ïÅÉ PVP Õ½ÕùÖнûÖ¹²¿·Ö¹¥»÷
|
|
if (GetFactionID() == pNPC.GetOwnerFaction() || // ²»¹¥»÷ͬ°ï¹Ö
|
|
pNPC.IsFactionPVPMineCar() && !CanAttackFactionPVPMineCar() || // ÎÞ·¨ÔÙ¹¥»÷Ëû°ï¿ó³µÇé¿ö
|
|
pNPC.IsFactionPVPMineBase() && !CanAttackFactionPVPMineBase())
|
|
{ // ÎÞ·¨ÔÙ¹¥»÷Ëû°ï´æ¿óµãÇé¿ö
|
|
iRet = 0;
|
|
}
|
|
}
|
|
}
|
|
// TO DO: fix later
|
|
//else if (GPDataTypeHelper.ISPLAYERID(idTarget))
|
|
//{
|
|
// // Check duel at first
|
|
// if (m_pvp.iDuelState == Duel_state.DUEL_ST_INDUEL && m_pvp.idDuelOpp == idTarget)
|
|
// return 1;
|
|
// else if (m_pvp.iDuelState == Duel_state.DUEL_ST_STOPPING && m_pvp.idDuelOpp == idTarget)
|
|
// return 0;
|
|
|
|
// // In sanctuary we cannot attack other players
|
|
// if (m_bInSanctuary)
|
|
// return 0;
|
|
|
|
// //ASSERT(pObject.GetClassID() == CECObject::OCID_ELSEPLAYER);
|
|
// EC_ElsePlayer pPlayer = (EC_ElsePlayer)pObject;
|
|
// ROLEBASICPROP bp = pPlayer.GetBasicProps();
|
|
// EC_GAME_SETTING gs = g_pGame.GetConfigs().GetGameSettings();
|
|
|
|
// if (m_pvp.bFreePVP)
|
|
// {
|
|
// if (IsTeamMember(idTarget))
|
|
// return 0;
|
|
|
|
// // In free pvp mode, for example, host is in arena.
|
|
// if (bForceAttack)
|
|
// iRet = 1;
|
|
// else if (gs.bAtk_NoMafia && IsFactionMember(pPlayer.GetFactionID()))
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoWhite && !pPlayer.IsInvader() && !pPlayer.IsPariah())
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoAlliance && g_pGame.GetFactionMan().IsFactionAlliance(pPlayer.GetFactionID()))
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoForce && GetForce() > 0 && GetForce() == pPlayer.GetForce())
|
|
// iRet = 0;
|
|
// else
|
|
// iRet = 1;
|
|
// }
|
|
// else if (m_iBattleCamp != GP_BATTLE_CAMP_NONE)
|
|
// {
|
|
// // Host is in battle
|
|
// int iCamp = pPlayer.GetBattleCamp();
|
|
// if (iCamp != GP_BATTLE_CAMP_NONE && iCamp != m_iBattleCamp)
|
|
// iRet = 1;
|
|
// else
|
|
// iRet = 0;
|
|
// }
|
|
// else // Normal mode
|
|
// {
|
|
// if (IsTeamMember(idTarget))
|
|
// return 0;
|
|
|
|
// if (!IsPVPOpen() || !pPlayer.IsPVPOpen() || m_BasicProps.iLevel < EC_MAXNOPKLEVEL || bp.iLevel < EC_MAXNOPKLEVEL)
|
|
// iRet = 0;
|
|
// else if (bForceAttack)
|
|
// iRet = 1;
|
|
// else if (!gs.bAtk_Player)
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoMafia && IsFactionMember(pPlayer.GetFactionID()))
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoWhite && !pPlayer.IsInvader() && !pPlayer.IsPariah())
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoAlliance && g_pGame.GetFactionMan().IsFactionAlliance(pPlayer.GetFactionID()))
|
|
// iRet = 0;
|
|
// else if (gs.bAtk_NoForce && GetForce() > 0 && GetForce() == pPlayer.GetForce())
|
|
// iRet = 0;
|
|
// else
|
|
// iRet = 1;
|
|
// }
|
|
//}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
private float A3d_Magnitude(A3DVECTOR3 v)
|
|
{
|
|
return Mathf.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
|
|
}
|
|
|
|
public int GetCharacterID() { return m_PlayerInfo.cid; }
|
|
|
|
public bool CannotAttack() { return (m_dwLIES & (uint)Logic_Influence_Extned_states.LIES_DISABLEFIGHT) != 0; }
|
|
|
|
public bool CanTouchTarget(A3DVECTOR3 vHostPos, A3DVECTOR3 vTargetPos, float fTargetRad, int iReason, float fMaxCut = 1.0f)
|
|
{
|
|
float fDist = A3d_Magnitude(vTargetPos - vHostPos);
|
|
switch (iReason)
|
|
{
|
|
case 1: // melee
|
|
{
|
|
float fRange;
|
|
if (fMaxCut >= 0.0f)
|
|
{
|
|
float fCutDist = m_ExtProps.ak.AttackRange * 0.3f;
|
|
if (fCutDist > fMaxCut)
|
|
fCutDist = fMaxCut;
|
|
|
|
fRange = m_ExtProps.ak.AttackRange - fCutDist;
|
|
}
|
|
|
|
else
|
|
fRange = m_ExtProps.ak.AttackRange * 0.7f;
|
|
|
|
if (fDist - fTargetRad <= fRange)
|
|
return true;
|
|
|
|
break;
|
|
}
|
|
//case 2: // cast magic
|
|
//{
|
|
// if (m_pPrepSkill)
|
|
// {
|
|
// float fRange = m_pPrepSkill.GetCastRange(m_ExtProps.ak.AttackRange, GetPrayDistancePlus());
|
|
// if (fRange > 0.0f)
|
|
// {
|
|
// if (fDist - fTargetRad <= fRange)
|
|
// return true;
|
|
// }
|
|
// else
|
|
// return true;
|
|
// }
|
|
|
|
// break;
|
|
//}
|
|
case 3: // talk
|
|
{
|
|
if (fDist - fTargetRad <= 5.0f)
|
|
return true;
|
|
|
|
break;
|
|
}
|
|
default: // no special reason
|
|
{
|
|
if (fDist < (fTargetRad + m_fTouchRad) * 3.0f)
|
|
return true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool CanTouchTarget(A3DVECTOR3 vTargetPos, float fTargetRad, int iReason, float fMaxCut = 1.0f)
|
|
{
|
|
A3DVECTOR3 vector = new A3DVECTOR3(gameObject.transform.position.x, gameObject.transform.position.y, gameObject.transform.position.z);
|
|
return CanTouchTarget(vector, vTargetPos, fTargetRad, iReason, fMaxCut);
|
|
}
|
|
public bool IsRooting()
|
|
{
|
|
var mask = (uint)(Logic_Influence_Extned_states.LIES_ROOT
|
|
| Logic_Influence_Extned_states.LIES_SLEEP
|
|
| Logic_Influence_Extned_states.LIES_STUN);
|
|
return (m_dwLIES & mask) != 0;
|
|
}
|
|
|
|
bool IsInFortress() { return m_fortressEnter.role_in_war != 0; }
|
|
|
|
bool IsPVPOpen() { return m_pvp.bEnable; }
|
|
// Get faction ID
|
|
int GetFactionID() { return m_idFaction; }
|
|
|
|
public bool IsJumping() { return m_iJumpCount > 0; }
|
|
|
|
public bool IsPlayingAction(int iAction)
|
|
{
|
|
if (iAction == (int)PLAYER_ACTION_TYPE.ACT_WALK && _playerStateMachine.State is PlayerMoveState)
|
|
{
|
|
return true;
|
|
}
|
|
if (iAction == (int)PLAYER_ACTION_TYPE.ACT_STAND && _playerStateMachine.State is PlayerIdleState)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void ResetJump() { m_iJumpCount = 0; m_bJumpInWater = false; }
|
|
// Get move speed
|
|
public float GetFlySpeed() { return m_ExtProps.mv.flight_speed; }
|
|
public float GetSwimSpeed() { return m_ExtProps.mv.swim_speed; }
|
|
|
|
//public float GetSwimSpeedSev()
|
|
//{
|
|
// float fSpeedSev = GetSwimSpeed();
|
|
// while (true)
|
|
// {
|
|
// if (!IsUnderWater()) break;
|
|
// //CECWorld* pWorld = g_pGame.GetGameRun().GetWorld();
|
|
// //if (!pWorld) break;
|
|
|
|
// const A3DVECTOR3 vPos = GetPos();
|
|
// float fTerrainHeight = pWorld.GetTerrainHeight(vPos);
|
|
// float fWaterHeight = pWorld.GetWaterHeight(vPos);
|
|
// if (fWaterHeight <= fTerrainHeight) break;
|
|
|
|
// float fBorderLine = fWaterHeight - 2.0f;
|
|
// if (vPos.y <= fBorderLine) break;
|
|
|
|
// // ·þÎñÆ÷¶Ë½«Ë®ÃæÒÔÏÂ2Ã×ÒÔÉÏ´¦ÀíΪ run_speed£¨ÓÐÎÊÌ⣩
|
|
// // µ«Î´Ê¹ÓüÓËÙ¼¼ÄÜʱ swim_speed СÓÚ run_speed£¬
|
|
// // ¿ÉÒÔÔÚË®ÃæÒÔÏÂ2Ã×ÒÔÉÏ»ñÈ¡³¬¹ý swim_speed µÄËٶȣ¬Òò´Ë£¬´Ë´¦È¡Á½Õß½ÏСֵΪºÏÀí×ö·¨
|
|
// fSpeedSev = min(m_ExtProps.mv.run_speed, fSpeedSev);
|
|
// break;
|
|
// }
|
|
// return fSpeedSev;
|
|
//}
|
|
}
|
|
|
|
public enum StateAnim
|
|
{
|
|
Idle = 1,
|
|
Walk = 2,
|
|
Run = 3,
|
|
Jump = 4
|
|
}
|
|
|
|
// Mask of some special extend states which will influence host game logic.
|
|
// Logic Influence Extned states
|
|
[Flags]
|
|
public enum Logic_Influence_Extned_states
|
|
{
|
|
LIES_SLEEP = 0x0001,
|
|
LIES_STUN = 0x0002,
|
|
LIES_ROOT = 0x0004,
|
|
LIES_NOFGIHT = 0x0008,
|
|
|
|
LIES_DISABLEFIGHT = 0x000B,
|
|
}
|
|
|
|
// ½øÈë»ùµØÐÅÏ¢
|
|
public struct FACTION_FORTRESS_ENTER
|
|
{
|
|
public int faction_id;
|
|
public int role_in_war; // 0 : ÖÐÁ¢»ò²»ÔÚ»ùµØ 1:¹¥·½ 2: ÊØ·½
|
|
public int end_time;
|
|
|
|
public FACTION_FORTRESS_ENTER(int faction_id, int role_in_war, int end_time)
|
|
{
|
|
this.faction_id = faction_id;
|
|
this.role_in_war = role_in_war;
|
|
this.end_time = end_time;
|
|
}
|
|
}
|
|
|
|
// PVP infomation
|
|
public struct PVPINFO
|
|
{
|
|
public bool bEnable; // PVP switch
|
|
public uint dwCoolTime;
|
|
public uint dwMaxCoolTime;
|
|
public bool bFreePVP; // Free PVP flag, ignore bEnable flag
|
|
public bool bInPVPCombat; // true, in PVP combat
|
|
public int iDuelState; // Duel state
|
|
public int idDuelOpp; // Duel opponent
|
|
public int iDuelTimeCnt; // Duel time counter
|
|
public int iDuelRlt; // Duel result. 0, no defined; 1-win; 2-lose; 3-draw
|
|
};
|
|
|
|
// Current ground information
|
|
public struct GNDINFO
|
|
{
|
|
public float fGndHei; // Ground height
|
|
public float fWaterHei; // Water height
|
|
public A3DVECTOR3 vGndNormal; // Terrain normal
|
|
public bool bOnGround; // On ground flag
|
|
}; |