Implement a proper ability system (#2166)

* Apply fix `21dec2fe`

* Apply fix `89d01d5f`

* Apply fix `d900f154`

this one was already implemented; updated to use call from previous commit

* Ability changing commit

TODO: change info to debug

* Remove use of deprecated methods/fields

* Temp commit v2
(Adding LoseHP and some fixes)

* Oopsie

* Probably fix monster battle

* Fix issue with reflecting into fields

* Fix some things

* Fix ability names for 3.6 resources

* Improve logging

---------

Co-authored-by: StartForKiller <jesussanz2003@gmail.com>

src/main/java/emu/grasscutter/game/ability/AbilityManager.java

@@ -1,70 +1,62 @@
 package emu.grasscutter.game.ability;
 
+import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 import emu.grasscutter.Grasscutter;
 import emu.grasscutter.data.GameData;
 import emu.grasscutter.data.binout.AbilityData;
+import emu.grasscutter.data.binout.AbilityMixinData;
+import emu.grasscutter.data.binout.AbilityModifier;
 import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
-import emu.grasscutter.data.binout.AbilityModifierEntry;
-import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.game.ability.actions.AbilityAction;
+import emu.grasscutter.game.ability.actions.AbilityActionHandler;
+import emu.grasscutter.game.ability.mixins.AbilityMixin;
+import emu.grasscutter.game.ability.mixins.AbilityMixinHandler;
 import emu.grasscutter.game.entity.GameEntity;
-import emu.grasscutter.game.entity.gadget.GadgetGatherObject;
 import emu.grasscutter.game.player.BasePlayerManager;
 import emu.grasscutter.game.player.Player;
-import emu.grasscutter.game.quest.enums.QuestContent;
 import emu.grasscutter.net.proto.AbilityInvokeEntryOuterClass.AbilityInvokeEntry;
 import emu.grasscutter.net.proto.AbilityMetaAddAbilityOuterClass.AbilityMetaAddAbility;
 import emu.grasscutter.net.proto.AbilityMetaModifierChangeOuterClass.AbilityMetaModifierChange;
-import emu.grasscutter.net.proto.AbilityMetaModifierDurabilityChangeOuterClass.AbilityMetaModifierDurabilityChange;
 import emu.grasscutter.net.proto.AbilityMetaReInitOverrideMapOuterClass.AbilityMetaReInitOverrideMap;
-import emu.grasscutter.net.proto.AbilityMixinCostStaminaOuterClass.AbilityMixinCostStamina;
+import emu.grasscutter.net.proto.AbilityScalarTypeOuterClass.AbilityScalarType;
 import emu.grasscutter.net.proto.AbilityScalarValueEntryOuterClass.AbilityScalarValueEntry;
 import emu.grasscutter.net.proto.ModifierActionOuterClass.ModifierAction;
 import io.netty.util.concurrent.FastThreadLocalThread;
+import lombok.Getter;
+import org.reflections.Reflections;
+
 import java.util.HashMap;
-import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import lombok.Getter;
-import org.reflections.Reflections;
 
 public final class AbilityManager extends BasePlayerManager {
+
+    private final static HashMap<AbilityModifierAction.Type, AbilityActionHandler> actionHandlers = new HashMap<>();
+    private final static HashMap<AbilityMixinData.Type, AbilityMixinHandler> mixinHandlers = new HashMap<>();
+
     public static final ExecutorService eventExecutor;
-
     static {
-        eventExecutor =
-                new ThreadPoolExecutor(
-                        4,
-                        4,
-                        60,
-                        TimeUnit.SECONDS,
-                        new LinkedBlockingDeque<>(1000),
-                        FastThreadLocalThread::new,
-                        new ThreadPoolExecutor.AbortPolicy());
-    }
+        eventExecutor = new ThreadPoolExecutor(4, 4,
+            60, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1000),
+            FastThreadLocalThread::new, new ThreadPoolExecutor.AbortPolicy());
 
-    private final HealAbilityManager healAbilityManager;
-    private final Map<AbilityModifierAction.Type, AbilityActionHandler> actionHandlers;
+        registerHandlers();
+    }
 
     @Getter private boolean abilityInvulnerable = false;
 
     public AbilityManager(Player player) {
         super(player);
-
-        this.healAbilityManager = new HealAbilityManager(player);
-        this.actionHandlers = new HashMap<>();
-
-        this.registerHandlers();
     }
 
-    /** Registers all present ability handlers. */
-    private void registerHandlers() {
-        var reflections = new Reflections("emu.grasscutter.game.ability.actions");
-        var handlerClasses = reflections.getSubTypesOf(AbilityActionHandler.class);
+    public static void registerHandlers() {
+        Reflections reflections = new Reflections("emu.grasscutter.game.ability.actions");
+        var handlerClassesAction = reflections.getSubTypesOf(AbilityActionHandler.class);
 
-        for (var obj : handlerClasses) {
+        for (var obj : handlerClassesAction) {
             try {
                 if (obj.isAnnotationPresent(AbilityAction.class)) {
                     AbilityModifierAction.Type abilityAction = obj.getAnnotation(AbilityAction.class).value();
@@ -76,37 +68,74 @@ public final class AbilityManager extends BasePlayerManager {
                 Grasscutter.getLogger().error("Unable to register handler.", e);
             }
         }
+
+        reflections = new Reflections("emu.grasscutter.game.ability.mixins");
+        var handlerClassesMixin = reflections.getSubTypesOf(AbilityMixinHandler.class);
+
+        for (var obj : handlerClassesMixin) {
+            try {
+                if (obj.isAnnotationPresent(AbilityAction.class)) {
+                    AbilityMixinData.Type abilityMixin = obj.getAnnotation(AbilityMixin.class).value();
+                    mixinHandlers.put(abilityMixin, obj.getDeclaredConstructor().newInstance());
+                } else {
+                    return;
+                }
+            } catch (Exception e) {
+                Grasscutter.getLogger().error("Unable to register handler.", e);
+            }
+        }
     }
 
-    public void executeAction(Ability ability, AbilityModifierAction action) {
-        var handler = actionHandlers.get(action.type);
+    public void executeAction(Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        AbilityActionHandler handler = actionHandlers.get(action.type);
 
         if (handler == null || ability == null) {
-            Grasscutter.getLogger()
-                    .trace("Could not execute ability action {} at {}", action.type, ability);
+            Grasscutter.getLogger().debug("Could not execute ability action {} at {}", action.type, ability);
             return;
         }
 
-        eventExecutor.submit(
-                () -> {
-                    if (!handler.execute(ability, action)) {
-                        Grasscutter.getLogger()
-                                .debug("exec ability action failed {} at {}", action.type, ability);
-                    }
-                });
+        eventExecutor.submit(() -> {
+            if (!handler.execute(ability, action, abilityData, target)) {
+                Grasscutter.getLogger().debug("Execute ability action failed {} at {}", action.type, ability);
+            }
+        });
+    }
+
+    public void executeMixin(Ability ability, AbilityMixinData mixinData, ByteString abilityData) {
+        AbilityMixinHandler handler = mixinHandlers.get(mixinData.type);
+
+        if (handler == null || ability == null || mixinData == null) {
+            Grasscutter.getLogger().error("Could not execute ability mixin {} at {}", mixinData.type, ability);
+            return;
+        }
+
+        eventExecutor.submit(() -> {
+            if (!handler.execute(ability, mixinData, abilityData)) {
+                Grasscutter.getLogger().error("exec ability action failed {} at {}", mixinData.type, ability);
+            }
+        });
     }
 
     public void onAbilityInvoke(AbilityInvokeEntry invoke) throws Exception {
-        this.healAbilityManager.healHandler(invoke);
+        Grasscutter.getLogger().trace("Ability invoke: " + invoke + " " + invoke.getArgumentType() + " (" + invoke.getArgumentTypeValue() + "): " + this.player.getScene().getEntityById(invoke.getEntityId()));
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (entity != null) {
+            Grasscutter.getLogger().trace("Entity {} has a group of {} and a config of {}.",
+                invoke.getEntityId(), entity.getGroupId(), entity.getConfigId());
 
-        if (invoke.getEntityId() == 67109298) {
-            Grasscutter.getLogger()
-                    .info(
-                            invoke.getArgumentType()
-                                    + " ("
-                                    + invoke.getArgumentTypeValue()
-                                    + "): "
-                                    + invoke.getEntityId());
+            Grasscutter.getLogger().trace("Invoke type of {} ({}) has entity {}.",
+                invoke.getArgumentType(), invoke.getArgumentTypeValue(), entity.getId());
+        } else {
+            Grasscutter.getLogger().debug("Invoke type of {} ({}) has no entity. (referring to {})",
+                invoke.getArgumentType(), invoke.getArgumentTypeValue(), invoke.getEntityId());
+        }
+
+        if (invoke.getHead().getTargetId() != 0) {
+            Grasscutter.getLogger().trace("Target: " + this.player.getScene().getEntityById(invoke.getHead().getTargetId()));
+        }
+        if (invoke.getHead().getLocalId() != 0) {
+            this.handleServerInvoke(invoke);
+            return;
         }
 
         switch (invoke.getArgumentType()) {
@@ -116,17 +145,63 @@ public final class AbilityManager extends BasePlayerManager {
             case ABILITY_INVOKE_ARGUMENT_MIXIN_COST_STAMINA -> this.handleMixinCostStamina(invoke);
             case ABILITY_INVOKE_ARGUMENT_ACTION_GENERATE_ELEM_BALL -> this.handleGenerateElemBall(invoke);
             case ABILITY_INVOKE_ARGUMENT_META_GLOBAL_FLOAT_VALUE -> this.handleGlobalFloatValue(invoke);
-            case ABILITY_INVOKE_ARGUMENT_META_MODIFIER_DURABILITY_CHANGE -> this
-                    .handleModifierDurabilityChange(invoke);
+            case ABILITY_INVOKE_ARGUMENT_META_MODIFIER_DURABILITY_CHANGE -> this.handleModifierDurabilityChange(invoke);
             case ABILITY_INVOKE_ARGUMENT_META_ADD_NEW_ABILITY -> this.handleAddNewAbility(invoke);
-            case ABILITY_INVOKE_ARGUMENT_NONE -> this.handleInvoke(invoke);
             default -> {}
         }
     }
 
+    public void handleServerInvoke(AbilityInvokeEntry invoke) {
+        var head = invoke.getHead();
+
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (entity == null) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
+            return;
+        }
+
+        var target = this.player.getScene().getEntityById(head.getTargetId());
+        if(target == null) target = entity;
+
+        Ability ability = null;
+
+        // Seems that target is used, but need to be sure, TODO: Research
+
+        // Find ability or modifier's ability
+        if (head.getInstancedModifierId() != 0 && entity.getInstancedModifiers().containsKey(head.getInstancedModifierId())) {
+            ability = entity.getInstancedModifiers().get(head.getInstancedModifierId()).getAbility();
+        }
+
+        if (ability == null && head.getInstancedAbilityId() != 0 && (head.getInstancedAbilityId() - 1) < entity.getInstancedAbilities().size()) {
+            ability = entity.getInstancedAbilities().get(head.getInstancedAbilityId() - 1);
+        }
+
+        if (ability == null) {
+            Grasscutter.getLogger().trace("Ability not found: ability {} modifier {}", head.getInstancedAbilityId(), head.getInstancedModifierId());
+            return;
+        }
+
+        //Time to reach the handlers
+        var action = ability.getData().localIdToAction.get(head.getLocalId());
+        if (action != null) {
+            //Executing action
+            this.executeAction(ability, action, invoke.getAbilityData(), target);
+            return;
+        } else {
+            var mixin = ability.getData().localIdToMixin.get(head.getLocalId());
+
+            if(mixin != null) {
+                executeMixin(ability, mixin, invoke.getAbilityData());
+
+                return;
+            }
+        }
+
+        Grasscutter.getLogger().trace("Action or mixin not found: local_id {} ability {} actions to ids {}", head.getLocalId(), ability.getData().abilityName, ability.getData().localIdToAction.toString());
+    }
+
     /**
      * Invoked when a player starts a skill.
-     *
      * @param player The player who started the skill.
      * @param skillId The skill ID.
      * @param casterId The caster ID.
@@ -158,7 +233,6 @@ public final class AbilityManager extends BasePlayerManager {
 
     /**
      * Invoked when a player ends a skill.
-     *
      * @param player The player who started the skill.
      */
     public void onSkillEnd(Player player) {
@@ -176,293 +250,228 @@ public final class AbilityManager extends BasePlayerManager {
         this.abilityInvulnerable = false;
     }
 
-    /**
-     * Handles an ability invoke.
-     *
-     * @param invoke The invocation.
-     */
-    private void handleInvoke(AbilityInvokeEntry invoke) {
-        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
-        if (entity == null) {
-            return;
-        }
-
-        var head = invoke.getHead();
-        Grasscutter.getLogger()
-                .trace(
-                        "{} {} {}",
-                        head.getInstancedAbilityId(),
-                        entity.getInstanceToHash(),
-                        head.getLocalId());
-
-        var hash = entity.getInstanceToHash().get(head.getInstancedAbilityId());
-        if (hash == null) {
-            var abilities = entity.getAbilities().values().toArray(new Ability[0]);
-
-            if (head.getInstancedAbilityId() <= abilities.length) {
-                var ability = abilities[head.getInstancedAbilityId() - 1];
-                Grasscutter.getLogger().trace("-> {}", ability.getData().localIdToAction);
-                var action = ability.getData().localIdToAction.get(head.getLocalId());
-                if (action != null) ability.getManager().executeAction(ability, action);
-            }
+    private void setAbilityOverrideValue(Ability ability, AbilityScalarValueEntry valueChange) {
+        if(valueChange.getValueType() != AbilityScalarType.ABILITY_SCALAR_TYPE_FLOAT) {
+            Grasscutter.getLogger().trace("Scalar type not supported: {}", valueChange.getValueType());
 
             return;
         }
 
-        var stream =
-                entity.getAbilities().values().stream()
-                        .filter(
-                                a ->
-                                        a.getHash() == hash
-                                                || a.getData().abilityName
-                                                        == entity.getInstanceToName().get(head.getInstancedAbilityId()));
-        stream.forEach(
-                ability -> {
-                    var action = ability.getData().localIdToAction.get(head.getLocalId());
-                    if (action != null) ability.getManager().executeAction(ability, action);
-                });
+        if(!valueChange.getKey().hasStr()) {
+            Grasscutter.getLogger().trace("TODO: Calculate all the ability value hashes");
+
+            return;
+        }
+
+        ability.getAbilitySpecials().put(valueChange.getKey().getStr(), valueChange.getFloatValue());
+        Grasscutter.getLogger().trace("Ability {} changed {} to {}", ability.getData().abilityName, valueChange.getKey().getStr(), valueChange.getFloatValue());
     }
 
     private void handleOverrideParam(AbilityInvokeEntry invoke) throws Exception {
         var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var head = invoke.getHead();
 
-        if (entity == null) {
+        if(entity == null) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
             return;
         }
 
-        var entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
-        entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+        var instancedAbilityIndex = head.getInstancedAbilityId() - 1;
+        if(instancedAbilityIndex >= entity.getInstancedAbilities().size()) {
+            Grasscutter.getLogger().error("Ability not found {}", head.getInstancedAbilityId());
+            return;
+        }
+
+        var valueChange = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
+
+        var ability = entity.getInstancedAbilities().get(instancedAbilityIndex);
+        setAbilityOverrideValue(ability, valueChange);
     }
 
     private void handleReinitOverrideMap(AbilityInvokeEntry invoke) throws Exception {
         var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var head = invoke.getHead();
 
-        if (entity == null) {
+        if(entity == null) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
             return;
         }
 
-        var map = AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
-        for (var entry : map.getOverrideMapList()) {
-            entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+        var instancedAbilityIndex = head.getInstancedAbilityId() - 1;
+        if(instancedAbilityIndex >= entity.getInstancedAbilities().size()) {
+            Grasscutter.getLogger().error("Ability not found {}", head.getInstancedAbilityId());
+            return;
+        }
+
+        var ability = entity.getInstancedAbilities().get(instancedAbilityIndex);
+        var valueChanges = AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
+        for (var variableChange : valueChanges.getOverrideMapList()) {
+            setAbilityOverrideValue(ability, variableChange);
         }
     }
 
     private void handleModifierChange(AbilityInvokeEntry invoke) throws Exception {
-        // Sanity checks
-        var target = this.player.getScene().getEntityById(invoke.getEntityId());
-        if (target == null) {
-            return;
-        }
-
-        var data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
-        if (data == null) {
-            return;
-        }
-
-        // Destroying rocks
-        if (target instanceof EntityGadget targetGadget
-                && targetGadget.getContent() instanceof GadgetGatherObject gatherObject) {
-            if (data.getAction() == ModifierAction.MODIFIER_ACTION_REMOVED) {
-                gatherObject.dropItems(this.getPlayer());
-                return;
-            }
-        }
-
-        // Sanity checks
+        //TODO:
+        var modChange = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
         var head = invoke.getHead();
 
-        if (data.getAction() == ModifierAction.MODIFIER_ACTION_REMOVED) {
-            var ability = target.getAbilities().get(data.getParentAbilityName().getStr());
-            if (ability != null) {
-                var modifier = ability.getModifiers().get(head.getInstancedModifierId());
-                if (modifier != null) {
-                    modifier.onRemoved();
-                    ability.getModifiers().remove(modifier);
-                }
-            }
-        }
+        if (head.getInstancedAbilityId() == 0 ||
+            head.getInstancedModifierId() > 2000) return; // Error: TODO: display error
 
-        if (data.getAction() == ModifierAction.MODIFIER_ACTION_ADDED) {
-            var modifierString = data.getParentAbilityName().getStr();
-            var hash = target.getInstanceToHash().get(head.getInstancedAbilityId());
-            if (hash == null) return;
-
-            target.getAbilities().values().stream()
-                    .filter(
-                            a ->
-                                    a.getHash() == hash
-                                            || a.getData().abilityName
-                                                    == target.getInstanceToName().get(head.getInstancedAbilityId()))
-                    .forEach(
-                            a -> {
-                                a.getModifiers().keySet().stream()
-                                        .filter(key -> key.compareTo(modifierString) == 0)
-                                        .forEach(
-                                                key -> {
-                                                    a.getModifiers().get(key).setLocalId(head.getInstancedModifierId());
-                                                });
-                            });
-        }
-
-        var sourceEntity = this.player.getScene().getEntityById(data.getApplyEntityId());
-        if (sourceEntity == null) {
+        if (head.getIsServerbuffModifier()) {
+            //TODO
+            Grasscutter.getLogger().trace("TODO: Handle serverbuff modifier");
             return;
         }
 
-        // This is not how it works but we will keep it for now since healing abilities dont work
-        // properly anyways
-        if (data.getAction() == ModifierAction.MODIFIER_ACTION_ADDED
-                && data.getParentAbilityName() != null) {
-            // Handle add modifier here
-            String modifierString = data.getParentAbilityName().getStr();
-            AbilityModifierEntry modifier = GameData.getAbilityModifiers().get(modifierString);
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (entity == null) {
+            Grasscutter.getLogger().debug("Entity not found: {}", invoke.getEntityId());
+            return;
+        }
 
-            if (modifier != null && modifier.getOnAdded().size() > 0) {
-                for (AbilityModifierAction action : modifier.getOnAdded()) {
-                    this.invokeAction(action, target, sourceEntity);
-                }
-            }
+        if (modChange.getAction() == ModifierAction.MODIFIER_ACTION_ADDED) {
+            AbilityData instancedAbilityData = null;
+            Ability instancedAbility = null;
 
-            // Add to meta modifier list
-            target.getMetaModifiers().put(head.getInstancedModifierId(), modifierString);
-        } else if (data.getAction() == ModifierAction.MODIFIER_ACTION_REMOVED) {
-            // Handle remove modifier
-            String modifierString = target.getMetaModifiers().get(head.getInstancedModifierId());
-
-            if (modifierString != null) {
-                // Get modifier and call on remove event
-                AbilityModifierEntry modifier = GameData.getAbilityModifiers().get(modifierString);
-
-                if (modifier != null && modifier.getOnRemoved().size() > 0) {
-                    for (AbilityModifierAction action : modifier.getOnRemoved()) {
-                        this.invokeAction(action, target, sourceEntity);
+            if (head.getTargetId() != 0) {
+                //Get ability from target entity
+                var targetEntity = this.player.getScene().getEntityById(head.getTargetId());
+                if (targetEntity != null) {
+                    if ((head.getInstancedAbilityId() - 1) < targetEntity.getInstancedAbilities().size()) {
+                        instancedAbility = targetEntity.getInstancedAbilities().get(head.getInstancedAbilityId() - 1);
+                        if (instancedAbility != null) instancedAbilityData = instancedAbility.getData();
                     }
                 }
-
-                // Remove from meta modifiers
-                target.getMetaModifiers().remove(head.getInstancedModifierId());
             }
+
+            if (instancedAbilityData == null) {
+                //search on entity base id
+                if (entity != null) {
+                    if ((head.getInstancedAbilityId() - 1) < entity.getInstancedAbilities().size()) {
+                        instancedAbility = entity.getInstancedAbilities().get(head.getInstancedAbilityId() - 1);
+                        if (instancedAbility != null) instancedAbilityData = instancedAbility.getData();
+                    }
+                }
+            }
+
+            if (instancedAbilityData == null) {
+                //Search for the parent ability
+
+                //TODO: Research about hash
+                instancedAbilityData = GameData.getAbilityData(modChange.getParentAbilityName().getStr());
+            }
+
+            if (instancedAbilityData == null) {
+                Grasscutter.getLogger().trace("No ability found");
+                return; //TODO: Display error message
+            }
+
+            var modifierArray = instancedAbilityData.modifiers.values().toArray();
+            if (modChange.getModifierLocalId() >= modifierArray.length) {
+                Grasscutter.getLogger().trace("Modifier local id {} not found", modChange.getModifierLocalId());
+                return;
+            }
+
+            var modifierData = (AbilityModifier)modifierArray[modChange.getModifierLocalId()];
+            if (entity.getInstancedModifiers().containsKey(head.getInstancedModifierId())) {
+                Grasscutter.getLogger().trace("Replacing entity {} modifier id {} with ability {} modifier {}", invoke.getEntityId(), head.getInstancedModifierId(), instancedAbilityData.abilityName, modifierData);
+            } else {
+                Grasscutter.getLogger().trace("Adding entity {} modifier id {} with ability {} modifier {}", invoke.getEntityId(), head.getInstancedModifierId(), instancedAbilityData.abilityName, modifierData);
+            }
+
+            AbilityModifierController modifier = new AbilityModifierController(instancedAbility, instancedAbilityData, modifierData);
+
+            entity.getInstancedModifiers().put(head.getInstancedModifierId(), modifier);
+
+            //TODO: Add all the ability modifier property change
+        } else if(modChange.getAction() == ModifierAction.MODIFIER_ACTION_REMOVED) {
+            Grasscutter.getLogger().trace("Removed on entity {} modifier id {}: {}", invoke.getEntityId(), head.getInstancedModifierId(), entity.getInstancedModifiers().get(head.getInstancedModifierId()));
+
+            //TODO: Add debug log
+
+            entity.getInstancedModifiers().remove(head.getInstancedModifierId());
+        } else {
+            //TODO: Display error message
+            Grasscutter.getLogger().debug("Unknown action");
         }
     }
 
-    private void handleMixinCostStamina(AbilityInvokeEntry invoke)
-            throws InvalidProtocolBufferException {
-        AbilityMixinCostStamina costStamina =
-                AbilityMixinCostStamina.parseFrom((invoke.getAbilityData()));
-        this.getPlayer().getStaminaManager().handleMixinCostStamina(costStamina.getIsSwim());
+    private void handleMixinCostStamina(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+
     }
 
-    private void handleGenerateElemBall(AbilityInvokeEntry invoke)
-            throws InvalidProtocolBufferException {
-        this.player.getEnergyManager().handleGenerateElemBall(invoke);
+    private void handleGenerateElemBall(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+
     }
 
-    /**
-     * Handles a float value ability entry.
-     *
-     * @param invoke The ability invoke entry.
-     */
-    private void handleGlobalFloatValue(AbilityInvokeEntry invoke)
-            throws InvalidProtocolBufferException {
+    private void handleGlobalFloatValue(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        if(entity == null) return;
+
         var entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
-        if (entry.getKey().hasStr()
-                && entry.hasFloatValue()
-                && entry.getFloatValue() == 2.0f
-                && entry.getKey().getStr().equals("_ABILITY_UziExplode_Count")) {
-            player.getQuestManager().queueEvent(QuestContent.QUEST_CONTENT_SKILL, 10006);
+        if(entry == null || !entry.hasFloatValue()) return;
+
+        String key = null;
+        if(entry.getKey().hasStr())
+            key = entry.getKey().getStr();
+        else if(entry.getKey().hasHash())
+            key = GameData.getAbilityHashes().get(entry.getKey().getHash());
+
+        if(key == null) return;
+
+        if(key.startsWith("SGV_")) return; //Server does not allow to change this variables I think
+        switch(entry.getValueType().getNumber()) {
+            case AbilityScalarType.ABILITY_SCALAR_TYPE_FLOAT_VALUE:
+                if(!Float.isNaN(entry.getFloatValue())) entity.getGlobalAbilityValues().put(key, entry.getFloatValue());
+                break;
+            case AbilityScalarType.ABILITY_SCALAR_TYPE_UINT_VALUE:
+                entity.getGlobalAbilityValues().put(key, (float)entry.getUintValue());
+                break;
+            default:
+                return;
         }
     }
 
-    private void invokeAction(
-            AbilityModifierAction action, GameEntity target, GameEntity sourceEntity) {
-        switch (action.type) {
-            case HealHP -> {}
-            case LoseHP -> {
-                if (action.amountByTargetCurrentHPRatio == null) {
-                    return;
-                }
+    private void invokeAction(AbilityModifierAction action, GameEntity target, GameEntity sourceEntity) {
 
-                float damageAmount = action.amount.get();
-
-                // if (action.amount.isDynamic && action.amount.dynamicKey != null) {
-                //     damageAmount =
-                // sourceEntity.getMetaOverrideMap().getOrDefault(action.amount.dynamicKey, 0f);
-                // }
-
-                if (damageAmount > 0) {
-                    target.damage(damageAmount);
-                }
-            }
-            default -> {}
-        }
     }
 
-    private void handleModifierDurabilityChange(AbilityInvokeEntry invoke)
-            throws InvalidProtocolBufferException {
-        var target = this.player.getScene().getEntityById(invoke.getEntityId());
-        if (target == null) {
-            return;
-        }
+    private void handleModifierDurabilityChange(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
 
-        var data = AbilityMetaModifierDurabilityChange.parseFrom(invoke.getAbilityData());
-        if (data == null) {
-            return;
-        }
-
-        var head = invoke.getHead();
-        var hash = target.getInstanceToHash().get(head.getInstancedAbilityId());
-        if (hash == null) return;
-        target.getAbilities().values().stream()
-                .filter(
-                        a ->
-                                a.getHash() == hash
-                                        || a.getData().abilityName
-                                                == target.getInstanceToName().get(head.getInstancedAbilityId()))
-                .forEach(
-                        a -> {
-                            a.getModifiers().values().stream()
-                                    .filter(m -> m.getLocalId() == head.getInstancedModifierId())
-                                    .forEach(
-                                            modifier -> {
-                                                modifier.setElementDurability(data.getRemainDurability());
-                                            });
-                        });
     }
 
-    private void handleAddNewAbility(AbilityInvokeEntry invoke)
-            throws InvalidProtocolBufferException {
-        var data = AbilityMetaAddAbility.parseFrom(invoke.getAbilityData());
-        if (data == null) {
+    private void handleAddNewAbility(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+
+        if(entity == null) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
             return;
         }
 
-        var ability = data.getAbility();
-        var abilityName = ability.getAbilityName();
-        if (abilityName.getHash() != 0)
-            Grasscutter.getLogger()
-                    .trace("Instancing {} in to {}", abilityName.getHash(), ability.getInstancedAbilityId());
-        else
-            Grasscutter.getLogger()
-                    .trace("Instancing {} in to {}", abilityName.getStr(), ability.getInstancedAbilityId());
+        var addAbility = AbilityMetaAddAbility.parseFrom(invoke.getAbilityData());
 
-        var target = this.player.getScene().getEntityById(invoke.getEntityId());
-        if (target == null) {
+        var abilityName = Ability.getAbilityName(addAbility.getAbility().getAbilityName());
+
+        var ability = GameData.getAbilityData(abilityName);
+        if(ability == null) {
+            Grasscutter.getLogger().trace("Ability not found: {}", abilityName);
             return;
         }
 
-        target.getInstanceToHash().put(ability.getInstancedAbilityId(), abilityName.getHash());
-        target.getInstanceToName().put(ability.getInstancedAbilityId(), abilityName.getStr());
+        entity.getInstancedAbilities().add(new Ability(ability, entity, player));
+
+        Grasscutter.getLogger().trace("Ability added to entity {} at index {}", entity.getId(), entity.getInstancedAbilities().size());
     }
 
     public void addAbilityToEntity(GameEntity entity, String name) {
-        var data = GameData.getAbilityData(name);
-        if (data != null) addAbilityToEntity(entity, data, name);
+        AbilityData data = GameData.getAbilityData(name);
+        if(data != null)
+            addAbilityToEntity(entity, data);
     }
 
-    public void addAbilityToEntity(GameEntity entity, AbilityData abilityData, String id) {
-        var ability = new Ability(abilityData, entity);
-        entity.getAbilities().put(id, ability);
-
-        ability.onAdded();
+    public void addAbilityToEntity(GameEntity entity, AbilityData abilityData) {
+        Ability ability = new Ability(abilityData, entity, this.player);
+        entity.getInstancedAbilities().add(ability); //This are in order
     }
 }