private void OnExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
foreach (BingoVariant variant in typeof(BingoVariant).GetEnumValues())
{
BingoMonitor.SetVariantEnabled(variant, false);
}
}
private void SkipToBoss()
{
Game.instance.currentDungeonFloor = 4;
LevelExit exit = GameObject.FindObjectOfType <LevelExit>();
Game.instance.avatar.transform.position = exit.transform.position + Vector3.right;
}
void Awake()
{
LevelInstance = this;
generator = new MapGenerator();
exitComponent = ExitMap.gameObject.GetComponent <LevelExit>();
}
void Start()
{
animator = GetComponent <Animator>();
controller = FindObjectOfType <GameController>();
exit = FindObjectOfType <LevelExit>();
exit.gameObject.SetActive(false);
}
private void HijackExitBegin(On.Celeste.LevelExit.orig_Begin orig, LevelExit self)
{
orig(self);
var settings = this.InRandomizerSettings;
this.endingSettings = settings;
if (settings == null || settings.Algorithm != LogicType.Endless)
{
return;
}
LevelExit.Mode mode = (LevelExit.Mode) typeof(LevelExit).GetField("mode", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(self);
if (mode != LevelExit.Mode.Completed)
{
return;
}
var newSettings = settings.Copy();
newSettings.EndlessLevel++;
Audio.SetMusic(SFX.music_complete_bside);
Audio.SetAmbience(null);
this.genTask = Task.Run(() => {
try {
return(RandoLogic.GenerateMap(newSettings));
} catch (GenerationError e) {
LevelEnterExt.ErrorMessage = e.Message ?? "Failed to generate area";
LevelEnter.Go(new Session(new AreaKey(1).SetSID("")), false);
return(AreaKey.None);
}
});
}
// abrir puerta sereta o salida secreta
private void TurnLevelExitAndSecretDoor()
{
SecretDoor secretDoor = FindObjectOfType <SecretDoor>();
LevelExit levelExit = FindObjectOfType <LevelExit>();
if (levelExit)
{
// print("hay salida");
if (tortchOn >= tortchInScene.Count)
{
// print("aparece salida");
levelExit.ActivateLevelExit();
}
else
{
levelExit.DeactivateLevelExit();
}
}
if (secretDoor)
{
//print("Hay secret door");
if (secretDoorTortchOn >= secretDoorTortchInScene.Count)
{
//print("Desaparece secret door");
secretDoor.OpenSecretDoor();
}
else
{
secretDoor.CloseSecretDoor();
}
}
}
public override void Paint(GridLayout grid, GameObject layer, Vector3Int position)
{
// Get all LevelExits in grid
LevelExit[] levelExits = BrushUtility.GetRootGrid().GetComponentsInChildren <LevelExit>();
for (int i = 0; i < levelExits.Length; ++i)
{
// If a LevelExit already exists at the current position, exit
if (position == grid.WorldToCell(levelExits[i].transform.position))
{
return;
}
}
LevelExit le = BrushUtility.Instantiate <LevelExit>(
prefab,
BrushUtility.GetWorldPos(grid, position + prefabOffset),
BrushUtility.GetLayer(layerName));
Tilemap tm = BrushUtility
.GetLayer(layerName)
.GetComponent <Tilemap>();
if (tm == null)
{
return;
}
le.SetGridAndTilemap(grid, tm);
BrushUtility.RegisterUndo(tm, $"Add LevelExit tile to Grid");
tm.SetTile(grid.WorldToCell(le.transform.position), closedDoor);
}
protected void LoopPresets(uint pRoom, Room2 room, Level lvl)
{
for (var pPreset = room.pPreset; pPreset != 0;)
{
var preset = game.Debugger.Read <PresetUnit>(pPreset);
var tileLevelNo = CollisionMap.GetTileLevelNo(game, room, preset.dwTxtFileNo);
if (tileLevelNo != 0)
{
var exit = new LevelExit
{
dwTargetLevel = tileLevelNo,
ptPos = new Point((int)((room.dwPosX * 5) + preset.dwPosX), (int)((room.dwPosY * 5) + preset.dwPosY)),
dwType = (uint)ExitType.Tile,
dwId = preset.dwTxtFileNo,
pRoom2 = pRoom
};
if (!levelExits.ContainsKey(lvl.dwLevelNo))
{
levelExits.Add(lvl.dwLevelNo, new List <LevelExit>());
}
if (levelExits[lvl.dwLevelNo].Find(it => it.dwTargetLevel == tileLevelNo) == null)
{
levelExits[lvl.dwLevelNo].Add(exit);
}
}
DrawPreset(room, lvl, preset);
pPreset = preset.pPresetNext;
}
}
private static void OnLevelExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
DiscordPresence.startTimestamp = 0;
DiscordPresence.endTimestamp = 0;
UpdateText(CoreModule.Settings.DiscordTextInMenu);
}
public void OnExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
if (mode == LevelExit.Mode.Completed ||
mode == LevelExit.Mode.CompletedInterlude)
{
Step(level);
}
}
// cancel on level exit
public static void LevelExit_Begin(On.Celeste.LevelExit.orig_Begin orig, LevelExit self)
{
if (EmoteModMain.anim_by_game == 1)
{
cancelEmote();
}
orig(self);
}
internal static void LevelExit(On.Celeste.LevelExit.orig_ctor orig, LevelExit self, LevelExit.Mode mode, Session session, HiresSnow snow)
{
if (EmoteModMain.anim_by_game == 1)
{
cancelEmote();
}
orig(self, mode, session, snow);
}
private void LevelExitOnCtor(On.Celeste.LevelExit.orig_ctor orig, LevelExit self, LevelExit.Mode mode, Session session, HiresSnow snow)
{
orig(self, mode, session, snow);
previousRoom = null;
if (mode == LevelExit.Mode.Restart && !StateManager.Instance.IsSaved)
{
SpeedrunToolModule.Settings.RoomTimer = SpeedrunToolSettings.RoomTimerStrings.First();
}
}
private void onLevelExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
ExistingColorGrades.Remove("trigger");
if (Settings.ColorGrading >= ExistingColorGrades.Count)
{
Settings.ColorGrading = -1;
Settings.ModColorGrade = null;
}
}
void Awake()
{
_exit = transform.root?.GetComponentInChildren <LevelExit>();
EventsManager.StartListening("OnPlayerHit", PlayerHit);
if (_exit != null)
{
_exit.triggerCount++;
}
}
private static void LevelExitOnCtor(On.Celeste.LevelExit.orig_ctor orig, LevelExit self, LevelExit.Mode mode,
Session session, HiresSnow snow)
{
orig(self, mode, session, snow);
if (mode != LevelExit.Mode.GoldenBerryRestart)
{
Reset();
}
}
private void EndlessCantRestart(On.Celeste.LevelExit.orig_ctor orig, LevelExit self, LevelExit.Mode mode, Session session, HiresSnow snow)
{
var settings = this.InRandomizerSettings;
if (settings != null && settings.Algorithm == LogicType.Endless && (mode == LevelExit.Mode.Restart || mode == LevelExit.Mode.GoldenBerryRestart))
{
mode = LevelExit.Mode.SaveAndQuit;
}
orig(self, mode, session, snow);
}
// Use this for initialization
void Start()
{
allWereHit = false;
targetsHit = new bool[3];
targetsHit[0] = false;
targetsHit[1] = false;
targetsHit[2] = false;
exit = FindObjectOfType <LevelExit>();
exit.gameObject.SetActive(false);
}
void Start()
{
enemyArm = transform.Find("EnemyArm").gameObject;
RandomizeStartingWeapon();
if (enemyArm.transform.childCount > 0)
{
enemyWeapon = enemyArm.transform.GetChild(0).gameObject;
}
player = Player.instance;
enemyMovementScript = gameObject.GetComponent <EnemyMovement>();
enemyWeaponScript = enemyArm.GetComponentInChildren <EnemyWeapon>();
lootDropScript = GetComponent <LootDrop>();
levelExitScript = GameObject.Find("LevelExitTrigger").GetComponent <LevelExit>();
cursor = MouseCursor.instance;
gadgetScript = GameObject.Find("GadgetSlotPanel").GetComponent <Gadget>();
scannerInfoTooltip = gadgetScript.scannerInfoTooltip;
spriteRenderer = GetComponent <SpriteRenderer>();
playerCapsuleCollider = player.GetComponent <CapsuleCollider2D>();
thisEnemyCollider = GetComponent <CapsuleCollider2D>();
hearingCollider = transform.Find("Hearing").GetComponent <CircleCollider2D>();
sightCollider = transform.Find("Sight").GetComponent <CircleCollider2D>();
lootBoxCollider = GetComponent <BoxCollider2D>();
lootBoxCollider.enabled = false;
Physics2D.IgnoreCollision(thisEnemyCollider, playerCapsuleCollider);
enemyStats.actualMaxHealth = enemyStats.maxHealth * enemyStats.startHealthPercent;
enemyStats.Init();
actualMoney = Mathf.RoundToInt(Random.Range(minMoneyDrop, maxMoneyDrop));
anim = GetComponent <Animator>();
anim.SetFloat("health", enemyStats.currentHealth);
/*if (statusIndicator != null)
* {
* statusIndicator.SetHealth(enemyStats.currentHealth, enemyStats.maxHealth); // Set health to max health at start
* }*/
GameMaster.gm.onToggleUpgradeMenu += OnUpgradeMenuToggle;
GameMaster.gm.onTogglePauseMenu += OnPauseMenuToggle;
audioManager = AudioManager.instance;
if (audioManager == null)
{
Debug.LogError("No audio manager in scene.");
}
}
private static void onLevelExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
if (mode == LevelExit.Mode.SaveAndQuit)
{
// if saving in a No Refill Field, be sure to restore the refills.
Player player = level.Tracker.GetEntity <Player>();
if (player != null && player.CollideCheck <NoRefillField>())
{
level.Session.Inventory.NoRefills = false;
}
}
}
public void LoadFirstLevel()
{
LevelExit exit = FindObjectOfType <LevelExit>();
exit.gameObject.SetActive(true);
TextCollider textCollider = FindObjectOfType <TextCollider>();
textCollider.gameObject.GetComponent <BoxCollider2D>().enabled = true;
Destroy(gameObject);
}
protected void FillLevelExits(Level level, CollisionMap cmap)
{
var ptCenters = cmap.GetPtCenters();
for (var pRoom = level.pRoom2First; pRoom != 0;)
{
var room = game.Debugger.Read <Room2>(pRoom);
var roomsNear = game.Debugger.ReadArray <uint>(room.pRoom2Near, (int)room.dwRoomsNear);
foreach (var pr in roomsNear)
{
var r = game.Debugger.Read <Room2>(pr);
var lvl = game.Debugger.Read <Level>(r.pLevel);
if (lvl.dwLevelNo != level.dwLevelNo)
{
int nRoomX = (int)room.dwPosX * 5;
int nRoomY = (int)room.dwPosY * 5;
foreach (var ptCenter in ptCenters)
{
if ((ptCenter.X + cmap.LevelOrigin.X) >= (short)nRoomX && (ptCenter.X + cmap.LevelOrigin.X) <= (short)(nRoomX + (room.dwSizeX * 5)))
{
if ((ptCenter.Y + cmap.LevelOrigin.Y) >= (short)nRoomY && (ptCenter.Y + cmap.LevelOrigin.Y) <= (short)(nRoomY + (room.dwSizeY * 5)))
{
var exit = new LevelExit
{
dwTargetLevel = lvl.dwLevelNo,
ptPos = new Point(ptCenter.X + cmap.LevelOrigin.X, ptCenter.Y + cmap.LevelOrigin.Y),
dwType = (uint)ExitType.Level,
dwId = 0,
pRoom2 = 0,
};
if (!levelExits.ContainsKey(level.dwLevelNo))
{
levelExits.Add(level.dwLevelNo, new List <LevelExit>());
}
if (levelExits[level.dwLevelNo].Find(it => it.dwTargetLevel == lvl.dwLevelNo) == null)
{
levelExits[level.dwLevelNo].Add(exit);
}
}
}
}
break;
}
}
pRoom = room.pRoom2Next;
}
}
public void SoundsToggle()
{
player = FindObjectOfType <Player>();
coins = FindObjectsOfType <CoinPickup>();
LevelExit levelExit = FindObjectOfType <LevelExit>();
foreach (CoinPickup coin in coins)
{
coin.GetComponent <AudioSource>().mute = !soundsToggle.isOn;
}
player.GetComponent <AudioSource>().mute = !soundsToggle.isOn;
levelExit.GetComponent <AudioSource>().mute = !soundsToggle.isOn;
}
// Use this for initialization
void Start()
{
wasHit = false;
laser = FindObjectOfType <Laser>();
offSprite = transform.GetChild(0).gameObject;
onSprite = transform.GetChild(1).gameObject;
offSprite.SetActive(true);
onSprite.SetActive(false);
exit = FindObjectOfType <LevelExit>();
exit.gameObject.SetActive(false);
}
private PlayerDeadBody onPlayerDie(On.Celeste.Player.orig_Die orig, Player self, Vector2 direction, bool evenIfInvincible, bool registerDeathInStats)
{
if (!Settings.AllStrawberriesAreGoldens)
{
return(orig(self, direction, evenIfInvincible, registerDeathInStats));
}
// get the first following strawberry before it is detached by the orig method
Strawberry firstStrawberry = null;
foreach (Follower follower in self.Leader.Followers)
{
if (follower.Entity is Strawberry)
{
firstStrawberry = (follower.Entity as Strawberry);
break;
}
}
Level level = self.SceneAs <Level>();
// call the orig method
PlayerDeadBody deadBody = orig(self, direction, evenIfInvincible, registerDeathInStats);
if (deadBody != null && !deadBody.HasGolden && firstStrawberry != null)
{
// the player is dead, doesn't have the actual golden but has a strawberry.
// we have to do magic to make the game believe they had the golden.
// (actually, we just do what vanilla does, but with a regular berry instead.)
deadBody.HasGolden = true;
deadBody.DeathAction = () => {
LevelExit exit = new LevelExit(LevelExit.Mode.GoldenBerryRestart, level.Session)
{
GoldenStrawberryEntryLevel = firstStrawberry.ID.Level
};
// if the berry saved the player's inventory on collection, pass it over to the scene.
DynData <Strawberry> firstStrawberryData = new DynData <Strawberry>(firstStrawberry);
if (firstStrawberryData.Data.ContainsKey("playerInventoryOnCollection"))
{
new DynData <LevelExit>(exit)["playerInventoryToRestore"] = firstStrawberryData.Get <PlayerInventory>("playerInventoryOnCollection");
}
Engine.Scene = exit;
};
}
// proceed
return(deadBody);
}
private void Start()
{
levelExit = FindObjectOfType <LevelExit>();
player = FindObjectOfType <Player>();
//levelExit.SetFirstLastLevel();
var totalNumberOfScenes = SceneManager.sceneCountInBuildSettings;
var currentSceneIndex = SceneManager.GetActiveScene().buildIndex;
if (currentSceneIndex == totalNumberOfScenes - 1)
{
FindObjectOfType <UI>().gameObject.SetActive(false);
}
}
private void Awake()
{
// May need to wait for LevelManager to finish loading level before spawning player
int spawnIndex = GameManager.GM.GetLevelManager().curSpawnIndex;
LevelExit curExit = exits[spawnIndex];
Vector3 spawnPosition = curExit.GetSpawnPoint();
Direction playerDir = curExit.GetSpawnDirection();
BlockDirection blockDir = BlockDirection.Null;
GameObject[] camBlockingVolumes = curExit.cameraBlockingVolumes;
Vector3 camOffset = Vector3.zero;
// Apply offset for each camera blocking volume player is spawning into
foreach (GameObject camBlockingVolume in camBlockingVolumes)
{
// Calculate camera offset
Bounds camBlockBounds = camBlockingVolume.GetComponent <Collider>().bounds;
blockDir = camBlockingVolume.GetComponent <CameraBlockCollision>().blockDir;
if (blockDir == BlockDirection.PosX)
{
Vector3 edge = camBlockBounds.center + camBlockBounds.extents;
camOffset.x = edge.x - spawnPosition.x + playerSize;
}
else if (blockDir == BlockDirection.NegX)
{
Vector3 edge = camBlockBounds.center - camBlockBounds.extents;
camOffset.x = edge.x - spawnPosition.x - playerSize;
}
else if (blockDir == BlockDirection.PosZ)
{
Vector3 edge = camBlockBounds.center + camBlockBounds.extents;
camOffset.z = edge.z - spawnPosition.z + playerSize;
}
else if (blockDir == BlockDirection.NegZ)
{
Vector3 edge = camBlockBounds.center - camBlockBounds.extents;
camOffset.z = edge.z - spawnPosition.z - playerSize;
}
}
GameManager.GM.SpawnPlayer(spawnPosition, playerDir, camOffset);
}
private void checkForTriggerUnhooking(On.Celeste.LevelExit.orig_ctor orig, LevelExit self, LevelExit.Mode mode, Session session, HiresSnow snow)
{
orig(self, mode, session, snow);
// SaveAndQuit => leaving
// GiveUp => leaving
// Restart => restarting
// GoldenBerryRestart => restarting
// Completed => leaving
// CompletedInterlude => leaving
// we want to unhook the trigger if and only if we are actually leaving the level.
if (triggerIsHooked && mode != LevelExit.Mode.Restart && mode != LevelExit.Mode.GoldenBerryRestart)
{
// we want to get rid of the trigger now.
unhookTrigger();
}
}
/// <summary>
/// Reset values if player exits or restarts chapter.
/// </summary>
/// <param name="level">Level object.</param>
/// <param name="exit">Level exit object.</param>
/// <param name="mode">Level exit mode.</param>
/// <param name="session">Current session.</param>
/// <param name="snow">???</param>
private void OnLevelExit(Level level, LevelExit exit, LevelExit.Mode mode, Session session, HiresSnow snow)
{
Log($"OnLevelExit: mode={mode}");
switch (mode)
{
case LevelExit.Mode.GoldenBerryRestart:
case LevelExit.Mode.SaveAndQuit:
break;
default:
// Reset player life count
lifeCount = 1;
infiniteLives = true;
SaveSessionData();
break;
}
}
// Use this for initialization
void Start()
{
currentHealth = maxHealth;
anim = GetComponent<Animator>();
anim.SetFloat("health", currentHealth);
player = Player.instance;
victimMovementScript = GetComponent<VictimMovement>();
levelExitScript = GameObject.Find("LevelExitTrigger").GetComponent<LevelExit>();
thisVictimCollider = GetComponent<CapsuleCollider2D>();
otherVictims = GameObject.FindGameObjectsWithTag("Victim");
audioManager = AudioManager.instance;
if (audioManager == null)
{
Debug.LogError("No audio manager in scene.");
}
}
internal List<LevelExit> DeserializeLevelExits(JArray levelExitObjects)
{
List<LevelExit> result = new List<LevelExit>();
foreach (var entry in levelExitObjects)
{
LevelExit levelExit = new LevelExit();
levelExit.ExitIndex = (int)entry["exitIndex"];
levelExit.ExitDirection = (Direction)(int)entry["exitDirection"];
levelExit.ObjectName = (string)entry["objectName"];
result.Add(levelExit);
}
return result;
}
