mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-12 22:44:35 +01:00
666 lines
25 KiB
C#
666 lines
25 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using BehaviorDesigner.Runtime;
|
|
using MoleMole.Config;
|
|
using UnityEngine;
|
|
using proto;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public class MonoDevLevel : MonoTheLevelV1
|
|
{
|
|
private const float KeyRotationDelta = 300f;
|
|
|
|
[HideInInspector]
|
|
public List<int> monsterInstanceIds;
|
|
|
|
[HideInInspector]
|
|
public List<DevMonsterData> monsterDevDatas;
|
|
|
|
[HideInInspector]
|
|
public List<string> avatarTypeNames;
|
|
|
|
[HideInInspector]
|
|
public List<DevAvatarData> avatarDevDatas;
|
|
|
|
[HideInInspector]
|
|
public DevStageData stageDevData;
|
|
|
|
[HideInInspector]
|
|
public int avatarCount;
|
|
|
|
[HideInInspector]
|
|
public string LEVEL_PATH;
|
|
|
|
[HideInInspector]
|
|
public LevelActor.Mode LEVEL_MODE;
|
|
|
|
[HideInInspector]
|
|
public int LEVEL_HARDLEVEL;
|
|
|
|
[HideInInspector]
|
|
public int LEVEL_DIFFICULTY;
|
|
|
|
[HideInInspector]
|
|
public int TEAM_LEVEL = 1;
|
|
|
|
[HideInInspector]
|
|
public LevelManager _levelManager;
|
|
|
|
[HideInInspector]
|
|
public bool pariticleMode;
|
|
|
|
[HideInInspector]
|
|
public bool useFakeHelper;
|
|
|
|
[HideInInspector]
|
|
public bool isBenchmark;
|
|
|
|
private bool isRotating;
|
|
|
|
public new void Awake()
|
|
{
|
|
AwakeTryLoadFromFile();
|
|
GlobalVars.DISABLE_NETWORK_DEBUG = true;
|
|
QualitySettings.vSyncCount = 1;
|
|
Singleton<LevelManager>.Create();
|
|
Singleton<EffectManager>.Create();
|
|
Singleton<RuntimeIDManager>.Instance.InitAtAwake();
|
|
Singleton<StageManager>.Instance.InitAtAwake();
|
|
Singleton<AvatarManager>.Instance.InitAtAwake();
|
|
Singleton<CameraManager>.Instance.InitAtAwake();
|
|
Singleton<MonsterManager>.Instance.InitAtAwake();
|
|
Singleton<PropObjectManager>.Instance.InitAtAwake();
|
|
Singleton<DynamicObjectManager>.Instance.InitAtAwake();
|
|
Singleton<EffectManager>.Instance.InitAtAwake();
|
|
Singleton<EventManager>.Instance.InitAtAwake();
|
|
HandleBeforeLevelDesignAwake();
|
|
Singleton<LevelDesignManager>.Instance.InitAtAwake();
|
|
Singleton<AuxObjectManager>.Instance.InitAtAwake();
|
|
Singleton<DetourManager>.Instance.InitAtAwake();
|
|
Singleton<ShaderDataManager>.Instance.InitAtAwake();
|
|
Singleton<CinemaDataManager>.Instance.InitAtAwake();
|
|
_levelManager = Singleton<LevelManager>.Instance;
|
|
_levelManager.CreateBehaviorManager();
|
|
MonoLevelEntity monoLevelEntity = base.gameObject.AddComponent<MonoLevelEntity>();
|
|
_levelManager.levelEntity = monoLevelEntity;
|
|
monoLevelEntity.Init(562036737u);
|
|
LevelActor levelActor = Singleton<EventManager>.Instance.CreateActor<LevelActor>(monoLevelEntity);
|
|
_levelManager.levelActor = levelActor;
|
|
levelActor.PostInit();
|
|
levelActor.AddPlugin(new DevLevelActorPlugin(this));
|
|
levelActor.RemovePlugin<LevelMissionStatisticsPlugin>();
|
|
PostAwakeTryLoadFromFile();
|
|
}
|
|
|
|
public new void Start()
|
|
{
|
|
UnityEngine.Object.Instantiate(Miscs.LoadResource<GameObject>("UI/UIToolkits/FPSIndicator"));
|
|
PreStartHandleBenchmark();
|
|
Singleton<StageManager>.Instance.InitAtStart();
|
|
Singleton<AvatarManager>.Instance.InitAtStart();
|
|
HandleAlreadyLoadedCameras();
|
|
Singleton<MonsterManager>.Instance.InitAtStart();
|
|
Singleton<PropObjectManager>.Instance.InitAtStart();
|
|
Singleton<DynamicObjectManager>.Instance.InitAtStart();
|
|
Singleton<EffectManager>.Instance.InitAtStart();
|
|
Singleton<EventManager>.Instance.InitAtStart();
|
|
Singleton<AuxObjectManager>.Instance.InitAtStart();
|
|
Singleton<DetourManager>.Instance.InitAtStart();
|
|
HandleAlreadyLoadedPrefabs();
|
|
BaseMonoAvatar baseMonoAvatar = Singleton<AvatarManager>.Instance.TryGetLocalAvatar();
|
|
if (baseMonoAvatar != null)
|
|
{
|
|
Singleton<WwiseAudioManager>.Instance.SetListenerFollowing(baseMonoAvatar.transform, new Vector3(0f, 2f, 0f));
|
|
}
|
|
Singleton<WwiseAudioManager>.Instance.PushSoundBankScale(new string[4] { "All_In_One_Bank", "BK_Global", "BK_Events", "Test_3D_Att" });
|
|
PostFXBase postFXBase = UnityEngine.Object.FindObjectOfType<PostFXBase>();
|
|
if (postFXBase != null)
|
|
{
|
|
postFXBase.originalEnabled = true;
|
|
}
|
|
PostStartHandleBenchmark();
|
|
}
|
|
|
|
private void AwakeTryLoadFromFile()
|
|
{
|
|
if (DevLevelConfigData.configFromScene)
|
|
{
|
|
LEVEL_PATH = DevLevelConfigData.LEVEL_PATH;
|
|
LEVEL_MODE = DevLevelConfigData.LEVEL_MODE;
|
|
stageDevData = DevLevelConfigData.stageDevData;
|
|
avatarDevDatas = DevLevelConfigData.avatarDevDatas;
|
|
monsterDevDatas = DevLevelConfigData.monsterDevDatas;
|
|
isBenchmark = DevLevelConfigData.isBenchmark;
|
|
GlobalVars.IS_BENCHMARK = isBenchmark;
|
|
avatarCount = DevLevelConfigData.avatarDevDatas.Count;
|
|
if (isBenchmark)
|
|
{
|
|
pariticleMode = true;
|
|
}
|
|
avatarTypeNames = new List<string>();
|
|
{
|
|
foreach (DevAvatarData avatarDevData in avatarDevDatas)
|
|
{
|
|
avatarTypeNames.Add(avatarDevData.avatarType);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
MainUIData.USE_VIEW_CACHING = false;
|
|
GeneralLogicManager.InitAll();
|
|
GlobalDataManager.Refresh();
|
|
}
|
|
|
|
private void PostAwakeTryLoadFromFile()
|
|
{
|
|
if (!DevLevelConfigData.configFromScene)
|
|
{
|
|
return;
|
|
}
|
|
TryDestroyTypeAll<BaseMonoAvatar>();
|
|
TryDestroyTypeAll<BaseMonoMonster>();
|
|
TryDestroyTypeAll<MonoBasePerpStage>();
|
|
TryDestroyTypeAll<MonoStageEnv>();
|
|
Resources.UnloadUnusedAssets();
|
|
GC.Collect();
|
|
GC.WaitForPendingFinalizers();
|
|
StageEntry stageEntryByName = StageData.GetStageEntryByName(stageDevData.stageName);
|
|
GameObject gameObject = UnityEngine.Object.Instantiate(Miscs.LoadResource<GameObject>(stageEntryByName.GetPerpStagePrefabPath()));
|
|
gameObject.transform.position = Vector3.zero;
|
|
gameObject.transform.position -= gameObject.transform.Find(stageEntryByName.LocationPointName).position;
|
|
StageManager.SetPerpstageNodeVisibility(gameObject.GetComponent<MonoBasePerpStage>(), stageEntryByName, false, false);
|
|
StageManager.SetPerpstageNodeVisibility(gameObject.GetComponent<MonoBasePerpStage>(), stageEntryByName, true, true);
|
|
UnityEngine.Object.Instantiate(Miscs.LoadResource<GameObject>(stageEntryByName.GetEnvPrefabPath()));
|
|
DevAvatarData devAvatarData = avatarDevDatas[0];
|
|
string prefabResPath = AvatarData.GetPrefabResPath(devAvatarData.avatarType);
|
|
GameObject original = Miscs.LoadResource<GameObject>(prefabResPath);
|
|
UnityEngine.Object.Instantiate(original);
|
|
monsterInstanceIds = new List<int>();
|
|
foreach (DevMonsterData monsterDevData in monsterDevDatas)
|
|
{
|
|
GameObject gameObject2 = UnityEngine.Object.Instantiate(Miscs.LoadResource<GameObject>(MonsterData.GetPrefabResPath(monsterDevData.monsterName, monsterDevData.typeName)));
|
|
monsterInstanceIds.Add(gameObject2.GetInstanceID());
|
|
}
|
|
}
|
|
|
|
private void PreStartHandleBenchmark()
|
|
{
|
|
if (!isBenchmark)
|
|
{
|
|
return;
|
|
}
|
|
foreach (DevAvatarData avatarDevData in avatarDevDatas)
|
|
{
|
|
if (!Miscs.ArrayContains(avatarDevData.avatarTestSkills, "Test_UnlockAllAniSkill"))
|
|
{
|
|
Miscs.ArrayAppend(ref avatarDevData.avatarTestSkills, "Test_UnlockAllAniSkill");
|
|
}
|
|
if (!Miscs.ArrayContains(avatarDevData.avatarTestSkills, "Test_Undamagable"))
|
|
{
|
|
Miscs.ArrayAppend(ref avatarDevData.avatarTestSkills, "Test_Undamagable");
|
|
}
|
|
}
|
|
foreach (DevMonsterData monsterDevData in monsterDevDatas)
|
|
{
|
|
if (!Miscs.ArrayContains(monsterDevData.abilities, "Test_Undamagable"))
|
|
{
|
|
Miscs.ArrayAppend(ref monsterDevData.abilities, "Test_Undamagable");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PostStartHandleBenchmark()
|
|
{
|
|
if (!isBenchmark)
|
|
{
|
|
return;
|
|
}
|
|
Singleton<AvatarManager>.Instance.SetAutoBattle(true);
|
|
List<BaseMonoAvatar> allPlayerAvatars = Singleton<AvatarManager>.Instance.GetAllPlayerAvatars();
|
|
for (int i = 0; i < allPlayerAvatars.Count; i++)
|
|
{
|
|
if (!string.IsNullOrEmpty(avatarDevDatas[i].avatarAI))
|
|
{
|
|
ExternalBehaviorTree externalBehaviorTree = Miscs.LoadResource<ExternalBehaviorTree>(avatarDevDatas[i].avatarAI);
|
|
((BTreeAvatarAIController)allPlayerAvatars[i].GetActiveAIController()).autoBattleBehavior = externalBehaviorTree;
|
|
((BTreeAvatarAIController)allPlayerAvatars[i].GetActiveAIController()).autoMoveBehvior = externalBehaviorTree;
|
|
((BTreeAvatarAIController)allPlayerAvatars[i].GetActiveAIController()).supporterBehavior = externalBehaviorTree;
|
|
allPlayerAvatars[i].GetComponent<BehaviorTree>().ExternalBehavior = externalBehaviorTree;
|
|
allPlayerAvatars[i].GetComponent<BehaviorTree>().EnableBehavior();
|
|
}
|
|
}
|
|
Screen.sleepTimeout = -1;
|
|
SuperDebug.CloseAllDebugs();
|
|
GameObject gameObject = new GameObject();
|
|
gameObject.name = "__Benchmark";
|
|
gameObject.AddComponent<MonoBenchmarkSwitches>();
|
|
}
|
|
|
|
private void HandleBeforeLevelDesignAwake()
|
|
{
|
|
Singleton<LevelScoreManager>.Create();
|
|
FriendDetailDataItem friend = null;
|
|
if (true)
|
|
{
|
|
DevAvatarData devAvatarData = avatarDevDatas[0];
|
|
AvatarDataItem dummyAvatarDataItem = Singleton<AvatarModule>.Instance.GetDummyAvatarDataItem(avatarTypeNames[0], devAvatarData.avatarLevel, devAvatarData.avatarStar);
|
|
SetUpAvatarDataItem(dummyAvatarDataItem, devAvatarData);
|
|
friend = new FriendDetailDataItem(0, "FakeHelper", 1, dummyAvatarDataItem);
|
|
}
|
|
Singleton<LevelScoreManager>.Instance.SetDevLevelBeginIntent(LEVEL_PATH, LEVEL_MODE, LEVEL_HARDLEVEL, LEVEL_DIFFICULTY + 1, friend);
|
|
Singleton<PlayerModule>.Instance.playerData.teamLevel = TEAM_LEVEL;
|
|
}
|
|
|
|
private void HandleAlreadyLoadedCameras()
|
|
{
|
|
RuntimeIDManager instance = Singleton<RuntimeIDManager>.Instance;
|
|
MonoMainCamera monoMainCamera = UnityEngine.Object.FindObjectOfType<MonoMainCamera>();
|
|
uint nextRuntimeID = instance.GetNextRuntimeID(2);
|
|
monoMainCamera.Init(nextRuntimeID);
|
|
Singleton<CameraManager>.Instance.RegisterCameraData(1u, monoMainCamera, nextRuntimeID);
|
|
MonoInLevelUICamera monoInLevelUICamera = UnityEngine.Object.FindObjectOfType<MonoInLevelUICamera>();
|
|
nextRuntimeID = instance.GetNextRuntimeID(2);
|
|
monoInLevelUICamera.Init(nextRuntimeID);
|
|
Singleton<CameraManager>.Instance.RegisterCameraData(2u, monoInLevelUICamera, nextRuntimeID);
|
|
}
|
|
|
|
private void HandleAlreadyLoadedPrefabs()
|
|
{
|
|
RuntimeIDManager instance = Singleton<RuntimeIDManager>.Instance;
|
|
StageEntry stageEntryByName = StageData.GetStageEntryByName(stageDevData.stageName);
|
|
MonoBasePerpStage monoBasePerpStage = UnityEngine.Object.FindObjectOfType<MonoBasePerpStage>();
|
|
if (monoBasePerpStage != null)
|
|
{
|
|
monoBasePerpStage.Init(stageEntryByName, (string)null);
|
|
}
|
|
MonoStageEnv stageEnv = UnityEngine.Object.FindObjectOfType<MonoStageEnv>();
|
|
Singleton<StageManager>.Instance.RegisterStage(stageEntryByName, monoBasePerpStage, stageEnv);
|
|
LevelActor levelActor = (LevelActor)Singleton<EventManager>.Instance.GetActor(562036737u);
|
|
levelActor.levelMode = LEVEL_MODE;
|
|
BaseMonoAvatar baseMonoAvatar = UnityEngine.Object.FindObjectOfType<BaseMonoAvatar>();
|
|
if (baseMonoAvatar != null)
|
|
{
|
|
DevAvatarData devAvatarData = avatarDevDatas[0];
|
|
AvatarDataItem dummyAvatarDataItem = Singleton<AvatarModule>.Instance.GetDummyAvatarDataItem(avatarTypeNames[0], devAvatarData.avatarLevel, devAvatarData.avatarStar);
|
|
SetUpAvatarDataItem(dummyAvatarDataItem, devAvatarData);
|
|
uint nextRuntimeID = instance.GetNextRuntimeID(3);
|
|
baseMonoAvatar.Init(true, nextRuntimeID, dummyAvatarDataItem.AvatarRegistryKey, dummyAvatarDataItem.GetWeapon().ID, baseMonoAvatar.transform.position, baseMonoAvatar.transform.forward, true);
|
|
LoadAvatarWwiseSoundBank(baseMonoAvatar);
|
|
AvatarActor avatarActor = Singleton<EventManager>.Instance.CreateActor<AvatarActor>(baseMonoAvatar);
|
|
avatarActor.InitAvatarDataItem(dummyAvatarDataItem, true, false, true, true);
|
|
avatarActor.PostInit();
|
|
Singleton<AvatarManager>.Instance.RegisterAvatar(baseMonoAvatar, true, true, false);
|
|
SetUpAvatarSkill(avatarActor, devAvatarData);
|
|
CheatForPariticleMode(avatarActor);
|
|
for (int i = 1; i < avatarCount; i++)
|
|
{
|
|
DevAvatarData devAvatarData2 = avatarDevDatas[i];
|
|
AvatarDataItem dummyAvatarDataItem2 = Singleton<AvatarModule>.Instance.GetDummyAvatarDataItem(avatarTypeNames[i], devAvatarData2.avatarLevel, devAvatarData2.avatarStar);
|
|
SetUpAvatarDataItem(dummyAvatarDataItem2, devAvatarData2);
|
|
uint nextRuntimeID2 = instance.GetNextRuntimeID(3);
|
|
Singleton<AvatarManager>.Instance.CreateAvatar(dummyAvatarDataItem2, false, baseMonoAvatar.XZPosition, baseMonoAvatar.FaceDirection, nextRuntimeID2, false, false);
|
|
AvatarActor actor = Singleton<EventManager>.Instance.GetActor<AvatarActor>(nextRuntimeID2);
|
|
SetUpAvatarSkill(actor, devAvatarData2);
|
|
CheatForPariticleMode(actor);
|
|
}
|
|
if (useFakeHelper)
|
|
{
|
|
CreateFakeFriendAvatar();
|
|
}
|
|
Singleton<CinemaDataManager>.Instance.Preload(baseMonoAvatar);
|
|
}
|
|
BaseMonoMonster[] array = UnityEngine.Object.FindObjectsOfType<BaseMonoMonster>();
|
|
foreach (BaseMonoMonster baseMonoMonster in array)
|
|
{
|
|
DevMonsterData devMonsterData = null;
|
|
int instanceID = baseMonoMonster.gameObject.GetInstanceID();
|
|
for (int k = 0; k < monsterInstanceIds.Count; k++)
|
|
{
|
|
if (monsterInstanceIds[k] == instanceID)
|
|
{
|
|
devMonsterData = monsterDevDatas[k];
|
|
break;
|
|
}
|
|
}
|
|
if (devMonsterData == null)
|
|
{
|
|
UnityEngine.Object.Destroy(baseMonoMonster.gameObject);
|
|
continue;
|
|
}
|
|
uint nextRuntimeID3 = instance.GetNextRuntimeID(4);
|
|
string monsterName;
|
|
string typeName;
|
|
if (devMonsterData.uniqueMonsterID != 0)
|
|
{
|
|
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(devMonsterData.uniqueMonsterID);
|
|
monsterName = uniqueMonsterMetaData.monsterName;
|
|
typeName = uniqueMonsterMetaData.typeName;
|
|
}
|
|
else
|
|
{
|
|
monsterName = devMonsterData.monsterName;
|
|
typeName = devMonsterData.typeName;
|
|
}
|
|
baseMonoMonster.Init(isElite: devMonsterData.isElite, monsterName: monsterName, typeName: typeName, runtimeID: nextRuntimeID3, initPos: baseMonoMonster.transform.position, uniqueMonsterID: devMonsterData.uniqueMonsterID, overrideAIName: null, checkOutsideWall: true, disableBehaviorWhenInit: true);
|
|
for (int l = 0; l < baseMonoMonster.config.CommonArguments.RequestSoundBankNames.Length; l++)
|
|
{
|
|
Singleton<WwiseAudioManager>.Instance.ManualPrepareBank(baseMonoMonster.config.CommonArguments.RequestSoundBankNames[l]);
|
|
}
|
|
MonsterActor monsterActor = Singleton<EventManager>.Instance.CreateActor<MonsterActor>(baseMonoMonster);
|
|
monsterActor.InitLevelData(devMonsterData.level, devMonsterData.isElite);
|
|
monsterActor.PostInit();
|
|
Singleton<MonsterManager>.Instance.RegisterMonster(baseMonoMonster);
|
|
if (devMonsterData.abilities.Length > 0)
|
|
{
|
|
for (int m = 0; m < devMonsterData.abilities.Length; m++)
|
|
{
|
|
string value = devMonsterData.abilities[m];
|
|
if (!string.IsNullOrEmpty(value))
|
|
{
|
|
monsterActor.abilityPlugin.InsertPreInitAbility(AbilityData.GetAbilityConfig(devMonsterData.abilities[m]));
|
|
}
|
|
}
|
|
}
|
|
if (devMonsterData.isStationary)
|
|
{
|
|
MonsterActor actor2 = Singleton<EventManager>.Instance.GetActor<MonsterActor>(baseMonoMonster.GetRuntimeID());
|
|
actor2.baseMaxHP = (actor2.HP = (actor2.maxHP = 999999f));
|
|
baseMonoMonster.GetActiveAIController().SetActive(false);
|
|
}
|
|
}
|
|
Singleton<LevelManager>.Instance.levelActor.SuddenLevelStart();
|
|
Singleton<EventManager>.Instance.FireEvent(new EvtStageReady
|
|
{
|
|
isBorn = true
|
|
});
|
|
Singleton<DetourManager>.Instance.LoadNavMeshRelatedLevel(stageDevData.stageName);
|
|
Singleton<MainUIManager>.Instance.GetInLevelUICanvas().FadeInStageTransitPanel();
|
|
}
|
|
|
|
public void ReplaceInstanceID(int oldID, int newID)
|
|
{
|
|
if (!monsterInstanceIds.Contains(oldID))
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < monsterInstanceIds.Count; i++)
|
|
{
|
|
if (monsterInstanceIds[i] == oldID)
|
|
{
|
|
monsterInstanceIds[i] = newID;
|
|
}
|
|
}
|
|
}
|
|
|
|
public new void Update()
|
|
{
|
|
Singleton<StageManager>.Instance.Core();
|
|
Singleton<AvatarManager>.Instance.Core();
|
|
Singleton<CameraManager>.Instance.Core();
|
|
Singleton<MonsterManager>.Instance.Core();
|
|
Singleton<PropObjectManager>.Instance.Core();
|
|
Singleton<DynamicObjectManager>.Instance.Core();
|
|
Singleton<EffectManager>.Instance.Core();
|
|
Singleton<EventManager>.Instance.Core();
|
|
Singleton<LevelDesignManager>.Instance.Core();
|
|
Singleton<AuxObjectManager>.Instance.Core();
|
|
Singleton<DetourManager>.Instance.Core();
|
|
if (Singleton<WwiseAudioManager>.Instance != null)
|
|
{
|
|
Singleton<WwiseAudioManager>.Instance.Core();
|
|
}
|
|
}
|
|
|
|
public new void OnDestroy()
|
|
{
|
|
Singleton<LevelManager>.Instance.Destroy();
|
|
Singleton<LevelManager>.Destroy();
|
|
}
|
|
|
|
private void UpdateForKeyboradInput()
|
|
{
|
|
Vector2 zero = Vector2.zero;
|
|
if (Input.GetKeyUp(KeyCode.Semicolon))
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().SetRotateToFaceDirection();
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha8))
|
|
{
|
|
Singleton<AvatarManager>.Instance.GetLocalAvatar().SetTrigger("TriggerHit");
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha9))
|
|
{
|
|
BaseMonoAvatar localAvatar = Singleton<AvatarManager>.Instance.GetLocalAvatar();
|
|
localAvatar.SetTrigger("TriggerHit");
|
|
localAvatar.SetTrigger("TriggerKnockDown");
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha0))
|
|
{
|
|
Singleton<AvatarManager>.Instance.GetLocalAvatar().SetDied(KillEffect.KillNow);
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha1))
|
|
{
|
|
List<BaseMonoMonster> allMonsters = Singleton<MonsterManager>.Instance.GetAllMonsters();
|
|
if (allMonsters.Count > 0)
|
|
{
|
|
Singleton<CameraManager>.Instance.EnableBossCamera(allMonsters[0].GetRuntimeID());
|
|
}
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha2))
|
|
{
|
|
Singleton<CameraManager>.Instance.DisableBossCamera();
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha3))
|
|
{
|
|
Singleton<CameraManager>.Instance.controlledRotateKeepManual = !Singleton<CameraManager>.Instance.controlledRotateKeepManual;
|
|
}
|
|
if (Input.GetKeyDown(KeyCode.Alpha4))
|
|
{
|
|
Singleton<CameraManager>.Instance.EnableCrowdCamera();
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad4))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(-300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, 0f);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad6))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, 0f);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad8))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(0f, 300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad2))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(0f, -300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad7))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(-300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, 300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad9))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, 300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad1))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(-300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, -300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKey(KeyCode.Keypad3))
|
|
{
|
|
if (!isRotating)
|
|
{
|
|
isRotating = true;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStart();
|
|
}
|
|
zero += new Vector2(300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime, -300f * Singleton<LevelManager>.Instance.levelEntity.TimeScale * Time.deltaTime);
|
|
}
|
|
if (Input.GetKeyUp(KeyCode.Keypad4) || Input.GetKeyUp(KeyCode.Keypad6) || Input.GetKeyUp(KeyCode.Keypad8) || Input.GetKeyUp(KeyCode.Keypad5) || Input.GetKeyUp(KeyCode.Keypad7) || Input.GetKeyUp(KeyCode.Keypad9) || Input.GetKeyUp(KeyCode.Keypad1) || Input.GetKeyUp(KeyCode.Keypad2) || Input.GetKeyUp(KeyCode.Keypad3))
|
|
{
|
|
isRotating = false;
|
|
Singleton<CameraManager>.Instance.GetMainCamera().FollowControlledRotateStop();
|
|
}
|
|
if (isRotating)
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().SetFollowControledRotationData(zero);
|
|
}
|
|
if (Input.GetKey(KeyCode.KeypadPlus) && !Singleton<CameraManager>.Instance.GetMainCamera().storyState.active)
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().PlayStoryCameraState(20001, true, false);
|
|
}
|
|
if (Input.GetKey(KeyCode.KeypadMinus) && Singleton<CameraManager>.Instance.GetMainCamera().storyState.active)
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().storyState.QuitStoryStateWithFade(0.5f, true, true);
|
|
}
|
|
if (Input.GetKey(KeyCode.KeypadMultiply) && Singleton<CameraManager>.Instance.GetMainCamera().storyState.active)
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().storyState.QuitStoryStateWithLerp();
|
|
}
|
|
if (Input.GetKey(KeyCode.X))
|
|
{
|
|
Singleton<MainUIManager>.Instance.GetInLevelUICanvas().FadeOutStageTransitPanel(3f);
|
|
}
|
|
if (Input.GetKey(KeyCode.C))
|
|
{
|
|
Singleton<MainUIManager>.Instance.GetInLevelUICanvas().FadeInStageTransitPanel(3f);
|
|
}
|
|
}
|
|
|
|
private void SetUpAvatarDataItem(AvatarDataItem avatarDataItem, DevAvatarData devAvatarData)
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)1] = Singleton<StorageModule>.Instance.GetDummyWeaponDataItem(devAvatarData.avatarWeapon, devAvatarData.avatarWeaponLevel);
|
|
if (devAvatarData.avatarStigmata[0] != -1)
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)2] = Singleton<StorageModule>.Instance.GetDummyStigmataDataItem(devAvatarData.avatarStigmata[0], devAvatarData.avatarStigmataLevels[0]);
|
|
}
|
|
else
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)2] = null;
|
|
}
|
|
if (devAvatarData.avatarStigmata[1] != -1)
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)3] = Singleton<StorageModule>.Instance.GetDummyStigmataDataItem(devAvatarData.avatarStigmata[1], devAvatarData.avatarStigmataLevels[1]);
|
|
}
|
|
else
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)3] = null;
|
|
}
|
|
if (devAvatarData.avatarStigmata[2] != -1)
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)4] = Singleton<StorageModule>.Instance.GetDummyStigmataDataItem(devAvatarData.avatarStigmata[2], devAvatarData.avatarStigmataLevels[2]);
|
|
}
|
|
else
|
|
{
|
|
avatarDataItem.equipsMap[(EquipmentSlot)4] = null;
|
|
}
|
|
}
|
|
|
|
private void SetUpAvatarSkill(AvatarActor actor, DevAvatarData devAvatarData)
|
|
{
|
|
if (devAvatarData.avatarTestSkills.Length <= 0)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < devAvatarData.avatarTestSkills.Length; i++)
|
|
{
|
|
string value = devAvatarData.avatarTestSkills[i];
|
|
if (!string.IsNullOrEmpty(value))
|
|
{
|
|
actor.abilityPlugin.InsertPreInitAbility(AbilityData.GetAbilityConfig(devAvatarData.avatarTestSkills[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheatForPariticleMode(AvatarActor actor)
|
|
{
|
|
if (!pariticleMode)
|
|
{
|
|
return;
|
|
}
|
|
foreach (AvatarActor.SKillInfo skillInfo in actor.skillInfoList)
|
|
{
|
|
skillInfo.CD = 0f;
|
|
}
|
|
actor.baseMaxHP = (actor.HP = (actor.maxHP = 999999f));
|
|
actor.baseMaxSP = (actor.SP = (actor.maxSP = 999999f));
|
|
actor.ChangeSwitchInCDTime(0.1f);
|
|
}
|
|
|
|
private void CreateFakeFriendAvatar()
|
|
{
|
|
bool leaderSkillOn = false;
|
|
FriendDetailDataItem friendDetailItem = Singleton<LevelScoreManager>.Instance.friendDetailItem;
|
|
AvatarDataItem leaderAvatar = friendDetailItem.leaderAvatar;
|
|
Singleton<AvatarManager>.Instance.CreateAvatar(leaderAvatar, false, InLevelData.CREATE_INIT_POS, InLevelData.CREATE_INIT_FORWARD, Singleton<RuntimeIDManager>.Instance.GetNextRuntimeID(3), false, leaderSkillOn, true);
|
|
}
|
|
|
|
private void TryDestroyType<T>() where T : Component
|
|
{
|
|
T[] array = UnityEngine.Object.FindObjectsOfType<T>();
|
|
T[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
T val = array2[i];
|
|
if (val != null)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(val.gameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TryDestroyTypeAll<T>() where T : Component
|
|
{
|
|
T[] array = UnityEngine.Object.FindObjectsOfType<T>();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(array[i].gameObject);
|
|
}
|
|
}
|
|
|
|
private void LoadAvatarWwiseSoundBank(BaseMonoAvatar avatar)
|
|
{
|
|
int i = 0;
|
|
for (int num = avatar.config.CommonArguments.RequestSoundBankNames.Length; i < num; i++)
|
|
{
|
|
Singleton<WwiseAudioManager>.Instance.ManualPrepareBank(avatar.config.CommonArguments.RequestSoundBankNames[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|