public IEnumerator Generate()
{
if (loadedPreviouslyMadeWorld)
{
OverworldLoader.Load();
}
else
{
yield return(StartCoroutine(GenerateElevations()));
}
yield return(StartCoroutine(OverworldTerrainGenerator.Generate()));
yield return(StartCoroutine(OverworldPrefabGenerator.Generate()));
if (loadedPreviouslyMadeWorld)
{
OverworldLandmarkGenerator.Load();
}
else
{
yield return(StartCoroutine(OverworldLandmarkGenerator.Generate()));
}
SetStartGameCharacterPosition();
GetComponent <NavMeshSurface>().BuildNavMesh();
yield return(StartCoroutine(OverworldEncounterGenerator.Generate()));
Camera.main.GetComponent <Desaturate>().enabled = false;
LoadingProgressBar.EndLoad();
}
// This is a bit of a hack. is there a better way to control this?
private void HideMaddy(On.Celeste.Overworld.orig_ctor orig, Overworld self, OverworldLoader loader)
{
orig(self, loader);
if (this.InRandomizer)
{
self.Maddy.Hide();
}
}
private void EnterToRandoMenu(On.Celeste.OverworldLoader.orig_ctor orig, OverworldLoader self, Overworld.StartMode startMode, HiresSnow snow)
{
if ((startMode == Overworld.StartMode.MainMenu || startMode == Overworld.StartMode.AreaComplete) && this.InRandomizer)
{
startMode = RandoModule.STARTMODE_RANDOMIZER;
}
orig(self, startMode, snow);
}
public void EnterToRandoMenu(On.Celeste.OverworldLoader.orig_ctor orig, OverworldLoader self, Overworld.StartMode startMode, HiresSnow snow)
{
if ((startMode == Overworld.StartMode.MainMenu || startMode == Overworld.StartMode.AreaComplete) && this.InRandomizer)
{
startMode = (Overworld.StartMode) 55;
}
orig(self, startMode, snow);
}
public void LoadOverworld()
{
Logger.Log("Load overworld (in editor)");
if (string.IsNullOrWhiteSpace(_overworldName))
{
Logger.Warning(Logger.Datawriting, "In order to save the overworld, please fill in an overworld name");
return;
}
bool overworldNameExists = OverworldLoader.OverworldExists(_overworldName);
if (overworldNameExists)
{
OverworldData overworldData = OverworldLoader.LoadOverworldData(_overworldName);
OverworldLoader.LoadOverworldForEditor(overworldData);
}
EditorSelectedOverworldTileModifierContainer selectedTileModifierContainer = EditorCanvasUI.Instance.SelectedTileModifierContainer as EditorSelectedOverworldTileModifierContainer;
selectedTileModifierContainer?.SetInitialModifierValues();
EditorOverworldTileModificationPanel.Instance?.Reset();
EditorOverworldTileModificationPanel.Instance?.DestroyModifierActions();
}
public patch_Overworld(OverworldLoader loader)
: base(loader)
{
// no-op. MonoMod ignores this - we only need this to make the compiler shut up.
}
private void ClearStateAndPbTimes(On.Celeste.Overworld.orig_ctor orig, Overworld self, OverworldLoader loader)
{
orig(self, loader);
ClearState();
RoomTimerManager.Instance.ClearPbTimes();
}
public void GenerateTiles()
{
if (_gridWidth < 3)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a width of {0}. The minimum generatable grid width is 3", _gridWidth);
return;
}
if (_gridWidth > 25)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a width of {0}. The maximum generatable grid width is 20", _gridWidth);
return;
}
if (_gridHeight < 3)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a height of {0}. The minimum generatable grid height is 3", _gridHeight);
return;
}
if (_gridHeight > 25)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a height of {0}. The maximum generatable grid height is 20", _gridHeight);
return;
}
Logger.Log("Generate tile grid with a width of {0} and a height of {1}", _gridWidth, _gridHeight);
// remove everything from the currently loaded level
OverworldGameplayManager.Instance.UnloadOverworld();
// Create a new level from scratch with a obstacle ring at the edges
List <SerialisableTile> tiles = new List <SerialisableTile>();
for (int i = 0; i < _gridWidth; i++)
{
for (int j = 0; j < _gridHeight; j++)
{
string tileId = Guid.NewGuid().ToString();
GridLocation gridLocation = new GridLocation(i, j);
SerialisableTileMainMaterial mainMaterial = new SerialisableTileMainMaterial("GroundMainMaterial", new SerialisableLandMaterial());
List <SerialisableTileAttribute> tileAttributes = new List <SerialisableTileAttribute>();
List <SerialisableTileBackground> tileBackgrounds = new List <SerialisableTileBackground>();
List <SerialisableTileCornerFiller> tileCornerFillers = new List <SerialisableTileCornerFiller>();
SerialisableTileBaseGround baseBackground = TryAddBaseBackgroundForNewOverworld(tileBackgrounds, tileAttributes);
if (baseBackground != null)
{
tileBackgrounds.Add(new SerialisableTileBackground(baseBackground.GetType().ToString(), baseBackground));
}
SerialisableTile tile = new SerialisableTile(tileId, mainMaterial, tileAttributes, tileBackgrounds, tileCornerFillers, gridLocation.X, gridLocation.Y);
tiles.Add(tile);
}
}
OverworldData newOverworldData = new OverworldData();
newOverworldData.Tiles = tiles;
OverworldLoader.LoadOverworldForEditor(newOverworldData);
}
public void Start()
{
switch (PersistentGameManager.CurrentSceneType)
{
case SceneType.Overworld:
Logger.Log("instantiate overworld sprites, tiles and characters");
if (PersistentGameManager.SceneLoadOrigin == SceneLoadOrigin.Gameplay)
{
if (PersistentGameManager.OverworldName == "")
{
PersistentGameManager.SetOverworldName("overworld");
}
string overworldName = PersistentGameManager.OverworldName;
Logger.Log($"We will load the maze '{overworldName}'");
OverworldData startUpOverworldData = OverworldLoader.LoadOverworldData(overworldName);
if (startUpOverworldData == null)
{
Logger.Error("Could not find the default overworld for startup");
}
OverworldLoader.LoadOverworld(startUpOverworldData);
if (OverworldGameplayManager.Instance.Overworld == null)
{
Logger.Log(Logger.Initialisation, "No overworld loaded on startup. Returning");
return;
}
} // We loaded a overworld scene through the editor. Set up an empty grid for in the editor
else
{
Logger.Log("create empty grid");
EditorCanvasUI.Instance.OverworldModificationPanel.GenerateTiles();
}
break;
case SceneType.Maze:
// We loaded a maze scene through the game. Set up the maze level
if (PersistentGameManager.SceneLoadOrigin == SceneLoadOrigin.Gameplay)
{
if (PersistentGameManager.CurrentSceneName == "")
{
PersistentGameManager.SetCurrentSceneName("default");
}
string mazeName = PersistentGameManager.CurrentSceneName;
PersistentGameManager.SetLastMazeLevelName(mazeName);
Logger.Log($"We will load the maze '{mazeName}'");
MazeLevelData startUpMazeLevelData = MazeLevelLoader.LoadMazeLevelData(mazeName);
if (startUpMazeLevelData == null)
{
Logger.Error($"Could not find the level {mazeName} for startup. Will load defult level instead.");
mazeName = "default";
startUpMazeLevelData = MazeLevelLoader.LoadMazeLevelData(mazeName);
}
MazeLevelLoader.LoadMazeLevel(startUpMazeLevelData);
if (CurrentGameLevel == null)
{
Logger.Log(Logger.Initialisation, "No level loaded on startup. Returning");
return;
}
if (CurrentGameLevel.PlayerCharacterSpawnpoints.Count == 0)
{
return;
}
PlayableLevelNames = MazeLevelLoader.GetAllPlayableLevelNames();
} // We loaded a maze scene through the editor. Set up an empty grid for in the editor
else
{
Logger.Log("create empty grid");
EditorCanvasUI.Instance.MazeModificationPanel.GenerateTiles();
}
break;
default:
Logger.Error($"Scenetype {PersistentGameManager.CurrentSceneType} is not implemented yet");
break;
}
}
private static void onOverworldLoad(On.Celeste.OverworldLoader.orig_ctor orig, OverworldLoader self, Overworld.StartMode startMode, HiresSnow snow)
{
orig(self, startMode, snow);
if (startMode != (Overworld.StartMode)(-1)) // -1 = in-game overworld from the collab utils
{
deactivateHooks();
deactivateHooksNoJungleHelper();
}
}
