feat: add physics settings, input binding profile management, and RPG state serialization to settings menu

Author: S1mplector

core/src/main/java/com/jvn/core/input/ActionBindingProfileStore.java

@@ -0,0 +1,39 @@
+package com.jvn.core.input;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * Utility to persist/retrieve ActionBindingProfile from disk.
+ */
+public class ActionBindingProfileStore {
+  private final Path path;
+
+  public ActionBindingProfileStore(String path) {
+    this.path = Paths.get(path == null || path.isBlank() ? defaultPath() : path);
+  }
+
+  public ActionBindingProfile load() {
+    try {
+      if (!Files.exists(path)) return new ActionBindingProfile();
+      String data = Files.readString(path);
+      return ActionBindingProfile.deserialize(data);
+    } catch (IOException e) {
+      return new ActionBindingProfile();
+    }
+  }
+
+  public void save(ActionBindingProfile profile) throws IOException {
+    if (profile == null) return;
+    Files.createDirectories(path.getParent());
+    Files.writeString(path, profile.serialize());
+  }
+
+  public String getPath() { return path.toString(); }
+
+  public static String defaultPath() {
+    return System.getProperty("user.home") + "/.jvn/input-bindings.properties";
+  }
+}

core/src/main/java/com/jvn/core/menu/MainMenuScene.java

@@ -49,7 +49,10 @@ public void activateSelected() {
     switch (selected) {
       case 0 -> startNewGame();
       case 1 -> engine.scenes().push(new LoadMenuScene(engine, saveManager, defaultScriptName, settingsModel, audio));
-      case 2 -> engine.scenes().push(new SettingsScene(settingsModel, audio));
+      case 2 -> {
+        com.jvn.core.input.ActionBindingProfile profile = com.jvn.core.input.ActionBindingProfile.deserialize(settingsModel.getInputProfileSerialized());
+        engine.scenes().push(new SettingsScene(settingsModel, audio, profile));
+      }
       case 3 -> engine.stop();
     }
   }
@@ -70,11 +73,19 @@ private void startNewGame() {
     s.setAutoPlayDelay(settingsModel.getAutoPlayDelay());
     s.setSkipUnreadText(settingsModel.isSkipUnreadText());
     s.setSkipAfterChoices(settingsModel.isSkipAfterChoices());
+    s.setPhysicsFixedStepMs(settingsModel.getPhysicsFixedStepMs());
+    s.setPhysicsMaxSubSteps(settingsModel.getPhysicsMaxSubSteps());
+    s.setPhysicsDefaultFriction(settingsModel.getPhysicsDefaultFriction());
+    s.setInputProfilePath(settingsModel.getInputProfilePath());
+    s.setInputProfileSerialized(settingsModel.getInputProfileSerialized());
     if (audio != null) {
       audio.setBgmVolume(s.getBgmVolume());
       audio.setSfxVolume(s.getSfxVolume());
       audio.setVoiceVolume(s.getVoiceVolume());
     }
+    if (engine != null) {
+      engine.setFixedUpdateStepMs(settingsModel.getPhysicsFixedStepMs(), settingsModel.getPhysicsMaxSubSteps());
+    }
     engine.scenes().push(vnScene);
   }
 

core/src/main/java/com/jvn/core/menu/SettingsScene.java

@@ -2,23 +2,36 @@
 
 import com.jvn.core.audio.AudioFacade;
 import com.jvn.core.scene.Scene;
+import com.jvn.core.input.ActionBindingProfile;
+import com.jvn.core.input.ActionBindingProfileStore;
 import com.jvn.core.vn.VnSettings;
 import com.jvn.core.vn.VnSettingsStore;
 
 public class SettingsScene implements Scene {
   private final VnSettings settings;
   private final AudioFacade audio; // optional, to apply volumes live
   private int selected = 0;
+  private ActionBindingProfile bindings;
+  private String bindingStatus = "";
 
-  public SettingsScene(VnSettings settings) { this(settings, null); }
+  public SettingsScene(VnSettings settings) { this(settings, null, null); }
 
-  public SettingsScene(VnSettings settings, AudioFacade audio) {
+  public SettingsScene(VnSettings settings, AudioFacade audio) { this(settings, audio, null); }
+
+  public SettingsScene(VnSettings settings, AudioFacade audio, ActionBindingProfile bindings) {
     this.settings = settings;
     this.audio = audio;
+    if (bindings != null) {
+      this.bindings = bindings;
+    } else if (settings != null && settings.getInputProfileSerialized() != null && !settings.getInputProfileSerialized().isBlank()) {
+      this.bindings = ActionBindingProfile.deserialize(settings.getInputProfileSerialized());
+    } else {
+      this.bindings = new ActionBindingProfile();
+    }
   }
 
   public VnSettings model() { return settings; }
-  public int itemCount() { return 7; }
+  public int itemCount() { return 11; }
 
   public int getSelected() { return selected; }
   public void moveSelection(int delta) {
@@ -50,16 +63,22 @@ public void adjustCurrent(int delta) {
       case 4 -> settings.setAutoPlayDelay(settings.getAutoPlayDelay() + delta * 100L);
       case 5 -> settings.setSkipUnreadText(!settings.isSkipUnreadText());
       case 6 -> settings.setSkipAfterChoices(!settings.isSkipAfterChoices());
+      case 7 -> settings.setPhysicsFixedStepMs(Math.max(0, settings.getPhysicsFixedStepMs() + delta * 5));
+      case 8 -> settings.setPhysicsMaxSubSteps(Math.max(1, settings.getPhysicsMaxSubSteps() + delta));
+      case 9 -> settings.setPhysicsDefaultFriction(settings.getPhysicsDefaultFriction() + delta * 0.05);
+      case 10 -> {
+        // save profile when adjusting right, load when adjusting left
+        if (delta > 0) saveBindingsToDisk();
+        else loadBindingsFromDisk();
+      }
       default -> {}
     }
   }
 
   public void toggleCurrent() {
-    if (selected == 5) {
-      settings.setSkipUnreadText(!settings.isSkipUnreadText());
-    } else if (selected == 6) {
-      settings.setSkipAfterChoices(!settings.isSkipAfterChoices());
-    }
+    if (selected == 5) settings.setSkipUnreadText(!settings.isSkipUnreadText());
+    else if (selected == 6) settings.setSkipAfterChoices(!settings.isSkipAfterChoices());
+    else if (selected == 10) loadBindingsFromDisk();
   }
 
   @Override
@@ -84,6 +103,13 @@ public void setValueByIndex(int idx, double value01) {
       }
       case 5 -> settings.setSkipUnreadText(v >= 0.5);
       case 6 -> settings.setSkipAfterChoices(v >= 0.5);
+      case 7 -> settings.setPhysicsFixedStepMs(Math.round(v * 50)); // 0..50 ms
+      case 8 -> settings.setPhysicsMaxSubSteps(1 + (int) Math.round(v * 7)); // 1..8
+      case 9 -> settings.setPhysicsDefaultFriction(v);
+      case 10 -> {
+        // slider not used; interpret >0.5 as save
+        if (v > 0.5) saveBindingsToDisk(); else loadBindingsFromDisk();
+      }
       default -> {}
     }
     // Live-apply volumes
@@ -100,4 +126,26 @@ public void onExit() {
       new VnSettingsStore().save(settings);
     } catch (Exception ignored) {}
   }
+
+  public String getBindingStatus() { return bindingStatus; }
+
+  public void loadBindingsFromDisk() {
+    ActionBindingProfileStore store = new ActionBindingProfileStore(settings.getInputProfilePath());
+    bindings = store.load();
+    settings.setInputProfileSerialized(bindings.serialize());
+    bindingStatus = "Loaded from " + store.getPath();
+  }
+
+  public ActionBindingProfile getBindings() { return bindings; }
+
+  private void saveBindingsToDisk() {
+    ActionBindingProfileStore store = new ActionBindingProfileStore(settings.getInputProfilePath());
+    try {
+      store.save(bindings);
+      settings.setInputProfileSerialized(bindings.serialize());
+      bindingStatus = "Saved to " + store.getPath();
+    } catch (Exception e) {
+      bindingStatus = "Save failed";
+    }
+  }
 }

core/src/main/java/com/jvn/core/rpg/CombatInteractionSystem.java

@@ -0,0 +1,70 @@
+package com.jvn.core.rpg;
+
+import com.jvn.core.math.Rect;
+import com.jvn.core.physics.PhysicsWorld2D;
+import com.jvn.core.tween.TweenRunner;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class CombatInteractionSystem {
+  public static class Hitbox {
+    public String id;
+    public int team;
+    public Rect bounds = new Rect();
+  }
+
+  public static class DamagePopup {
+    public String text;
+    public double x, y;
+    public double alpha = 1.0;
+    public double lifetimeMs = 800;
+    public double elapsedMs = 0;
+  }
+
+  private final PhysicsWorld2D world;
+  private final List<Hitbox> hitboxes = new ArrayList<>();
+  private final List<DamagePopup> popups = new ArrayList<>();
+  private final TweenRunner tweens;
+
+  public CombatInteractionSystem(PhysicsWorld2D world, TweenRunner tweens) {
+    this.world = world;
+    this.tweens = tweens;
+  }
+
+  public void registerHitbox(Hitbox hb) { if (hb != null) hitboxes.add(hb); }
+  public void clearHitboxes() { hitboxes.clear(); }
+
+  public List<Hitbox> getTargetsAt(double x, double y, int attackerTeam) {
+    List<Hitbox> out = new ArrayList<>();
+    for (Hitbox hb : hitboxes) {
+      if (hb.team == attackerTeam) continue;
+      if (hb.bounds.contains(x, y)) out.add(hb);
+    }
+    return out;
+  }
+
+  public void spawnDamagePopup(String text, double x, double y) {
+    DamagePopup p = new DamagePopup();
+    p.text = text;
+    p.x = x;
+    p.y = y;
+    popups.add(p);
+  }
+
+  public List<DamagePopup> getPopups() { return popups; }
+
+  public void update(long deltaMs) {
+    if (deltaMs <= 0) return;
+    Iterator<DamagePopup> it = popups.iterator();
+    while (it.hasNext()) {
+      DamagePopup p = it.next();
+      p.elapsedMs += deltaMs;
+      double t = Math.min(1.0, p.elapsedMs / p.lifetimeMs);
+      p.alpha = 1.0 - t;
+      p.y -= deltaMs * 0.02; // float up
+      if (p.elapsedMs >= p.lifetimeMs) it.remove();
+    }
+  }
+}

core/src/main/java/com/jvn/core/rpg/Combatant.java

@@ -0,0 +1,30 @@
+package com.jvn.core.rpg;
+
+import java.io.Serializable;
+
+public class Combatant implements Serializable {
+  private String id;
+  private RpgStats stats = new RpgStats();
+  private double atb;
+  private int team; // 0 player, 1 enemy, etc.
+  private boolean actedThisRound;
+
+  public Combatant() {}
+  public Combatant(String id, RpgStats stats, int team) {
+    this.id = id;
+    if (stats != null) this.stats = stats;
+    this.team = team;
+  }
+
+  public String getId() { return id; }
+  public void setId(String id) { this.id = id; }
+  public RpgStats getStats() { return stats; }
+  public void setStats(RpgStats stats) { if (stats != null) this.stats = stats; }
+  public double getAtb() { return atb; }
+  public void setAtb(double atb) { this.atb = atb; }
+  public int getTeam() { return team; }
+  public void setTeam(int team) { this.team = team; }
+  public boolean hasActedThisRound() { return actedThisRound; }
+  public void setActedThisRound(boolean actedThisRound) { this.actedThisRound = actedThisRound; }
+  public double getSpeed() { return stats == null ? 0 : stats.getSpeed(); }
+}

core/src/main/java/com/jvn/core/rpg/Equipment.java

@@ -0,0 +1,19 @@
+package com.jvn.core.rpg;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Equipment implements Serializable {
+  private final Map<String, String> slots = new HashMap<>();
+
+  public Map<String, String> getSlots() { return slots; }
+
+  public void set(String slot, String itemId) {
+    if (slot == null || slot.isBlank()) return;
+    if (itemId == null || itemId.isBlank()) slots.remove(slot);
+    else slots.put(slot, itemId);
+  }
+
+  public String get(String slot) { return slots.get(slot); }
+}

core/src/main/java/com/jvn/core/rpg/Inventory.java

@@ -0,0 +1,39 @@
+package com.jvn.core.rpg;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Inventory implements Serializable {
+  private int slots;
+  private final Map<String, Integer> itemCounts = new HashMap<>();
+
+  public int getSlots() { return slots; }
+  public void setSlots(int slots) { this.slots = Math.max(0, slots); }
+
+  public Map<String, Integer> getItemCounts() { return Collections.unmodifiableMap(itemCounts); }
+
+  public int getCount(String itemId) {
+    if (itemId == null) return 0;
+    return itemCounts.getOrDefault(itemId, 0);
+  }
+
+  public boolean add(String itemId, int count) {
+    if (itemId == null || itemId.isBlank() || count <= 0) return false;
+    boolean hasItem = itemCounts.containsKey(itemId);
+    if (slots > 0 && !hasItem && itemCounts.size() >= slots) return false;
+    itemCounts.put(itemId, getCount(itemId) + count);
+    return true;
+  }
+
+  public boolean remove(String itemId, int count) {
+    if (itemId == null || itemId.isBlank() || count <= 0) return false;
+    int existing = getCount(itemId);
+    if (existing < count) return false;
+    int remaining = existing - count;
+    if (remaining <= 0) itemCounts.remove(itemId);
+    else itemCounts.put(itemId, remaining);
+    return true;
+  }
+}

core/src/main/java/com/jvn/core/rpg/Item.java

@@ -0,0 +1,27 @@
+package com.jvn.core.rpg;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Item implements Serializable {
+  public enum Type { CONSUMABLE, EQUIPMENT, KEY }
+
+  private String id;
+  private String name;
+  private String description;
+  private Type type = Type.CONSUMABLE;
+  private Map<String, Double> modifiers = new HashMap<>();
+
+  public String getId() { return id; }
+  public void setId(String id) { this.id = id; }
+  public String getName() { return name; }
+  public void setName(String name) { this.name = name; }
+  public String getDescription() { return description; }
+  public void setDescription(String description) { this.description = description; }
+  public Type getType() { return type; }
+  public void setType(Type type) { this.type = type == null ? Type.CONSUMABLE : type; }
+
+  public Map<String, Double> getModifiers() { return modifiers; }
+  public void setModifiers(Map<String, Double> modifiers) { this.modifiers = modifiers == null ? new HashMap<>() : modifiers; }
+}