mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 16:34:41 +01:00
545 lines
16 KiB
C#
545 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using MoleMole.Config;
|
|
using UniRx;
|
|
using UnityEngine;
|
|
using proto;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public class AvatarManager
|
|
{
|
|
private uint _localAvatarRuntimeID;
|
|
|
|
private uint _helperAvatarRuntimeID;
|
|
|
|
private Dictionary<uint, BaseMonoAvatar> _avatarDict;
|
|
|
|
private List<BaseMonoAvatar> _avatarLs;
|
|
|
|
private List<Tuple<string, GameObject>> _preloadedAvatar;
|
|
|
|
private List<BaseMonoAvatar> _playerAvatars;
|
|
|
|
public Action<BaseMonoAvatar, BaseMonoAvatar> onLocalAvatarChanged;
|
|
|
|
public bool isAutoBattle { get; private set; }
|
|
|
|
private AvatarManager()
|
|
{
|
|
_avatarDict = new Dictionary<uint, BaseMonoAvatar>();
|
|
_avatarLs = new List<BaseMonoAvatar>();
|
|
_preloadedAvatar = new List<Tuple<string, GameObject>>();
|
|
_playerAvatars = new List<BaseMonoAvatar>();
|
|
_localAvatarRuntimeID = 0u;
|
|
}
|
|
|
|
public void InitAtAwake()
|
|
{
|
|
}
|
|
|
|
public void InitAtStart()
|
|
{
|
|
}
|
|
|
|
public void Core()
|
|
{
|
|
RemoveAllRemoveableAvatars();
|
|
}
|
|
|
|
public List<BaseMonoAvatar> GetAllAvatars()
|
|
{
|
|
return _avatarLs;
|
|
}
|
|
|
|
public int GetActiveAvatarCount()
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < _avatarLs.Count; i++)
|
|
{
|
|
if (_avatarLs[i].IsActive())
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public List<BaseMonoAvatar> GetAllPlayerAvatars()
|
|
{
|
|
return _playerAvatars;
|
|
}
|
|
|
|
public bool IsPlayerAvatar(BaseMonoAvatar avatar)
|
|
{
|
|
return _playerAvatars.Contains(avatar);
|
|
}
|
|
|
|
public bool IsPlayerAvatar(uint avatarID)
|
|
{
|
|
for (int i = 0; i < _playerAvatars.Count; i++)
|
|
{
|
|
if (_playerAvatars[i].GetRuntimeID() == avatarID)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public BaseMonoAvatar GetAvatarByRuntimeID(uint runtimeID)
|
|
{
|
|
return _avatarDict[runtimeID];
|
|
}
|
|
|
|
public BaseMonoAvatar TryGetAvatarByRuntimeID(uint runtimeID)
|
|
{
|
|
BaseMonoAvatar value;
|
|
_avatarDict.TryGetValue(runtimeID, out value);
|
|
return value;
|
|
}
|
|
|
|
public BaseMonoAvatar GetLocalAvatar()
|
|
{
|
|
return _avatarDict[_localAvatarRuntimeID];
|
|
}
|
|
|
|
public BaseMonoAvatar TryGetLocalAvatar()
|
|
{
|
|
return (!_avatarDict.ContainsKey(_localAvatarRuntimeID)) ? null : _avatarDict[_localAvatarRuntimeID];
|
|
}
|
|
|
|
public BaseMonoAvatar GetHelperAvatar()
|
|
{
|
|
return (_helperAvatarRuntimeID == 0 || !_avatarDict.ContainsKey(_helperAvatarRuntimeID)) ? null : _avatarDict[_helperAvatarRuntimeID];
|
|
}
|
|
|
|
public BaseMonoAvatar GetTeamLeader()
|
|
{
|
|
return GetAllAvatars().Find((BaseMonoAvatar avatar) => avatar.isLeader);
|
|
}
|
|
|
|
public bool RemoveAvatarByRuntimeID(uint runtimeID)
|
|
{
|
|
BaseMonoAvatar baseMonoAvatar = _avatarDict[runtimeID];
|
|
Singleton<EventManager>.Instance.TryRemoveActor(runtimeID);
|
|
UnityEngine.Object.Destroy(baseMonoAvatar.gameObject);
|
|
bool flag = true;
|
|
flag &= _playerAvatars.Remove(baseMonoAvatar);
|
|
flag &= _avatarDict.Remove(runtimeID);
|
|
return flag & _avatarLs.Remove(baseMonoAvatar);
|
|
}
|
|
|
|
public void PreloadAvatar(string avatarType, bool useLow)
|
|
{
|
|
GameObject original = Miscs.LoadResource<GameObject>(AvatarData.GetPrefabResPath(avatarType, useLow));
|
|
GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate(original, InLevelData.CREATE_INIT_POS, Quaternion.Euler(0f, 200f, 0f));
|
|
gameObject.GetComponent<BaseMonoAnimatorEntity>().Preload();
|
|
_preloadedAvatar.Add(new Tuple<string, GameObject>(avatarType, gameObject));
|
|
}
|
|
|
|
public void PreloadTeamAvatars()
|
|
{
|
|
List<AvatarDataItem> list = new List<AvatarDataItem>();
|
|
LevelScoreManager instance = Singleton<LevelScoreManager>.Instance;
|
|
if (instance != null && instance.memberList != null)
|
|
{
|
|
list.AddRange(instance.memberList);
|
|
}
|
|
bool useLow = !GlobalVars.AVATAR_USE_DYNAMIC_BONE || Singleton<LevelManager>.Instance.levelActor.levelMode == LevelActor.Mode.Multi;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
PreloadAvatar(list[i].AvatarRegistryKey, useLow);
|
|
}
|
|
if (instance != null && instance.friendDetailItem != null)
|
|
{
|
|
FriendDetailDataItem friendDetailItem = instance.friendDetailItem;
|
|
AvatarDataItem leaderAvatar = friendDetailItem.leaderAvatar;
|
|
list.Add(leaderAvatar);
|
|
PreloadAvatar(leaderAvatar.AvatarRegistryKey, true);
|
|
}
|
|
}
|
|
|
|
public uint CreateAvatar(AvatarDataItem avatarDataItem, bool isLocal, Vector3 initPos, Vector3 initDir, uint runtimeID, bool isLeader, bool leaderSkillOn, bool isHelper = false, bool useLow = false)
|
|
{
|
|
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0175: Invalid comparison between Unknown and I4
|
|
BaseMonoAvatar baseMonoAvatar = null;
|
|
string avatarRegistryKey = avatarDataItem.AvatarRegistryKey;
|
|
GameObject gameObject = null;
|
|
int index = -1;
|
|
for (int i = 0; i < _preloadedAvatar.Count; i++)
|
|
{
|
|
if (_preloadedAvatar[i].Item1 == avatarRegistryKey)
|
|
{
|
|
gameObject = _preloadedAvatar[i].Item2;
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (gameObject != null)
|
|
{
|
|
gameObject.GetComponent<BaseMonoAvatar>().Enable();
|
|
_preloadedAvatar.RemoveAt(index);
|
|
}
|
|
else
|
|
{
|
|
useLow = useLow || !GlobalVars.AVATAR_USE_DYNAMIC_BONE || Singleton<LevelManager>.Instance.levelActor.levelMode == LevelActor.Mode.Multi;
|
|
GameObject original = Miscs.LoadResource<GameObject>(AvatarData.GetPrefabResPath(avatarRegistryKey, useLow));
|
|
gameObject = (GameObject)UnityEngine.Object.Instantiate(original, InLevelData.CREATE_INIT_POS, Quaternion.Euler(0f, 200f, 0f));
|
|
}
|
|
baseMonoAvatar = gameObject.GetComponent<BaseMonoAvatar>();
|
|
if (runtimeID == 0)
|
|
{
|
|
runtimeID = Singleton<RuntimeIDManager>.Instance.GetNextRuntimeID(3);
|
|
}
|
|
baseMonoAvatar.Init(isLocal, runtimeID, avatarDataItem.AvatarRegistryKey, avatarDataItem.GetWeapon().ID, initPos, initDir, isLeader);
|
|
bool isPlayerAvatar = !isHelper;
|
|
RegisterAvatar(baseMonoAvatar, isLocal, isPlayerAvatar, isHelper);
|
|
AvatarActor avatarActor = Singleton<EventManager>.Instance.CreateActor<AvatarActor>(baseMonoAvatar);
|
|
avatarActor.InitAvatarDataItem(avatarDataItem, isLocal, isHelper, isLeader, leaderSkillOn);
|
|
avatarActor.InitGalTouchBuff(avatarDataItem);
|
|
avatarActor.PostInit();
|
|
LevelScoreManager instance = Singleton<LevelScoreManager>.Instance;
|
|
if ((int)instance.LevelType == 4)
|
|
{
|
|
EndlessAvatarHp endlessAvatarHPData = Singleton<EndlessModule>.Instance.GetEndlessAvatarHPData(avatarDataItem.avatarID);
|
|
avatarActor.HP = (float)avatarActor.maxHP * (float)endlessAvatarHPData.hp_percent / 100f;
|
|
avatarActor.SP = (float)avatarActor.maxSP * (float)endlessAvatarHPData.sp_percent / 100f;
|
|
}
|
|
ConfigAvatar config = baseMonoAvatar.config;
|
|
for (int j = 0; j < config.CommonArguments.PreloadEffectPatternGroups.Length; j++)
|
|
{
|
|
Singleton<EffectManager>.Instance.PreloadEffectGroup(config.CommonArguments.PreloadEffectPatternGroups[j]);
|
|
}
|
|
if (baseMonoAvatar is MonoBronya)
|
|
{
|
|
if (avatarActor.HasAppliedAbilityName("Weapon_Additional_BronyaLaser"))
|
|
{
|
|
Singleton<EffectManager>.Instance.PreloadEffectGroup("Bronya_Laser_Effects");
|
|
}
|
|
else
|
|
{
|
|
Singleton<EffectManager>.Instance.PreloadEffectGroup("Bronya_Gun_Effects");
|
|
}
|
|
}
|
|
for (int k = 0; k < config.CommonArguments.RequestSoundBankNames.Length; k++)
|
|
{
|
|
Singleton<WwiseAudioManager>.Instance.ManualPrepareBank(config.CommonArguments.RequestSoundBankNames[k]);
|
|
}
|
|
return baseMonoAvatar.GetRuntimeID();
|
|
}
|
|
|
|
public uint CreateAvatarMirror(BaseMonoAvatar owner, Vector3 initPos, Vector3 initDir, string AIName, float hpRatio)
|
|
{
|
|
GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource<GameObject>(AvatarData.GetPrefabResPath(owner.AvatarTypeName, true)), initPos, Quaternion.LookRotation(initDir));
|
|
BaseMonoAvatar component = gameObject.GetComponent<BaseMonoAvatar>();
|
|
component.Init(false, Singleton<RuntimeIDManager>.Instance.GetNextRuntimeID(3), owner.AvatarTypeName, owner.EquipedWeaponID, initPos, initDir, false);
|
|
RegisterAvatar(component, false, false, false);
|
|
AvatarMirrorActor avatarMirrorActor = Singleton<EventManager>.Instance.CreateActor<AvatarMirrorActor>(component);
|
|
avatarMirrorActor.InitFromAvatarActor(Singleton<EventManager>.Instance.GetActor<AvatarActor>(owner.GetRuntimeID()), hpRatio);
|
|
avatarMirrorActor.PostInit();
|
|
component.TriggerSwitchIn();
|
|
BTreeAvatarAIController bTreeAvatarAIController = component.GetActiveAIController() as BTreeAvatarAIController;
|
|
if (string.IsNullOrEmpty(AIName))
|
|
{
|
|
bTreeAvatarAIController.SetActive(false);
|
|
}
|
|
else
|
|
{
|
|
bTreeAvatarAIController.ChangeBehavior(AIName);
|
|
component.ForceUseAIController();
|
|
}
|
|
return component.GetRuntimeID();
|
|
}
|
|
|
|
public void RegisterAvatar(BaseMonoAvatar avatar, bool isLocal, bool isPlayerAvatar, bool isHelperAvatar)
|
|
{
|
|
_avatarLs.Add(avatar);
|
|
_avatarDict.Add(avatar.GetRuntimeID(), avatar);
|
|
if (isLocal)
|
|
{
|
|
_localAvatarRuntimeID = avatar.GetRuntimeID();
|
|
}
|
|
if (isHelperAvatar)
|
|
{
|
|
_helperAvatarRuntimeID = avatar.GetRuntimeID();
|
|
}
|
|
if (isPlayerAvatar)
|
|
{
|
|
_playerAvatars.Add(avatar);
|
|
avatar.onDie = (Action<BaseMonoAvatar>)Delegate.Combine(avatar.onDie, new Action<BaseMonoAvatar>(OnPlayerAvatarDie));
|
|
}
|
|
}
|
|
|
|
private void RemoveAllRemoveableAvatars()
|
|
{
|
|
for (int i = 0; i < _avatarLs.Count; i++)
|
|
{
|
|
BaseMonoAvatar baseMonoAvatar = _avatarLs[i];
|
|
if (baseMonoAvatar.IsToBeRemove())
|
|
{
|
|
RemoveAvatarByRuntimeID(baseMonoAvatar.GetRuntimeID());
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RemoveAllAvatars()
|
|
{
|
|
int num;
|
|
for (num = 0; num < _avatarLs.Count; num++)
|
|
{
|
|
BaseMonoAvatar baseMonoAvatar = _avatarLs[num];
|
|
if (!baseMonoAvatar.IsToBeRemove())
|
|
{
|
|
baseMonoAvatar.SetDied(KillEffect.KillImmediately);
|
|
}
|
|
RemoveAvatarByRuntimeID(baseMonoAvatar.GetRuntimeID());
|
|
num--;
|
|
}
|
|
}
|
|
|
|
public void SetPause(bool pause)
|
|
{
|
|
foreach (BaseMonoAvatar value in _avatarDict.Values)
|
|
{
|
|
value.SetPause(pause);
|
|
}
|
|
}
|
|
|
|
public void SetAutoBattle(bool isAuto)
|
|
{
|
|
isAutoBattle = isAuto;
|
|
GetLocalAvatar().RefreshController();
|
|
}
|
|
|
|
public void SetLocalAvatar(uint runtimeID)
|
|
{
|
|
uint localAvatarRuntimeID = _localAvatarRuntimeID;
|
|
_localAvatarRuntimeID = runtimeID;
|
|
if (onLocalAvatarChanged != null)
|
|
{
|
|
onLocalAvatarChanged(_avatarDict[localAvatarRuntimeID], _avatarDict[_localAvatarRuntimeID]);
|
|
}
|
|
Singleton<EventManager>.Instance.FireEvent(new EvtLocalAvatarChanged(runtimeID, localAvatarRuntimeID));
|
|
}
|
|
|
|
public bool IsLocalAvatar(uint runtimeID)
|
|
{
|
|
return runtimeID == _localAvatarRuntimeID;
|
|
}
|
|
|
|
public bool IsHelperAvatar(uint runtimeID)
|
|
{
|
|
return runtimeID == _helperAvatarRuntimeID;
|
|
}
|
|
|
|
public void CreateTeamAvatars()
|
|
{
|
|
List<AvatarDataItem> memberList = Singleton<LevelScoreManager>.Instance.memberList;
|
|
for (int i = 0; i < memberList.Count; i++)
|
|
{
|
|
bool isLocal = i == 0;
|
|
bool flag = i == 0;
|
|
Singleton<AvatarManager>.Instance.CreateAvatar(memberList[i], isLocal, InLevelData.CREATE_INIT_POS, InLevelData.CREATE_INIT_FORWARD, Singleton<RuntimeIDManager>.Instance.GetNextRuntimeID(3), flag, flag);
|
|
}
|
|
CreateAvatarHelper();
|
|
_preloadedAvatar.Clear();
|
|
}
|
|
|
|
private void CreateAvatarHelper()
|
|
{
|
|
if (Singleton<LevelScoreManager>.Instance.friendDetailItem != null && _helperAvatarRuntimeID == 0)
|
|
{
|
|
FriendDetailDataItem friendDetailItem = Singleton<LevelScoreManager>.Instance.friendDetailItem;
|
|
AvatarDataItem leaderAvatar = friendDetailItem.leaderAvatar;
|
|
bool leaderSkillOn = Singleton<FriendModule>.Instance.IsMyFriend(friendDetailItem.uid);
|
|
Singleton<AvatarManager>.Instance.CreateAvatar(leaderAvatar, false, InLevelData.CREATE_INIT_POS, InLevelData.CREATE_INIT_FORWARD, Singleton<RuntimeIDManager>.Instance.GetNextRuntimeID(3), false, leaderSkillOn, true, true);
|
|
}
|
|
}
|
|
|
|
public void ShowHelperAvater()
|
|
{
|
|
BaseMonoAvatar helperAvatar = GetHelperAvatar();
|
|
if (!(helperAvatar != null))
|
|
{
|
|
return;
|
|
}
|
|
AvatarActor actor = Singleton<EventManager>.Instance.GetActor<AvatarActor>(helperAvatar.GetRuntimeID());
|
|
List<BaseMonoAvatar> allPlayerAvatars = Singleton<AvatarManager>.Instance.GetAllPlayerAvatars();
|
|
int num = 0;
|
|
foreach (BaseMonoAvatar item in allPlayerAvatars)
|
|
{
|
|
AvatarActor actor2 = Singleton<EventManager>.Instance.GetActor<AvatarActor>(item.GetRuntimeID());
|
|
if (actor2 != null)
|
|
{
|
|
num = Math.Max(actor2.level, num);
|
|
}
|
|
}
|
|
float num2 = ((num <= (int)actor.level) ? (AvatarLevelMetaDataReader.GetAvatarLevelMetaDataByKey(num).avatarAssistConf / AvatarLevelMetaDataReader.GetAvatarLevelMetaDataByKey(actor.level).avatarAssistConf) : 1f);
|
|
actor.attack = (float)actor.attack * num2;
|
|
actor.GetPlugin<AvatarHelperStatePlugin>().TriggerSwitchIn();
|
|
}
|
|
|
|
public void HideHelperAvatar(bool force)
|
|
{
|
|
BaseMonoAvatar helperAvatar = GetHelperAvatar();
|
|
if (helperAvatar != null)
|
|
{
|
|
AvatarActor actor = Singleton<EventManager>.Instance.GetActor<AvatarActor>(helperAvatar.GetRuntimeID());
|
|
actor.GetPlugin<AvatarHelperStatePlugin>().TriggerSwitchOut(force);
|
|
}
|
|
}
|
|
|
|
public void InitAvatarsPos(List<MonoSpawnPoint> avatarSpawnPointList)
|
|
{
|
|
Vector3[] array = new Vector3[3]
|
|
{
|
|
Vector3.zero,
|
|
Vector3.zero,
|
|
Vector3.zero
|
|
};
|
|
switch (Singleton<LevelManager>.Instance.levelActor.levelMode)
|
|
{
|
|
case LevelActor.Mode.Single:
|
|
array = InLevelData.SINGLE_MODE_AVATAR_INIT_POS_LIST;
|
|
break;
|
|
case LevelActor.Mode.Multi:
|
|
case LevelActor.Mode.NetworkedMP:
|
|
array = InLevelData.MUTIL_MODE_AVATAR_INIT_POS_LIST;
|
|
break;
|
|
case LevelActor.Mode.MultiRemote:
|
|
array = InLevelData.MUTIL_REMOTE_MODE_AVATAR_INIT_POS_LIST;
|
|
break;
|
|
}
|
|
List<BaseMonoAvatar> allPlayerAvatars = Singleton<AvatarManager>.Instance.GetAllPlayerAvatars();
|
|
if (Singleton<LevelManager>.Instance.levelActor.levelMode != LevelActor.Mode.NetworkedMP)
|
|
{
|
|
allPlayerAvatars.Sort(Compare);
|
|
}
|
|
for (int i = 0; i < allPlayerAvatars.Count; i++)
|
|
{
|
|
if (allPlayerAvatars[i].IsActive())
|
|
{
|
|
if (Singleton<LevelManager>.Instance.levelActor.levelMode == LevelActor.Mode.MultiRemote)
|
|
{
|
|
allPlayerAvatars[i].transform.position = avatarSpawnPointList[i].transform.TransformPoint(array[i]);
|
|
allPlayerAvatars[i].transform.forward = avatarSpawnPointList[i].transform.forward;
|
|
}
|
|
else
|
|
{
|
|
allPlayerAvatars[i].transform.position = avatarSpawnPointList[0].transform.TransformPoint(array[i]);
|
|
allPlayerAvatars[i].transform.forward = avatarSpawnPointList[0].transform.forward;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allPlayerAvatars[i].transform.position = InLevelData.CREATE_INIT_POS;
|
|
}
|
|
}
|
|
}
|
|
|
|
private int Compare(BaseMonoAvatar a, BaseMonoAvatar b)
|
|
{
|
|
if (a.GetRuntimeID() == _localAvatarRuntimeID && b.GetRuntimeID() != _localAvatarRuntimeID)
|
|
{
|
|
return -1;
|
|
}
|
|
if (a.GetRuntimeID() != _localAvatarRuntimeID && b.GetRuntimeID() == _localAvatarRuntimeID)
|
|
{
|
|
return 1;
|
|
}
|
|
if (a.IsActive() && !b.IsActive())
|
|
{
|
|
return -1;
|
|
}
|
|
if (!a.IsActive() && b.IsActive())
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public void SetMuteAllAvatarControl(bool mute)
|
|
{
|
|
foreach (BaseMonoAvatar value in _avatarDict.Values)
|
|
{
|
|
value.SetCountedMuteControl(mute);
|
|
if (value.IsActive())
|
|
{
|
|
value.OrderMove = false;
|
|
value.ClearAttackTriggers();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Destroy()
|
|
{
|
|
for (int i = 0; i < _preloadedAvatar.Count; i++)
|
|
{
|
|
if (_preloadedAvatar[i] != null && _preloadedAvatar[i].Item2 != null)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(_preloadedAvatar[i].Item2);
|
|
}
|
|
}
|
|
for (int j = 0; j < _avatarLs.Count; j++)
|
|
{
|
|
if (_avatarLs[j] != null)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(_avatarLs[j]);
|
|
}
|
|
}
|
|
onLocalAvatarChanged = null;
|
|
}
|
|
|
|
public void SetAllAvatarVisibility(bool visible)
|
|
{
|
|
for (int i = 0; i < _avatarLs.Count; i++)
|
|
{
|
|
BaseMonoAvatar baseMonoAvatar = _avatarLs[i];
|
|
for (int j = 0; j < baseMonoAvatar.renderers.Length; j++)
|
|
{
|
|
baseMonoAvatar.renderers[j].enabled = visible;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetAvatarVisibility(bool visible, BaseMonoAvatar avatar)
|
|
{
|
|
if (_avatarLs.Contains(avatar))
|
|
{
|
|
for (int i = 0; i < avatar.renderers.Length; i++)
|
|
{
|
|
avatar.renderers[i].enabled = visible;
|
|
}
|
|
}
|
|
}
|
|
|
|
public BaseMonoAvatar GetFirstAliveAvatar()
|
|
{
|
|
List<BaseMonoAvatar> playerAvatars = _playerAvatars;
|
|
for (int i = 0; i < playerAvatars.Count; i++)
|
|
{
|
|
if (playerAvatars[i].IsAlive())
|
|
{
|
|
return playerAvatars[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void OnPlayerAvatarDie(BaseMonoAvatar avatar)
|
|
{
|
|
if (!IsLocalAvatar(avatar.GetRuntimeID()))
|
|
{
|
|
avatar.gameObject.SetActive(false);
|
|
}
|
|
else
|
|
{
|
|
Singleton<LevelManager>.Instance.gameMode.HandleLocalPlayerAvatarDie(avatar);
|
|
}
|
|
}
|
|
}
|
|
}
|