internal async UniTask <ASceneGroup> LoadAsync(AReporter reporter)
{
reporter.SetCurrentSceneGroup(this);
await reporter.InternalPrepareAsync();
if (Ordering == E_SCENE_LOAD_ORDERING.RANDOM)
{
this.Scenes = SceneTypes.Select(x => (AScene)Activator.CreateInstance(x)).ToArray();
var sceneLoadTasks = Scenes.Select(x => x.LoadAsync(reporter));
await UniTask.WhenAll(sceneLoadTasks)
.ContinueWith(async() => await PreLoadAsync(Scenes, reporter))
.ContinueWith(async() => await reporter.ReportEnd());
}
else
{
this.Scenes = SceneTypes.Select(x => (AScene)Activator.CreateInstance(x)).ToArray();
foreach (var scene in Scenes)
{
await scene.LoadAsync(reporter);
}
await PreLoadAsync(Scenes, reporter);
await reporter.ReportEnd();
}
reporter.SetCurrentSceneGroup(null);
await AfterLoadAsync(Scenes);
return(this);
}
public static void SwitchToScene(SceneTypes scene, bool forceReload = false)
{
if (!settings.scenes.ContainsKey(scene))
{
return;
}
#if DEBUG
Plugin.Log.Info($"Switching to scene {scene}");
Plugin.Log.Info($"Cameras: {string.Join(", ", settings.scenes[scene])}");
#endif
if (loadedScene == scene && !forceReload && !isOnCustomScene)
{
return;
}
loadedScene = scene;
var toLoad = settings.scenes[scene];
if (scene == SceneTypes.Menu && toLoad.Count == 0)
{
toLoad = CamManager.cams.Keys.ToList();
}
SwitchToCamlist(toLoad);
isOnCustomScene = false;
UI.SpaghettiUI.scenesSwitchUI.Update(0, false);
}
public void ChangeScene(SceneTypes sceneType)
{
GUI.SetUpGUI(width, height);
switch (sceneType)
{
case SceneTypes.SCENE_GAME:
StartNewGame();
break;
case SceneTypes.SCENE_MAIN_MENU:
StartMenu();
break;
case SceneTypes.SCENE_GAME_OVER:
GameOver();
break;
case SceneTypes.SCENE_GAME_WIN:
GameWin();
break;
default:
break;
}
}
public void SetSceneType(SceneTypes scene)
{
switch (scene)
{
case SceneTypes.MainMenu:
return;
case SceneTypes.MedicinePreparation:
/*Need Support for multiple Scenarios.*/
AddTasks();
Calculator = new ScoreCalculator(allTasks);
GenerateScenarioOne();
break;
case SceneTypes.MembraneFilteration:
//todo
//GenerateScenarioTwo();
break;
case SceneTypes.Tutorial:
return;
}
if (scene != SceneTypes.MainMenu)
{
CurrentPackage = packages.First();
UpdateDescription();
UpdateHint();
}
}
private void OnGUI()
{
if (SceneMode == SceneTypes.TitleScene)
{
Rect labelRect = new Rect(5, 5, 40, 20);
Rect editRect = new Rect(labelRect.xMax + 5, 5, 400, 20);
Rect buttonRect = new Rect(editRect.xMax + 5, 5, 100, 20);
GUI.Label(labelRect, "ID");
if (_config != null)
{
_config._playerID = GUI.TextField(editRect, _config._playerID);
}
else
{
_config = GetDefaultConfig();
}
if (GUI.Button(buttonRect, "Start", GUI.skin.button))
{
SaveConfig();
SceneMode = SceneTypes.LobbyScene;
}
}
}
public static void LoadCamera2Scene()
{
var a = enumScenes.Where(x => x.ToString() == currentlyScenesSelected);
SceneTypes s = enumScenes.ElementAtOrDefault(enumScenes.ToList().IndexOf(a.First()));
Camera2Scenes camera2Scenes = JsonConvert.DeserializeObject <Camera2Scenes>(File.ReadAllText(Path.Combine(cam2Path, "Scenes.json")));
List <string> cameraList = camera2Scenes.scenes[s];
if (cameraList.Count > 0)
{
string ProfileName = CameraUtilities.GetNextProfileName(s.ToString());
if (ProfileName == string.Empty)
{
Logger.log.Error("No ProfileName in LoadCamera2Scene");
return;
}
CameraUtilities.DirectoryCreate(Path.Combine(CameraUtilities.profilePath, ProfileName));
for (int i = 0; i < cameraList.Count; i++)
{
Camera2ConfigLoader(Path.Combine(cam2Path, "Cameras", $"{cameraList[i]}.json"), ProfileName);
}
}
else
{
Logger.log.Error("No Camera Data from Camera2 Scene");
}
}
public void SetCurrentSceneType()
{
if (_currentSceneName == _startSceneName)
{
_currentSceneType = SceneTypes.Start;
}
else if (_currentSceneName == _instructionsSceneName)
{
_currentSceneType = SceneTypes.Instructions;
}
else if (_currentSceneName == _optionsSceneName)
{
_currentSceneType = SceneTypes.Options;
}
else if (_currentSceneName == _creditsSceneName)
{
_currentSceneType = SceneTypes.Credits;
}
else if (_currentSceneName == _gameOverSceneName)
{
_currentSceneType = SceneTypes.GameOver;
}
else
{
_currentSceneType = SceneTypes.Level;
}
}
/// <summary>
/// Builds a new scene containing a location dungeon.
/// </summary>
/// <param name="regionName">Region name.</param>
/// <param name="locationName">Location name.</param>
public void CreateDungeonLocationScene(string regionName, string locationName)
{
// Check if resulting scene will be the same
if (this.location.RegionName == regionName &&
this.location.Name == locationName &&
this.sceneType == SceneTypes.Dungeon)
{
return;
}
// Create location node
host.Core.Scene.ResetScene();
host.Core.Renderer.BackgroundColor = generalBackgroundColor;
LocationNode node = host.Core.SceneBuilder.CreateDungeonLocationNode(regionName, locationName);
if (node == null)
{
return;
}
// Store data
this.location = node.Location;
this.sceneType = SceneTypes.Dungeon;
base.Climate = null;
// Add node to scene
host.Core.Scene.AddNode(null, node);
// Update scene so bounds are correct
host.Core.Scene.Update(TimeSpan.MinValue);
// Set custom movement bounds
Vector3 center = host.Core.Scene.Root.TransformedBounds.Center;
float radius = host.Core.Scene.Root.TransformedBounds.Radius;
BoundingBox movementBounds = new BoundingBox(
new Vector3(center.X - radius, center.Y - radius, center.Z - radius),
new Vector3(center.X + radius, center.Y + radius, center.Z + radius));
topDownCamera.MovementBounds = movementBounds;
freeCamera.MovementBounds = movementBounds;
// Position top-down camera
topDownCamera.CentreInBounds(topDownCameraStartHeight);
// Position free camera
freeCamera.Reference = Vector3.Forward;
freeCamera.Position = new Vector3(
center.X + SceneBuilder.RDBSide / 2,
center.Y,
movementBounds.Max.Z - SceneBuilder.RDBSide / 2);
// Update camera
UpdateCamera();
// Set status message
currentStatus = string.Format("Exploring {0} (Dungeon).", locationName);
}
public static void Initialise()
{
CurrentScene = LevelScene.Instance;
SceneType = SceneTypes.LevelScene;
Functions.LoadLevel(Data.CurrentLevel);
Camera.Load();
CurrentScene.Load();
}
public static void ExportCamera2Scene()
{
Camera2Scenes camera2Scenes = JsonConvert.DeserializeObject <Camera2Scenes>(File.ReadAllText(Path.Combine(cam2Path, "Scenes.json")));
var cameraList = Camera2CameraExporter(CameraUtilities.currentlySelected);
SceneTypes selectedSceneType = enumScenes.Find(x => x.ToString() == currentlyScenesSelected);
camera2Scenes.scenes[selectedSceneType] = cameraList;
File.WriteAllText(Path.Combine(cam2Path, "Scenes.json"), JsonConvert.SerializeObject(camera2Scenes, Formatting.Indented));
}
//取得列舉結果
public static int GetEnumItemTypesResult(SceneTypes itemType)
{
switch (itemType)
{
case SceneTypes.BeforeStartMenuLogo:
return(0);
case SceneTypes.StartMenu:
return(1);
case SceneTypes.Setting:
return(2);
case SceneTypes.LightSystem:
return(3);
case SceneTypes.AdjustVR:
return(4);
case SceneTypes.BeforeGameTutorial:
return(5);
case SceneTypes.MainMenu:
return(6);
case SceneTypes.Stage000:
return(7);
case SceneTypes.Stage001:
return(8);
case SceneTypes.Stage002:
return(9);
case SceneTypes.Stage003:
return(10);
case SceneTypes.Stage004:
return(11);
case SceneTypes.Stage005:
return(12);
case SceneTypes.Stage006:
return(13);
case SceneTypes.Stage007:
return(14);
case SceneTypes.Stage008:
return(15);
}
return(-1);
}
public ScenePropertiesViewModel(
TreeViewViewModel treeParent,
CompoundObjectViewModel parentVm,
MainViewModel mainVm,
SceneProperties modelObject,
bool enabled = true) :
base(treeParent, parentVm, mainVm, enabled)
{
ModelObject = modelObject;
SelectedSceneTypeIndex = SceneTypes.IndexOf(ModelObject.SceneType);
}
private AbstractScene CreateScene(string sceneName)
{
SceneTypes.TryGetValue(sceneName, out var typeScene);
if (typeScene == null)
{
return(null);
}
var scene = (AbstractScene)Activator.CreateInstance(typeScene);
return(scene);
}
//*****************SUMMARY
// sceneNames Initialize
//************************
private void Awake()
{
_currentController = gameObject.AddComponent <SceneController>();
_sceneNames[SceneTypes.TitleScene] = SceneTypes.TitleScene.ToString();
_sceneNames[SceneTypes.LobbyScene] = SceneTypes.LobbyScene.ToString();
_sceneNames[SceneTypes.MapScene] = SceneTypes.MapScene.ToString();
if (SceneMode == SceneTypes.None)
{
SceneMode = SceneTypes.TitleScene;
}
}
public static void EnterScene(SceneTypes sceneType)
{
SceneType = sceneType;
switch (sceneType)
{
case SceneTypes.LevelScene:
NextScene = LevelScene.Instance;
break;
case SceneTypes.EditorScene:
NextScene = EditorScene.Instance;
break;
}
}
//private void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
//{
// switch (e.Button)
// {
// case MouseButton.Left:
// scene.Close();
// StartNewGame();
// break;
// case MouseButton.Right:
// scene.Close();
// StartMenu();
// break;
// }
//}
public void ChangeScene(SceneTypes sceneType)
{
scene.Close();
switch (sceneType)
{
case SceneTypes.SCENE_MAIN_MENU:
StartNewGame();
break;
case SceneTypes.SCENE_GAME:
StartGameOver();
break;
case SceneTypes.SCENE_GAME_OVER:
StartMenu();
break;
}
}
/*private void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
* {
* switch (e.Button)
* {
* case MouseButton.Left:
* scene.Close();
* StartNewGame();
* break;
* case MouseButton.Right:
* scene.Close();
* StartMenu();
* break;
* }
* }
*/
public void SceneChange(SceneTypes SceneType, int score)
{
scene.Close();
switch (SceneType)
{
case SceneTypes.MAIN_MENU:
StartMenu();
break;
case SceneTypes.GAME:
StartNewGame();
break;
case SceneTypes.GAME_OVER:
StartGameOver(score);
break;
case SceneTypes.GAME_WIN:
StartGameWin(score);
break;
}
}
public void SwapScene(SceneTypes type)
{
switch (type)
{
case SceneTypes.Restart:
ChangeScene("Restart");
return;
case SceneTypes.MainMenu:
ChangeScene("MainMenu");
return;
case SceneTypes.MedicinePreparation:
ChangeScene("MedicinePreparation");
return;
case SceneTypes.Tutorial:
ChangeScene("Tutorial");
return;
case SceneTypes.MembraneFilteration:
return;
}
}
public bool CompareSceneType(SceneTypes sceneType)
{
return(sceneType == CurSceneType);
}
/// <summary>
/// Builds a new scene containing a single RMB or RDB block.
/// </summary>
/// <param name="blockName">Block name.</param>
public void CreateBlockScene(string blockName, DFLocation.ClimateSettings?climate)
{
// Check if resulting scene will be the same
if (this.block.Name == blockName &&
this.sceneType == SceneTypes.Block)
{
return;
}
// Create block node
host.Core.Scene.ResetScene();
BlockNode node = host.Core.SceneBuilder.CreateBlockNode(blockName, climate, true);
if (node == null)
{
return;
}
// Store data
this.block = node.Block;
this.sceneType = SceneTypes.Block;
base.Climate = climate;
// Add node to scene
host.Core.Scene.AddNode(null, node);
// Update scene so bounds are correct
host.Core.Scene.Update(TimeSpan.MinValue);
// Get centre position for this block.
// This is worked out using static block dimensions to get a
// nice "centred" feeling when scrolling through blocks.
float side = (block.Type == DFBlock.BlockTypes.Rmb) ?
SceneBuilder.RMBSide : SceneBuilder.RDBSide;
Vector3 center = new Vector3(side / 2, 0, -side / 2);
// Set custom movement bounds
float radius = host.Core.Scene.Root.TransformedBounds.Radius;
BoundingBox movementBounds = new BoundingBox(
new Vector3(center.X - radius, cameraFloorHeight, center.Z - radius),
new Vector3(center.X + radius, cameraCeilingHeight, center.Z + radius));
topDownCamera.MovementBounds = movementBounds;
freeCamera.MovementBounds = movementBounds;
// Position top-down camera
topDownCamera.CentreInBounds(topDownCameraStartHeight);
// Position free camera
freeCamera.Reference = Vector3.Forward;
if (block.Type == DFBlock.BlockTypes.Rmb)
{
freeCamera.CentreInBounds(freeCamera.EyeHeight);
freeCamera.Position = new Vector3(
freeCamera.Position.X, freeCamera.Position.Y, 0f);
}
else
{
freeCamera.CentreInBounds(radius / 2);
freeCamera.Position = new Vector3(
freeCamera.Position.X, freeCamera.Position.Y, movementBounds.Max.Z);
}
// Set background
UpdateCamera();
// Set status message
currentStatus = string.Format("Exploring block {0}.", blockName);
}
private static SceneTypes CheckSceneType(string sceneName)
{
sceneType = SceneTypeDict[sceneName];
return(sceneType);
}
public void SetSubscene(SceneTypes curSceneType, Subscene subscene)
{
Subscene = subscene;
if (Subscene != null)
{
Debug.Log("SUBSCENE: found");
}
else
{
Debug.LogWarning("SUBSCENE: NULL!!!!!!!");
}
SceneCtrl.curSceneType = curSceneType;
gameManagerCanvas.Activate(false);
gameManagerCamera.gameObject.SetActive(false);
switch (SceneCtrl.CurSceneType)
{
case SceneTypes.MAINMENU:
GameManager.Cur.StateCtrl.ChangeGameState(GameState.MAINMENU);
if (Subscene.Canvas != null)
{
Canvas = Subscene.Canvas;
}
PauseFrameRate();
break;
case SceneTypes.LEVEL:
GameManager.Cur.StateCtrl.ChangeGameState(GameState.PLAYLEVEL);
if (Subscene.Canvas != null)
{
Canvas = Subscene.Canvas;
}
if (Subscene.CamCtrl != null)
{
CamCtrl = Subscene.CamCtrl;
}
if (Subscene.Player != null)
{
Player = Subscene.Player;
}
if (Subscene.Enemy != null)
{
Enemy = Subscene.Enemy;
}
UnpauseFrameRate();
break;
}
if (MainMenuCanvas != null)
{
Debug.Log("MAIN MENU CANVAS: found");
}
if (LevelCanvas != null)
{
Debug.Log("LEVEL CANVAS: found");
}
GameManager.Cur.EventCtrl.onSceneLoadEnded?.Invoke();
}
public string GetSceneName(SceneTypes sceneType)
{
return(_sceneNames[sceneType]);
}
