Merge unstable into development (#2173)

* Remove more scene synchronized

* Fix worktop options not appearing

* Format code [skip actions]

* Fix delay with server tasks

* Format code [skip actions]

* Fully fix fairy clock (#2146)

* Fix scene transition

* fully fix fairy clock

* Re-add call to `Player#updatePlayerGameTime`

* Format code [skip actions]

* Initialize the script loader in `ResourceLoader#loadAll`

* Fix region removal checking

* Format code [skip actions]

* Use Lombok's `EqualsAndHashCode` for comparing scene regions

* Format code [skip actions]

* Move 'invalid gather object' to `trace`

* Add more information to the 'unknown condition handler' message

* Move invalid ability action to trace

* Make `KcpTunnel` public

* Validate the NPC being talked to

* Format code [skip actions]

* NPCs are not spawned server side; change logic to handle it

* Format code [skip actions]

* unload scene when there are no players (#2147)

* unload scene when there are no players

* Update src/main/java/emu/grasscutter/game/world/Scene.java

Co-authored-by: Magix <27646710+KingRainbow44@users.noreply.github.com>

---------

Co-authored-by: Magix <27646710+KingRainbow44@users.noreply.github.com>

* Check if a command should be copied or HTTP should be used

* Lint Code [skip actions]

* Fix character names rendering incorrectly

* Add basic troubleshooting command

* Implement handbook teleporting

also a few formatting changes and sort data by logical sense

* Fix listener `ConcurrentModificationException` issue

* Add color change to `Join the Community!`

* Lint Code [skip actions]

* Make clickable buttons appear clickable

* Remove 'Mechanicus' entities from the list of entities

* Format code [skip actions]

* Fix going back returning a blank screen

* Implement entity spawning

* Add setting level to entity card

* Add support for 'plain text' mode

* Make descriptions of objects scrollable

* Lint Code [skip actions]

* Format code [skip actions]

* Change the way existing hooks work

* Format code [skip actions]

* Upgrade Javalin to 5.5.0 & Fix project warnings

* Upgrade logging libraries

* Fix gacha mappings static file issue

* Add temporary backwards compatability for `ServerHelper`

* Format code [skip actions]

* Remove artifact signatures from VCS

* Fix forge queue data protocol definition

* Run `spotlessApply`

* Format code [skip actions]

* Download data required for building artifacts

* Add call for Facebook logins

* Add the wiki page as a submodule

* Format code [skip actions]

* Update translation (#2150)

* Update translation

* Update translation

* Separate the dispatch and game servers (pt. 1)

gacha is still broken, handbook still needs to be done

* Format code [skip actions]

* Separate the dispatch and game servers (pt. 2)

this commit fixes the gacha page

* Add description for '/troubleshoot'

* Set default avatar talent level to 10

* Separate the dispatch and game servers (pt. 3)

implement handbook across servers!

* Format code [skip actions]

* Update GitHub Actions to use 'download-file' over 'wget'

* Gm handbook lmao (#2149)

* Fix font issue

* Fix avatars

* Fix text overflow in commands

* Fix virtualized lists and items page 😭😭

* magix why 💀

* use hover style in all minicards

* button

* remove console.log

* lint

* Add icons

* magix asked

* Fix overflow padding issue

* Fix achievement text overflow

* remove icons from repo

* Change command icon

* Add the wiki page as a submodule

* total magix moment

* fix text overflow in commands

* Fix discord button

* Make text scale on Minicard

* import icons and font from another source

* Add hover effects to siebar buttons

* move font and readme to submodule repo

* Make data folder a submodule

* import icons and font from data submodule

* Update README.md

* total magix moment

* magix moment v2

* submodule change

* Import `.webp` files

* Resize `HomeButton`

* Fix 'Copy Command' reappearing after changing pages

---------

Co-authored-by: KingRainbow44 <kobedo11@gmail.com>

* Lint Code [skip actions]

* Download data for the build, not for the lint

* format imports

this is really just to see if build handbook works kek

* Implement proper handbook authentication (pt. 1)

* Implement proper handbook authentication (pt. 2)

* Format code [skip actions]

* Add quest data dumping for the handbook

* Change colors to fit _something suitable_

* Format code [skip actions]

* Fix force pushing to branches after linting

* Fix logic of `SetPlayerPropReq`

* Move more group loading to `trace`

* Add handbook IP authentication in hybrid mode

* Fix player level up not displaying on the client properly

* Format code [skip actions]

* Fix game time locking

* Format code [skip actions]

* Update player properties

* Format code [skip actions]

* Move `warn`s for groups to `debug`

* Fix player pausing

* Move more logs to `trace`

* Use `removeItemById` for deleting items via quests

* Clean up logger more

* Pause in-game time when the world is paused

* Format code [skip actions]

* More player property documentation

* Multi-threaded resource loading

* Format code [skip actions]

* Add quest widgets

* Add quests page (basic impl.)

* Add/fix colors

also fix tailwind

* Remove banned packets

client modifications already perform the job of blocking malicious packets from being executed, no point in having this if self-windy is wanted

* Re-add `BeginCameraSceneLookNotify`

* Fix being unable to attack (#2157)

* Add `PlayerOpenChestEvent`

* Add methods to get players from the server

* Add static methods to register an event handler

* Add `PlayerEnterDungeonEvent`

* Remove legacy documentation from `PlayerMoveEvent`

* Add `PlayerChatEvent`

* Add defaults to `Position`

* Clean up `.utils`

* Revert `Multi-threaded resource loading`

* Fix changing target UID when talking to the server

* Lint Code [skip actions]

* Format code [skip actions]

* fix NPC talk triggering main quest in 46101 (#2158)

Make it so that only talks where the param matches the talkId are checked.

* Format code [skip actions]

* Partially fix Chasing Shadows (#2159)

* Partially fix Chasing Shadows

* Go ahead and move it before the return before Magix tells me to.

* Format code [skip actions]

* Bring back period lol (#2160)

* Disable SNI for the HTTPS server

* Add `EntityCreationEvent`

* Add initial startup message

this is so the server appears like its preparing to start

* Format code [skip actions]

* Enable debug mode for plugin loggers if enabled for the primary logger

* Add documentation about `WorldAreaConfigData`

* Make more fields in excels accessible

* Remove deprecated fields from `GetShopRsp`

* Run `spotlessApply` on definitions

* Add `PlayerEnterAreaEvent`

* Optimize event calls

* Fix event invokes

* Format code [skip actions]

* Remove manual autofinish for main quests. (#2162)

* Add world areas to the textmap cache

* Format code [skip actions]

* Don't overdefine variables in extended classes (#2163)

* Add dumper for world areas

* Format code [skip actions]

* instantiate personalLineList (#2165)

* Fix protocol definitions

thank you Nazrin! (+ hiro for raw definitions)

* Fix the background color leaking from the character widget

* Change HTML spacing to 2 spaces

* Implement hiding widgets

* Change scrollbar to a vibrant color

* Add _some_ scaling to the home buttons and its text

* Build the handbook with Gradle

* Fix the 'finer details' with the handbook UI

* Lint Code [skip actions]

* Fix target destination for the Gradle-built handbook

* Implement fetching a player across servers & Add a chainable JsonObject

useful for plugins! might be used in grasscutter eventually

* Fix GitHub actions

* Fix event calling & canceling

* Run `spotlessApply`

* Rename fields (might be wrong)

* Add/update all/more protocol definitions

* Add/update all/more protocol definitions

* Remove outdated packet

* Fix protocol definitions

* Format code [skip actions]

* Implement some lua variables for less console spam (#2172)

* Implement some lua variables for less console spam

* Add GetHostQuestState

This fixes some chapter 3 stuff.

* Format code [skip actions]

* Fix merge import

* Format code [skip actions]

* Fully fix fairy clock for real this time (#2167)

* Fully fix fairy clock For real this time

* Make it so relogging keeps the time lock state.

* Refactor out questLockTime

* Per Hartie, the client packet needs to be changed too

* Update src/main/java/emu/grasscutter/game/world/World.java

Co-authored-by: Magix <27646710+KingRainbow44@users.noreply.github.com>

* Update src/main/java/emu/grasscutter/server/packet/recv/HandlerClientLockGameTimeNotify.java

* Remove all code not needed to get clock working

---------

Co-authored-by: Magix <27646710+KingRainbow44@users.noreply.github.com>

* 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>

* Format code [skip actions]

* Add system for sending messages between servers

* Format some code

* Remove protocol definitions from Spotless

* Default debug to false; enable with `-debug`

* Implement completely useless global value copying

* HACK: Return the avatar which holds the weapon when the weapon is referred to by ID

* Add properties to `AbilityModifier`

* Change the way HTML is served after authentication

* Use thread executors to speed up the database loading process

* Format code [skip actions]

* Add system for setting handbook address and port

* Lint Code [skip actions]

* Format code [skip actions]

* Fix game-related data not saving

* Format code [skip actions]

* Fix handbook server details

* Lint Code [skip actions]

* Format code [skip actions]

* Use the headers provided by a context to get the IP address

should acknowledge #1975

* Format code [skip actions]

* Move more logs to `trace`

* Format code [skip actions]

* more trace

* Fix something and implement weapon entities

* Format code [skip actions]

* Fix `EntityWeapon`

* Remove deprecated API & Fix resource checking

* Fix unnecessary warning for first-time setup

* Implement handbook request limiting

* Format code [skip actions]

* Fix new avatar weapons being null

* Format code [skip actions]

* Fix issue with 35303 being un-completable & Try to fix fulfilled quest conditions being met

* Load activity config on server startup

* Require plugins to specify an API version and match with the server

* Add default open state ignore list

* Format code [skip actions]

* Quick fix for questing, needs more investigation
This would make the questing work again

* Remove existing hack for 35303

* Fix ignored open states from being set

* Format code [skip actions]

* fix the stupidest bug ive ever seen

* Optimize player kicking on server close

* Format code [skip actions]

* Re-add hack to fix 35303

* Update GitHub actions

* Format code [skip actions]

* Potentially fix issues with regions

* Download additional handbook data

* Revert "Potentially fix issues with regions"

This reverts commit 84e3823695.

---------

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: scooterboo <lewasite@yahoo.com>
Co-authored-by: Tesutarin <105267106+Tesutarin@users.noreply.github.com>
Co-authored-by: Scald <104459145+Arikatsu@users.noreply.github.com>
Co-authored-by: StartForKiller <jesussanz2003@gmail.com>

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

@@ -0,0 +1,61 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.binout.AbilityData;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.net.proto.AbilityStringOuterClass.AbilityString;
+import emu.grasscutter.utils.Utils;
+import it.unimi.dsi.fastutil.objects.*;
+import java.util.*;
+import lombok.Getter;
+
+public class Ability {
+    @Getter private AbilityData data;
+    @Getter private GameEntity owner;
+    @Getter private Player playerOwner;
+
+    @Getter private AbilityManager manager;
+
+    @Getter private Map<String, AbilityModifierController> modifiers = new HashMap<>();
+    @Getter private Object2FloatMap<String> abilitySpecials = new Object2FloatOpenHashMap<>();
+
+    @Getter
+    private static Map<String, Object2FloatMap<String>> abilitySpecialsModified = new HashMap<>();
+
+    @Getter private int hash;
+
+    public Ability(AbilityData data, GameEntity owner, Player playerOwner) {
+        this.data = data;
+        this.owner = owner;
+        this.manager = owner.getWorld().getHost().getAbilityManager();
+
+        if (this.data.abilitySpecials != null) {
+            for (var entry : this.data.abilitySpecials.entrySet())
+                abilitySpecials.put(entry.getKey(), entry.getValue().floatValue());
+        }
+
+        // if(abilitySpecialsModified.containsKey(this.data.abilityName)) {//Modify talent data
+        //    abilitySpecials.putAll(abilitySpecialsModified.get(this.data.abilityName));
+        // }
+
+        this.playerOwner = playerOwner;
+
+        hash = Utils.abilityHash(data.abilityName);
+
+        data.initialize();
+    }
+
+    public static String getAbilityName(AbilityString abString) {
+        if (abString.hasStr()) return abString.getStr();
+        if (abString.hasHash()) return GameData.getAbilityHashes().get(abString.getHash());
+
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "Ability Name: %s; Entity Owner: %s; Player Owner: %s"
+                .formatted(data.abilityName, owner, playerOwner);
+    }
+}

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

@@ -0,0 +1,82 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityMixinData;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import java.util.Map;
+import lombok.AllArgsConstructor;
+
+@SuppressWarnings("ALL")
+public class AbilityLocalIdGenerator {
+    @AllArgsConstructor
+    public enum ConfigAbilitySubContainerType {
+        NONE(0),
+        ACTION(1),
+        MIXIN(2),
+        MODIFIER_ACTION(3),
+        MODIFIER_MIXIN(4);
+
+        final long value;
+    }
+
+    public ConfigAbilitySubContainerType type;
+    public long modifierIndex = 0;
+    public long configIndex = 0;
+    public long mixinIndex = 0;
+    private long actionIndex = 0;
+
+    public AbilityLocalIdGenerator(ConfigAbilitySubContainerType type) {
+        this.type = type;
+    }
+
+    public void initializeActionLocalIds(
+            AbilityModifierAction[] actions, Map<Integer, AbilityModifierAction> localIdToAction) {
+        if (actions == null) return;
+        actionIndex = 0;
+        for (AbilityModifierAction action : actions) {
+            actionIndex++;
+            long id = GetLocalId();
+            localIdToAction.put((int) id, action);
+        }
+
+        actionIndex = 0;
+    }
+
+    public void initializeMixinsLocalIds(
+            AbilityMixinData[] mixins, Map<Integer, AbilityMixinData> localIdToAction) {
+        if (mixins == null) return;
+        mixinIndex = 0;
+        for (AbilityMixinData mixin : mixins) {
+            long id = GetLocalId();
+            localIdToAction.put((int) id, mixin);
+
+            mixinIndex++;
+        }
+
+        mixinIndex = 0;
+    }
+
+    public long GetLocalId() {
+        switch (type) {
+            case ACTION -> {
+                return (long) type.value + (configIndex << 3) + (actionIndex << 9);
+            }
+            case MIXIN -> {
+                return (long) type.value + (mixinIndex << 3) + (configIndex << 9) + (actionIndex << 15);
+            }
+            case MODIFIER_ACTION -> {
+                return (long) type.value + (modifierIndex << 3) + (configIndex << 9) + (actionIndex << 15);
+            }
+            case MODIFIER_MIXIN -> {
+                return (long) type.value
+                        + (modifierIndex << 3)
+                        + (mixinIndex << 9)
+                        + (configIndex << 15)
+                        + (actionIndex << 21);
+            }
+            case NONE -> Grasscutter.getLogger().error("Ability local id generator using NONE type.");
+        }
+
+        return -1;
+    }
+}

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

@@ -1,50 +1,247 @@
 package emu.grasscutter.game.ability;
 
-import com.google.protobuf.InvalidProtocolBufferException;
-
+import com.google.protobuf.*;
+import emu.grasscutter.Grasscutter;
 import emu.grasscutter.data.GameData;
-import emu.grasscutter.data.binout.AbilityModifierEntry;
+import emu.grasscutter.data.binout.*;
 import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
-import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.game.ability.actions.*;
+import emu.grasscutter.game.ability.mixins.*;
 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.net.proto.AbilityInvokeEntryHeadOuterClass.AbilityInvokeEntryHead;
+import emu.grasscutter.game.player.*;
 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.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 java.util.HashMap;
+import java.util.concurrent.*;
 import lombok.Getter;
+import org.reflections.Reflections;
 
 public final class AbilityManager extends BasePlayerManager {
-    HealAbilityManager healAbilityManager;
+
+    private static final HashMap<AbilityModifierAction.Type, AbilityActionHandler> actionHandlers =
+            new HashMap<>();
+    private static final 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());
+
+        registerHandlers();
+    }
 
     @Getter private boolean abilityInvulnerable = false;
 
     public AbilityManager(Player player) {
         super(player);
-        this.healAbilityManager = new HealAbilityManager(player);
+    }
+
+    public static void registerHandlers() {
+        Reflections reflections = new Reflections("emu.grasscutter.game.ability.actions");
+        var handlerClassesAction = reflections.getSubTypesOf(AbilityActionHandler.class);
+
+        for (var obj : handlerClassesAction) {
+            try {
+                if (obj.isAnnotationPresent(AbilityAction.class)) {
+                    AbilityModifierAction.Type abilityAction = obj.getAnnotation(AbilityAction.class).value();
+                    actionHandlers.put(abilityAction, obj.getDeclaredConstructor().newInstance());
+                } else {
+                    return;
+                }
+            } catch (Exception e) {
+                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, ByteString abilityData, GameEntity target) {
+        var handler = actionHandlers.get(action.type);
+        if (handler == null || ability == null) {
+            Grasscutter.getLogger()
+                    .debug("Could not execute ability action {} at {}", action.type, ability);
+            return;
+        }
+
+        eventExecutor.submit(
+                () -> {
+                    if (!handler.execute(ability, action, abilityData, target)) {
+                        Grasscutter.getLogger()
+                                .debug("Ability execute action failed for {} at {}.", action.type, ability);
+                    }
+                });
+    }
+
+    public void executeMixin(Ability ability, AbilityMixinData mixinData, ByteString abilityData) {
+        var handler = mixinHandlers.get(mixinData.type);
+        if (handler == null || ability == null) {
+            Grasscutter.getLogger()
+                    .trace("Could not execute ability mixin {} at {}", mixinData.type, ability);
+            return;
+        }
+
+        eventExecutor.submit(
+                () -> {
+                    if (!handler.execute(ability, mixinData, abilityData)) {
+                        Grasscutter.getLogger()
+                                .error("Ability execute action failed for {} 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());
+
+            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;
+        }
 
-         //Grasscutter.getLogger().info(invoke.getArgumentType() + " (" + invoke.getArgumentTypeValue() + "): " + Utils.bytesToHex(invoke.toByteArray()));
         switch (invoke.getArgumentType()) {
             case ABILITY_INVOKE_ARGUMENT_META_OVERRIDE_PARAM -> this.handleOverrideParam(invoke);
             case ABILITY_INVOKE_ARGUMENT_META_REINIT_OVERRIDEMAP -> this.handleReinitOverrideMap(invoke);
             case ABILITY_INVOKE_ARGUMENT_META_MODIFIER_CHANGE -> this.handleModifierChange(invoke);
             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_ADD_NEW_ABILITY -> this.handleAddNewAbility(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.
@@ -76,6 +273,7 @@ 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) {
@@ -93,126 +291,257 @@ public final class AbilityManager extends BasePlayerManager {
         this.abilityInvulnerable = false;
     }
 
-    private void handleOverrideParam(AbilityInvokeEntry invoke) throws Exception {
-        GameEntity entity = this.player.getScene().getEntityById(invoke.getEntityId());
+    private void setAbilityOverrideValue(Ability ability, AbilityScalarValueEntry valueChange) {
+        if (valueChange.getValueType() != AbilityScalarType.ABILITY_SCALAR_TYPE_FLOAT) {
+            Grasscutter.getLogger().trace("Scalar type not supported: {}", valueChange.getValueType());
 
-        if (entity == null) {
             return;
         }
 
-        AbilityScalarValueEntry entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
+        if (!valueChange.getKey().hasStr()) {
+            Grasscutter.getLogger().trace("TODO: Calculate all the ability value hashes");
 
-        entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+            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) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
+            return;
+        }
+
+        var instancedAbilityIndex = head.getInstancedAbilityId() - 1;
+        if (instancedAbilityIndex >= entity.getInstancedAbilities().size()) {
+            Grasscutter.getLogger().trace("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 {
-        GameEntity entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var head = invoke.getHead();
 
         if (entity == null) {
+            Grasscutter.getLogger().trace("Entity not found: {}", invoke.getEntityId());
             return;
         }
 
-        AbilityMetaReInitOverrideMap map = AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
+        var instancedAbilityIndex = head.getInstancedAbilityId() - 1;
+        if (instancedAbilityIndex >= entity.getInstancedAbilities().size()) {
+            Grasscutter.getLogger().trace("Ability not found {}", head.getInstancedAbilityId());
+            return;
+        }
 
-        for (AbilityScalarValueEntry entry : map.getOverrideMapList()) {
-            entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+        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
-        GameEntity target = this.player.getScene().getEntityById(invoke.getEntityId());
-        if (target == null) {
+        // TODO:
+        var modChange = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
+        var head = invoke.getHead();
+
+        if (head.getInstancedAbilityId() == 0 || head.getInstancedModifierId() > 2000)
+            return; // Error: TODO: display error
+
+        if (head.getIsServerbuffModifier()) {
+            // TODO
+            Grasscutter.getLogger().trace("TODO: Handle serverbuff modifier");
             return;
         }
 
-        AbilityMetaModifierChange data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
-        if (data == null) {
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (entity == null) {
+            Grasscutter.getLogger().debug("Entity not found: {}", invoke.getEntityId());
             return;
         }
 
-        // Destroying rocks
-        if (target instanceof EntityGadget targetGadget && targetGadget.getContent() instanceof GadgetGatherObject gatherObject) {
-            if (data.getAction() == ModifierAction.MODIFIER_ACTION_REMOVED) {
-                gatherObject.dropItems(this.getPlayer());
+        if (modChange.getAction() == ModifierAction.MODIFIER_ACTION_ADDED) {
+            AbilityData instancedAbilityData = null;
+            Ability instancedAbility = null;
+
+            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();
+                    }
+                }
+            }
+
+            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 {}
+
+    private void handleGenerateElemBall(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 == 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());
+            }
+            case AbilityScalarType.ABILITY_SCALAR_TYPE_UINT_VALUE -> entity
+                    .getGlobalAbilityValues()
+                    .put(key, (float) entry.getUintValue());
+            default -> {
                 return;
             }
         }
 
-        // Sanity checks
-        AbilityInvokeEntryHead head = invoke.getHead();
-        if (head == null) {
+        entity.onAbilityValueUpdate();
+    }
+
+    private void invokeAction(
+            AbilityModifierAction action, GameEntity target, GameEntity sourceEntity) {}
+
+    private void handleModifierDurabilityChange(AbilityInvokeEntry invoke)
+            throws InvalidProtocolBufferException {}
+
+    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;
         }
 
-        GameEntity sourceEntity = this.player.getScene().getEntityById(data.getApplyEntityId());
-        if (sourceEntity == null) {
+        var addAbility = AbilityMetaAddAbility.parseFrom(invoke.getAbilityData());
+
+        var abilityName = Ability.getAbilityName(addAbility.getAbility().getAbilityName());
+
+        var ability = GameData.getAbilityData(abilityName);
+        if (ability == null) {
+            Grasscutter.getLogger().trace("Ability not found: {}", abilityName);
             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);
+        entity.getInstancedAbilities().add(new Ability(ability, entity, player));
 
-            if (modifier != null && modifier.getOnAdded().size() > 0) {
-                for (AbilityModifierAction action : modifier.getOnAdded()) {
-                    this.invokeAction(action, target, sourceEntity);
-                }
-            }
-
-            // 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);
-                    }
-                }
-
-                // Remove from meta modifiers
-                target.getMetaModifiers().remove(head.getInstancedModifierId());
-            }
-        }
+        Grasscutter.getLogger()
+                .trace(
+                        "Ability added to entity {} at index {}",
+                        entity.getId(),
+                        entity.getInstancedAbilities().size());
     }
 
-    private void handleMixinCostStamina(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
-        AbilityMixinCostStamina costStamina = AbilityMixinCostStamina.parseFrom((invoke.getAbilityData()));
-        this.getPlayer().getStaminaManager().handleMixinCostStamina(costStamina.getIsSwim());
+    public void addAbilityToEntity(GameEntity entity, String name) {
+        AbilityData data = GameData.getAbilityData(name);
+        if (data != null) addAbilityToEntity(entity, data);
     }
 
-    private void handleGenerateElemBall(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
-        this.player.getEnergyManager().handleGenerateElemBall(invoke);
-    }
-
-    private void invokeAction(AbilityModifierAction action, GameEntity target, GameEntity sourceEntity) {
-        switch (action.type) {
-            case HealHP -> {}
-            case LoseHP -> {
-                if (action.amountByTargetCurrentHPRatio == null) {
-                    return;
-                }
-
-                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 -> {}
-        }
+    public void addAbilityToEntity(GameEntity entity, AbilityData abilityData) {
+        Ability ability = new Ability(abilityData, entity, this.player);
+        entity.getInstancedAbilities().add(ability); // This are in order
     }
 }
-

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.data.binout.AbilityData;
+import emu.grasscutter.data.binout.AbilityModifier;
+import lombok.Getter;
+
+public class AbilityModifierController {
+    @Getter private Ability ability;
+
+    @Getter private AbilityData abilityData;
+    @Getter private AbilityModifier modifierData;
+
+    public AbilityModifierController(
+            Ability ability, AbilityData abilityData, AbilityModifier modifierData) {
+        this.ability = ability;
+        this.abilityData = abilityData;
+        this.modifierData = modifierData;
+    }
+}

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

@@ -1,208 +0,0 @@
-package emu.grasscutter.game.ability;
-
-import java.util.*;
-import java.util.Optional;
-import java.util.Map.Entry;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-
-import emu.grasscutter.Grasscutter;
-
-import emu.grasscutter.data.GameData;
-import emu.grasscutter.data.binout.AbilityModifierEntry;
-import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
-import emu.grasscutter.data.excels.AvatarSkillDepotData;
-import emu.grasscutter.data.excels.ItemData;
-import emu.grasscutter.game.avatar.Avatar;
-import emu.grasscutter.game.entity.EntityAvatar;
-import emu.grasscutter.game.entity.EntityClientGadget;
-import emu.grasscutter.game.entity.EntityItem;
-import emu.grasscutter.game.entity.GameEntity;
-import emu.grasscutter.game.player.Player;
-import emu.grasscutter.game.props.ElementType;
-import emu.grasscutter.net.proto.AbilityActionGenerateElemBallOuterClass.AbilityActionGenerateElemBall;
-import emu.grasscutter.net.proto.AbilityInvokeEntryHeadOuterClass.AbilityInvokeEntryHead;
-import emu.grasscutter.net.proto.AbilityInvokeEntryOuterClass.AbilityInvokeEntry;
-import emu.grasscutter.net.proto.AbilityMetaModifierChangeOuterClass.AbilityMetaModifierChange;
-import emu.grasscutter.net.proto.AbilityMetaReInitOverrideMapOuterClass.AbilityMetaReInitOverrideMap;
-import emu.grasscutter.net.proto.AbilityMixinCostStaminaOuterClass.AbilityMixinCostStamina;
-import emu.grasscutter.net.proto.AbilityScalarValueEntryOuterClass.AbilityScalarValueEntry;
-import emu.grasscutter.net.proto.ModifierActionOuterClass.ModifierAction;
-import emu.grasscutter.utils.Position;
-import emu.grasscutter.utils.Utils;
-import emu.grasscutter.game.props.FightProperty;
-
-public class HealAbilityManager {
-    private class HealData {
-        public boolean isString = true;
-        public String abilityType = ""; //"E" or "Q"
-        public String sRatio = "";
-        public String sBase = "";
-        public float fRatio = 0;
-        public float fBase = 0;
-        public boolean healAll = false;
-        
-        public HealData(String _abilityType, String _sRatio, String _sBase, boolean _healAll) {
-            abilityType = _abilityType;
-            isString = true;
-            sRatio = _sRatio;
-            sBase = _sBase;
-            healAll = _healAll;
-        }
-
-        public HealData(String _abilityType, String _sRatio, float _fRatio, float _fBase, boolean _healAll) {
-            abilityType = _abilityType;
-            isString = false;
-            sRatio = _sRatio;
-            fRatio = _fRatio;
-            fBase = _fBase;
-            healAll = _healAll;
-        }
-    }
-
-    private class HealDataAvatar {
-        public int avatarId = 0;
-        public String avatarName = "";
-        public int fightPropertyType= 0; //0: maxHP, 1: curAttack, 2: curDefense
-        public ArrayList<HealData> healDataList;
-
-        public HealDataAvatar(int _avatarId, String _avatarName, int _fightPropertyType) {
-            avatarId = _avatarId;
-            avatarName = _avatarName;
-            fightPropertyType = _fightPropertyType;
-            healDataList = new ArrayList();
-        }
-
-        public HealDataAvatar addHealData(String abilityType, String sRatio, String sBase, boolean healAll) {
-            HealData healData = new HealData(abilityType, sRatio, sBase, healAll);
-            healDataList.add(healData);
-            return this;
-        }
-
-        public HealDataAvatar addHealData(String abilityType, String sRatio, float fRatio, float fBase, boolean healAll) {
-            HealData healData = new HealData(abilityType, sRatio, fRatio, fBase, healAll);
-            healDataList.add(healData);
-            return this;
-        }
-    }
-
-    ArrayList<HealDataAvatar> healDataAvatarList;
-	private Player player;
-    
-    public HealAbilityManager (Player player) {
-		this.player = player;
-        healDataAvatarList = new ArrayList();
-        healDataAvatarList.add(new HealDataAvatar(10000054, "Kokomi", 0).addHealData("E", "ElementalArt_Heal_MaxHP_Base_Percentage", "ElementalArt_Heal_Base_Amount", false).addHealData("Q", "Avatar_Kokomi_ElementalBurst_Heal", 0.0172f, 212f, false));
-        healDataAvatarList.add(new HealDataAvatar(10000003, "Qin", 1).addHealData("Q", "Heal", "BurstHealConst", true)); 
-        healDataAvatarList.add(new HealDataAvatar(10000034, "Noel", 2).addHealData("E", "OnAttack_HealthRate", 0.452f, 282f, true));
-        healDataAvatarList.add(new HealDataAvatar(10000032, "Bennett", 0).addHealData("Q", "HealMaxHpRatio", "HealConst", false));
-        healDataAvatarList.add(new HealDataAvatar(10000039, "Diona", 0).addHealData("Q", "HealHPRatio", "HealHP_Const", false));
-        healDataAvatarList.add(new HealDataAvatar(10000053, "Sayu", 1).addHealData("Q", "Constellation_6_Damage", "Heal_BaseAmount", true).addHealData("Q", "Heal_AttackRatio", "Constellation_6_Heal", true));
-        healDataAvatarList.add(new HealDataAvatar(10000014, "Barbara", 0).addHealData("E", "HealHPOnAdded", "HealHPOnAdded_Const", true).addHealData("E", "HealHP_OnHittingOthers", "HealHP_Const_OnHittingOthers", true).addHealData("Q", "Avatar_Barbara_IdolHeal", 0.374f, 4660f, true));
-        healDataAvatarList.add(new HealDataAvatar(10000065, "Shinobu", 0).addHealData("E", "ElementalArt_Heal_MaxHP_Percentage", 0.064f, 795f, false));
-        healDataAvatarList.add(new HealDataAvatar(10000035, "Qiqi", 1).addHealData("E", "HealHP_OnHittingOthers", "HealHP_Const_OnHittingOthers", true).addHealData("E", "ElementalArt_HealHp_Ratio", "ElementalArt_HealHp_Const", true).addHealData("Q", "Avatar_Qiqi_ElementalBurst_ApplyModifier", 0.0191f, 1588f, false));
-        healDataAvatarList.add(new HealDataAvatar(10000046, "Hutao", 0).addHealData("Q", "Avatar_Hutao_VermilionBite_BakeMesh", 0.1166f, 0f, false));
-    }
-
-	public Player getPlayer() {
-		return this.player;
-	}
-
-    public void healHandler(AbilityInvokeEntry invoke) throws Exception {
-		AbilityMetaModifierChange data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
-		
-		if (data == null) {
-			return;
-		}
-		
-		GameEntity sourceEntity = player.getScene().getEntityById(data.getApplyEntityId());
-
-        String modifierString = "";
-        if(data.getParentAbilityName() != null)
-			modifierString = data.getParentAbilityName().getStr();
-
-        if(sourceEntity != null)
-            checkAndHeal(sourceEntity, modifierString);
-    }
-
-    public void checkAndHeal(GameEntity sourceEntity, String modifierString) {
-        int fightPropertyType = 0;
-        float healAmount = 0;
-        float ratio = 0, base = 0;
-        float maxHP, curHP, curAttack, curDefense;
-        Map<String, Float> map = sourceEntity.getMetaOverrideMap();
-
-        for(int i = 0 ; i < healDataAvatarList.size() ; i ++) {
-            HealDataAvatar healDataAvatar = healDataAvatarList.get(i);
-            if(modifierString.contains(healDataAvatar.avatarName)) {
-                fightPropertyType = healDataAvatar.fightPropertyType;
-                ArrayList<HealData> healDataList = healDataAvatar.healDataList;
-
-                for(int j = 0 ; j < healDataList.size(); j++) {
-                    HealData healData = healDataList.get(j);
-                    if(map.containsKey(healData.sRatio) || modifierString.equals(healData.sRatio)) {
-                        if(healData.isString) {
-                            ratio = map.get(healData.sRatio);
-                            base = map.get(healData.sBase);
-                        }
-                        else {
-                            ratio = healData.fRatio;
-                            base = healData.fBase;
-                        }
-                    }
-
-                    List<EntityAvatar> activeTeam = player.getTeamManager().getActiveTeam();
-                    List<EntityAvatar> needHealAvatars = new ArrayList();
-                    int currentIndex = player.getTeamManager().getCurrentCharacterIndex();
-                    EntityAvatar currentAvatar = activeTeam.get(currentIndex);
-                    if(healData.healAll) {
-                        needHealAvatars = activeTeam;
-                    }
-                    else {
-                        needHealAvatars.add(currentAvatar);
-                    }
-
-                    EntityAvatar healActionAvatar = null;
-                    for(int k = 0 ; k < activeTeam.size() ; k ++) {
-                        EntityAvatar avatar = activeTeam.get(k);
-                        int avatarId = avatar.getAvatar().getAvatarId();
-                        if(avatarId == healDataAvatar.avatarId) {
-                            healActionAvatar = avatar;
-                            break;
-                        }
-                    }
-
-                    if(healActionAvatar != null) {
-                        maxHP = healActionAvatar.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
-                        curHP = healActionAvatar.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
-                        curAttack = healActionAvatar.getFightProperty(FightProperty.FIGHT_PROP_CUR_ATTACK);
-                        curDefense = healActionAvatar.getFightProperty(FightProperty.FIGHT_PROP_CUR_DEFENSE);
-
-                        //Special case for Hu Tao:
-                        if(healDataAvatar.avatarName.equals("Hutao") && curHP <= maxHP * 0.5 && ratio != 0) {
-                            ratio = 0.1555f;
-                        }
-
-                        switch(fightPropertyType) {
-                            case 0:
-                                healAmount = ratio * maxHP + base;
-                                break;
-                            case 1:
-                                healAmount = ratio * curAttack + base;
-                                break;
-                            case 2:
-                                healAmount = ratio * curDefense + base;
-                                break;
-                        }
-                    }
-
-                    for(int k = 0 ; k < needHealAvatars.size() ; k ++) {
-                        EntityAvatar avatar = needHealAvatars.get(k);
-                        avatar.heal(healAmount);
-                    }
-                }
-                break;
-            }
-        }
-    }
-}

src/main/java/emu/grasscutter/game/ability/actions/AbilityAction.java

@@ -0,0 +1,10 @@
+package emu.grasscutter.game.ability.actions;
+
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AbilityAction {
+    AbilityModifierAction.Type value();
+}

src/main/java/emu/grasscutter/game/ability/actions/AbilityActionHandler.java

@@ -0,0 +1,35 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+public abstract class AbilityActionHandler {
+    public abstract boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target);
+
+    /**
+     * Returns the target entity.
+     *
+     * @param ability The ability being invoked.
+     * @param entity The entity invoking the ability.
+     * @param target The target entity type.
+     * @return The target entity.
+     */
+    protected GameEntity getTarget(Ability ability, GameEntity entity, String target) {
+        return switch (target) {
+            default -> throw new RuntimeException("Unknown target type: " + target);
+            case "Self" -> entity;
+            case "Team" -> ability.getPlayerOwner().getTeamManager().getEntity();
+            case "OriginOwner" -> ability.getPlayerOwner().getTeamManager().getCurrentAvatarEntity();
+            case "Owner" -> ability.getOwner();
+            case "Applier" -> entity; // TODO: Validate.
+            case "CurLocalAvatar" -> ability
+                    .getPlayerOwner()
+                    .getTeamManager()
+                    .getCurrentAvatarEntity(); // TODO: Validate.
+            case "CasterOriginOwner" -> null; // TODO: Figure out.
+        };
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionApplyModifier.java

@@ -0,0 +1,35 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.ApplyModifier)
+public class ActionApplyModifier extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        // var modifierData = ability.getData().modifiers.get(action.modifierName);
+        // if(modifierData == null) {
+        //    Grasscutter.getLogger().debug("Modifier {} not found", action.modifierName);
+        //    return false;
+        // }
+        //
+        // if(modifierData.stacking != null && modifierData.stacking.compareTo("Unique") == 0 &&
+        //    ability.getModifiers().values().stream().filter(m ->
+        // m.getData().equals(modifierData)).count() != 0) {
+        //    return true;
+        // }
+        //
+        //// TODO: Check predicates before executing all of these actions
+        //
+        // AbilityModifierController modifier = new AbilityModifierController(ability, modifierData);
+        // ability.getModifiers().put(action.modifierName, modifier);
+        // modifier.onAdded();
+        //
+        // return true;
+
+        return false; // TODO
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionAvatarSkillStart.java

@@ -0,0 +1,30 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.quest.enums.QuestContent;
+
+@AbilityAction(AbilityModifierAction.Type.AvatarSkillStart)
+public class ActionAvatarSkillStart extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        var owner = ability.getOwner();
+        if (owner instanceof EntityAvatar avatar) {
+            avatar
+                    .getPlayer()
+                    .getQuestManager()
+                    .queueEvent(QuestContent.QUEST_CONTENT_SKILL, action.skillID);
+        } else {
+            Grasscutter.getLogger()
+                    .warn("AvatarSkillStart not implemented for other entities than EntityAvatar right now");
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionCopyGlobalValue.java

@@ -0,0 +1,35 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.CopyGlobalValue)
+public final class ActionCopyGlobalValue extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity entity) {
+        // Get the entities referred to.
+        var source = this.getTarget(ability, entity, action.srcTarget);
+        var destination = this.getTarget(ability, entity, action.dstTarget);
+        // Check the entities.
+        if (source == null || destination == null) {
+            Grasscutter.getLogger().debug("ActionCopyGlobalValue: source or destination is null");
+            return false;
+        }
+
+        // Get the global value.
+        var value = source.getGlobalAbilityValues().get(action.srcKey);
+        if (value == null) {
+            Grasscutter.getLogger().debug("ActionCopyGlobalValue: source value is null");
+            return false;
+        }
+
+        // Apply the new global value.
+        destination.getGlobalAbilityValues().put(action.dstKey, value);
+        destination.onAbilityValueUpdate();
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionCreateGadget.java

@@ -0,0 +1,56 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.props.CampTargetType;
+import emu.grasscutter.game.world.Position;
+import emu.grasscutter.net.proto.AbilityActionCreateGadgetOuterClass.AbilityActionCreateGadget;
+
+@AbilityAction(AbilityModifierAction.Type.CreateGadget)
+public class ActionCreateGadget extends AbilityActionHandler {
+
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        if (!action.byServer) {
+            Grasscutter.getLogger().debug("Action not executed by server");
+
+            return true;
+        }
+
+        var entity = ability.getOwner();
+        AbilityActionCreateGadget createGadget;
+        try {
+            createGadget = AbilityActionCreateGadget.parseFrom(abilityData);
+        } catch (InvalidProtocolBufferException e) {
+            return false;
+        }
+
+        var entityCreated =
+                new EntityGadget(
+                        entity.getScene(),
+                        action.gadgetID,
+                        new Position(createGadget.getPos()),
+                        new Position(createGadget.getRot()),
+                        action.campID,
+                        CampTargetType.getTypeByName(action.campTargetType).getValue());
+        if (action.ownerIsTarget) entityCreated.setOwner(target);
+        else entityCreated.setOwner(entity);
+
+        entity.getScene().addEntity(entityCreated);
+
+        Grasscutter.getLogger()
+                .trace(
+                        "Gadget {} created at pos {} rot {}",
+                        action.gadgetID,
+                        entityCreated.getPosition(),
+                        entityCreated.getRotation());
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionExecuteGadgetLua.java

@@ -0,0 +1,26 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.ExecuteGadgetLua)
+public class ActionExecuteGadgetLua extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        GameEntity owner = ability.getOwner();
+
+        // Investigate if we need to use target
+
+        if (owner.getEntityController() != null) {
+            owner
+                    .getEntityController()
+                    .onClientExecuteRequest(owner, action.param1, action.param2, action.param3);
+            return true;
+        }
+
+        return false;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionHealHP.java

@@ -0,0 +1,86 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.EntityClientGadget;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.props.FightProperty;
+
+@AbilityAction(AbilityModifierAction.Type.HealHP)
+public final class ActionHealHP extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        Grasscutter.getLogger().debug("Heal ability action executing 1");
+
+        var owner = ability.getOwner();
+        // handle client gadgets, that the effective caster is the current local avatar
+        if (owner instanceof EntityClientGadget ownerGadget) {
+            owner =
+                    ownerGadget
+                            .getScene()
+                            .getEntityById(ownerGadget.getOwnerEntityId()); // Caster for EntityClientGadget
+            Grasscutter.getLogger()
+                    .debug(
+                            "Owner {} has top owner {}: {}",
+                            ability.getOwner(),
+                            ownerGadget.getOwnerEntityId(),
+                            owner);
+        }
+
+        if (owner == null) return false;
+
+        ability
+                .getAbilitySpecials()
+                .forEach((k, v) -> Grasscutter.getLogger().trace(">>> {}: {}", k, v));
+
+        var amountByCasterMaxHPRatio = action.amountByCasterMaxHPRatio.get(ability);
+        var amountByCasterAttackRatio = action.amountByCasterAttackRatio.get(ability);
+        var amountByCasterCurrentHPRatio = action.amountByCasterCurrentHPRatio.get(ability);
+        var amountByTargetCurrentHPRatio = action.amountByTargetCurrentHPRatio.get(ability);
+        var amountByTargetMaxHPRatio = action.amountByTargetMaxHPRatio.get(ability);
+
+        Grasscutter.getLogger().trace("amountByCasterMaxHPRatio: " + amountByCasterMaxHPRatio);
+        Grasscutter.getLogger().trace("amountByCasterAttackRatio: " + amountByCasterAttackRatio);
+        Grasscutter.getLogger().trace("amountByCasterCurrentHPRatio: " + amountByCasterCurrentHPRatio);
+        Grasscutter.getLogger().trace("amountByTargetCurrentHPRatio: " + amountByTargetCurrentHPRatio);
+        Grasscutter.getLogger().trace("amountByTargetMaxHPRatio: " + amountByTargetMaxHPRatio);
+
+        var amountToRegenerate = action.amount.get(ability);
+        Grasscutter.getLogger().trace("Base amount: " + amountToRegenerate);
+
+        amountToRegenerate +=
+                amountByCasterMaxHPRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
+        amountToRegenerate +=
+                amountByCasterAttackRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_CUR_ATTACK);
+        amountToRegenerate +=
+                amountByCasterCurrentHPRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
+
+        Grasscutter.getLogger().trace("amountToRegenerate: " + amountToRegenerate);
+
+        var abilityRatio = 1.0f;
+        Grasscutter.getLogger().trace("Base abilityRatio: " + abilityRatio);
+
+        if (!action.ignoreAbilityProperty)
+            abilityRatio +=
+                    target.getFightProperty(FightProperty.FIGHT_PROP_HEAL_ADD)
+                            + target.getFightProperty(FightProperty.FIGHT_PROP_HEALED_ADD);
+
+        Grasscutter.getLogger().trace("abilityRatio: " + abilityRatio);
+
+        Grasscutter.getLogger().trace("Sub-regenerate amount: " + amountToRegenerate);
+        amountToRegenerate +=
+                amountByTargetCurrentHPRatio * target.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
+        amountToRegenerate +=
+                amountByTargetMaxHPRatio * target.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
+
+        Grasscutter.getLogger().debug(">>> Healing {} without ratios", amountToRegenerate);
+        target.heal(
+                amountToRegenerate * abilityRatio * action.healRatio.get(ability, 1f),
+                action.muteHealEffect);
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionKillSelf.java

@@ -0,0 +1,18 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.KillSelf)
+public final class ActionKillSelf extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        GameEntity owner = ability.getOwner();
+        owner.getScene().killEntity(owner);
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionLoseHP.java

@@ -0,0 +1,71 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.EntityClientGadget;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.props.FightProperty;
+
+@AbilityAction(AbilityModifierAction.Type.LoseHP)
+public final class ActionLoseHP extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        GameEntity owner = ability.getOwner();
+        // handle client gadgets, that the effective caster is the current local avatar
+        if (owner instanceof EntityClientGadget ownerGadget) {
+            owner =
+                    ownerGadget
+                            .getScene()
+                            .getEntityById(ownerGadget.getOwnerEntityId()); // Caster for EntityClientGadget
+
+            // TODO: Do this per entity, not just the player
+            if (ownerGadget.getOwner().getAbilityManager().isAbilityInvulnerable()) return true;
+        }
+        if (owner == null || target == null) return false;
+
+        if (action.enableLockHP && target.isLockHP()) {
+            return true;
+        }
+
+        if (action.disableWhenLoading
+                && target.getScene().getWorld().getHost().getSceneLoadState().getValue() < 2) {
+            return true;
+        }
+
+        var amountByCasterMaxHPRatio = action.amountByCasterMaxHPRatio.get(ability);
+        var amountByCasterAttackRatio = action.amountByCasterAttackRatio.get(ability);
+        var amountByCasterCurrentHPRatio =
+                action.amountByCasterCurrentHPRatio.get(ability); // Seems unused on server
+        var amountByTargetCurrentHPRatio = action.amountByTargetCurrentHPRatio.get(ability);
+        var amountByTargetMaxHPRatio = action.amountByTargetMaxHPRatio.get(ability);
+        var limboByTargetMaxHPRatio = action.limboByTargetMaxHPRatio.get(ability);
+
+        var amountToLose = action.amount.get(ability);
+        amountToLose +=
+                amountByCasterMaxHPRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
+        amountToLose +=
+                amountByCasterAttackRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_CUR_ATTACK);
+        amountToLose +=
+                amountByCasterCurrentHPRatio * owner.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
+
+        var currentHp = target.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
+        var maxHp = target.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
+        amountToLose += amountByTargetCurrentHPRatio * currentHp;
+        amountToLose += amountByTargetMaxHPRatio * maxHp;
+
+        if (limboByTargetMaxHPRatio > 1.192093e-07)
+            amountToLose =
+                    (float)
+                            Math.min(
+                                    Math.max(currentHp - Math.max(limboByTargetMaxHPRatio * maxHp, 1.0), 0.0),
+                                    amountToLose);
+
+        if (currentHp < (amountToLose + 0.01) && !action.lethal) amountToLose = 0;
+
+        target.damage(amountToLose);
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionPredicated.java

@@ -0,0 +1,16 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.Predicated)
+public class ActionPredicated extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        // This doesn't do nothing on server
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/actions/ActionSetGlobalValueToOverrideMap.java

@@ -0,0 +1,40 @@
+package emu.grasscutter.game.ability.actions;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.entity.EntityClientGadget;
+import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.SetGlobalValueToOverrideMap)
+public class ActionSetGlobalValueToOverrideMap extends AbilityActionHandler {
+    @Override
+    public boolean execute(
+            Ability ability, AbilityModifierAction action, ByteString abilityData, GameEntity target) {
+        // TODO:
+        var entity = target;
+        if (action.isFromOwner) {
+            if (target instanceof EntityClientGadget gadget)
+                entity = entity.getScene().getEntityById(gadget.getOwnerEntityId());
+            else if (target instanceof EntityGadget gadget) entity = gadget.getOwner();
+        }
+
+        var globalValueKey = action.globalValueKey;
+        var abilityFormula = action.abilityFormula;
+
+        if (!entity.getGlobalAbilityValues().containsKey(globalValueKey)) return false;
+
+        var globalValue = entity.getGlobalAbilityValues().getOrDefault(globalValueKey, 0.0f);
+        if (abilityFormula.compareTo("DummyThrowSpeed") == 0) {
+            globalValue = ((globalValue * 30.0f) / ((float) Math.sin(0.9424778) * 100.0f)) - 1.0f;
+        }
+
+        entity.getGlobalAbilityValues().put(globalValueKey, globalValue);
+        entity.onAbilityValueUpdate();
+
+        // TODO: ChangeServerGlobalValueNotify
+
+        return true;
+    }
+}

src/main/java/emu/grasscutter/game/ability/mixins/AbilityMixin.java

@@ -0,0 +1,10 @@
+package emu.grasscutter.game.ability.mixins;
+
+import emu.grasscutter.data.binout.AbilityMixinData;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AbilityMixin {
+    AbilityMixinData.Type value();
+}

src/main/java/emu/grasscutter/game/ability/mixins/AbilityMixinHandler.java

@@ -0,0 +1,11 @@
+package emu.grasscutter.game.ability.mixins;
+
+import com.google.protobuf.ByteString;
+import emu.grasscutter.data.binout.AbilityMixinData;
+import emu.grasscutter.game.ability.Ability;
+
+public abstract class AbilityMixinHandler {
+
+    public abstract boolean execute(
+            Ability ability, AbilityMixinData mixinData, ByteString abilityData);
+}