Apply changes from #63 (Anime-Game-Servers/Grasscutter-Quests)

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

@@ -0,0 +1,47 @@
+package emu.grasscutter.game.ability;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import emu.grasscutter.data.binout.AbilityData;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.server.event.entity.EntityDamageEvent;
+import emu.grasscutter.utils.Utils;
+import lombok.Getter;
+
+public final class Ability {
+    @Getter private AbilityData data;
+    @Getter private GameEntity owner;
+
+    @Getter private AbilityManager manager;
+    @Getter private Map<String, AbilityModifierController> modifiers
+        = new HashMap<>();
+
+    @Getter private int hash;
+
+    public Ability(AbilityData data, GameEntity owner) {
+        this.data = data;
+        this.owner = owner;
+        this.manager = owner.getScene().getWorld().getHost().getAbilityManager();
+        this.hash = Utils.abilityHash(data.abilityName);
+
+        data.initialize();
+    }
+
+    public void onAdded() {
+        if (this.data.onAdded == null) return;
+        for (var action : data.onAdded) {
+            this.manager.executeAction(this, action);
+        }
+    }
+
+    public void onRemoved() {
+        var tempModifiers = new HashMap<>(this.modifiers);
+        tempModifiers.values().forEach(AbilityModifierController::onRemoved);
+    }
+
+    public void onBeingHit(EntityDamageEvent event) {
+        var tempModifiers = new HashMap<>(this.modifiers);
+        tempModifiers.values().forEach(m -> m.onBeingHit(event));
+    }
+}

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

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

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

@@ -0,0 +1,7 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+
+public abstract class AbilityActionHandler {
+    public abstract boolean execute(Ability ability, AbilityModifierAction action);
+}

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

@@ -0,0 +1,65 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import lombok.AllArgsConstructor;
+
+import java.util.Map;
+
+public final class AbilityLocalIdGenerator {
+    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 (var action : actions) {
+            actionIndex++;
+            long id = GetLocalId();
+            localIdToAction.put((int) id, action);
+        }
+
+        actionIndex = 0;
+    }
+
+    public long GetLocalId() {
+        switch (type) {
+            case ACTION -> {
+                return type.value + (configIndex << 3) + (actionIndex << 9);
+            }
+            case MIXIN -> {
+                return type.value + (mixinIndex << 3) + (configIndex << 9) + (actionIndex << 15);
+            }
+            case MODIFIER_ACTION -> {
+                return type.value + (modifierIndex << 3) + (configIndex << 9) + (actionIndex << 15);
+            }
+            case MODIFIER_MIXIN -> {
+                return type.value + (modifierIndex << 3) + (mixinIndex << 9) + (configIndex << 15) + (actionIndex << 21);
+            }
+            case NONE -> Grasscutter.getLogger().error("Ability local id generator using NONE type.");
+        }
+
+        return -1;
+    }
+
+    @AllArgsConstructor
+    public enum ConfigAbilitySubContainerType {
+        NONE(0),
+        ACTION(1),
+        MIXIN(2),
+        MODIFIER_ACTION(3),
+        MODIFIER_MIXIN(4);
+
+        public final long value;
+    }
+}

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

@@ -1,7 +1,9 @@
 package emu.grasscutter.game.ability;
 
 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.AbilityModifier.AbilityModifierAction;
 import emu.grasscutter.data.binout.AbilityModifierEntry;
 import emu.grasscutter.game.entity.EntityGadget;
@@ -10,30 +12,89 @@ 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.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 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;
 
 public final class AbilityManager extends BasePlayerManager {
-    HealAbilityManager healAbilityManager;
+    public static final ExecutorService eventExecutor;
+
+    static {
+        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;
 
     @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);
+
+        for (var obj : handlerClasses) {
+            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);
+            }
+        }
+    }
+
+    public void executeAction(Ability ability, AbilityModifierAction action) {
+        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)) {
+                Grasscutter.getLogger().debug("exec ability action failed {} at {}", action.type, ability);
+            }
+        });
     }
 
     public void onAbilityInvoke(AbilityInvokeEntry invoke) throws Exception {
         this.healAbilityManager.healHandler(invoke);
 
-        // Grasscutter.getLogger().info(invoke.getArgumentType() + " (" + invoke.getArgumentTypeValue()
-        // + "): " + Utils.bytesToHex(invoke.toByteArray()));
+        if (invoke.getEntityId() == 67109298) {
+            Grasscutter.getLogger().info(invoke.getArgumentType() + " (" + invoke.getArgumentTypeValue() + "): " + invoke.getEntityId());
+        }
+
         switch (invoke.getArgumentType()) {
             case ABILITY_INVOKE_ARGUMENT_META_OVERRIDE_PARAM -> this.handleOverrideParam(invoke);
             case ABILITY_INVOKE_ARGUMENT_META_REINIT_OVERRIDEMAP -> this.handleReinitOverrideMap(invoke);
@@ -41,6 +102,9 @@ 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_ADD_NEW_ABILITY -> this.handleAddNewAbility(invoke);
+            case ABILITY_INVOKE_ARGUMENT_NONE -> this.handleInvoke(invoke);
             default -> {}
         }
     }
@@ -97,41 +161,75 @@ 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().debug("{} {} {}", 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().warn("-> {}", ability.getData().localIdToAction);
+                var action = ability.getData().localIdToAction.get(head.getLocalId());
+                if(action != null) ability.getManager().executeAction(ability, action);
+            }
+
+            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);
+        });
+    }
+
     private void handleOverrideParam(AbilityInvokeEntry invoke) throws Exception {
-        GameEntity entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
 
         if (entity == null) {
             return;
         }
 
-        AbilityScalarValueEntry entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
-
+        var entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
         entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
     }
 
     private void handleReinitOverrideMap(AbilityInvokeEntry invoke) throws Exception {
-        GameEntity entity = this.player.getScene().getEntityById(invoke.getEntityId());
+        var entity = this.player.getScene().getEntityById(invoke.getEntityId());
 
         if (entity == null) {
             return;
         }
 
-        AbilityMetaReInitOverrideMap map =
-                AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
-
-        for (AbilityScalarValueEntry entry : map.getOverrideMapList()) {
+        var map = AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
+        for (var entry : map.getOverrideMapList()) {
             entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
         }
     }
 
     private void handleModifierChange(AbilityInvokeEntry invoke) throws Exception {
         // Sanity checks
-        GameEntity target = this.player.getScene().getEntityById(invoke.getEntityId());
+        var target = this.player.getScene().getEntityById(invoke.getEntityId());
         if (target == null) {
             return;
         }
 
-        AbilityMetaModifierChange data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
+        var data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
         if (data == null) {
             return;
         }
@@ -146,12 +244,32 @@ public final class AbilityManager extends BasePlayerManager {
         }
 
         // Sanity checks
-        AbilityInvokeEntryHead head = invoke.getHead();
-        if (head == null) {
-            return;
+        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);
+                }
+            }
         }
 
-        GameEntity sourceEntity = this.player.getScene().getEntityById(data.getApplyEntityId());
+        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) {
             return;
         }
@@ -243,4 +361,60 @@ public final class AbilityManager extends BasePlayerManager {
             default -> {}
         }
     }
+
+    private void handleModifierDurabilityChange(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+        var target = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (target == null) {
+            return;
+        }
+
+        var data = AbilityMetaModifierDurabilityChange.parseFrom(invoke.getAbilityData());
+        if (data == null) {
+            return;
+        }
+
+        var head = invoke.getHead();
+        if (head == null) {
+            return;
+        }
+
+        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) {
+            return;
+}
+
+        if(data.getAbility().getAbilityName().getHash() != 0) Grasscutter.getLogger().warn("Instancing {} in to {}", data.getAbility().getAbilityName().getHash(), data.getAbility().getInstancedAbilityId());
+        else Grasscutter.getLogger().warn("Instancing {} in to {}", data.getAbility().getAbilityName().getStr(), data.getAbility().getInstancedAbilityId());
+
+        GameEntity target = this.player.getScene().getEntityById(invoke.getEntityId());
+        if (target == null) {
+            return;
+        }
+
+        target.getInstanceToHash().put(data.getAbility().getInstancedAbilityId(), data.getAbility().getAbilityName().getHash());
+        target.getInstanceToName().put(data.getAbility().getInstancedAbilityId(), data.getAbility().getAbilityName().getStr());
+    }
+
+    public void addAbilityToEntity(GameEntity entity, String name) {
+        var data = GameData.getAbilityData(name);
+        if(data != null)
+            addAbilityToEntity(entity, data, name);
+    }
+
+    public void addAbilityToEntity(GameEntity entity, AbilityData abilityData, String id) {
+        var ability = new Ability(abilityData, entity);
+        entity.getAbilities().put(id, ability);
+
+        ability.onAdded();
+    }
 }

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

@@ -0,0 +1,63 @@
+package emu.grasscutter.game.ability;
+
+import emu.grasscutter.data.binout.AbilityModifier;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.server.event.entity.EntityDamageEvent;
+import lombok.Getter;
+import lombok.Setter;
+
+public final class AbilityModifierController {
+    @Getter private AbilityModifier data;
+
+    @Getter private Ability ability; //Owner ability instance
+
+    @Getter private float elementDurability;
+
+    @Getter @Setter private int localId;
+
+    public AbilityModifierController(Ability ability, AbilityModifier data) {
+        this.ability = ability;
+        this.data = data;
+        this.elementDurability = data.elementDurability.get();
+    }
+
+    public void setElementDurability(float durability) {
+        this.elementDurability = durability;
+
+        if (durability <= 0) {
+            onRemoved();
+            ability.getModifiers().values().removeIf(a -> a == this);
+        }
+    }
+
+    public void onAdded() {
+        if (data.onAdded == null) return;
+
+        for (AbilityModifierAction action : data.onAdded) {
+            ability.getManager().executeAction(ability, action);
+        }
+    }
+
+    public void onRemoved() {
+        if (data.onRemoved == null) return;
+
+        for (AbilityModifierAction action : data.onRemoved) {
+            ability.getManager().executeAction(ability, action);
+        }
+    }
+
+    public void onBeingHit(EntityDamageEvent event) {
+        if (data.onBeingHit != null)
+            for (var action : data.onBeingHit) {
+                ability.getManager().executeAction(ability, action);
+            }
+
+        if (event.getAttackElementType().equals(data.elementType)) {
+            elementDurability -= event.getDamage();
+            if(elementDurability <= 0) {
+                onRemoved();
+                ability.getModifiers().values().removeIf(a -> a == this);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package emu.grasscutter.game.ability.actions;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.data.common.DynamicFloat;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.ability.AbilityAction;
+import emu.grasscutter.game.ability.AbilityActionHandler;
+import emu.grasscutter.game.ability.AbilityModifierController;
+
+@AbilityAction(AbilityModifierAction.Type.ApplyModifier)
+public final class ActionApplyModifier extends AbilityActionHandler {
+    @Override
+    public boolean execute(Ability ability, AbilityModifierAction action) {
+        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()
+                .anyMatch(m -> m.getData().equals(modifierData))) {
+            return true;
+        }
+
+        var modifier = new AbilityModifierController(ability, modifierData);
+        ability.getModifiers().put(action.modifierName, modifier);
+        modifier.onAdded();
+
+        if(modifierData.duration != DynamicFloat.ZERO) {
+            Grasscutter.getGameServer().getScheduler().scheduleAsyncTask(() -> {
+                try {
+                    Thread.sleep((int)(modifierData.duration.get() * 1000));
+                    modifier.onRemoved();
+                } catch (InterruptedException ignored) {
+                    Grasscutter.getLogger().error("Failed to schedule ability modifier async task.");
+                }
+            });
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.game.ability.actions;
+
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.game.ability.Ability;
+import emu.grasscutter.game.ability.AbilityAction;
+import emu.grasscutter.game.ability.AbilityActionHandler;
+import emu.grasscutter.game.entity.GameEntity;
+
+@AbilityAction(AbilityModifierAction.Type.ExecuteGadgetLua)
+public final class ActionExecuteGadgetLua extends AbilityActionHandler {
+    @Override
+    public boolean execute(Ability ability, AbilityModifierAction action) {
+        var owner = ability.getOwner();
+
+        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/ActionKillSelf.java

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

src/main/java/emu/grasscutter/game/activity/ActivityHandler.java

@@ -71,11 +71,11 @@ public abstract class ActivityHandler {
                 .forEach(
                         condGroupId -> {
                             var condGroup = GameData.getActivityCondGroupMap().get((int) condGroupId);
-                            condGroup
-                                    .getCondIds()
-                                    .forEach(
-                                            condition ->
-                                                    questManager.queueEvent(QuestCond.QUEST_COND_ACTIVITY_COND, condition));
+                            if (condGroup != null) condGroup
+                                .getCondIds()
+                                .forEach(
+                                    condition ->
+                                        questManager.queueEvent(QuestCond.QUEST_COND_ACTIVITY_COND, condition));
                         });
     }
 

src/main/java/emu/grasscutter/game/entity/EntityGadget.java

@@ -2,6 +2,7 @@ package emu.grasscutter.game.entity;
 
 import emu.grasscutter.data.GameData;
 import emu.grasscutter.data.binout.config.ConfigEntityGadget;
+import emu.grasscutter.data.binout.config.fields.ConfigAbilityData;
 import emu.grasscutter.data.excels.GadgetData;
 import emu.grasscutter.game.entity.gadget.*;
 import emu.grasscutter.game.entity.gadget.platform.BaseRoute;
@@ -100,8 +101,26 @@ public class EntityGadget extends EntityBaseGadget {
             String controllerName = GameData.getGadgetMappingMap().get(gadgetId).getServerController();
             this.setEntityController(EntityControllerScriptManager.getGadgetController(controllerName));
         }
+
+        this.addConfigAbilities();
     }
 
+    private void addConfigAbilities(){
+        if(this.configGadget != null && this.configGadget.getAbilities() != null) {
+            for (var ability : this.configGadget.getAbilities()) {
+                this.addConfigAbility(ability);
+            }
+        }
+    }
+
+    private void addConfigAbility(ConfigAbilityData abilityData){
+        var data = GameData.getAbilityData(abilityData.getAbilityName());
+        if(data != null)
+            getScene().getWorld().getHost().getAbilityManager().addAbilityToEntity(
+                this, data, abilityData.getAbilityID());
+    }
+
+
     public void setState(int state) {
         this.state = state;
         // Cache the gadget state

src/main/java/emu/grasscutter/game/entity/GameEntity.java

@@ -1,5 +1,6 @@
 package emu.grasscutter.game.entity;
 
+import emu.grasscutter.game.ability.Ability;
 import emu.grasscutter.game.player.Player;
 import emu.grasscutter.game.props.ElementType;
 import emu.grasscutter.game.props.FightProperty;
@@ -26,6 +27,9 @@ import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
 import lombok.Getter;
 import lombok.Setter;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public abstract class GameEntity {
     @Getter private final Scene scene;
     @Getter protected int id;
@@ -48,6 +52,10 @@ public abstract class GameEntity {
     // Abilities
     private Object2FloatMap<String> metaOverrideMap;
     private Int2ObjectMap<String> metaModifiers;
+    private Map<Integer, Integer> instanceToHash;
+    private Int2ObjectMap<String> instanceToName;
+
+    @Getter private Map<String, Ability> abilities = new HashMap<>();
 
     public GameEntity(Scene scene) {
         this.scene = scene;
@@ -86,6 +94,22 @@ public abstract class GameEntity {
         return this.metaModifiers;
     }
 
+    public Map<Integer, Integer> getInstanceToHash() {
+        if (this.instanceToHash == null) {
+            this.instanceToHash = new HashMap<>();
+        }
+
+        return this.instanceToHash;
+    }
+
+    public Int2ObjectMap<String> getInstanceToName() {
+        if (this.instanceToName == null) {
+            this.instanceToName = new Int2ObjectOpenHashMap<>();
+        }
+
+        return this.instanceToName;
+    }
+
     public abstract Int2FloatMap getFightProperties();
 
     public abstract Position getPosition();
@@ -189,7 +213,9 @@ public abstract class GameEntity {
             this.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, 0f);
             isDead = true;
         }
+
         this.runLuaCallbacks(event);
+        this.runAbilityCallbacks(event);
 
         // Packets
         this.getScene()
@@ -213,6 +239,15 @@ public abstract class GameEntity {
         }
     }
 
+    /**
+     * Runs the ability callbacks for {@link EntityDamageEvent}.
+     *
+     * @param event The damage event.
+     */
+    public void runAbilityCallbacks(EntityDamageEvent event) {
+        this.abilities.values().forEach(ability -> ability.onBeingHit(event));
+    }
+
     /**
      * Move this entity to a new position.
      *

src/main/java/emu/grasscutter/game/player/Player.java

@@ -169,6 +169,8 @@ public class Player {
     @Getter private transient PlayerProgressManager progressManager;
     @Getter private transient SatiationManager satiationManager;
 
+    @Getter @Setter private transient Position lastCheckedPosition = null;
+
     // Manager data (Save-able to the database)
     @Getter private transient Achievements achievements;
     private PlayerProfile playerProfile;  // Getter has null-check

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

@@ -330,16 +330,30 @@ public final class Scene {
         addEntities(entities, VisionType.VISION_TYPE_BORN);
     }
 
+    private static <T> List<List<T>> chopped(List<T> list, final int L) {
+        List<List<T>> parts = new ArrayList<List<T>>();
+        final int N = list.size();
+        for (int i = 0; i < N; i += L) {
+            parts.add(new ArrayList<T>(
+                list.subList(i, Math.min(N, i + L)))
+            );
+        }
+        return parts;
+    }
+
     public synchronized void addEntities(
             Collection<? extends GameEntity> entities, VisionType visionType) {
         if (entities == null || entities.isEmpty()) {
             return;
         }
-        for (GameEntity entity : entities) {
+
+        for (var entity : entities) {
             this.addEntityDirectly(entity);
         }
 
-        this.broadcastPacket(new PacketSceneEntityAppearNotify(entities, visionType));
+        for(var l : chopped(new ArrayList<>(entities), 100)) {
+            this.broadcastPacket(new PacketSceneEntityAppearNotify(l, visionType));
+        }
     }
 
     private GameEntity removeEntityDirectly(GameEntity entity) {