Exemplo n.º 1
0
        public override void Load()
        {
            IL.Celeste.BounceBlock.ShakeOffPlayer += onJumpGraceTimerReset;
            IL.Celeste.Player.DreamDashEnd        += modCoyoteTime;

            hookOrigUpdate = new ILHook(typeof(Player).GetMethod("orig_Update"), modCoyoteTime);
        }
Exemplo n.º 2
0
        public static void Load()
        {
            using (new DetourContext {
                Before = { "*" }
            }) {                                             // these don't always call the orig methods, better apply them first.
                // fix general actor/platform behavior to make them comply with jumpthrus.
                On.Celeste.Actor.MoveVExact += onActorMoveVExact;
                On.Celeste.Platform.MoveVExactCollideSolids += onPlatformMoveVExactCollideSolids;
            }

            using (new DetourContext {
                After = { "*" }
            }) {
                // fix player specific behavior allowing them to go through upside-down jumpthrus.
                On.Celeste.Player.ctor += onPlayerConstructor;
            }


            using (new DetourContext()) {
                // block player if they try to climb past an upside-down jumpthru.
                IL.Celeste.Player.ClimbUpdate += patchPlayerClimbUpdate;

                // ignore upside-down jumpthrus in select places.
                playerOrigUpdateHook             = new ILHook(typeof(Player).GetMethod("orig_Update"), filterOutJumpThrusFromCollideChecks);
                IL.Celeste.Player.DashUpdate    += filterOutJumpThrusFromCollideChecks;
                IL.Celeste.Player.RedDashUpdate += filterOutJumpThrusFromCollideChecks;

                // listen for the player unducking, to knock the player down before they would go through upside down jumpthrus.
                On.Celeste.Player.Update += onPlayerUpdate;
            }
        }
Exemplo n.º 3
0
        public override void Load()
        {
            Everest.Events.MainMenu.OnCreateButtons       += CreateMainMenuButtons;
            Everest.Events.Level.OnCreatePauseMenuButtons += CreatePauseMenuButtons;
            nluaAssemblyGetTypesHook = new ILHook(typeof(Lua).Assembly.GetType("NLua.Extensions.TypeExtensions").GetMethod("GetExtensionMethods"), patchNLuaAssemblyGetTypes);

            if (Everest.Flags.IsMobile)
            {
                // It shouldn't look that bad on mobile screens...
                Environment.SetEnvironmentVariable("FNA_OPENGL_BACKBUFFER_SCALE_NEAREST", "1");
            }

            foreach (KeyValuePair <string, LogLevel> logLevel in Settings.LogLevels)
            {
                Logger.SetLogLevelFromYaml(logLevel.Key, logLevel.Value);
            }

            if (Directory.Exists("LogHistory"))
            {
                int           historyToKeep = Math.Max(Settings.LogHistoryCountToKeep, 0); // just in case someone tries to set the value to -42
                List <string> files         = Directory.GetFiles("LogHistory", "log_*.txt").ToList();
                files.Sort(new LogRotationHelper.OldestFirst());
                int historyToDelete = files.Count - historyToKeep;
                foreach (string file in files.Take(historyToDelete))
                {
                    Logger.Log("core", $"log.txt history: keeping {historyToKeep} file(s) of history, deleting {file}");
                    File.Delete(file);
                }
            }
        }
Exemplo n.º 4
0
 public override void Unload()
 {
     Everest.Events.MainMenu.OnCreateButtons       -= CreateMainMenuButtons;
     Everest.Events.Level.OnCreatePauseMenuButtons -= CreatePauseMenuButtons;
     nluaAssemblyGetTypesHook?.Dispose();
     nluaAssemblyGetTypesHook = null;
 }
Exemplo n.º 5
0
        public static void activateHooksNoJungleHelper()
        {
            if (hooksActiveNoJungleHelper)
            {
                return;
            }
            hooksActiveNoJungleHelper = true;

            Logger.Log(LogLevel.Debug, "MaxHelpingHand/SidewaysJumpThru", "=== Activating non Jungle Helper sideways jumpthru hooks");

            // implement the basic collision between actors/platforms and sideways jumpthrus.
            using (new DetourContext {
                Before = { "*" }
            }) {                                             // these don't always call the orig methods, better apply them first.
                On.Celeste.Actor.MoveHExact += onActorMoveHExact;
            }

            using (new DetourContext {
                Before = { "*" }
            }) {                                                   // let's take over Spring Collab 2020, we can break it, this is not a collab map!
                // mod collide checks to include sideways jumpthrus, so that the player behaves with them like with walls.
                IL.Celeste.Player.ClimbCheck  += modCollideChecks; // allow player to climb on them
                IL.Celeste.Player.ClimbBegin  += modCollideChecks; // if not applied, the player will clip through jumpthrus if trying to climb on them
                IL.Celeste.Player.ClimbUpdate += modCollideChecks; // when climbing, jumpthrus are handled like walls
                IL.Celeste.Player.SlipCheck   += modCollideChecks; // make climbing on jumpthrus not slippery
                IL.Celeste.Player.OnCollideH  += modCollideChecks; // handle dashes against jumpthrus properly, without "shifting" down

                // have the push animation when Madeline runs against a jumpthru for example
                hookOnUpdateSprite = new ILHook(typeof(Player).GetMethod("orig_UpdateSprite", BindingFlags.NonPublic | BindingFlags.Instance), modCollideChecks);
            }
        }
Exemplo n.º 6
0
 internal static void Load()
 {
     IL.Celeste.Refill.Update  += Refill_Update;
     IL.Celeste.Refill.Respawn += Refill_Respawn;
     hook_Refill_RefillRoutine  = new ILHook(m_Refill_RefillRoutine.GetStateMachineTarget(),
                                             Refill_RefillRoutine);
 }
Exemplo n.º 7
0
        public override void Initialize()
        {
            Type       T = typeof(HeroController).GetNestedTypes(BindingFlags.NonPublic | BindingFlags.Instance).First(t => t.Name == "<EnterScene>c__Iterator0");
            MethodBase M = T.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.Public);

            fasterTransitionHook = new ILHook(M, RemoveTransitionWaits);
        }
 public static void OnLoad()
 {
     origLoadLevelHook        = new ILHook(typeof(Level).GetMethod("orig_LoadLevel"), ModOrigLoadLevel);
     loadCustomEntityHook     = new ILHook(typeof(Level).GetMethod("LoadCustomEntity"), ModLoadCustomEntity);
     On.Monocle.Entity.Added += EntityOnAdded;
     CustomEntityId2Utils.OnLoad();
 }
        public override void Unload()
        {
            On.Celeste.Player.Jump          -= OnPlayerJump;
            On.Celeste.Player.DashBegin     -= OnPlayerDashBegin;
            On.Celeste.Player.Die           -= OnPlayerDie;
            On.Celeste.PlayerSprite.ctor    -= OnPlayerSprite_ctor;
            On.Celeste.Distort.Render       -= OnDistortRender;
            On.Celeste.Player.Update        -= OnPlayerUpdate;
            On.Celeste.Level.LoadLevel      -= OnLevelLoadLevel;
            On.Celeste.Strawberry.OnCollect -= OnStrawberryOnCollect;
            On.Celeste.Key.OnPlayer         -= OnKeyOnPlayer;
            On.Celeste.Key.RegisterUsed     -= OnKeyRegisterUsed;
            On.Celeste.Player.Duck          -= OnPlayerDuck;
            On.Celeste.Level.CompleteArea_bool_bool_bool -= OnLevelCompleteArea;
            On.Celeste.HeartGem.Collect      -= OnHeartGemCollect;
            On.Celeste.Player.UseRefill      -= OnPlayerUseRefill;
            On.Celeste.Spring.OnCollide      -= OnSpringOnCollide;
            On.Celeste.Player.DreamDashBegin -= OnPlayerDreamDashBegin;
            On.Celeste.CutsceneEntity.Start  -= OnCutsceneEntityStart;

            IL.Monocle.Engine.Update   -= ILEngineUpdate;
            IL.Celeste.Bumper.OnPlayer -= ILBumperOnPlayer;
            ILPlayer_orig_Update.Dispose();
            ILPlayer_orig_Update = null;
            ILPlayerStarFlyCoroutine.Dispose();
            ILPlayerStarFlyCoroutine = null;
        }
        public override void Load()
        {
            On.Celeste.Player.Jump          += OnPlayerJump;
            On.Celeste.Player.DashBegin     += OnPlayerDashBegin;
            On.Celeste.Player.Die           += OnPlayerDie;
            On.Celeste.PlayerSprite.ctor    += OnPlayerSprite_ctor;
            On.Celeste.Distort.Render       += OnDistortRender;
            On.Celeste.Player.Update        += OnPlayerUpdate;
            On.Celeste.Level.LoadLevel      += OnLevelLoadLevel;
            On.Celeste.Strawberry.OnCollect += OnStrawberryOnCollect;
            On.Celeste.Key.OnPlayer         += OnKeyOnPlayer;
            On.Celeste.Key.RegisterUsed     += OnKeyRegisterUsed;
            On.Celeste.Player.Duck          += OnPlayerDuck;
            On.Celeste.Level.CompleteArea_bool_bool_bool += OnLevelCompleteArea;
            On.Celeste.HeartGem.Collect      += OnHeartGemCollect;
            On.Celeste.Player.UseRefill      += OnPlayerUseRefill;
            On.Celeste.Player.StartStarFly   += OnPlayerStartStarFly;
            On.Celeste.Spring.OnCollide      += OnSpringOnCollide;
            On.Celeste.Player.DreamDashBegin += OnPlayerDreamDashBegin;
            On.Celeste.CutsceneEntity.Start  += OnCutsceneEntityStart;

            IL.Monocle.Engine.Update   += ILEngineUpdate;
            IL.Celeste.Bumper.OnPlayer += ILBumperOnPlayer;
            ILPlayer_orig_Update        = new ILHook(typeof(Celeste.Player).GetMethod("orig_Update", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance), ILPlayerUpdate);
            ILPlayerStarFlyCoroutine    = new ILHook(typeof(Celeste.Player).GetMethod("StarFlyCoroutine", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetStateMachineTarget(), ILPlayerStarFlyCoroutine_Actual);
        }
Exemplo n.º 11
0
 public override void Load()
 {
     IL.Celeste.Player.Jump          += modJump;
     IL.Celeste.Player.SuperJump     += modSuperJump;
     IL.Celeste.Player.SuperWallJump += modSuperWallJump;
     wallJumpHook = new ILHook(typeof(Player).GetMethod("orig_WallJump", BindingFlags.Instance | BindingFlags.NonPublic), modWallJump);
 }
        public static void Load()
        {
            On.Celeste.SwapBlock.ctor_EntityData_Vector2 += onSwapBlockConstruct;
            IL.Celeste.SwapBlock.ctor_Vector2_float_float_Vector2_Themes += modSwapBlockTexturesInConstructor;

            hookOnPathRendererConstructor = new ILHook(pathRendererType.GetConstructor(new Type[] { typeof(SwapBlock) }), modSwapBlockTexturesInPathRenderer);
        }
Exemplo n.º 13
0
        internal static void ApplyFieldSets()
        {
            foreach (MethodInfo method in Reflection.GetMethodsWithAttribute <FieldSetAttribute>())
            {
                if (method.ReturnType != typeof(void))
                {
                    throw new LibvaxyException($"The FieldSet method '{method.FullMemberName()}' must have a return type of void");
                }

                if (method.GetCustomAttribute <ExtensionAttribute>() == null)
                {
                    throw new LibvaxyException($"The FieldSet method '{method.FullMemberName()} must be an extension method targetting the type with the specified field");
                }

                ParameterInfo[] parameters = method.GetParameters();

                if (parameters.Length != 2)
                {
                    throw new LibvaxyException($"The FieldSet method '{method.FullMemberName()}' must have a second parameter whose type matches the specified field's type");
                }

                Type targetType             = parameters[0].ParameterType;
                FieldSetAttribute attribute = method.GetCustomAttribute <FieldSetAttribute>();

                if (!Reflection.HasField(targetType, attribute.fieldName))
                {
                    throw new LibvaxyException($"The FieldSet method '{method.FullMemberName()}' targets field '{attribute.fieldName}' which does not exist in type '{targetType.FullName}'");
                }

                FieldInfo     targetFieldInfo = Reflection.GetFieldInfo(targetType, attribute.fieldName);
                ParameterInfo valueParameter  = parameters[1];

                if (valueParameter.ParameterType != targetFieldInfo.FieldType)
                {
                    throw new LibvaxyException($"The setter parameter '{valueParameter.Name}' in the FieldSet method '{method.FullMemberName()}' does not have a type matching the target field '{attribute.fieldName}'");
                }

                ILHook hook = new ILHook(method, il =>
                {
                    il.Body.Instructions.Clear();
                    ILCursor cursor = new ILCursor(il);

                    cursor.Emit(OpCodes.Ldarg_1);

                    if (targetFieldInfo.IsStatic)
                    {
                        cursor.Emit(OpCodes.Stsfld, targetFieldInfo);
                    }
                    else
                    {
                        cursor.Emit(OpCodes.Ldarg_0);
                        cursor.Emit(OpCodes.Stfld, targetFieldInfo);
                    }

                    cursor.Emit(OpCodes.Ret);
                });

                LibvaxyMod.DisposeOnUnload(hook);
            }
        }
Exemplo n.º 14
0
 internal static void Load()
 {
     hookOnHeartCount = new Hook(typeof(HeartGemDoor).GetMethod("get_HeartGems"),
                                 typeof(MiniHeartDoor).GetMethod(nameof(getCollectedHeartGems), BindingFlags.NonPublic | BindingFlags.Static));
     hookOnDoorRoutine = HookHelper.HookCoroutine("Celeste.HeartGemDoor", "Routine", modDoorRoutine);
     IL.Celeste.HeartGemDoor.DrawInterior += modDoorColor;
 }
 public static void Unload()
 {
     IL.Celeste.NorthernLights.ctor         -= hookConstructor;
     IL.Celeste.NorthernLights.BeforeRender -= hookBeforeRender;
     strandILHook?.Dispose();
     strandILHook = null;
 }
Exemplo n.º 16
0
        public static void Load()
        {
            string updateSpriteMethodToPatch = Everest.Loader.DependencyLoaded(new EverestModuleMetadata {
                Name = "Everest", Version = new Version(1, 1432)
            }) ?
                                               "orig_UpdateSprite" : "UpdateSprite";

            // implement the basic collision between actors/platforms and sideways jumpthrus.
            using (new DetourContext {
                Before = { "*" }
            }) {                                             // these don't always call the orig methods, better apply them first.
                On.Celeste.Actor.MoveHExact += onActorMoveHExact;
                On.Celeste.Platform.MoveHExactCollideSolids += onPlatformMoveHExactCollideSolids;
            }

            // block "climb hopping" on top of sideways jumpthrus, because this just looks weird.
            On.Celeste.Player.ClimbHopBlockedCheck += onPlayerClimbHopBlockedCheck;

            using (new DetourContext()) {
                // mod collide checks to include sideways jumpthrus, so that the player behaves with them like with walls.
                IL.Celeste.Player.WallJumpCheck += modCollideChecks; // allow player to walljump off them
                IL.Celeste.Player.ClimbCheck    += modCollideChecks; // allow player to climb on them
                IL.Celeste.Player.ClimbBegin    += modCollideChecks; // if not applied, the player will clip through jumpthrus if trying to climb on them
                IL.Celeste.Player.ClimbUpdate   += modCollideChecks; // when climbing, jumpthrus are handled like walls
                IL.Celeste.Player.SlipCheck     += modCollideChecks; // make climbing on jumpthrus not slippery
                IL.Celeste.Player.NormalUpdate  += modCollideChecks; // get the wall slide effect
                IL.Celeste.Player.OnCollideH    += modCollideChecks; // handle dashes against jumpthrus properly, without "shifting" down

                // have the push animation when Madeline runs against a jumpthru for example
                hookOnUpdateSprite = new ILHook(typeof(Player).GetMethod(updateSpriteMethodToPatch, BindingFlags.NonPublic | BindingFlags.Instance), modCollideChecks);
            }

            // one extra hook that kills the player momentum when hitting a jumpthru so that they don't get "stuck" on them.
            On.Celeste.Player.NormalUpdate += onPlayerNormalUpdate;
        }
        public void Load()
        {
            // Optional: Various graphical simplifications to cut down on visual noise.
            On.Celeste.LightingRenderer.Render            += LightingRenderer_Render;
            On.Monocle.Particle.Render                    += Particle_Render;
            IL.Celeste.BackdropRenderer.Render            += BackdropRenderer_Render;
            On.Celeste.CrystalStaticSpinner.CreateSprites += CrystalStaticSpinner_CreateSprites;
            On.Celeste.DustStyles.Get_Session             += DustStyles_Get_Session;
            On.Celeste.LavaRect.Wave                 += LavaRect_Wave;
            On.Celeste.DreamBlock.Lerp               += DreamBlock_Lerp;
            On.Celeste.FloatingDebris.ctor_Vector2   += FloatingDebris_ctor;
            On.Celeste.MoonCreature.ctor_Vector2     += MoonCreature_ctor;
            On.Celeste.LightningRenderer.Render      += LightningRenderer_Render;
            IL.Celeste.LightningRenderer.Render      += LightningRenderer_RenderIL;
            On.Celeste.LightningRenderer.Bolt.Render += Bolt_Render;
            On.Celeste.Decal.Render       += Decal_Render;
            On.Celeste.SummitCloud.Render += SummitCloudOnRender;

            // Hide screen wipe when beginning level if simple graphic is enabled
            On.Celeste.Level.Begin += Level_Begin;

            if (Type.GetType("FrostHelper.CustomSpinner, FrostTempleHelper") is Type customSpinnerType)
            {
                customSpinnerHook = new ILHook(customSpinnerType.GetConstructors()[0], modCustomSpinnerColor);
            }

            if (Type.GetType("Celeste.Mod.MaxHelpingHand.Entities.RainbowSpinnerColorController, MaxHelpingHand") is Type rainbowSpinnerType)
            {
                rainbowSpinnerColorControllerHook = new ILHook(rainbowSpinnerType.GetConstructors()[0], modRainbowSpinnerColor);
            }
        }
Exemplo n.º 18
0
        internal static void Load()
        {
            // timer pausing when returning to lobby
            On.Celeste.Level.LoadLevel += onLoadLevel;
            On.Celeste.Player.Update   += onPlayerUpdate;

            // hiding collab maps from chapter select
            hookOnLevelSetSwitch = HookHelper.HookCoroutine(typeof(OuiHelper_ChapterSelect_LevelSet).FullName, "Enter", modLevelSetSwitch);
            IL.Celeste.Mod.UI.OuiMapSearch.ReloadItems += modMapSearch;
            IL.Celeste.Mod.UI.OuiMapList.ReloadItems   += modMapListReloadItems;
            IL.Celeste.Mod.UI.OuiMapList.CreateMenu    += modMapListCreateMenu;
            IL.Celeste.Mod.UI.OuiFileSelectSlotLevelSetPicker.changeStartingLevelSet += modFileSelectChangeStartingLevelSet;

            On.Celeste.SaveData.RegisterHeartGem   += onRegisterHeartGem;
            On.Celeste.SaveData.RegisterPoemEntry  += onRegisterPoemEntry;
            On.Celeste.SaveData.RegisterCompletion += onRegisterCompletion;
            On.Celeste.SaveData.AfterInitialize    += onSaveDataAfterInitialize;
            On.Celeste.OuiChapterSelectIcon.AssistModeUnlockRoutine += onAssistUnlockRoutine;
            Everest.Events.Journal.OnEnter    += onJournalEnter;
            On.Celeste.OuiFileSelectSlot.Show += onOuiFileSelectSlotShow;

            hookOnOuiFileSelectRenderDisplayName     = new ILHook(typeof(OuiFileSelectSlot).GetMethod("orig_Render"), modSelectSlotLevelSetDisplayName);
            hookOnOuiFileSelectRenderStrawberryStamp = new ILHook(typeof(OuiFileSelectSlot).GetMethod("orig_Render"), modSelectSlotCollectedStrawberries);
            hookOnOuiJournalPoemLines     = new ILHook(typeof(OuiJournalPoem).GetNestedType("PoemLine", BindingFlags.NonPublic).GetMethod("Render"), modJournalPoemHeartColors);
            hookOnOuiFileSelectSlotGolden = new ILHook(typeof(OuiFileSelectSlot).GetMethod("get_Golden", BindingFlags.NonPublic | BindingFlags.Instance), modSelectSlotCollectedStrawberries);
            hookOnOuiFileSelectSlotRender = new ILHook(typeof(OuiFileSelectSlot).GetMethod("orig_Render"), modOuiFileSelectSlotRender);
        }
 public void ILThenOn()
 {
     hIL = new ILHook(
         typeof(OnIL).GetMethod("DoNothing"),
         il => {
         ILCursor c = new ILCursor(il);
         c.EmitDelegate <Action>(() => {
             hILRun = true;
         });
     },
         new ILHookConfig {
         ManualApply = false
     }
         );
     h1 = new Hook(
         typeof(OnIL).GetMethod("DoNothing"),
         new Action <Action <OnIL>, OnIL>((orig, self) => {
         orig(self);
         h1Run = true;
     }),
         new HookConfig {
         ManualApply = false
     }
         );
     h1Run  = false;
     hILRun = false;
     DoNothing();
     Assert.True(h1Run);
     Assert.True(hILRun);
     h1.Dispose();
     hIL.Dispose();
 }
Exemplo n.º 20
0
        public void HookStuff()
        {
            if (stuffIsHooked)
            {
                return;
            }

            Logger.Log("ExtendedVariantMode/ExtendedVariantsModule", $"Loading variant common methods...");
            On.Celeste.AreaComplete.VersionNumberAndVariants += modVersionNumberAndVariants;
            Everest.Events.Level.OnExit                   += onLevelExit;
            On.Celeste.BadelineBoost.BoostRoutine         += modBadelineBoostRoutine;
            On.Celeste.CS00_Ending.OnBegin                += onPrologueEndingCutsceneBegin;
            Everest.Events.Level.OnCreatePauseMenuButtons += onCreatePauseMenuButtons;
            hookOnVersionNumberAndVariants                 = new ILHook(typeof(AreaComplete).GetMethod("orig_VersionNumberAndVariants"), ilModVersionNumberAndVariants);

            On.Celeste.Level.LoadLevel       += onLoadLevel;
            On.Celeste.Level.EndPauseEffects += onUnpause;
            On.Celeste.Level.End             += onLevelEnd;

            Logger.Log("ExtendedVariantMode/ExtendedVariantsModule", $"Loading variant randomizer...");
            Randomizer.Load();

            foreach (Variant variant in VariantHandlers.Keys)
            {
                Logger.Log("ExtendedVariantMode/ExtendedVariantsModule", $"Loading variant {variant}...");
                VariantHandlers[variant].Load();
            }

            LeakPreventionHack.Load();

            Logger.Log(LogLevel.Info, "ExtendedVariantMode/ExtendedVariantsModule", "Done hooking stuff.");

            stuffIsHooked = true;
        }
        public static void Load()
        {
            Assembly collabUtils = typeof(CollabUtils2.CollabModule).Assembly;

            hookIsHeartSide = new Hook(
                collabUtils.GetType("Celeste.Mod.CollabUtils2.LobbyHelper").GetMethod("IsHeartSide"),
                typeof(GrandmasterHeartSideHelper).GetMethod("modIsHeartSide", BindingFlags.NonPublic | BindingFlags.Static));

            hookOverworldJournal = new ILHook(
                collabUtils.GetType("Celeste.Mod.CollabUtils2.UI.OuiJournalCollabProgressInOverworld").GetConstructor(new Type[] { typeof(OuiJournal) }),
                modOverworldJournal);

            hookLobbyJournal = new ILHook(
                collabUtils.GetType("Celeste.Mod.CollabUtils2.UI.OuiJournalCollabProgressInLobby").GetMethod("GeneratePages"),
                modLobbyJournal);

            IL.Celeste.Level.CompleteArea_bool_bool_bool += modLevelComplete;
            IL.Celeste.OuiChapterPanel.Render            += renderOldGMHSCompletionStamp;

            // we are looking for a lambda in Celeste.Mod.CollabUtils2.LobbyHelper.modJournalPoemHeartColors...
            // except it is located in Celeste.Mod.CollabUtils2.LobbyHelper.<>c.<modJournalPoemHeartColors>b__{someRandomNumber}_0.
            // find it by bruteforcing it a bit.
            Type innerType = collabUtils.GetType("Celeste.Mod.CollabUtils2.LobbyHelper").GetNestedType("<>c", BindingFlags.NonPublic);

            for (int i = 0; i < 100; i++)
            {
                MethodInfo innerMethod = innerType.GetMethod($"<modJournalPoemHeartColors>b__{i}_0", BindingFlags.NonPublic | BindingFlags.Instance);
                if (innerMethod != null)
                {
                    // found it!
                    hookPoemColors = new ILHook(innerMethod, modifyGMHSeartColor);
                    break;
                }
            }
        }
Exemplo n.º 22
0
        public override void Unload()
        {
            IL.Celeste.BounceBlock.ShakeOffPlayer -= onJumpGraceTimerReset;
            IL.Celeste.Player.DreamDashEnd        -= modCoyoteTime;

            hookOrigUpdate?.Dispose();
            hookOrigUpdate = null;
        }
Exemplo n.º 23
0
 private static void Load()
 {
     On.Monocle.Engine.Update            += EngineOnUpdate;
     On.Monocle.Scene.AfterUpdate        += SceneOnAfterUpdate;
     Everest.Events.Level.OnTransitionTo += LevelOnOnTransitionTo;
     On.Celeste.Level.Update             += LevelOnUpdate;
     dashCoroutineIlHook = new ILHook(typeof(Player).GetMethodInfo("DashCoroutine").GetStateMachineTarget(), PlayerOnDashCoroutine);
 }
Exemplo n.º 24
0
        public override void Unload()
        {
            dashCoroutineHook?.Dispose();
            redDashCoroutineHook?.Dispose();

            dashCoroutineHook    = null;
            redDashCoroutineHook = null;
        }
        public static void Unload()
        {
            On.Celeste.SwapBlock.ctor_EntityData_Vector2 -= onSwapBlockConstruct;
            IL.Celeste.SwapBlock.ctor_Vector2_float_float_Vector2_Themes -= modSwapBlockTexturesInConstructor;

            hookOnPathRendererConstructor?.Dispose();
            hookOnPathRendererConstructor = null;
        }
 public override void Load()
 {
     // we cannot hook ExplodeLaunch because of https://github.com/EverestAPI/Everest/issues/66
     // so we'll wrap each call of it instead.
     IL.Celeste.Bumper.OnPlayer           += wrapExplodeLaunchCall;
     IL.Celeste.Puffer.Explode            += wrapExplodeLaunchCall;
     IL.Celeste.TempleBigEyeball.OnPlayer += wrapExplodeLaunchCall;
     seekerRegenerateHook = new ILHook(typeof(Seeker).GetMethod("RegenerateCoroutine", BindingFlags.NonPublic | BindingFlags.Instance).GetStateMachineTarget(), wrapExplodeLaunchCall);
 }
Exemplo n.º 27
0
        public override void Load()
        {
            bool isUpdateSpritePatched = Everest.Loader.DependencyLoaded(new EverestModuleMetadata {
                Name = "Everest", Version = new Version(1, 1432)
            });

            IL.Celeste.Player.NormalUpdate += modNormalUpdate;
            hookUpdateSprite = new ILHook(typeof(Player).GetMethod(isUpdateSpritePatched ? "orig_UpdateSprite" : "UpdateSprite", BindingFlags.NonPublic | BindingFlags.Instance), modUpdateSprite);
        }
Exemplo n.º 28
0
        public override void Load()
        {
            On.Celeste.Player.DashBegin += modDashBegin;

            MethodInfo dashCoroutine = typeof(Player).GetMethod("DashCoroutine", BindingFlags.NonPublic | BindingFlags.Instance).GetStateMachineTarget();

            dashCoroutineHookForTimer   = new ILHook(dashCoroutine, modDashLength);
            dashCoroutineHookForCounter = new ILHook(dashCoroutine, modDashTrailCounter);
        }
Exemplo n.º 29
0
 private static void Unload()
 {
     On.Monocle.Engine.Update            -= EngineOnUpdate;
     On.Monocle.Scene.AfterUpdate        -= SceneOnAfterUpdate;
     Everest.Events.Level.OnTransitionTo -= LevelOnOnTransitionTo;
     On.Celeste.Level.Update             -= LevelOnUpdate;
     dashCoroutineIlHook?.Dispose();
     dashCoroutineIlHook = null;
 }
 public static void Load()
 {
     using (new DetourContext()
     {
         After = { "*" }
     }) {                                              // be sure to be applied after Spring Collab 2020 because we don't want to break it
         playerOrigUpdateHook = new ILHook(typeof(Player).GetMethod("orig_Update"), modPlayerOrigUpdate);
     }
 }