Ejemplo n.º 1
0
        public static void ResetVanillaVariants()
        {
            bool wasPlayAsBadeline = SaveData.Instance.Assists.PlayAsBadeline;

            // from SaveData.AssistModeChecks() when both assist and variant mode are disabled
            SaveData.Instance.Assists           = default(Assists);
            SaveData.Instance.Assists.GameSpeed = 10;

            // apply the Other Self variant right now, if the Other Self variant was enabled before the reset.
            Player p = Engine.Scene.Tracker.GetEntity <Player>();

            if (wasPlayAsBadeline && p != null)
            {
                PlayerSpriteMode mode = p.DefaultSpriteMode;
                if (p.Active)
                {
                    p.ResetSpriteNextFrame(mode);
                }
                else
                {
                    p.ResetSprite(mode);
                }
            }

            if (SaveData.Instance != null)
            {
                Instance.Randomizer.RefreshEnabledVariantsDisplayList();
            }
        }
        private static bool SettingsSpecialCases(string setting, object obj, object value)
        {
            Player player;

            switch (setting)
            {
            case "GameSpeed":
                SaveData.Instance.Assists.GameSpeed = (int)value;
                Engine.TimeRateB = SaveData.Instance.Assists.GameSpeed / 10f;
                break;

            case "MirrorMode":
                SaveData.Instance.Assists.MirrorMode = (bool)value;
                Celeste.Input.MoveX.Inverted         = Celeste.Input.Aim.InvertedX = (bool)value;
                break;

            case "PlayAsBadeline":
                SaveData.Instance.Assists.PlayAsBadeline = (bool)value;
                player = (Engine.Scene as Level)?.Tracker.GetEntity <Player>();
                if (player != null)
                {
                    PlayerSpriteMode mode = SaveData.Instance.Assists.PlayAsBadeline
                            ? PlayerSpriteMode.MadelineAsBadeline
                            : player.DefaultSpriteMode;
                    if (player.Active)
                    {
                        player.ResetSpriteNextFrame(mode);
                    }
                    else
                    {
                        player.ResetSprite(mode);
                    }
                }

                break;

            case "DashMode":
                SaveData.Instance.Assists.DashMode = (Assists.DashModes)Convert.ToInt32((string)value);
                player = (Engine.Scene as Level)?.Tracker.GetEntity <Player>();
                if (player != null)
                {
                    player.Dashes = Math.Min(player.Dashes, player.MaxDashes);
                }

                break;

            case "DashAssist":
                break;

            case "SpeedrunClock":
                Settings.Instance.SpeedrunClock = (SpeedrunType)Convert.ToInt32((string)value);
                break;

            default:
                return(false);
            }

            return(true);
        }
Ejemplo n.º 3
0
        private Player LevelOnLoadNewPlayer(On.Celeste.Level.orig_LoadNewPlayer orig, Vector2 position,
                                            PlayerSpriteMode spriteMode)
        {
            Player player = orig(position, spriteMode);

            player.SetEntityId2(EntityId2.PlayerFixedEntityId2);
            return(player);
        }
Ejemplo n.º 4
0
        // Called from LoadLevel, patched via MonoModRules.PatchLevelLoader
        private static Player LoadNewPlayer(Vector2 position, PlayerSpriteMode spriteMode)
        {
            Player player = NextLoadedPlayer;

            if (player != null)
            {
                NextLoadedPlayer = null;
                return(player);
            }

            return(new Player(position, spriteMode));
        }
Ejemplo n.º 5
0
 void PlayerHair_Update(On.Celeste.PlayerHair.orig_Update orig, PlayerHair self)
 {
     if ((self.Entity as BadelineOldsite) == null && ((self.Entity as Player) != null && Settings.HairLength != HairCount))
     {
         Player player = self.Entity as Player;
         player.Sprite.HairCount = Settings.HairLength;
         HairCount = Settings.HairLength;
         player.Remove(player.Hair);
         PlayerSpriteMode mode = self.Sprite.Mode;
         player.Remove(player.Sprite);
         player.Add(player.Hair = new PlayerHair(player.Sprite));
         player.Add(player.Sprite);
     }
     if ((self.Entity as BadelineOldsite) == null && (self.Entity as Player) != null)
     {
         self.Sprite.HairCount = Settings.HairLength;
     }
     orig(self);
 }
Ejemplo n.º 6
0
        public void Load(PlayerSpriteMode mode)
        //: base((Atlas)null, (string)null)
        {
            this.Mode = mode;
            string id = "";

            switch (mode)
            {
            case PlayerSpriteMode.Madeline:
                id = "player";
                break;

            case PlayerSpriteMode.MadelineNoBackpack:
                id = "player_no_backpack";
                break;

            case PlayerSpriteMode.Badeline:
                id = "badeline";
                break;

            case PlayerSpriteMode.MadelineAsBadeline:
                id = "player_badeline";
                break;

            case PlayerSpriteMode.Playback:
                id = "player_playback";
                break;
            }
            this.spriteName = id;

            //初始化PlayerSprite
            SpriteData spriteData = Gfx.SpriteBank.GetSpriteData(id);

            this.Init(spriteData.Atlas, "");
            spriteData.WrapUnitSprite(this);

            //Gfx.SpriteBank.CreateOn((UnitSprite)this, id);
        }
Ejemplo n.º 7
0
        public Ghost(Player player, GhostData data)
            : base(player.Position)
        {
            Player = player;
            Data   = data;

            Depth = 1;
            // Tag = Tags.PauseUpdate;

            PlayerSpriteMode playerSpriteMode = player.Sprite.Mode;

            if (GhostModule.ModuleSettings.ReversedPlayerSpriteMode)
            {
                if (playerSpriteMode == PlayerSpriteMode.MadelineAsBadeline)
                {
                    if (player.Inventory.Backpack)
                    {
                        playerSpriteMode = PlayerSpriteMode.MadelineNoBackpack;
                    }
                    else
                    {
                        playerSpriteMode = PlayerSpriteMode.Madeline;
                    }
                }
                else
                {
                    playerSpriteMode = PlayerSpriteMode.MadelineAsBadeline;
                }
            }
            Sprite           = new PlayerSprite(playerSpriteMode);
            Sprite.HairCount = player.Sprite.HairCount;
            Add(Hair         = new PlayerHair(Sprite));
            Add(Sprite);

            Hair.Color = Player.NormalHairColor;

            Name = new GhostName(this, Data?.Name ?? "");
        }
Ejemplo n.º 8
0
 private static PlayerSpriteMode GetMode(int settings, PlayerSpriteMode mode = PlayerSpriteMode.Madeline)
 {
     if (settings == (int)MadelineBackpackModes.Backpack)
     {
         return(PlayerSpriteMode.Madeline);
     }
     else if (settings == (int)MadelineBackpackModes.NoBackpack)
     {
         return(PlayerSpriteMode.MadelineNoBackpack);
     }
     else if (settings == (int)MadelineBackpackModes.Playback)
     {
         return(PlayerSpriteMode.Playback);
     }
     else if (PlayerModule.GetPlayer() is Player)
     {
         return(PlayerModule.GetPlayer().DefaultSpriteMode);
     }
     else
     {
         return(mode);
     }
 }
Ejemplo n.º 9
0
 private static void PlayerOnCtor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position,
                                  PlayerSpriteMode spriteMode)
 {
     self.SetEntityId2(EntityId2.PlayerFixedEntityId2);
     orig(self, position, spriteMode);
 }
Ejemplo n.º 10
0
 private void Player_ctor1(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
 {
     orig(self, position, spriteMode);
     thePlayer = self;
     self.StateMachine.SetCallbacks(26, new Func <int>(this.RewindTime));
 }
Ejemplo n.º 11
0
        private static void onPlayerConstructor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(self, position, spriteMode);

            Collision originalSquishCallback = self.SquishCallback;

            Collision patchedSquishCallback = collisionData => {
                // State 21 is the state where the player is located within the Cassette Bubble.
                // They shouldn't be squished by moving blocks inside of it, so we prevent that.
                if (self.StateMachine.State == 21)
                {
                    return;
                }

                originalSquishCallback(collisionData);
            };

            self.SquishCallback = patchedSquishCallback;
        }
Ejemplo n.º 12
0
 private static void onPlayerResetSprite(On.Celeste.Player.orig_ResetSprite orig, Player self, PlayerSpriteMode mode)
 {
     // filter all calls to ResetSprite when MadelineIsSilhouette is enabled, only the ones with Playback will go through.
     // this prevents Madeline from turning back into normal when the Other Self variant is toggled.
     if (!SpringCollab2020Module.Instance.Session.MadelineIsSilhouette || mode == PlayerSpriteMode.Playback)
     {
         orig(self, mode);
     }
 }
Ejemplo n.º 13
0
 public patch_Player(Vector2 position, PlayerSpriteMode spriteMode)
     : base(position, spriteMode)
 {
     // no-op. MonoMod ignores this - we only need this to make the compiler shut up.
 }
 private void OnPlayerSprite_ctor(On.Celeste.PlayerSprite.orig_ctor orig, Celeste.PlayerSprite self, PlayerSpriteMode mode)
 {
     orig(self, mode);
     if (Settings.Enabled)
     {
         self.HairCount = Math.Max(1, self.HairCount + Session.ExtraHair);
     }
 }
Ejemplo n.º 15
0
        private static Player LevelOnLoadNewPlayer(On.Celeste.Level.orig_LoadNewPlayer orig, Vector2 position, PlayerSpriteMode spriteMode)
        {
            Player player = orig(position, spriteMode);

            if (resetRemainder != Vector2.Zero)
            {
                MovementCounter.SetValue(player, resetRemainder);
                resetRemainder = Vector2.Zero;
            }

            return(player);
        }
        private static void ctor(On.Celeste.Player.orig_ctor orig, Celeste.Player self, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(self, position, spriteMode);
            var conveyorMover = new ConveyorMover();

            conveyorMover.OnMove = (amount) =>
            {
                if (self.StateMachine.State != 1)
                {
                    self.MoveH(amount * Engine.DeltaTime);
                }
            };
            self.Add(conveyorMover);
        }
Ejemplo n.º 17
0
        // when constructing the player set the sprite to the one we need (needs resetting)
        internal static void PlayerSprite(On.Celeste.PlayerSprite.orig_ctor orig, PlayerSprite self, PlayerSpriteMode mode)
        {
            // code stolen from max (extended variant mode)
            if (mode == PlayerSpriteMode.Madeline || mode == PlayerSpriteMode.MadelineNoBackpack)
            {
                mode = GetMode(EmoteModMain.Settings.Backpack, mode);
            }

            orig(self, mode);
        }
Ejemplo n.º 18
0
        private void Player_Update(On.Celeste.Player.orig_Update orig, Player self)
        {
            //Logger.Log("w", self.GetType().ToString());
            if (self.GetType().Name == "Ghost")
            {
                orig(self);
                return;
            }
            if (Settings.Enabled)
            {
                UsedHairColor.SetValue(null, Calc.HexToColor(Settings.Dash0Color));
                NormalHairColor.SetValue(null, Calc.HexToColor(Settings.Dash1Color));
                TwoDashesHairColor.SetValue(null, Calc.HexToColor(Settings.Dash2Color));
            }
            else
            {
                NormalHairColor.SetValue(null, Calc.HexToColor("AC3232"));
                TwoDashesHairColor.SetValue(null, Calc.HexToColor("FF6DEF"));
                UsedHairColor.SetValue(null, Calc.HexToColor("44B7FF"));
                if (((Entity)self as BadelineOldsite) != null)
                {
                    self.Sprite.HairCount = Settings.HairLength;
                }
            }
            if ((Settings.Badeline) != (self.Sprite.Mode == PlayerSpriteMode.Badeline))
            {
                PlayerSpriteMode mode = self.Sprite.Mode;
                self.Remove(self.Sprite);
                if (Settings.Badeline)
                {
                    self.Sprite = new PlayerSprite(PlayerSpriteMode.Badeline);
                }
                else
                {
                    self.Sprite = new PlayerSprite(mode);
                }
                self.Remove(self.Hair);
                self.Sprite.HairCount = Settings.HairLength;
                self.Add(self.Hair    = new PlayerHair(self.Sprite));
                self.Add(self.Sprite);
            }
            //if (Settings.Badeline != Badeline)
            //{
            //    if (Settings.Badeline)
            //    {
            //        self.Remove(self.Sprite);
            //        self.Sprite = new PlayerSprite(PlayerSpriteMode.Badeline);
            //        self.Remove(self.Hair);
            //        self.Add(self.Hair = new PlayerHair(self.Sprite));
            //        self.Add(self.Sprite);
            //        Logger.Log("w", self.GetType().ToString());
            //    }
            //    else
            //    {
            //        self.Remove(self.Sprite);
            //        self.Sprite = new PlayerSprite(PlayerSpriteMode.Madeline);
            //        self.Remove(self.Hair);
            //        self.Add(self.Hair = new PlayerHair(self.Sprite));
            //        self.Add(self.Sprite);
            //    }
            //    Badeline = Settings.Badeline;
            //}
            if (Settings.HairLength != HairCount && self.Sprite.Entity as Player != null)
            {
                self.Sprite.HairCount = Settings.HairLength;
                HairCount             = Settings.HairLength;
                self.Remove(self.Hair);
                PlayerSpriteMode mode = self.Sprite.Mode;
                self.Remove(self.Sprite);
                self.Add(self.Hair = new PlayerHair(self.Sprite));
                self.Add(self.Sprite);
            }
            if (Settings.BadelineFloat)
            {
                if (Keyboard.GetState().IsKeyDown(Keys.A))
                {
                    Floating = true;
                    //self.Collidable = false;
                    //((Level)self.Scene).SolidTiles.Collidable = false;
                    self.DummyGravity = true;

                    self.Speed.Y = -15f;
                    if (Keyboard.GetState().IsKeyDown(Keys.P))
                    {
                        self.Speed.Y = Calc.Approach(self.Speed.Y, -120f, 360f);
                    }
                    if (Keyboard.GetState().IsKeyDown(Keys.L))
                    {
                        self.Speed.X = Calc.Approach(self.Speed.X, -120f, 360f);
                    }
                    if (Keyboard.GetState().IsKeyDown(Keys.OemQuotes))
                    {
                        self.Speed.X = Calc.Approach(self.Speed.X, 120f, 360f);
                    }
                    if (Keyboard.GetState().IsKeyDown(Keys.OemSemicolon))
                    {
                        self.Speed.Y = Calc.Approach(self.Speed.Y, 120f, 360f);
                    }
                }
                else
                {
                    if (Floating)
                    {
                        //self.Collidable = true;
                        Floating          = false;
                        self.DummyGravity = false;
                        //((Level)self.Scene).SolidTiles.Collidable = true;
                    }
                }
            }
            orig(self);
        }
Ejemplo n.º 19
0
        private static void onPlayerConstructor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(self, position, spriteMode);

            Collision originalOnCollideV = (Collision)playerOnCollideV.GetValue(self);

            Collision patchedOnCollideV = collisionData => {
                // we just want to kill a piece of code that executes in these conditions (supposed to push the player left or right when hitting a wall angle).
                if (self.StateMachine.State != 19 && self.StateMachine.State != 3 && self.StateMachine.State != 9 && self.Speed.Y < 0 &&
                    self.CollideCheckOutside <UpsideDownJumpThru>(self.Position - Vector2.UnitY))
                {
                    // kill the player's vertical speed.
                    self.Speed.Y = 0;

                    // reset varJumpTimer to prevent a weird "stuck on ceiling" effect.
                    playerVarJumpTimer.SetValue(self, 0);
                }

                originalOnCollideV(collisionData);
            };

            playerOnCollideV.SetValue(self, patchedOnCollideV);
        }
Ejemplo n.º 20
0
 public PlayerTwo(Vector2 position, PlayerSpriteMode spriteMode)
     : base(position, spriteMode)
 {
 }
Ejemplo n.º 21
0
 private void modPlayerConstructor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
 {
     forceRefillStamina = true;
     orig(self, position, spriteMode);
     forceRefillStamina = false;
 }
        private void OnPlayerSprite_ctor(On.Celeste.PlayerSprite.orig_ctor orig, Celeste.PlayerSprite self, PlayerSpriteMode mode)
        {
            orig(self, mode);
            if (Settings.Enabled && (self.Mode == PlayerSpriteMode.Madeline || self.Mode == PlayerSpriteMode.MadelineNoBackpack))
            {
                string id = "";
                switch (self.Mode)
                {
                case PlayerSpriteMode.Madeline:
                    id = "player_KaydenFox";
                    break;

                case PlayerSpriteMode.MadelineNoBackpack:
                    id = "player_no_backpack_KaydenFox";
                    break;
                }

                DynData <Celeste.PlayerSprite> spriteDynData = new DynData <Celeste.PlayerSprite>(self);
                spriteDynData.Set("spriteName", id);
                if (!self.HasHair)
                {
                    Celeste.PlayerSprite.CreateFramesMetadata(id);
                }

                Celeste.GFX.SpriteBank.CreateOn(self, id);
            }
        }
        private void onPlayerSpriteConstructor(On.Celeste.PlayerSprite.orig_ctor orig, PlayerSprite self, PlayerSpriteMode mode)
        {
            // modify Madeline or MadelineNoBackpack as needed, if the variant is enabled.
            if (mode == PlayerSpriteMode.Madeline || mode == PlayerSpriteMode.MadelineNoBackpack)
            {
                if (Settings.MadelineBackpackMode == 1)
                {
                    mode = PlayerSpriteMode.Madeline;
                }
                else if (Settings.MadelineBackpackMode == 2)
                {
                    mode = PlayerSpriteMode.MadelineNoBackpack;
                }
            }

            orig(self, mode);
        }
Ejemplo n.º 24
0
 private void Player_ctor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
 {
     orig(self, position, spriteMode);
     self.Add(new TransitionListener()
     {
         OnOutBegin = () => {
             Transitioning = true;
         },
         OnInEnd = () => {
             Transitioning = false;
         }
     });
 }
Ejemplo n.º 25
0
 private static void onPlayerSpriteConstructor(On.Celeste.PlayerSprite.orig_ctor orig, PlayerSprite self, PlayerSpriteMode mode)
 {
     if (MaxHelpingHandModule.Instance.Session.MadelineIsSilhouette && (mode == PlayerSpriteMode.Madeline || mode == PlayerSpriteMode.MadelineAsBadeline || mode == PlayerSpriteMode.MadelineNoBackpack))
     {
         mode = PlayerSpriteMode.Playback;
     }
     orig(self, mode);
 }
Ejemplo n.º 26
0
        private void onPlayerConstructor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(self, position, spriteMode);

            // make the player spy on transitions
            self.Add(new TransitionListener {
                OnOutBegin = () => transitionPercent = 0f,
                OnOut      = percent => transitionPercent = percent
            });
        }
Ejemplo n.º 27
0
        private static void onPlayerSpriteConstructor(On.Celeste.PlayerSprite.orig_ctor orig, PlayerSprite self, PlayerSpriteMode mode)
        {
            orig(self, mode);

            if (XmlSpriteName != null && (mode == PlayerSpriteMode.Madeline || mode == PlayerSpriteMode.MadelineAsBadeline || mode == PlayerSpriteMode.MadelineNoBackpack))
            {
                // replace the sprite with the defined sprite (from Graphics/Sprites.xml).
                GFX.SpriteBank.CreateOn(self, XmlSpriteName);
            }
        }
        // Adds custom dream tunnel dash state
        private static void Player_ctor(On.Celeste.Player.orig_ctor orig, Player player, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(player, position, spriteMode);
            HasDreamTunnelDash = dreamTunnelDashAttacking = false;

            if (StDreamTunnelDash != -1)
            {
                Extensions.UnregisterState(StDreamTunnelDash);
            }
            StDreamTunnelDash = player.StateMachine.AddState(player.DreamTunnelDashUpdate, null, player.DreamTunnelDashBegin, player.DreamTunnelDashEnd);
            Extensions.RegisterState(StDreamTunnelDash, "StDreamTunnelDash");
        }
Ejemplo n.º 29
0
        private void Player_ctor(On.Celeste.Player.orig_ctor orig, Player self, Vector2 position, PlayerSpriteMode spriteMode)
        {
            orig(self, position, spriteMode);
            new DynData <Player>(self).Set("lastDreamSpeed", 0f);
            // Let's define new states
            // .AddState is defined in StateMachineExt
            YellowBoostState = self.StateMachine.AddState(new Func <int>(YellowBoostUpdate), YellowBoostCoroutine, YellowBoostBegin, YellowBoostEnd);
            GenericCustomBooster.CustomBoostState    = self.StateMachine.AddState(new Func <int>(GenericCustomBooster.BoostUpdate), GenericCustomBooster.BoostCoroutine, GenericCustomBooster.BoostBegin, GenericCustomBooster.BoostEnd);
            GenericCustomBooster.CustomRedBoostState = self.StateMachine.AddState(new Func <int>(GenericCustomBooster.RedDashUpdate), GenericCustomBooster.RedDashCoroutine, GenericCustomBooster.RedDashBegin, GenericCustomBooster.RedDashEnd);
#pragma warning disable CS0618 // Type or member is obsolete
            CustomDreamDashState = self.StateMachine.AddState(new Func <int>(CustomDreamBlock.DreamDashUpdate), null, CustomDreamBlock.DreamDashBegin, CustomDreamBlock.DreamDashEnd);
#pragma warning restore CS0618 // Type or member is obsolete
            CustomFeather.CustomFeatherState = self.StateMachine.AddState(CustomFeather.StarFlyUpdate, CustomFeather.CustomFeatherCoroutine, CustomFeather.CustomFeatherBegin, CustomFeather.CustomFeatherEnd);
        }