using UnityEngine;
|
|
|
public abstract class GActorNpcNoFight : GActor, IOtherSelectable
|
{
|
protected GameObject m_Model;
|
protected Animator m_Animator;
|
protected UnityEngine.AI.NavMeshObstacle m_Dig;
|
private SFXController m_Shadow;
|
|
public NPCConfig NpcConfig { get; protected set; }
|
public SFXController m_AppearEffect;
|
protected bool m_LoadDefaultRes = false;
|
protected bool IsUnInit = false;
|
public override int NextAction
|
{
|
get
|
{
|
if (!m_Animator)
|
{
|
return -1;
|
}
|
return m_Animator.GetInteger(GAStaticDefine.Param_Action);
|
}
|
set
|
{
|
if (m_Animator)
|
{
|
m_Animator.SetInteger(GAStaticDefine.Param_Action, value);
|
}
|
}
|
}
|
|
public virtual void InitNpcConfig(int npcID)
|
{
|
if (npcID > 0)
|
{
|
NpcConfig = NPCConfig.Get(npcID);
|
}
|
}
|
|
protected override void OnInit(GameNetPackBasic package)
|
{
|
m_LoadDefaultRes = false;
|
IsUnInit = false;
|
int _npcID = 0;
|
if (this is GA_NpcSummonFunc)
|
{
|
_npcID = (int)(package as H0408_tagPlayerSummonNPCAppear).NPCID;
|
}
|
else
|
{
|
_npcID = (int)(package as H0406_tagNPCAppear).NPCID;
|
}
|
|
if (_npcID == 0)
|
{
|
return;
|
}
|
|
HandleNpcConfig(_npcID);
|
|
if (NpcConfig == null)
|
{
|
// 报错
|
return;
|
}
|
|
ActorType = GameObjType.gotNPC;
|
Root.gameObject.layer = LayerUtility.Monster;
|
|
if (NpcConfig.ModeProportion != 1)
|
{
|
Root.localScale = Vector3.one * NpcConfig.ModeProportion;
|
}
|
|
if (CanBeSelected())
|
{
|
CapsuleCollider _collider = Root.AddMissingComponent<CapsuleCollider>();
|
_collider.center = new Vector3(0, NpcConfig.ModleHeight * .5f, 0);
|
_collider.radius = NpcConfig.ModelRadius;
|
_collider.height = NpcConfig.ModleHeight;
|
}
|
|
RequestShadow();
|
|
if (NpcConfig.NPCEffect != 0)
|
{
|
m_AppearEffect = SFXPlayUtility.Instance.PlayBattleEffect(NpcConfig.NPCEffect, this);
|
}
|
|
// 开始异步加载表现层
|
InstanceResourcesLoader.AsyncLoadNpc(NpcConfig.NPCID, OnPrefabLoadFinished);
|
}
|
|
public override void ShowEffect() { }
|
|
protected virtual void HandleNpcConfig(int npcID)
|
{
|
NpcConfig = NPCConfig.Get(npcID);
|
}
|
|
protected override void OnUnit()
|
{
|
HideEffect();
|
|
if (m_LoadDefaultRes)
|
{
|
GameObjectPoolManager.Instance.ReleaseDefaultFuncNPC(m_Model);
|
}
|
else
|
{
|
if (NpcConfig != null)
|
{
|
GameObject _prefab = InstanceResourcesLoader.LoadNpc(NpcConfig.NPCID);
|
GameObjectPoolManager.Instance.ReleaseGameObject(_prefab, m_Model);
|
|
if (m_Model)
|
{
|
if (NpcConfig.MODE.Contains("A_Zs") || NpcConfig.MODE.Contains("A_Fs"))
|
{
|
var _renderer = m_Model.GetComponentInChildren<SkinnedMeshRenderer>();
|
if (_renderer)
|
{
|
MaterialLoader.Release(_renderer.material);
|
_renderer.material = _renderer.sharedMaterial = null;
|
_renderer.materials = _renderer.sharedMaterials = new Material[0];
|
}
|
}
|
}
|
}
|
}
|
|
m_Model = null;
|
|
if (m_AppearEffect)
|
{
|
SFXPlayUtility.Instance.Release(m_AppearEffect);
|
m_AppearEffect = null;
|
}
|
|
if (m_Animator)
|
{
|
m_Animator.runtimeAnimatorController = null;
|
m_Animator.enabled = false;
|
m_Animator = null;
|
}
|
|
ReleaseName();
|
ReleaseShadow();
|
|
if (m_Dig)
|
{
|
Object.Destroy(m_Dig.gameObject);
|
m_Dig = null;
|
}
|
|
if (Root)
|
{
|
Root.localScale = Vector3.one;
|
}
|
IsUnInit = true;
|
}
|
|
public override void Destroy()
|
{
|
}
|
|
protected virtual void OnPrefabLoadFinished(bool result, UnityEngine.Object prefab)
|
{
|
if (IsUnInit)
|
{
|
return;
|
}
|
|
if (!result || prefab == null)
|
{
|
if (!m_LoadDefaultRes)
|
{
|
m_LoadDefaultRes = true;
|
InstanceResourcesLoader.AsyncLoadDefaultFuncNpc(OnPrefabLoadFinished);
|
}
|
else
|
{
|
m_LoadDefaultRes = false;
|
Debug.LogErrorFormat("加载Npc模型资源出错: {0}", NpcConfig.NPCID);
|
}
|
|
return;
|
}
|
|
if (PreFightMission.Instance.IsFinished())
|
{
|
GAMgr.Instance.AddNeedDestroyPrefab(prefab as GameObject);
|
}
|
|
if (this is GA_Guard
|
|| NpcConfig.MODE.Contains("A_Zs")
|
|| NpcConfig.MODE.Contains("A_Fs")
|
|| NpcConfig.MODE.Contains("Sh0"))
|
{
|
GAMgr.Instance.RemoveNeedDestroyPrefab(prefab as GameObject);
|
}
|
|
if (m_LoadDefaultRes)
|
{
|
m_Model = GameObjectPoolManager.Instance.RequestDefaultFuncNpc();
|
}
|
else
|
{
|
m_Model = GameObjectPoolManager.Instance.RequestGameObject(prefab as GameObject);
|
}
|
|
if (m_Model)
|
{
|
m_Animator = m_Model.GetComponentInChildren<Animator>();
|
if (m_Animator)
|
{
|
RuntimeAnimatorController _controller = null;
|
if (m_LoadDefaultRes)
|
{
|
_controller = AnimatorControllerLoader.LoadDefaultMobAnimatorController_Func();
|
}
|
else
|
{
|
int _loadNpcID = NpcConfig.NPCID;
|
if (_loadNpcID == 10804101)
|
{
|
if (PlayerDatas.Instance.baseData.Job == 1)
|
{
|
_loadNpcID = 10404100;
|
}
|
else if (PlayerDatas.Instance.baseData.Job == 2)
|
{
|
_loadNpcID = 10404101;
|
}
|
}
|
|
var _npcConfig = NPCConfig.Get(_loadNpcID);
|
|
string _name = _npcConfig.MODE;
|
var _configName = string.Empty;
|
|
if (NpcConfig.NPCID != 10804101)
|
{
|
if (_name.Contains("A_Zs"))
|
{
|
_configName = _name.Substring(_name.LastIndexOf("A_"));
|
_name = "A_Zs";
|
GameObjectPoolManager.Instance.AddDontDestroyGoInstID(m_Model.GetInstanceID());
|
}
|
else if (_name.Contains("A_Fs"))
|
{
|
_configName = _name.Substring(_name.LastIndexOf("A_"));
|
_name = "A_Fs";
|
GameObjectPoolManager.Instance.AddDontDestroyGoInstID(m_Model.GetInstanceID());
|
}
|
|
if (_name.Contains("A_Zs") || _name.Contains("A_Fs"))
|
{
|
if (!string.IsNullOrEmpty(_configName))
|
{
|
var _renderer = m_Model.GetComponentInChildren<SkinnedMeshRenderer>();
|
if (_renderer)
|
{
|
MaterialLoader.Release(_renderer.material);
|
|
var _modelResConfig = ModelResConfig.GetClothesConfig(_configName);
|
if (_modelResConfig != null)
|
{
|
_renderer.material = MaterialLoader.LoadClothesMaterial(_modelResConfig.ID, false, false);
|
}
|
}
|
}
|
}
|
|
_controller = AnimatorControllerLoader.LoadMobController(AnimatorControllerLoader.controllerSuffix, _name);
|
}
|
|
}
|
|
if (_controller)
|
{
|
m_Animator.runtimeAnimatorController = _controller;
|
}
|
m_Animator.enabled = true;
|
m_Animator.SetInteger(GAStaticDefine.Param_ActorInstID, (int)ClientInstID);
|
if (HasState(GAStaticDefine.State_IdleHash))
|
{
|
IdleImmediate();
|
}
|
}
|
|
SetupBindNode(m_Model.transform);
|
|
m_Model.transform.SetParent(m_Root);
|
m_Model.transform.localPosition = Vector3.zero;
|
m_Model.transform.localScale = Vector3.one;
|
m_Model.transform.localRotation = Quaternion.identity;
|
|
RequestName();
|
|
OnMainModelLoaded();
|
}
|
}
|
|
protected virtual void OnMainModelLoaded()
|
{
|
SkinnedMeshRenderer _renderer = m_Model.GetComponentInChildren<SkinnedMeshRenderer>();
|
if (_renderer)
|
{
|
_renderer.gameObject.layer = LayerUtility.Monster;
|
}
|
}
|
|
public virtual void InitPerformance(uint clientInstID, int npcID)
|
{
|
GameObject _prefab = InstanceResourcesLoader.LoadNpcPrefab(npcID);
|
InstanceResourcesLoader.AsyncLoadNpc(npcID, OnPrefabLoadFinished);
|
}
|
|
public sealed override void SetAnimatorSpeed(float speed)
|
{
|
if (m_Animator)
|
{
|
m_Animator.speed = speed;
|
}
|
}
|
|
public sealed override void Play(int stateNameHash, float normalizeTime = 0)
|
{
|
if (m_Animator)
|
{
|
if (m_Animator.HasState(0, stateNameHash))
|
{
|
m_Animator.Play(stateNameHash, 0, normalizeTime);
|
}
|
}
|
}
|
|
public override void Idle()
|
{
|
NextAction = GAStaticDefine.Act_Idle;
|
}
|
|
public override void IdleImmediate()
|
{
|
if (m_Animator)
|
{
|
Idle();
|
m_Animator.Play(GAStaticDefine.State_IdleHash);
|
}
|
}
|
|
public override void Run()
|
{
|
NextAction = GAStaticDefine.Act_Run;
|
}
|
|
public override void RunImmediate()
|
{
|
if (m_Animator)
|
{
|
Run();
|
m_Animator.Play(GAStaticDefine.State_RunHash);
|
}
|
}
|
|
public override bool IsIdle()
|
{
|
AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
|
return _stateInfo.shortNameHash == GAStaticDefine.State_IdleHash;
|
}
|
|
public override bool IsRun()
|
{
|
AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
|
return _stateInfo.shortNameHash == GAStaticDefine.State_RunHash;
|
}
|
|
public override bool IsHurt()
|
{
|
AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
|
return _stateInfo.shortNameHash == GAStaticDefine.State_HurtHash;
|
}
|
|
public sealed override bool IsStun()
|
{
|
AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
|
|
return _stateInfo.shortNameHash == GAStaticDefine.State_StunHash;
|
}
|
|
public sealed override bool HasState(int stateHash)
|
{
|
if (m_Animator)
|
{
|
return m_Animator.HasState(0, stateHash);
|
}
|
return false;
|
}
|
|
public override void RequestShadow()
|
{
|
ReleaseShadow();
|
m_Shadow = SFXPlayUtility.Instance.PlayBattleEffect(999999, m_Root);
|
m_Shadow.duration = 0;
|
if (Root.transform.localScale == Vector3.zero)
|
{
|
Root.transform.localScale = Vector3.one;
|
}
|
m_Shadow.transform.localScale = new Vector3((NpcConfig.ModelRadius * 2) / Root.transform.localScale.x,
|
1,
|
(NpcConfig.ModelRadius * 2) / Root.transform.localScale.z);
|
}
|
|
public sealed override void ReleaseShadow()
|
{
|
if (m_Shadow)
|
{
|
SFXPlayUtility.Instance.Release(m_Shadow);
|
m_Shadow = null;
|
}
|
}
|
|
public sealed override void ShowOrHideModel(bool showOrHide)
|
{
|
if (ShowOrHide == showOrHide)
|
{
|
return;
|
}
|
|
if (showOrHide)
|
{
|
if (m_Model)
|
{
|
m_Model.transform.localPosition = Vector3.zero;
|
m_Model.transform.localRotation = Quaternion.identity;
|
}
|
|
RequestName();
|
RequestShadow();
|
}
|
else
|
{
|
if (m_Model)
|
{
|
m_Model.transform.localPosition = Constants.Special_Hide_Position;
|
}
|
|
if (PlayerDatas.Instance.hero.SelectTarget == this)
|
{
|
PlayerDatas.Instance.hero.SelectTarget = null;
|
}
|
|
if (PlayerDatas.Instance.hero.LockTarget == this)
|
{
|
PlayerDatas.Instance.hero.LockTarget = null;
|
}
|
|
ReleaseName();
|
ReleaseShadow();
|
}
|
|
ShowOrHide = showOrHide;
|
}
|
|
public override abstract void RequestName();
|
public override abstract void RequestLifeBar();
|
|
public abstract void OnSelect();
|
public abstract void OnUnSelect();
|
public abstract bool CanBeSelected();
|
public abstract void OnClick();
|
}
|
