Small Changes

Zennysoft.Game.Ma/src/items/weapons/resources/NebulaChain.tres

@@ -8,6 +8,7 @@ script = ExtResource("2_4aje4")
 AttackSpeed = 1.0
 WeaponElement = 0
 WeaponTag = 2
+SelfDamage = 0
 SoundEffect = 22
 Name = "Nebula Chain"
 Description = "Chain Whip that strikes through time and dimension."

Zennysoft.Game.Ma/src/items/weapons/textures/Nebula Chain.png.import

@@ -3,7 +3,7 @@
 importer="texture"
 type="CompressedTexture2D"
 uid="uid://cr2jhtawg0lsw"
-path.s3tc="res://.godot/imported/Nebula Chain.png-99ddad7d70f9e8aa9060816e05a6f73d.s3tc.ctex"
+path.bptc="res://.godot/imported/Nebula Chain.png-99ddad7d70f9e8aa9060816e05a6f73d.bptc.ctex"
 metadata={
 "imported_formats": ["s3tc_bptc"],
 "vram_texture": true
@@ -12,12 +12,12 @@ metadata={
 [deps]
 
 source_file="res://src/items/weapons/textures/Nebula Chain.png"
-dest_files=["res://.godot/imported/Nebula Chain.png-99ddad7d70f9e8aa9060816e05a6f73d.s3tc.ctex"]
+dest_files=["res://.godot/imported/Nebula Chain.png-99ddad7d70f9e8aa9060816e05a6f73d.bptc.ctex"]
 
 [params]
 
 compress/mode=2
-compress/high_quality=false
+compress/high_quality=true
 compress/lossy_quality=0.7
 compress/hdr_compression=1
 compress/normal_map=0

Zennysoft.Game.Ma/src/map/dungeon/code/DungeonFloor.cs

@@ -20,9 +20,9 @@ public partial class DungeonFloor : Node3D, IDungeonFloor
 
   public void InitializeDungeon()
   {
-    Rooms = [];
-    Rooms = FindAllDungeonRooms([.. GetChildren()], Rooms);
-    _playerSpawnPoint = RandomizePlayerSpawnPoint();
+	Rooms = [];
+	Rooms = FindAllDungeonRooms([.. GetChildren()], Rooms);
+	_playerSpawnPoint = RandomizePlayerSpawnPoint();
   }
 
   public void FadeOutAudio()
@@ -32,27 +32,27 @@ public partial class DungeonFloor : Node3D, IDungeonFloor
 
   public void SpawnEnemies(DungeonFloorNode floorNode)
   {
-    var enemyOdds = new Godot.Collections.Dictionary<EnemyType, float>
-    {
-      { EnemyType.Sproingy, floorNode.Sproingy },
-      { EnemyType.Michael, floorNode.Michael },
-      { EnemyType.FilthEater, floorNode.FilthEater },
-      { EnemyType.Sara, floorNode.Sara },
-      { EnemyType.Ballos, floorNode.Ballos },
-      { EnemyType.Chariot, floorNode.Chariot },
-      { EnemyType.Chinthe, floorNode.Chinthe },
-      { EnemyType.AmbassadorGreen, floorNode.GreenAmbassador },
-      { EnemyType.AmbassadorRed, floorNode.RedAmbassador },
-      { EnemyType.AmbassadorSteel, floorNode.SteelAmbassador },
-      { EnemyType.AgniDemon, floorNode.AgniDemon },
-      { EnemyType.AqueousDemon, floorNode.AqueosDemon },
-      { EnemyType.Palan, floorNode.Palan },
-      { EnemyType.ShieldOfHeaven, floorNode.ShieldOfHeaven },
-      { EnemyType.GoldSproingy, floorNode.GoldSproingy },
-    };
-    var monsterRooms = Rooms.OfType<MonsterRoom>();
-    foreach (var room in monsterRooms)
-      room.SpawnEnemies(enemyOdds);
+	var enemyOdds = new Godot.Collections.Dictionary<EnemyType, float>
+	{
+	  { EnemyType.Sproingy, floorNode.Sproingy },
+	  { EnemyType.Michael, floorNode.Michael },
+	  { EnemyType.FilthEater, floorNode.FilthEater },
+	  { EnemyType.Sara, floorNode.Sara },
+	  { EnemyType.Ballos, floorNode.Ballos },
+	  { EnemyType.Chariot, floorNode.Chariot },
+	  { EnemyType.Chinthe, floorNode.Chinthe },
+	  { EnemyType.AmbassadorGreen, floorNode.GreenAmbassador },
+	  { EnemyType.AmbassadorRed, floorNode.RedAmbassador },
+	  { EnemyType.AmbassadorSteel, floorNode.SteelAmbassador },
+	  { EnemyType.AgniDemon, floorNode.AgniDemon },
+	  { EnemyType.AqueousDemon, floorNode.AqueosDemon },
+	  { EnemyType.Palan, floorNode.Palan },
+	  { EnemyType.ShieldOfHeaven, floorNode.ShieldOfHeaven },
+	  { EnemyType.GoldSproingy, floorNode.GoldSproingy },
+	};
+	var monsterRooms = Rooms.OfType<MonsterRoom>();
+	foreach (var room in monsterRooms)
+	  room.SpawnEnemies(enemyOdds);
   }
 
   public (Vector3 Rotation, Vector3 Position) GetPlayerSpawnPoint() { return (_playerSpawnPoint.Rotation, new Vector3(_playerSpawnPoint.GlobalPosition.X, 0, _playerSpawnPoint.GlobalPosition.Z)); }
@@ -60,25 +60,25 @@ public partial class DungeonFloor : Node3D, IDungeonFloor
 
   private Marker3D RandomizePlayerSpawnPoint()
   {
-    var randomSpawnLocations = Rooms
-      .OfType<MonsterRoom>()
-      .Select(x => x.PlayerSpawn);
-    var godotCollection = new Godot.Collections.Array<Marker3D>(randomSpawnLocations);
-    var result = godotCollection.PickRandom();
-    return result;
+	var randomSpawnLocations = Rooms
+	  .OfType<MonsterRoom>()
+	  .Select(x => x.PlayerSpawn);
+	var godotCollection = new Godot.Collections.Array<Marker3D>(randomSpawnLocations);
+	var result = godotCollection.PickRandom();
+	return result;
   }
 
   private static ImmutableList<IDungeonRoom> FindAllDungeonRooms(List<Node> nodesToSearch, ImmutableList<IDungeonRoom> roomsFound)
   {
-    if (nodesToSearch.Count == 0)
-      return roomsFound;
+	if (nodesToSearch.Count == 0)
+	  return roomsFound;
 
-    foreach (var node in nodesToSearch)
-    {
-      if (node is IDungeonRoom dungeonRoom)
-        roomsFound = roomsFound.Add(dungeonRoom);
-    }
+	foreach (var node in nodesToSearch)
+	{
+	  if (node is IDungeonRoom dungeonRoom)
+		roomsFound = roomsFound.Add(dungeonRoom);
+	}
 
-    return FindAllDungeonRooms([.. nodesToSearch.SelectMany(x => x.GetChildren())], roomsFound);
+	return FindAllDungeonRooms([.. nodesToSearch.SelectMany(x => x.GetChildren())], roomsFound);
   }
 }

Zennysoft.Game.Ma/src/map/dungeon/code/ExitRoom.cs

@@ -18,21 +18,21 @@ public partial class ExitRoom : DungeonRoom
 
   public override void _Ready()
   {
-    _exit.AreaEntered += Exit_AreaEntered;
+	_exit.AreaEntered += Exit_AreaEntered;
   }
 
   public void ExitReached()
-    => Game.FloorExitReached();
+	=> Game.FloorExitReached();
 
   private void Exit_AreaEntered(Area3D area)
   {
-    if (area.GetOwner() is IPlayer)
-      ExitReached();
+	if (area.GetOwner() is IPlayer)
+	  ExitReached();
   }
 
   public new void OnExitTree()
   {
-    base.OnExitTree();
-    _exit.AreaEntered -= Exit_AreaEntered;
+	base.OnExitTree();
+	_exit.AreaEntered -= Exit_AreaEntered;
   }
 }

Zennysoft.Game.Ma/src/player/Player.cs

@@ -112,117 +112,117 @@ public partial class Player : CharacterBody3D, IPlayer, IProvide<IPlayer>
 
   public void Initialize()
   {
-    var container = new SimpleInjector.Container();
-    container.Register<IPlayerLogic, PlayerLogic>(Lifestyle.Singleton);
+	var container = new SimpleInjector.Container();
+	container.Register<IPlayerLogic, PlayerLogic>(Lifestyle.Singleton);
 
-    PlayerLogic = container.GetInstance<IPlayerLogic>();
-    PlayerLogic.Set(this as IPlayer);
-    PlayerLogic.Set(Settings);
+	PlayerLogic = container.GetInstance<IPlayerLogic>();
+	PlayerLogic.Set(this as IPlayer);
+	PlayerLogic.Set(Settings);
 
-    Inventory = new Inventory();
-    HealthComponent = new HealthComponent(InitialHP);
-    VTComponent = new VTComponent(InitialVT);
-    AttackComponent = new AttackComponent(InitialAttack);
-    DefenseComponent = new DefenseComponent(InitialDefense);
-    ExperiencePointsComponent = new ExperiencePointsComponent();
-    LuckComponent = new LuckComponent(InitialLuck);
-    EquipmentComponent = new EquipmentComponent();
+	Inventory = new Inventory();
+	HealthComponent = new HealthComponent(InitialHP);
+	VTComponent = new VTComponent(InitialVT);
+	AttackComponent = new AttackComponent(InitialAttack);
+	DefenseComponent = new DefenseComponent(InitialDefense);
+	ExperiencePointsComponent = new ExperiencePointsComponent();
+	LuckComponent = new LuckComponent(InitialLuck);
+	EquipmentComponent = new EquipmentComponent();
 
-    _itemReroller = new ItemReroller(ItemDatabase.Instance);
-    _playerEffectService = new PlayerEffectService(this);
+	_itemReroller = new ItemReroller(ItemDatabase.Instance);
+	_playerEffectService = new PlayerEffectService(this);
 
-    Settings = new PlayerLogic.Settings() { RotationSpeed = RotationSpeed, MoveSpeed = MoveSpeed, Acceleration = Acceleration };
+	Settings = new PlayerLogic.Settings() { RotationSpeed = RotationSpeed, MoveSpeed = MoveSpeed, Acceleration = Acceleration };
 
-    PlayerBinding = PlayerLogic.Bind();
+	PlayerBinding = PlayerLogic.Bind();
 
-    PlayerBinding
-      .Handle((in PlayerLogic.Output.ThrowItem output) =>
-      {
-      })
-      .Handle((in PlayerLogic.Output.Move output) =>
-      {
-        Move(output.delta);
-      });
+	PlayerBinding
+	  .Handle((in PlayerLogic.Output.ThrowItem output) =>
+	  {
+	  })
+	  .Handle((in PlayerLogic.Output.Move output) =>
+	  {
+		Move(output.delta);
+	  });
 
-    PlayerLogic.Start();
-    this.Provide();
+	PlayerLogic.Start();
+	this.Provide();
   }
 
   public void ResetPlayerData()
   {
-    PlayerFXAnimations.Play("RESET");
+	PlayerFXAnimations.Play("RESET");
 
-    foreach (var item in Inventory.Items)
-      Inventory.Remove(item);
+	foreach (var item in Inventory.Items)
+	  Inventory.Remove(item);
 
-    HealthComponent.Reset();
-    VTComponent.Reset();
-    AttackComponent.Reset();
-    DefenseComponent.Reset();
-    ExperiencePointsComponent.Reset();
-    LuckComponent.Reset();
-    EquipmentComponent.Reset();
+	HealthComponent.Reset();
+	VTComponent.Reset();
+	AttackComponent.Reset();
+	DefenseComponent.Reset();
+	ExperiencePointsComponent.Reset();
+	LuckComponent.Reset();
+	EquipmentComponent.Reset();
 
-    HealthTimer.Timeout += OnHealthTimerTimeout;
+	HealthTimer.Timeout += OnHealthTimerTimeout;
   }
 
   #region Initialization
   public void OnReady()
   {
-    Hitbox.AreaEntered += Hitbox_AreaEntered;
-    CollisionDetector.AreaEntered += CollisionDetector_AreaEntered;
-    HealthComponent.CurrentHP.Changed += InverseHPToAttackPowerSync;
-    HealthComponent.HealthReachedZero += Die;
-    ExperiencePointsComponent.PlayerLevelUp += OnLevelUp;
-    PlayerFXAnimations.AnimationFinished += PlayerFXAnimations_AnimationFinished;
-    HealthTimer.WaitTime = _healthTimerWaitTime;
-    SetProcessInput(false);
-    SetPhysicsProcess(false);
+	Hitbox.AreaEntered += Hitbox_AreaEntered;
+	CollisionDetector.AreaEntered += CollisionDetector_AreaEntered;
+	HealthComponent.CurrentHP.Changed += InverseHPToAttackPowerSync;
+	HealthComponent.HealthReachedZero += Die;
+	ExperiencePointsComponent.PlayerLevelUp += OnLevelUp;
+	PlayerFXAnimations.AnimationFinished += PlayerFXAnimations_AnimationFinished;
+	HealthTimer.WaitTime = _healthTimerWaitTime;
+	SetProcessInput(false);
+	SetPhysicsProcess(false);
   }
   #endregion
 
   public void Activate()
   {
-    SetProcessInput(true);
-    SetPhysicsProcess(true);
-    SetHealthTimerStatus(HealthTimerIsActive);
+	SetProcessInput(true);
+	SetPhysicsProcess(true);
+	SetHealthTimerStatus(HealthTimerIsActive);
   }
 
   public void Deactivate()
   {
-    Velocity = Vector3.Zero;
-    SetProcessInput(false);
-    SetPhysicsProcess(false);
-    SetHealthTimerStatus(false);
+	Velocity = Vector3.Zero;
+	SetProcessInput(false);
+	SetPhysicsProcess(false);
+	SetHealthTimerStatus(false);
   }
 
   public void SetHealthTimerStatus(bool isActive)
   {
-    if (isActive)
-      HealthTimer.Start();
-    else
-      HealthTimer.Stop();
+	if (isActive)
+	  HealthTimer.Start();
+	else
+	  HealthTimer.Stop();
   }
 
   public void TeleportPlayer((Vector3 Rotation, Vector3 Position) newTransform)
   {
-    Rotation = newTransform.Rotation;
-    Position = newTransform.Position;
+	Rotation = newTransform.Rotation;
+	Position = newTransform.Position;
   }
 
   public void TakeDamage(AttackData damage)
   {
-    _camera3D.AddShake(1.0f);
-    TakeDamageAnimationPlayer.Play("take_damage");
-    var damageReceived = DamageCalculator.CalculateDamage(damage, TotalDefense, EquipmentComponent.ElementalResistance);
-    HealthComponent.Damage(damageReceived);
-    SfxDatabase.Instance.Play(SoundEffect.TakeDamage);
+	_camera3D.AddShake(1.0f);
+	TakeDamageAnimationPlayer.Play("take_damage");
+	var damageReceived = DamageCalculator.CalculateDamage(damage, TotalDefense, EquipmentComponent.ElementalResistance);
+	HealthComponent.Damage(damageReceived);
+	SfxDatabase.Instance.Play(SoundEffect.TakeDamage);
   }
 
   public void Knockback(float impulse)
   {
-    _knockbackStrength = impulse;
-    _knockbackDirection = GlobalBasis.Z.Normalized();
+	_knockbackStrength = impulse;
+	_knockbackDirection = GlobalBasis.Z.Normalized();
   }
 
   public void PlayJumpScareAnimation() => PlayerFXAnimations.Play("jump_scare");
@@ -235,82 +235,82 @@ public partial class Player : CharacterBody3D, IPlayer, IProvide<IPlayer>
 
   public void LevelUp()
   {
-    ExperiencePointsComponent.LevelUp();
+	ExperiencePointsComponent.LevelUp();
   }
 
   public void Die()
   {
-    PlayerFXAnimations.Play("death");
-    HealthTimer.WaitTime = _healthTimerWaitTime;
-    HealthTimer.Timeout -= OnHealthTimerTimeout;
-    SetProcessInput(false);
-    SetPhysicsProcess(false);
+	PlayerFXAnimations.Play("death");
+	HealthTimer.WaitTime = _healthTimerWaitTime;
+	HealthTimer.Timeout -= OnHealthTimerTimeout;
+	SetProcessInput(false);
+	SetPhysicsProcess(false);
   }
 
   public override void _Input(InputEvent @event)
   {
-    if (@event.IsActionPressed(GameInputs.Attack))
-      Attack();
-    if (@event.IsActionPressed(GameInputs.Sprint))
-      _debugSprint = true;
-    else if (@event.IsActionReleased(GameInputs.Sprint))
-      _debugSprint = false;
+	if (@event.IsActionPressed(GameInputs.Attack))
+	  Attack();
+	if (@event.IsActionPressed(GameInputs.Sprint))
+	  _debugSprint = true;
+	else if (@event.IsActionReleased(GameInputs.Sprint))
+	  _debugSprint = false;
   }
 
   public void OnPhysicsProcess(double delta)
   {
-    PlayerLogic.Input(new PlayerLogic.Input.PhysicsTick(delta));
-    PlayerLogic.Input(new PlayerLogic.Input.Moved(GlobalPosition, GlobalTransform));
+	PlayerLogic.Input(new PlayerLogic.Input.PhysicsTick(delta));
+	PlayerLogic.Input(new PlayerLogic.Input.Moved(GlobalPosition, GlobalTransform));
   }
 
   public void Equip(EquipableItem equipable)
   {
-    if (equipable.ItemTag == ItemTag.MysteryItem)
-    {
-      var rerolledItem = _itemReroller.RerollItem(equipable, Inventory);
-      Equip(rerolledItem);
-      return;
-    }
+	if (equipable.ItemTag == ItemTag.MysteryItem)
+	{
+	  var rerolledItem = _itemReroller.RerollItem(equipable, Inventory);
+	  Equip(rerolledItem);
+	  return;
+	}
 
-    HealthComponent.RaiseMaximumHP(equipable.BonusHP, false);
-    VTComponent.RaiseMaximumVT(equipable.BonusVT, false);
+	HealthComponent.RaiseMaximumHP(equipable.BonusHP, false);
+	VTComponent.RaiseMaximumVT(equipable.BonusVT, false);
 
-    EquipmentComponent.Equip(equipable);
+	EquipmentComponent.Equip(equipable);
   }
 
   public void Unequip(EquipableItem equipable)
   {
-    HealthComponent.SetMaximumHealth(HealthComponent.MaximumHP.Value - equipable.BonusHP);
-    VTComponent.SetMaximumVT(VTComponent.MaximumVT.Value - equipable.BonusVT);
+	HealthComponent.SetMaximumHealth(HealthComponent.MaximumHP.Value - equipable.BonusHP);
+	VTComponent.SetMaximumVT(VTComponent.MaximumVT.Value - equipable.BonusVT);
 
-    EquipmentComponent.Unequip(equipable);
+	EquipmentComponent.Unequip(equipable);
   }
 
   private static Vector3 GlobalInputVector
   {
-    get
-    {
-      var rawInput = Input.GetVector(GameInputs.MoveLeft, GameInputs.MoveRight, GameInputs.MoveUp, GameInputs.MoveDown);
-      var input = new Vector3
-      {
-        X = rawInput.X,
-        Z = rawInput.Y
-      };
-      return input with { Y = 0f };
-    }
+	get
+	{
+	  var rawInput = Input.GetVector(GameInputs.MoveLeft, GameInputs.MoveRight, GameInputs.MoveUp, GameInputs.MoveDown);
+	  var input = new Vector3
+	  {
+		X = rawInput.X,
+		Z = rawInput.Y
+	  };
+	  return input with { Y = 0f };
+	}
   }
 
   private void OnLevelUp()
   {
-    BoostPlayerHPFromLevelUp();
+	BoostPlayerHPFromLevelUp();
   }
 
   private void BoostPlayerHPFromLevelUp()
   {
-    var rng = new RandomNumberGenerator();
-    rng.Randomize();
-    var hpIncrease = rng.RandiRange(3, 6);
-    HealthComponent.RaiseMaximumHP(hpIncrease);
+	var rng = new RandomNumberGenerator();
+	rng.Randomize();
+	var hpIncrease = rng.RandiRange(3, 6);
+	HealthComponent.RaiseMaximumHP(hpIncrease);
   }
 
   private static float LeftStrafeInputVector => Input.GetActionStrength(GameInputs.StrafeLeft);
@@ -319,176 +319,176 @@ public partial class Player : CharacterBody3D, IPlayer, IProvide<IPlayer>
 
   private void Attack()
   {
-    if (PlayerIsHittingGeometry())
-      AnimationPlayer.Play("hit_wall");
-    else if (!AnimationPlayer.IsPlaying())
-      PlayAttackAnimation();
-    else
-      return;
+	if (PlayerIsHittingGeometry())
+	  AnimationPlayer.Play("hit_wall");
+	else if (!AnimationPlayer.IsPlaying())
+	  PlayAttackAnimation();
+	else
+	  return;
 
-      var weapon = EquipmentComponent.EquippedWeapon.Value as Weapon;
-    if (weapon.WeaponTag == WeaponTag.DegradeOnSwing)
-      _playerEffectService.Degrade();
+	  var weapon = EquipmentComponent.EquippedWeapon.Value as Weapon;
+	if (weapon.WeaponTag == WeaponTag.DegradeOnSwing)
+	  _playerEffectService.Degrade();
   }
 
   private void ThrowItem()
   {
-    var itemScene = GD.Load<PackedScene>("res://src/items/throwable/ThrowableItem.tscn");
-    var throwItem = itemScene.Instantiate<ThrowableItem>();
-    GetTree().Root.AddChildEx(throwItem);
-    throwItem.GlobalPosition = CurrentPosition + new Vector3(0, 3.5f, 0);
-    throwItem.GlobalRotation = GlobalRotation;
+	var itemScene = GD.Load<PackedScene>("res://src/items/throwable/ThrowableItem.tscn");
+	var throwItem = itemScene.Instantiate<ThrowableItem>();
+	GetTree().Root.AddChildEx(throwItem);
+	throwItem.GlobalPosition = CurrentPosition + new Vector3(0, 3.5f, 0);
+	throwItem.GlobalRotation = GlobalRotation;
   }
 
   private void PlayAttackAnimation()
   {
-    SfxDatabase.Instance.Play(((Weapon)EquipmentComponent.EquippedWeapon.Value).SoundEffect);
-    var attackSpeed = ((Weapon)EquipmentComponent.EquippedWeapon.Value).AttackSpeed;
-    AnimationPlayer.SetSpeedScale((float)attackSpeed);
-    AnimationPlayer.Play("attack");
+	SfxDatabase.Instance.Play(((Weapon)EquipmentComponent.EquippedWeapon.Value).SoundEffect);
+	var attackSpeed = ((Weapon)EquipmentComponent.EquippedWeapon.Value).AttackSpeed;
+	AnimationPlayer.SetSpeedScale((float)attackSpeed);
+	AnimationPlayer.Play("attack");
   }
 
   private void PlayerFXAnimations_AnimationFinished(StringName animName)
   {
-    if (animName == "death")
-      PlayerDied?.Invoke();
+	if (animName == "death")
+	  PlayerDied?.Invoke();
   }
 
   private void InverseHPToAttackPowerSync(int obj)
   {
-    var weapon = (Weapon)EquipmentComponent.EquippedWeapon.Value;
-    if (weapon.WeaponTag == WeaponTag.InverseHPAttackPower)
-    {
-      var healthPercentage = (HealthComponent.CurrentHP.Value * 10) / HealthComponent.MaximumHP.Value;
-      weapon.SetWeaponAttack(10 - healthPercentage);
-      EquipmentComponent.Equip(weapon);
-    }
+	var weapon = (Weapon)EquipmentComponent.EquippedWeapon.Value;
+	if (weapon.WeaponTag == WeaponTag.InverseHPAttackPower)
+	{
+	  var healthPercentage = (HealthComponent.CurrentHP.Value * 10) / HealthComponent.MaximumHP.Value;
+	  weapon.SetWeaponAttack(10 - healthPercentage);
+	  EquipmentComponent.Equip(weapon);
+	}
   }
 
   private void OnExitTree()
   {
-    PlayerLogic.Stop();
-    PlayerBinding.Dispose();
-    Hitbox.AreaEntered -= Hitbox_AreaEntered;
-    CollisionDetector.AreaEntered -= CollisionDetector_AreaEntered;
-    HealthComponent.HealthReachedZero -= Die;
-    HealthTimer.Timeout -= OnHealthTimerTimeout;
-    HealthComponent.CurrentHP.Changed -= InverseHPToAttackPowerSync;
-    HealthComponent.HealthReachedZero -= Die;
-    ExperiencePointsComponent.PlayerLevelUp -= OnLevelUp;
-    PlayerFXAnimations.AnimationFinished -= PlayerFXAnimations_AnimationFinished;
+	PlayerLogic.Stop();
+	PlayerBinding.Dispose();
+	Hitbox.AreaEntered -= Hitbox_AreaEntered;
+	CollisionDetector.AreaEntered -= CollisionDetector_AreaEntered;
+	HealthComponent.HealthReachedZero -= Die;
+	HealthTimer.Timeout -= OnHealthTimerTimeout;
+	HealthComponent.CurrentHP.Changed -= InverseHPToAttackPowerSync;
+	HealthComponent.HealthReachedZero -= Die;
+	ExperiencePointsComponent.PlayerLevelUp -= OnLevelUp;
+	PlayerFXAnimations.AnimationFinished -= PlayerFXAnimations_AnimationFinished;
   }
 
   private void Move(float delta)
   {
-    var rawInput = GlobalInputVector;
-    var strafeLeftInput = LeftStrafeInputVector;
-    var strafeRightInput = RightStrafeInputVector;
+	var rawInput = GlobalInputVector;
+	var strafeLeftInput = LeftStrafeInputVector;
+	var strafeRightInput = RightStrafeInputVector;
 
-    var transform = Transform;
-    transform.Basis = new Basis(Vector3.Up, Settings.RotationSpeed * -rawInput.X * delta) * transform.Basis;
-    var moveDirection = new Vector3(strafeRightInput - strafeLeftInput, 0, rawInput.Z).Normalized();
-    var velocity = Basis * moveDirection * Settings.MoveSpeed * Settings.Acceleration;
-    if (_debugSprint)
-      velocity *= 2;
-    _knockbackStrength *= 0.9f;
-    Transform = Transform with { Basis = transform.Basis };
-    Velocity = velocity + (_knockbackDirection * _knockbackStrength);
-    var rng = new RandomNumberGenerator();
-    rng.Randomize();
+	var transform = Transform;
+	transform.Basis = new Basis(Vector3.Up, Settings.RotationSpeed * -rawInput.X * delta) * transform.Basis;
+	var moveDirection = new Vector3(strafeRightInput - strafeLeftInput, 0, rawInput.Z).Normalized();
+	var velocity = Basis * moveDirection * Settings.MoveSpeed * Settings.Acceleration;
+	if (_debugSprint)
+	  velocity *= 2;
+	_knockbackStrength *= 0.9f;
+	Transform = Transform with { Basis = transform.Basis };
+	Velocity = velocity + (_knockbackDirection * _knockbackStrength);
+	var rng = new RandomNumberGenerator();
+	rng.Randomize();
 
-    WalkSFX.PitchScale = rng.RandfRange(0.5f, 1.5f);
-    if (!WalkSFX.Playing && !Velocity.IsZeroApprox())
-      WalkSFX.Play();
-    else if (Velocity.IsZeroApprox())
-      WalkSFX.Stop();
-    MoveAndSlide();
+	WalkSFX.PitchScale = rng.RandfRange(0.5f, 1.5f);
+	if (!WalkSFX.Playing && !Velocity.IsZeroApprox())
+	  WalkSFX.Play();
+	else if (Velocity.IsZeroApprox())
+	  WalkSFX.Stop();
+	MoveAndSlide();
   }
 
   private void OnPlayerPositionUpdated(Vector3 globalPosition) => GlobalPosition = globalPosition;
 
   private void OnHealthTimerTimeout()
   {
-    if (VTComponent.CurrentVT.Value > 0)
-    {
-      if (((Accessory)EquipmentComponent.EquippedAccessory.Value).AccessoryTag == AccessoryTag.HalfVTConsumption)
-        _healthTimerActive = !_healthTimerActive;
+	if (VTComponent.CurrentVT.Value > 0)
+	{
+	  if (((Accessory)EquipmentComponent.EquippedAccessory.Value).AccessoryTag == AccessoryTag.HalfVTConsumption)
+		_healthTimerActive = !_healthTimerActive;
 
-      HealthComponent.Heal(1);
+	  HealthComponent.Heal(1);
 
-      if (_healthTimerActive)
-        VTComponent.Reduce(1);
-    }
-    else
-      HealthComponent.Damage(1);
+	  if (_healthTimerActive)
+		VTComponent.Reduce(1);
+	}
+	else
+	  HealthComponent.Damage(1);
   }
 
   private void Hitbox_AreaEntered(Area3D area)
   {
-    var target = area.GetOwner();
-    if (target is IEnemy enemy)
-      HitEnemy(enemy);
+	var target = area.GetOwner();
+	if (target is IEnemy enemy)
+	  HitEnemy(enemy);
   }
 
   private void HitEnemy(IEnemy enemy)
   {
-    var weapon = EquipmentComponent.EquippedWeapon.Value as Weapon;
-    var isCriticalHit = BattleExtensions.IsCriticalHit(TotalLuck);
-    var totalDamage = TotalAttack;
+	var weapon = EquipmentComponent.EquippedWeapon.Value as Weapon;
+	var isCriticalHit = BattleExtensions.IsCriticalHit(TotalLuck);
+	var totalDamage = TotalAttack;
 
-    if (isCriticalHit)
-    {
-      totalDamage += (int)(totalDamage * 0.5f);
-      SfxDatabase.Instance.Play(SoundEffect.Crit);
-    }
+	if (isCriticalHit)
+	{
+	  totalDamage += (int)(totalDamage * 0.5f);
+	  SfxDatabase.Instance.Play(SoundEffect.Crit);
+	}
 
-    var baseAttack = new AttackData(totalDamage, weapon.WeaponElement, weapon.WeaponTag == WeaponTag.IgnoreDefense, weapon.WeaponTag == WeaponTag.IgnoreAffinity);
-    var damageDealt = DamageCalculator.CalculateDamage(baseAttack, enemy.DefenseComponent.CurrentDefense.Value, enemy.ElementalResistanceSet);
-    enemy.HealthComponent.Damage(damageDealt);
+	var baseAttack = new AttackData(totalDamage, weapon.WeaponElement, weapon.WeaponTag == WeaponTag.IgnoreDefense, weapon.WeaponTag == WeaponTag.IgnoreAffinity);
+	var damageDealt = DamageCalculator.CalculateDamage(baseAttack, enemy.DefenseComponent.CurrentDefense.Value, enemy.ElementalResistanceSet);
+	enemy.HealthComponent.Damage(damageDealt);
 
-    if (weapon.WeaponTag == WeaponTag.Knockback && enemy is IKnockbackable knockbackable)
-      knockbackable.Knockback(0.3f, -CurrentBasis.Z.Normalized());
-    if (weapon.WeaponTag == WeaponTag.SelfDamage)
-      _playerEffectService.TakeSelfDamage(weapon.Stats.SelfDamage);
-    if (weapon.WeaponTag == WeaponTag.Instakill)
-      _playerEffectService.Instakill(enemy);
+	if (weapon.WeaponTag == WeaponTag.Knockback && enemy is IKnockbackable knockbackable)
+	  knockbackable.Knockback(0.3f, -CurrentBasis.Z.Normalized());
+	if (weapon.WeaponTag == WeaponTag.SelfDamage)
+	  _playerEffectService.TakeSelfDamage(weapon.Stats.SelfDamage);
+	if (weapon.WeaponTag == WeaponTag.Instakill)
+	  _playerEffectService.Instakill(enemy);
   }
 
   private void CollisionDetector_AreaEntered(Area3D area)
   {
-    if (area.GetParent() is InventoryItem inventoryItem)
-    {
-      var isAdded = Inventory.PickUpItem(inventoryItem);
-      if (isAdded)
-        inventoryItem.QueueFree();
-    }
-    if (area.GetParent() is DroppedItem droppedItem)
-    {
-      var isAdded = Inventory.PickUpItem(droppedItem.Item);
-      if (isAdded)
-        droppedItem.QueueFree();
-    }
-    if (area.GetParent() is ThrownItem thrownItem)
-    {
-      var isAdded = Inventory.PickUpItem(thrownItem.ItemThatIsThrown);
-      if (isAdded)
-        thrownItem.QueueFree();
-    }
-    if (area.GetParent() is Restorative restorative)
-    {
-      restorative.QueueFree();
-    }
+	if (area.GetParent() is InventoryItem inventoryItem)
+	{
+	  var isAdded = Inventory.PickUpItem(inventoryItem);
+	  if (isAdded)
+		inventoryItem.QueueFree();
+	}
+	if (area.GetParent() is DroppedItem droppedItem)
+	{
+	  var isAdded = Inventory.PickUpItem(droppedItem.Item);
+	  if (isAdded)
+		droppedItem.QueueFree();
+	}
+	if (area.GetParent() is ThrownItem thrownItem)
+	{
+	  var isAdded = Inventory.PickUpItem(thrownItem.ItemThatIsThrown);
+	  if (isAdded)
+		thrownItem.QueueFree();
+	}
+	if (area.GetParent() is Restorative restorative)
+	{
+	  restorative.QueueFree();
+	}
   }
 
   private bool PlayerIsHittingGeometry()
   {
-    var collisions = WallCheck.GetCollidingBodies();
-    return collisions.Count > 0;
+	var collisions = WallCheck.GetCollidingBodies();
+	return collisions.Count > 0;
   }
 
   private void WallCheck_BodyEntered(Node body)
   {
-    GD.Print("Hit wall");
-    AnimationPlayer.Stop();
+	GD.Print("Hit wall");
+	AnimationPlayer.Stop();
   }
 }