Added Features and Restructured Vibration States

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/AbstractVibrationState.java

@@ -0,0 +1,128 @@
+package com.therainbowville.minegasm.common;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import com.therainbowville.minegasm.config.ClientConfig;
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+// Architecture inspired from https://github.com/Fyustorm/mInetiface
+public abstract class AbstractVibrationState
+{
+
+    protected static final org.apache.logging.log4j.Logger LOGGER = LogManager.getLogger();
+    protected final float streakCountdownAmount;
+    protected float intensity;
+
+    protected float vibrationCountdown;
+    protected float vibrationFeedbackCountdown;
+
+    protected AbstractVibrationState(float streakSeconds)
+    {
+        streakCountdownAmount = streakSeconds;
+        vibrationCountdown = 0;
+        vibrationFeedbackCountdown = 0;
+        intensity = 0;
+    }
+
+    public void onTick()
+    {
+        if (accumulationEnabled())
+        {
+            if (vibrationCountdown > 0)
+                vibrationCountdown--;
+            else if (intensity > 0) {
+                intensity = Math.max(0, intensity - 5);
+                vibrationCountdown = streakCountdownAmount * MinegasmConfig.ticksPerSecond;
+            }
+        } else {
+            vibrationCountdown = Math.max(0, vibrationCountdown - 1);        
+        }
+
+        vibrationFeedbackCountdown = Math.max(0, vibrationFeedbackCountdown - 1);
+    }
+
+    public void resetState()
+    {
+        vibrationCountdown = 0;
+        vibrationFeedbackCountdown = 0;
+        intensity = 0;
+    }
+
+    protected static boolean accumulationEnabled()
+    {
+        return MinegasmConfig.mode.equals(ClientConfig.GameplayMode.ACCUMULATION);
+    }
+
+    public static int getIntensity(String type) {
+        Map<String, Integer> normal = new HashMap<>();
+        normal.put("attack", 60);
+        normal.put("hurt", 0);
+        normal.put("mine", 80);
+        normal.put("place", 20);
+        normal.put("xpChange", 100);
+        normal.put("harvest", 10);
+        normal.put("fishing", 50);
+        normal.put("vitality", 0);
+        normal.put("advancement", 100);
+
+        Map<String, Integer> masochist = new HashMap<>();
+        masochist.put("attack", 0);
+        masochist.put("hurt", 100);
+        masochist.put("mine", 0);
+        masochist.put("place", 0);
+        masochist.put("xpChange", 0);
+        masochist.put("fishing", 0);
+        masochist.put("harvest", 0);
+        masochist.put("vitality", 10);
+        masochist.put("advancement", 0);
+
+        Map<String, Integer> hedonist = new HashMap<>();
+        hedonist.put("attack", 60);
+        hedonist.put("hurt", 10);
+        hedonist.put("mine", 80);
+        hedonist.put("place", 20);
+        hedonist.put("xpChange", 100);
+        hedonist.put("fishing", 50);
+        hedonist.put("harvest", 20);
+        hedonist.put("vitality", 10);
+        hedonist.put("advancement", 100);
+
+        Map<String, Integer> accumulation = new HashMap<>();
+        accumulation.put("attack", 1);
+        accumulation.put("hurt", 1);
+        accumulation.put("mine", 1);
+        accumulation.put("place", 1);
+        accumulation.put("xpChange", 1);
+        accumulation.put("fishing", 50);
+        accumulation.put("harvest", 10);
+        accumulation.put("vitality", 0);
+        accumulation.put("advancement", 1);
+
+        Map<String, Integer> custom = new HashMap<>();
+        custom.put("attack", MinegasmConfig.attackIntensity);
+        custom.put("hurt", MinegasmConfig.hurtIntensity);
+        custom.put("mine", MinegasmConfig.mineIntensity);
+        custom.put("place", MinegasmConfig.placeIntensity);
+        custom.put("xpChange", MinegasmConfig.xpChangeIntensity);
+        custom.put("fishing", MinegasmConfig.fishingIntensity);
+        custom.put("harvest", MinegasmConfig.harvestIntensity);
+        custom.put("vitality", MinegasmConfig.vitalityIntensity);
+        custom.put("advancement", MinegasmConfig.advancementIntensity);
+
+
+        return switch (MinegasmConfig.mode)
+        {
+            case NORMAL -> normal.get(type);
+            case MASOCHIST -> masochist.get(type);
+            case HEDONIST -> hedonist.get(type);
+            case ACCUMULATION -> accumulation.get(type);
+            case CUSTOM -> custom.get(type);
+        };
+    }
+
+    public abstract int getIntensity();
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateAdvancement.java

@@ -0,0 +1,47 @@
+package com.therainbowville.minegasm.common;
+
+import net.minecraft.advancements.FrameType;
+import net.minecraft.advancements.Advancement;
+import net.minecraftforge.event.entity.player.AdvancementEvent;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateAdvancement extends AbstractVibrationState
+{
+    public VibrationStateAdvancement()
+    {
+        super(0);
+    }
+
+    public void onAdvancement(AdvancementEvent event)
+    {
+        if (getIntensity("advancement") == 0) return;
+    try {
+        LOGGER.info("Advancement Event: " + event);
+        Advancement advancement = event.getAdvancement();
+        if (advancement == null) return;
+        FrameType type = advancement.getDisplay().getFrame();
+        int duration = switch (type) {
+            case TASK -> 5;
+            case GOAL -> 7;
+            case CHALLENGE -> 10;
+        };
+
+        vibrationCountdown = duration * MinegasmConfig.ticksPerSecond;
+        vibrationFeedbackCountdown = 1.5f * MinegasmConfig.ticksPerSecond;
+    } catch (Throwable e) {
+            LOGGER.throwing(e);
+    }
+    }
+
+    public int getIntensity()
+    {
+        if (accumulationEnabled())
+            return Math.toIntExact(Math.round(intensity));
+        else if (vibrationFeedbackCountdown > 0)
+            return Math.min(100, getIntensity("advancement") + 20);
+        else if (vibrationCountdown > 0)
+            return getIntensity("advancement");
+        else return 0;
+    }
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateAttack.java

@@ -0,0 +1,37 @@
+package com.therainbowville.minegasm.common;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateAttack extends AbstractVibrationState
+{
+    public VibrationStateAttack()
+    {
+        super(3);
+    }
+
+    public void onAttack()
+    {
+        if (getIntensity("attack") == 0) return;
+
+        if (accumulationEnabled())
+        {
+            intensity = Math.min(100, intensity + 5);
+            vibrationCountdown = streakCountdownAmount * MinegasmConfig.ticksPerSecond;
+            vibrationFeedbackCountdown = 1 * 0;
+        } else {
+            vibrationCountdown = 3 * MinegasmConfig.ticksPerSecond;
+            vibrationFeedbackCountdown = 1 * MinegasmConfig.ticksPerSecond;
+        }
+    }
+
+    public int getIntensity()
+    {
+        if (accumulationEnabled())
+            return Math.toIntExact(Math.round(intensity));
+        else if (vibrationFeedbackCountdown > 0)
+            return Math.min(100, getIntensity("attack") + 20);
+        else if (vibrationCountdown > 0)
+            return getIntensity("attack");
+        else return 0;
+    }
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateClient.java

@@ -0,0 +1,24 @@
+package com.therainbowville.minegasm.common;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateClient extends AbstractVibrationState
+{
+    public VibrationStateClient()
+    {
+        super(0);
+    }
+
+    public void setVibration(int intensity, int durationSeconds)
+    {
+        intensity = intensity;
+        vibrationCountdown = durationSeconds * MinegasmConfig.ticksPerSecond;
+    }
+
+    public int getIntensity()
+    {
+        if (vibrationCountdown > 0)
+            return Math.toIntExact(Math.round(intensity));
+        else return 0;
+    }
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateFish.java

@@ -0,0 +1,37 @@
+package com.therainbowville.minegasm.common;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateFish extends AbstractVibrationState
+{
+    public VibrationStateFish()
+    {
+        super(0);
+    }
+
+    public void onTick(Player player)
+    {
+        if (player.fishing != null)
+        {
+            Vec3 vector = player.fishing.getDeltaMovement();
+            double x = vector.x();
+            double y = vector.y();
+            double z = vector.z();
+            if (y < -0.075 && !player.level.getFluidState(player.fishing.blockPosition()).isEmpty() && x == 0 && z == 0)
+            {
+                vibrationCountdown = 1.5f * MinegasmConfig.ticksPerSecond;
+                LOGGER.info("Fishing!");
+            }
+        }
+    }
+
+    public int getIntensity()
+    {
+        if (vibrationCountdown > 0)
+            return getIntensity("fishing");
+        else return 0;
+    }
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateHarvest.java

@@ -0,0 +1,32 @@
+package com.therainbowville.minegasm.common;
+
+import net.minecraft.world.level.block.state.BlockState;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateHarvest extends AbstractVibrationState
+{
+    private VibrationStateMine mineState;
+
+    public VibrationStateHarvest(VibrationStateMine state)
+    {
+        super(0);
+        mineState = state;
+    }
+
+	public void onHarvest() {
+        vibrationCountdown = 3;
+        mineState.onHarvest();
+	}
+
+    public int getIntensity()
+    {
+        if (vibrationCountdown > 0){
+            if (accumulationEnabled())
+                return Math.min(100, mineState.getIntensity() + 20);
+            else 
+                return getIntensity("harvest");            
+        }
+        else return 0;
+    }
+}

forge/fg-6.0/1.18.2/src/main/java/com/therainbowville/minegasm/common/VibrationStateHurt.java

@@ -0,0 +1,36 @@
+package com.therainbowville.minegasm.common;
+
+import com.therainbowville.minegasm.config.MinegasmConfig;
+
+public class VibrationStateHurt extends AbstractVibrationState
+{
+    public VibrationStateHurt()
+    {
+        super(3);
+    }
+
+	public void onHurt() {
+        if (getIntensity("hurt") == 0) return;
+
+        if (accumulationEnabled())
+        {
+            intensity = Math.min(100, intensity + 10);
+            vibrationCountdown = streakCountdownAmount * MinegasmConfig.ticksPerSecond;
+            vibrationFeedbackCountdown = 1 * MinegasmConfig.ticksPerSecond;
+        } else {
+            vibrationCountdown = 3 * MinegasmConfig.ticksPerSecond;
+            vibrationFeedbackCountdown = 1 * MinegasmConfig.ticksPerSecond;
+        }
+	}
+
+    public int getIntensity()
+    {
+        if (accumulationEnabled())
+            return Math.toIntExact(Math.round(intensity));
+        else if (vibrationFeedbackCountdown > 0)
+            return Math.min(100, getIntensity("hurt") + 20);
+        else if (vibrationCountdown > 0)
+            return getIntensity("hurt");
+        else return 0;
+    }
+}