private Vector3 GetSpawnPointPos(float distance, bool fromTarget = false)
{
Vector3 position = base.entity.transform.position;
if (fromTarget)
{
BaseMonoEntity attackTarget = base.entity.GetAttackTarget();
if (attackTarget != null)
{
position = attackTarget.transform.position;
}
}
MonoStageEnv stageEnv = Singleton <StageManager> .Instance.GetStageEnv();
int index = -1;
float num2 = 100f;
for (int i = 0; i < Singleton <StageManager> .Instance.GetStageEnv().spawnPoints.Length; i++)
{
float num4 = Mathf.Abs((float)(Vector3.Distance(stageEnv.spawnPoints[i].transform.position, position) - distance));
if (num4 < num2)
{
index = i;
num2 = num4;
}
}
return(stageEnv.spawnPoints[index].transform.position);
}
public override void OnAwake()
{
base.failMoveTime = 0f;
base.OnAwake();
this._entity = base.GetComponent <BaseMonoAnimatorEntity>();
this._stageEnv = Singleton <StageManager> .Instance.GetStageEnv();
}
private Vector3 GetSpawnPointPos(string spawnName)
{
MonoStageEnv stageEnv = Singleton <StageManager> .Instance.GetStageEnv();
int namedSpawnPointIx = stageEnv.GetNamedSpawnPointIx(spawnName);
return(stageEnv.spawnPoints[namedSpawnPointIx].transform.position);
}
private Vector3 GetSpawnPointPos(string spawnName)
{
int namedSpawnPointIx;
MonoStageEnv stageEnv = Singleton <StageManager> .Instance.GetStageEnv();
if (spawnName != null)
{
namedSpawnPointIx = stageEnv.GetNamedSpawnPointIx(spawnName);
}
else
{
namedSpawnPointIx = UnityEngine.Random.Range(0, Singleton <StageManager> .Instance.GetStageEnv().spawnPoints.Length);
}
return(stageEnv.spawnPoints[namedSpawnPointIx].transform.position);
}
private void HandleAlreadyLoadedPrefabs()
{
RuntimeIDManager instance = Singleton <RuntimeIDManager> .Instance;
StageEntry stageEntryByName = StageData.GetStageEntryByName(this.stageDevData.stageName);
MonoBasePerpStage perpStage = UnityEngine.Object.FindObjectOfType <MonoBasePerpStage>();
if (perpStage != null)
{
perpStage.Init(stageEntryByName, (string)null);
}
MonoStageEnv stageEnv = UnityEngine.Object.FindObjectOfType <MonoStageEnv>();
Singleton <StageManager> .Instance.RegisterStage(stageEntryByName, perpStage, stageEnv);
LevelActor actor = (LevelActor)Singleton <EventManager> .Instance.GetActor(0x21800001);
actor.levelMode = this.LEVEL_MODE;
BaseMonoAvatar avatar = UnityEngine.Object.FindObjectOfType <BaseMonoAvatar>();
if (avatar != null)
{
DevAvatarData devAvatarData = this.avatarDevDatas[0];
AvatarDataItem avatarDataItem = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[0], devAvatarData.avatarLevel, devAvatarData.avatarStar);
this.SetUpAvatarDataItem(avatarDataItem, devAvatarData);
uint nextRuntimeID = instance.GetNextRuntimeID(3);
avatar.Init(true, nextRuntimeID, avatarDataItem.AvatarRegistryKey, avatarDataItem.GetWeapon().ID, avatar.transform.position, avatar.transform.forward, true);
this.LoadAvatarWwiseSoundBank(avatar);
AvatarActor actor2 = Singleton <EventManager> .Instance.CreateActor <AvatarActor>(avatar);
actor2.InitAvatarDataItem(avatarDataItem, true, false, true, true);
actor2.PostInit();
Singleton <AvatarManager> .Instance.RegisterAvatar(avatar, true, true, false);
this.SetUpAvatarSkill(actor2, devAvatarData);
this.CheatForPariticleMode(actor2);
for (int i = 1; i < this.avatarCount; i++)
{
DevAvatarData data2 = this.avatarDevDatas[i];
AvatarDataItem item2 = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[i], data2.avatarLevel, data2.avatarStar);
this.SetUpAvatarDataItem(item2, data2);
uint runtimeID = instance.GetNextRuntimeID(3);
Singleton <AvatarManager> .Instance.CreateAvatar(item2, false, avatar.XZPosition, avatar.FaceDirection, runtimeID, false, false, false, false);
AvatarActor actor3 = Singleton <EventManager> .Instance.GetActor <AvatarActor>(runtimeID);
this.SetUpAvatarSkill(actor3, data2);
this.CheatForPariticleMode(actor3);
}
if (this.useFakeHelper)
{
this.CreateFakeFriendAvatar();
}
Singleton <CinemaDataManager> .Instance.Preload(avatar);
}
foreach (BaseMonoMonster monster in UnityEngine.Object.FindObjectsOfType <BaseMonoMonster>())
{
DevMonsterData data3 = null;
int instanceID = monster.gameObject.GetInstanceID();
for (int j = 0; j < this.monsterInstanceIds.Count; j++)
{
if (this.monsterInstanceIds[j] == instanceID)
{
data3 = this.monsterDevDatas[j];
break;
}
}
if (data3 == null)
{
UnityEngine.Object.Destroy(monster.gameObject);
}
else
{
string monsterName;
string typeName;
uint num7 = instance.GetNextRuntimeID(4);
if (data3.uniqueMonsterID != 0)
{
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(data3.uniqueMonsterID);
monsterName = uniqueMonsterMetaData.monsterName;
typeName = uniqueMonsterMetaData.typeName;
}
else
{
monsterName = data3.monsterName;
typeName = data3.typeName;
}
bool isElite = data3.isElite;
monster.Init(monsterName, typeName, num7, monster.transform.position, data3.uniqueMonsterID, null, true, isElite, true, 0);
for (int k = 0; k < monster.config.CommonArguments.RequestSoundBankNames.Length; k++)
{
Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(monster.config.CommonArguments.RequestSoundBankNames[k]);
}
MonsterActor actor4 = Singleton <EventManager> .Instance.CreateActor <MonsterActor>(monster);
actor4.InitLevelData(data3.level, data3.isElite);
actor4.PostInit();
Singleton <MonsterManager> .Instance.RegisterMonster(monster);
if (data3.abilities.Length > 0)
{
for (int m = 0; m < data3.abilities.Length; m++)
{
string str3 = data3.abilities[m];
if (!string.IsNullOrEmpty(str3))
{
actor4.abilityPlugin.InsertPreInitAbility(AbilityData.GetAbilityConfig(data3.abilities[m]));
}
}
}
if (data3.isStationary)
{
MonsterActor actor5 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(monster.GetRuntimeID());
actor5.baseMaxHP = actor5.HP = actor5.maxHP = 999999f;
monster.GetActiveAIController().SetActive(false);
}
}
}
Singleton <LevelManager> .Instance.levelActor.SuddenLevelStart();
EvtStageReady evt = new EvtStageReady {
isBorn = true
};
Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);
Singleton <DetourManager> .Instance.LoadNavMeshRelatedLevel(this.stageDevData.stageName);
Singleton <MainUIManager> .Instance.GetInLevelUICanvas().FadeInStageTransitPanel(0.18f, false, null, null);
}
public void RegisterStage(StageEntry stageEntry, MonoBasePerpStage perpStage, MonoStageEnv stageEnv)
{
this._activeStageEntry = stageEntry;
this._perpStage = perpStage;
this._stageEnv = stageEnv;
}
private Vector3 InitAfterCreateStage(StageEntry stageEntry, MonoBasePerpStage perpStage, Vector3 preStagePos, bool isBorn, string baseWeatherName, MonoBasePerpStage.ContinueWeatherDataSettings continueData, bool isContinued)
{
Vector3 zero = Vector3.zero;
Vector3 vector2 = Vector3.zero;
if (!string.IsNullOrEmpty(stageEntry.LocationPointName))
{
perpStage.transform.position = Vector3.zero;
perpStage.transform.position = -perpStage.transform.Find(stageEntry.LocationPointName).localPosition;
vector2 = perpStage.transform.position - preStagePos;
}
if (this._activeStageEntry == null)
{
perpStage.Init(stageEntry, baseWeatherName);
}
else
{
float renderingTimer = 0f;
float weatherTimer = 0f;
ConfigWeatherData fromWeatherData = null;
ConfigWeatherData toWeatherData = null;
string toWeatherName = null;
if (continueData != null)
{
renderingTimer = continueData.renderingDataContinueTimer;
weatherTimer = continueData.weatherContinueTimer;
fromWeatherData = continueData.currentWeatherData;
toWeatherData = continueData.continueWeatherData;
toWeatherName = continueData.continueWeatherName;
}
if (this._activeStageEntry.PerpStagePrefabPath != stageEntry.PerpStagePrefabPath)
{
if (isContinued)
{
if (renderingTimer > 0f)
{
if (toWeatherName != null)
{
perpStage.Init(stageEntry, fromWeatherData, toWeatherName, renderingTimer, weatherTimer);
}
else
{
perpStage.Init(stageEntry, fromWeatherData, toWeatherData, renderingTimer, weatherTimer);
}
}
else if (toWeatherName != null)
{
perpStage.Init(stageEntry, toWeatherName);
}
else
{
perpStage.Init(stageEntry, toWeatherData);
}
}
else
{
perpStage.Init(stageEntry, baseWeatherName);
}
}
else if (isContinued)
{
if (renderingTimer > 0f)
{
perpStage.TransitWeatherData(toWeatherData, renderingTimer, weatherTimer);
}
else
{
perpStage.Reset(stageEntry, toWeatherData);
}
}
else
{
perpStage.Reset(stageEntry, WeatherData.GetWeatherDataConfig(baseWeatherName));
}
this.CleanForStageTransit();
}
GameObject obj2 = (GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource(stageEntry.GetEnvPrefabPath(), BundleType.RESOURCE_FILE));
obj2.transform.position = Vector3.zero;
obj2.transform.rotation = Quaternion.identity;
MonoStageEnv component = obj2.GetComponent <MonoStageEnv>();
Vector3 vector3 = new Vector3(0f, -0.05f, 0f);
Transform transform = Miscs.FindFirstChildGivenLayerAndCollider(obj2.transform, LayerMask.NameToLayer("StageCollider"));
if (transform != null)
{
transform.position += vector3;
}
this.RegisterStage(stageEntry, perpStage, component);
return(vector2);
}
