diff --git a/EXILED/Exiled.API/Features/Items/MicroHid.cs b/EXILED/Exiled.API/Features/Items/MicroHid.cs
index aaf29b6689..f83dab90d3 100644
--- a/EXILED/Exiled.API/Features/Items/MicroHid.cs
+++ b/EXILED/Exiled.API/Features/Items/MicroHid.cs
@@ -30,11 +30,6 @@ public MicroHid(MicroHIDItem itemBase)
             : base(itemBase)
         {
             Base = itemBase;
-
-            EnergyManager = Base.EnergyManager;
-            BrokenModule = Base.BrokenSync;
-            InputModule = Base.InputSync;
-            CycleController = Base.CycleController;
         }
 
         /// <summary>
@@ -48,22 +43,22 @@ internal MicroHid()
         /// <summary>
         /// Gets the <see cref="EnergyManagerModule"/> of the MicroHID.
         /// </summary>
-        public EnergyManagerModule EnergyManager { get; }
+        public EnergyManagerModule EnergyManager => Base.EnergyManager;
 
         /// <summary>
         /// Gets the <see cref="BrokenSyncModule"/> of the MicroHID.
         /// </summary>
-        public BrokenSyncModule BrokenModule { get; }
+        public BrokenSyncModule BrokenModule => Base.BrokenSync;
 
         /// <summary>
         /// Gets the <see cref="InputSyncModule"/> of the MicroHID.
         /// </summary>
-        public InputSyncModule InputModule { get; }
+        public InputSyncModule InputModule => Base.InputSync;
 
         /// <summary>
         /// Gets the <see cref="CycleController"/> of the MicroHID.
         /// </summary>
-        public CycleController CycleController { get; }
+        public CycleController CycleController => Base.CycleController;
 
         /// <summary>
         /// Gets or sets the remaining energy in the MicroHID.
@@ -219,16 +214,5 @@ public bool TryGetFireController<T>(MicroHidFiringMode firingMode, out T module)
         /// </summary>
         /// <returns>A string containing MicroHid-related data.</returns>
         public override string ToString() => $"{Type} ({Serial}) [{Weight}] *{Scale}* |{Energy}| -{State}-";
-
-        /// <inheritdoc />
-        internal override void ReadPickupInfo(Pickup pickup)
-        {
-            base.ReadPickupInfo(pickup);
-
-            if (pickup.Is(out Pickups.MicroHIDPickup microHidPickup))
-            {
-                Energy = microHidPickup.Energy;
-            }
-        }
     }
 }
\ No newline at end of file
diff --git a/EXILED/Exiled.API/Features/Pickups/MicroHIDPickup.cs b/EXILED/Exiled.API/Features/Pickups/MicroHIDPickup.cs
index 87e21bf58d..255c32b6ad 100644
--- a/EXILED/Exiled.API/Features/Pickups/MicroHIDPickup.cs
+++ b/EXILED/Exiled.API/Features/Pickups/MicroHIDPickup.cs
@@ -50,7 +50,11 @@ internal MicroHIDPickup()
         /// <summary>
         /// Gets or sets the MicroHID Energy Level.
         /// </summary>
-        public float Energy { get; set; }
+        public float Energy
+        {
+            get => EnergyManagerModule.GetEnergy(Serial);
+            set => EnergyManagerModule.SyncEnergy[Serial] = value;
+        }
 
         /// <summary>
         /// Gets or sets the <see cref="MicroHidPhase"/>.
@@ -144,16 +148,5 @@ public bool TryGetFireController<T>(MicroHidFiringMode firingMode, out T module)
         /// </summary>
         /// <returns>A string containing MicroHIDPickup related data.</returns>
         public override string ToString() => $"{Type} ({Serial}) [{Weight}] *{Scale}* |{Energy}|";
-
-        /// <inheritdoc/>
-        internal override void ReadItemInfo(Item item)
-        {
-            base.ReadItemInfo(item);
-
-            if (item.Is(out MicroHid microHid))
-            {
-                Energy = microHid.Energy;
-            }
-        }
     }
 }
diff --git a/EXILED/Exiled.Events/EventArgs/Player/UsingMicroHIDEnergyEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/UsingMicroHIDEnergyEventArgs.cs
index 1d207cd801..86e76a2e75 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/UsingMicroHIDEnergyEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/UsingMicroHIDEnergyEventArgs.cs
@@ -25,16 +25,16 @@ public class UsingMicroHIDEnergyEventArgs : IDeniableEvent, IItemEvent
         /// <param name="microHIDitem">
         /// <inheritdoc cref="MicroHID" />
         /// </param>
-        /// <param name="drain">
+        /// <param name="newEnergy">
         /// <inheritdoc cref="Drain" />
         /// </param>
         /// <param name="isAllowed">
         /// <inheritdoc cref="IsAllowed" />
         /// </param>
-        public UsingMicroHIDEnergyEventArgs(MicroHIDItem microHIDitem, float drain, bool isAllowed = true)
+        public UsingMicroHIDEnergyEventArgs(MicroHIDItem microHIDitem, float newEnergy, bool isAllowed = true)
         {
             MicroHID = Item.Get<MicroHid>(microHIDitem);
-            Drain = MicroHID.Energy - drain;
+            Drain = MicroHID.Energy - newEnergy;
             IsAllowed = isAllowed;
         }
 
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/ChangingMicroHIDState.cs b/EXILED/Exiled.Events/Patches/Events/Player/ChangingMicroHIDState.cs
index 12f83e0c6c..c45000b676 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/ChangingMicroHIDState.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/ChangingMicroHIDState.cs
@@ -68,7 +68,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new(OpCodes.Brfalse_S, returnLabel),
 
                 // value = ev.NewPhase;
-                new(OpCodes.Ldarg_S, ev.LocalIndex),
+                new(OpCodes.Ldloc_S, ev.LocalIndex),
                 new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingMicroHIDStateEventArgs), nameof(ChangingMicroHIDStateEventArgs.NewPhase))),
                 new(OpCodes.Starg_S, 1),
             });
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/InteractingLocker.cs b/EXILED/Exiled.Events/Patches/Events/Player/InteractingLocker.cs
index 9024c74122..21f3ef2d23 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/InteractingLocker.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/InteractingLocker.cs
@@ -32,7 +32,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
         {
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
-            int index = newInstructions.FindLastIndex(instruction => instruction.opcode == OpCodes.Ldloc_0);
+            int index = newInstructions.FindLastIndex(instruction => instruction.opcode == OpCodes.Ldloc_1);
 
             newInstructions.InsertRange(
                 index,
@@ -64,7 +64,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Callvirt, PropertyGetter(typeof(InteractingLockerEventArgs), nameof(InteractingLockerEventArgs.IsAllowed))),
                     new(OpCodes.Ldc_I4_0),
                     new(OpCodes.Ceq),
-                    new(OpCodes.Stloc_0),
+                    new(OpCodes.Stloc_1),
                 });
 
             for (int z = 0; z < newInstructions.Count; z++)
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/UsingMicroHIDEnergy.cs b/EXILED/Exiled.Events/Patches/Events/Player/UsingMicroHIDEnergy.cs
index 1960426e8b..15634602db 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/UsingMicroHIDEnergy.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/UsingMicroHIDEnergy.cs
@@ -37,22 +37,23 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             LocalBuilder ev = generator.DeclareLocal(typeof(UsingMicroHIDEnergyEventArgs));
 
-            int offset = -1;
-            int index = newInstructions.FindLastIndex(instruction => instruction.opcode == OpCodes.Ldarg_0) + offset;
+            int offset = -4;
+            int index = newInstructions.FindLastIndex(i => i.Calls(Method(typeof(EnergyManagerModule), nameof(EnergyManagerModule.ServerSetEnergy)))) + offset;
 
             newInstructions.InsertRange(index, new CodeInstruction[]
             {
                 // this.MicroHID
-                new(OpCodes.Ldarg_0),
+                new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),
                 new(OpCodes.Callvirt, PropertyGetter(typeof(EnergyManagerModule), nameof(EnergyManagerModule.MicroHid))),
 
-                // energy
+                // newEnergy
                 new(OpCodes.Ldloc_0),
 
                 // true
                 new(OpCodes.Ldc_I4_1),
 
-                // UsingMicroHIDEnergyEventArgs ev = new(this.MicroHID, energy, true);
+                // calculate drain by delta between old energy and new energy
+                // UsingMicroHIDEnergyEventArgs ev = new(this.MicroHID, newEnergy, true);
                 new(OpCodes.Newobj, GetDeclaredConstructors(typeof(UsingMicroHIDEnergyEventArgs))[0]),
                 new(OpCodes.Dup),
                 new(OpCodes.Dup),
@@ -66,7 +67,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new(OpCodes.Callvirt, PropertyGetter(typeof(UsingMicroHIDEnergyEventArgs), nameof(UsingMicroHIDEnergyEventArgs.IsAllowed))),
                 new(OpCodes.Brfalse_S, returnLabel),
 
-                // energy = this.Energy - ev.Drain;
+                // newEnergy = this.Energy - ev.Drain;
                 new(OpCodes.Ldarg_0),
                 new(OpCodes.Callvirt, PropertyGetter(typeof(EnergyManagerModule), nameof(EnergyManagerModule.Energy))),
                 new(OpCodes.Ldloc_S, ev.LocalIndex),
@@ -83,4 +84,4 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             ListPool<CodeInstruction>.Pool.Return(newInstructions);
         }
     }
-}
\ No newline at end of file
+}