Merge pull request RobertSkalko#236 from AltimorTASDK/rework-spell-inputs

Improve spell input handling

Author: RobertSkalko

src/main/java/com/robertx22/mine_and_slash/database/data/game_balance_config/GameBalanceConfig.java

@@ -72,6 +72,8 @@ public void editForCompat() {
 
     public double MIN_SPELL_COOLDOWN_MULTI = 0.2;
 
+    public int GLOBAL_COOLDOWN_TICKS = 3;
+
     public double CRAFTED_GEAR_POTENTIAL_MULTI = 0.5;
 
     public int MAX_BONUS_SPELL_LEVELS = 5;

src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/SpellConfiguration.java

@@ -82,15 +82,7 @@ public SpellConfiguration setChargesAndRegen(String name, int charges, int ticks
         this.charge_regen = ticksToRegen;
         this.charges = charges;
         this.charge_name = name;
-
-
-        if (ticksToRegen > (20 * 30)) {
-            this.cooldown_ticks = 0; // we force the cooldown to be the same for all spells with charges so it feels consistent and good
-        } else {
-            this.cooldown_ticks = 0; // we force the cooldown to be the same for all spells with charges so it feels consistent and good
-        }
-
-
+        this.cooldown_ticks = 3; // we force the cooldown to be the same for all spells with charges so it feels consistent and good
         return this;
     }
 

src/main/java/com/robertx22/mine_and_slash/event_hooks/player/OnKeyPress.java

@@ -1,5 +1,7 @@
 package com.robertx22.mine_and_slash.event_hooks.player;
 
+import java.util.Stack;
+
 import com.robertx22.library_of_exile.main.Packets;
 import com.robertx22.mine_and_slash.config.forge.ClientConfigs;
 import com.robertx22.mine_and_slash.gui.screens.character_screen.MainHubScreen;
@@ -16,13 +18,15 @@ public class OnKeyPress {
 
     public static int cooldown = 0;
 
+    // Store what order spell keys are pressed in to prioritize most recently pressed
+    private static Stack<SpellKeybind> spellKeysPressed = new Stack<>();
 
-    public static void onEndTick(Minecraft mc) {
+    // Number of last spell sent to the server
+    private static int lastSpellNumber = -1;
+    // Timer to resend packet so the server knows we want to keep casting
+    private static int spellPacketResendTimer = 0;
 
-        if (cooldown > 0) {
-            cooldown--;
-            return;
-        }
+    public static void onEndTick(Minecraft mc) {
 
         if (mc.player == null) {
             return;
@@ -32,6 +36,12 @@ public static void onEndTick(Minecraft mc) {
             return;
         }
 
+        updateSpellInputs();
+
+        if (cooldown > 0) {
+            cooldown--;
+            return;
+        }
 
         if (KeybindsRegister.UNSUMMON.isDown()) {
             Packets.sendToServer(new UnsummonPacket());
@@ -44,46 +54,69 @@ public static void onEndTick(Minecraft mc) {
             cooldown = 5;
         } else if (KeybindsRegister.QUICK_DRINK_POTION.consumeClick()) {
             Packets.sendToServer(new QuickUsePotionPacket());
-        } else {
+        }
+    }
 
-            int number = -1;
+    private static boolean checkToAddSpellKeyPress(SpellKeybind key) {
+        if (key.key.consumeClick()) {
+            spellKeysPressed.add(key);
+            // Consume any remaining clicks
+            while (key.key.consumeClick()) {
+            }
+            return true;
+        }
+        return false;
+    }
 
-            var keys = SpellKeybind.ALL;
+    private static void updateSpellInputs() {
+        var keys = SpellKeybind.ALL;
 
-            if (ClientConfigs.getConfig().HOTBAR_SWAPPING.get()) {
-                keys = SpellKeybind.FIRST_HOTBAR_KEYS;
-            }
+        if (ClientConfigs.getConfig().HOTBAR_SWAPPING.get()) {
+            keys = SpellKeybind.FIRST_HOTBAR_KEYS;
+        }
+
+        spellKeysPressed.removeIf(key -> !key.key.isDown());
 
-            for (SpellKeybind key : keys) {
-                if (key.key.isDown()) {
-                    number = key.getIndex();
+        // Prioritize binds with modifiers in case the same key is reused but with a modifier
+        for (SpellKeybind key : keys) {
+            if (key.key.getKeyModifier() == KeyModifier.NONE) {
+                if (checkToAddSpellKeyPress(key)) {
+                    break;
                 }
             }
-            // we always use the key modifier when both are pressed but use same keybind
-            for (SpellKeybind key : keys) {
-                if (key.key.getKeyModifier() != KeyModifier.NONE && key.key.isDown()) {
-                    number = key.getIndex();
+        }
+
+        for (SpellKeybind key : keys) {
+            if (key.key.getKeyModifier() != KeyModifier.NONE) {
+                if (checkToAddSpellKeyPress(key)) {
+                    break;
                 }
             }
+        }
 
-            // try see if consuming clicks fixes the random key bugs
-            for (SpellKeybind key : SpellKeybind.ALL) {
-                key.key.consumeClick();
-            }
+        int number;
 
-            if (ClientConfigs.getConfig().HOTBAR_SWAPPING.get()) {
-                if (SpellKeybind.IS_ON_SECONd_HOTBAR) {
-                    if (number > -1) {
-                        number += 4;
-                    }
-                }
+        if (!spellKeysPressed.empty()) {
+            number = spellKeysPressed.lastElement().getIndex();
+            if (SpellKeybind.IS_ON_SECONd_HOTBAR) {
+                number += 4;
             }
+        } else {
+            number = -1;
+        }
 
-            if (number > -1) {
-                // todo make sure its not lagging servers
-                Packets.sendToServer(new TellServerToCastSpellPacket(number));
-                cooldown = 2;
+        if (number == lastSpellNumber) {
+            if (number == -1) {
+                return;
+            }
+            if (spellPacketResendTimer > 0) {
+                spellPacketResendTimer--;
+                return;
             }
         }
+
+        Packets.sendToServer(new TellServerToCastSpellPacket(number));
+        lastSpellNumber = number;
+        spellPacketResendTimer = 2;
     }
 }

src/main/java/com/robertx22/mine_and_slash/saveclasses/spells/SpellCastingData.java

@@ -4,6 +4,7 @@
 import com.robertx22.library_of_exile.util.ExplainedResult;
 import com.robertx22.mine_and_slash.a_libraries.player_animations.PlayerAnimations;
 import com.robertx22.mine_and_slash.capability.entity.EntityData;
+import com.robertx22.mine_and_slash.capability.player.data.PlayerConfigData;
 import com.robertx22.mine_and_slash.config.forge.compat.CompatConfig;
 import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffect;
 import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffectInstanceData;
@@ -32,9 +33,12 @@
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -207,13 +211,93 @@ public SkillGemData getData() {
         }
     }
 
+    private static class SpellInputBufferEntry {
+        public int number;
+        public int ticksLeft;
+
+        public SpellInputBufferEntry(int number) {
+            this.number = number;
+            this.ticksLeft = 5;
+        }
+    }
+
     public int castTickLeft = 0;
     public int castTicksDone = 0;
     public int spellTotalCastTicks = 0;
     public CalculatedSpellData calcSpell = null;
     public Boolean casting = false;
     public ChargeData charges = new ChargeData();
 
+    // Spell inputs to continuously attempt
+    transient List<SpellInputBufferEntry> spellInputBuffer = new LinkedList<>();
+    // The hotbar index of the spell key the client is holding
+    transient int spellInputNumber = -1;
+    // How many ticks left without another packet before we stop casting
+    transient int spellInputTimeoutTicks = 0;
+
+    public void onSpellInputPressed(int number) {
+        if (number != -1 && number != spellInputNumber) {
+            // Cap size to prevent DoS
+            if (spellInputBuffer.size() < 10) {
+                spellInputBuffer.add(new SpellInputBufferEntry(number));
+            }
+        }
+        spellInputNumber = number;
+        spellInputTimeoutTicks = 8;
+    }
+
+    public boolean tryStartSpellCast(Player player, Spell spell) {
+
+        var data = Load.player(player);
+        var cds = Load.Unit(player).getCooldowns();
+
+        if (player.isBlocking() || player.swinging) {
+            return false;
+        }
+
+        if (cds.isOnCooldown("global_cooldown")) {
+            return false;
+        }
+
+        if (spell != null) {
+
+            var can = canCast(spell, player);
+
+            if (can.can) {
+
+                ItemStack wep = player.getMainHandItem();
+
+                if (!wep.isEmpty() && !RepairUtils.isItemBroken(wep)) {
+                    wep.hurt(1, player.getRandom(), (ServerPlayer) player);
+                }
+
+                SpellCastContext c = new SpellCastContext(player, 0, spell);
+                setToCast(c);
+                spell.spendResources(c);
+
+                // Limit global cooldown to spell cooldown to allow rapid fire spells
+                int gcd = Math.min(GameBalanceConfig.get().GLOBAL_COOLDOWN_TICKS, spell.getCooldownTicks(c));
+                cds.setOnCooldown("global_cooldown", gcd);
+
+                data.playerDataSync.setDirty();
+                return true;
+            } else if (!cds.isOnCooldown("spell_fail")) {
+                cds.setOnCooldown("spell_fail", 40);
+                if (can.answer != null) {
+                    if (Load.Unit(player).getLevel() < 15 || Load.player(player).config.isConfigEnabled(PlayerConfigData.Config.CAST_FAIL)) {
+                        player.sendSystemMessage(Chats.CAST_FAILED.locName().append(can.answer));
+                    }
+                }
+            }
+
+        }
+        return false;
+    }
+
+    public boolean tryStartSpellCast(Player player, int number) {
+        Spell spell = Load.player(player).getSkillGemInventory().getHotbarGem(number).getSpell();
+        return tryStartSpellCast(player, spell);
+    }
 
     public void cancelCast(LivingEntity entity) {
         try {
@@ -252,11 +336,44 @@ public boolean isCasting() {
 
     transient static Spell lastSpell = null;
 
+    private void processSpellInputs(Player player) {
+
+        if (spellInputTimeoutTicks > 0) {
+            spellInputTimeoutTicks--;
+        } else {
+            // client stopped responding, don't cast forever
+            spellInputNumber = -1;
+        }
+
+        // Prune input buffer
+        for (Iterator<SpellInputBufferEntry> iterator = spellInputBuffer.iterator(); iterator.hasNext(); ) {
+            if (iterator.next().ticksLeft-- == 0) {
+                iterator.remove();
+            }
+        }
+
+        // See if any buffered inputs succeed
+        for (Iterator<SpellInputBufferEntry> iterator = spellInputBuffer.iterator(); iterator.hasNext(); ) {
+            if (tryStartSpellCast(player, iterator.next().number)) {
+                iterator.remove();
+                return;
+            }
+        }
+
+        // If not, try held input
+        if (spellInputNumber != -1) {
+            tryStartSpellCast(player, spellInputNumber);
+        }
+    }
+
     public void onTimePass(LivingEntity entity) {
 
-        try {
+        if (entity instanceof ServerPlayer player) {
+            processSpellInputs(player);
+        }
 
-            if (isCasting()) {
+        if (isCasting()) {
+            try {
                 Spell spell = this.calcSpell.getSpell();
 
                 SpellCastContext ctx = new SpellCastContext(entity, castTicksDone, spell);
@@ -291,15 +408,13 @@ public void onTimePass(LivingEntity entity) {
 
                     this.calcSpell = null;
                 }
-            } else {
-
-                lastSpell = null;
+            } catch (Exception e) {
+                e.printStackTrace();
+                this.cancelCast(entity);
+                // cancel when error, cus this is called on tick, so it doesn't crash servers when 1 spell fails
             }
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            this.cancelCast(entity);
-            // cancel when error, cus this is called on tick, so it doesn't crash servers when 1 spell fails
+        } else {
+            lastSpell = null;
         }
     }