[Et tu] Implement stat bounds

SFALL_COMPATIBILITY.md

@@ -57,7 +57,7 @@ See [`https://sfall-team.github.io/sfall/`](https://sfall-team.github.io/sfall/)
 | --- | --- | --- | --- |
 | Direct memory access| read_byte,short,int,string<br>write_byte,short,int,string<br>call_offset_vX | 🚫 | Not possible.  Open an issue if you need functionality not covered by other opcodes. |
 | Stats | get/set_pc_base_stat<br>get/set_pc_extra_stat<br>get/set_critter_base_stat<br>get/set_critter_extra_stat | ✅ | CE uses engine stat helpers here instead of sfall's direct proto-field behavior, so derived-stat update behavior can differ. |
-| Stats / Alter min/max | get/set_stat_min/max<br>set_pc_stat_min/max<br>set_npc_stat_min/max | not implemented | - |
+| Stats / Alter min/max | get/set_stat_min/max<br>set_pc_stat_min/max<br>set_npc_stat_min/max | ✅ | - |
 | Skills | get/set_critter_skill_points<br>get/set_available_skill_points<br>set_skill_max<br>set_critter_skill_mod<br>set_base_skill_mod<br>mod_skill_points_per_level | not implemented | - |
 | Graphics | graphics_funcs_available<br>force_graphics_refresh<br>get_screen_width<br>get_screen_height<br>set_palette | implemented: only get_screen_width, get_screen_height | - |
 | Shaders | load_shader<br>free_shader<br>activate_shader<br>deactivate_shader<br>set/get_shader_* | 🚫 | likely will not implement direct compatibility

sfall_testing/gl_test_stat_bounds.ssl

@@ -0,0 +1,80 @@
+#include "define_lite.h"
+#include "sfall.h"
+#include "test_utils.h"
+
+procedure start begin
+    variable original_extra;
+    variable original_value;
+    variable original_pc_max;
+    variable original_pc_min;
+    variable original_npc_max;
+    variable original_npc_min;
+    variable original_npc_luck_max;
+    variable test_npc;
+    variable test_npc_extra;
+    variable test_npc_luck;
+
+    if (not game_loaded) then return;
+
+    display_msg("Testing stat min/max...");
+    test_suite_errors := 0;
+
+    original_extra := get_pc_extra_stat(STAT_rad_resist);
+    original_value := get_critter_stat(dude_obj, STAT_rad_resist);
+    original_pc_max := get_pc_stat_max(STAT_rad_resist);
+    original_pc_min := get_pc_stat_min(STAT_rad_resist);
+    original_npc_max := get_npc_stat_max(STAT_rad_resist);
+    original_npc_min := get_npc_stat_min(STAT_rad_resist);
+
+    set_stat_max(STAT_rad_resist, 101);
+    call assertEquals("set_stat_max changes PC bound", get_pc_stat_max(STAT_rad_resist), 101);
+    call assertEquals("set_stat_max changes NPC bound", get_npc_stat_max(STAT_rad_resist), 101);
+
+    set_stat_min(STAT_rad_resist, -10);
+    call assertEquals("set_stat_min changes PC bound", get_pc_stat_min(STAT_rad_resist), -10);
+    call assertEquals("set_stat_min changes NPC bound", get_npc_stat_min(STAT_rad_resist), -10);
+
+    set_pc_extra_stat(STAT_rad_resist, 200);
+    set_pc_stat_max(STAT_rad_resist, 100);
+    call assertEquals("PC maximum changed independently", get_pc_stat_max(STAT_rad_resist), 100);
+    call assertEquals("NPC maximum unchanged by PC setter", get_npc_stat_max(STAT_rad_resist), 101);
+    call assertEquals("radiation resistance capped at 100", get_critter_stat(dude_obj, STAT_rad_resist), 100);
+
+    set_pc_extra_stat(STAT_rad_resist, -200);
+    set_pc_stat_min(STAT_rad_resist, -5);
+    call assertEquals("PC minimum changed independently", get_pc_stat_min(STAT_rad_resist), -5);
+    call assertEquals("NPC minimum unchanged by PC setter", get_npc_stat_min(STAT_rad_resist), -10);
+    call assertEquals("radiation resistance clamped to PC minimum", get_critter_stat(dude_obj, STAT_rad_resist), -5);
+
+    set_npc_stat_max(STAT_rad_resist, 99);
+    call assertEquals("NPC maximum changed independently", get_npc_stat_max(STAT_rad_resist), 99);
+    call assertEquals("PC maximum unchanged by NPC setter", get_pc_stat_max(STAT_rad_resist), 100);
+
+    set_npc_stat_min(STAT_rad_resist, -4);
+    call assertEquals("NPC minimum changed independently", get_npc_stat_min(STAT_rad_resist), -4);
+    call assertEquals("PC minimum unchanged by NPC setter", get_pc_stat_min(STAT_rad_resist), -5);
+
+    test_npc := create_object_sid(0x01000001, 0, 0, -1);
+    test_npc_extra := get_critter_extra_stat(test_npc, STAT_rad_resist);
+    set_critter_extra_stat(test_npc, STAT_rad_resist, 200);
+    call assertEquals("NPC radiation resistance uses NPC maximum", get_critter_stat(test_npc, STAT_rad_resist), 99);
+    set_critter_extra_stat(test_npc, STAT_rad_resist, test_npc_extra);
+
+    test_npc_luck := get_critter_base_stat(test_npc, STAT_lu);
+    original_npc_luck_max := get_npc_stat_max(STAT_lu);
+    set_npc_stat_max(STAT_lu, test_npc_luck - 1);
+    set_critter_base_stat(test_npc, STAT_lu, test_npc_luck + 1);
+    call assertEquals("NPC base stat rejects value above configured maximum", get_critter_base_stat(test_npc, STAT_lu), test_npc_luck);
+    set_npc_stat_max(STAT_lu, original_npc_luck_max);
+    destroy_object(test_npc);
+
+    set_pc_stat_max(STAT_rad_resist, original_pc_max);
+    set_pc_stat_min(STAT_rad_resist, original_pc_min);
+    set_npc_stat_max(STAT_rad_resist, original_npc_max);
+    set_npc_stat_min(STAT_rad_resist, original_npc_min);
+    set_pc_extra_stat(STAT_rad_resist, original_extra);
+    call assertEquals("original radiation resistance restored", get_critter_stat(dude_obj, STAT_rad_resist), original_value);
+
+    call report_test_results("stat min/max");
+    signal_close_game;
+end

src/sfall_metarules.cc

@@ -38,6 +38,7 @@
 #include "sfall_opcodes.h"
 #include "sfall_script_hooks.h"
 #include "skilldex.h"
+#include "stat.h"
 #include "text_font.h"
 #include "tile.h"
 #include "window.h"
@@ -779,6 +780,8 @@ static void mf_get_object_ai_data(OpcodeContext& ctx);
 static void mf_get_object_data(OpcodeContext& ctx);
 static void mf_get_outline(OpcodeContext& ctx);
 static void mf_get_sfall_arg_at(OpcodeContext& ctx);
+static void mf_get_stat_max(OpcodeContext& ctx);
+static void mf_get_stat_min(OpcodeContext& ctx);
 static void mf_get_terrain_name(OpcodeContext& ctx);
 static void mf_get_text_width(OpcodeContext& ctx);
 static void mf_get_window_attribute(OpcodeContext& ctx);
@@ -858,8 +861,8 @@ const MetaruleInfo kMetarules[] = {
     { "get_object_data", mf_get_object_data, 2, 2, 0, { ARG_OBJECT, ARG_INT } },
     { "get_outline", mf_get_outline, 1, 1, 0, { ARG_OBJECT } },
     { "get_sfall_arg_at", mf_get_sfall_arg_at, 1, 1, 0, { ARG_INT } },
-    // {"get_stat_max",              mf_get_stat_max,              1, 2,  0, {ARG_INT, ARG_INT}},
-    // {"get_stat_min",              mf_get_stat_min,              1, 2,  0, {ARG_INT, ARG_INT}},
+    { "get_stat_max", mf_get_stat_max, 1, 2, 0, { ARG_INT, ARG_INT } },
+    { "get_stat_min", mf_get_stat_min, 1, 2, 0, { ARG_INT, ARG_INT } },
     // {"get_string_pointer",        mf_get_string_pointer,        1, 1,  0, {ARG_STRING}}, // note: deprecated; do not implement
     { "get_terrain_name", mf_get_terrain_name, 0, 2, -1, { ARG_INT, ARG_INT } },
     { "get_text_width", mf_get_text_width, 1, 1, 0, { ARG_STRING } },
@@ -1216,6 +1219,18 @@ void mf_get_sfall_arg_at(OpcodeContext& ctx)
     ctx.setReturn(result);
 }
 
+void mf_get_stat_max(OpcodeContext& ctx)
+{
+    const bool npc = ctx.numArgs() > 1 && ctx.arg(1).asInt() != 0;
+    ctx.setReturn(statGetConfiguredMaximum(ctx.arg(0).asInt(), npc));
+}
+
+void mf_get_stat_min(OpcodeContext& ctx)
+{
+    const bool npc = ctx.numArgs() > 1 && ctx.arg(1).asInt() != 0;
+    ctx.setReturn(statGetConfiguredMinimum(ctx.arg(0).asInt(), npc));
+}
+
 void mf_get_object_ai_data(OpcodeContext& ctx)
 {
     Object* object = ctx.arg(0).asObject();

src/sfall_opcodes.cc

@@ -160,6 +160,50 @@ static void op_set_critter_extra_stat(Program* program)
     critterSetBonusStat(obj, stat, value);
 }
 
+static void op_set_stat_max(Program* program)
+{
+    int maximum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetPcMaximum(stat, maximum);
+    statSetNpcMaximum(stat, maximum);
+}
+
+static void op_set_stat_min(Program* program)
+{
+    int minimum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetPcMinimum(stat, minimum);
+    statSetNpcMinimum(stat, minimum);
+}
+
+static void op_set_pc_stat_max(Program* program)
+{
+    int maximum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetPcMaximum(stat, maximum);
+}
+
+static void op_set_pc_stat_min(Program* program)
+{
+    int minimum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetPcMinimum(stat, minimum);
+}
+
+static void op_set_npc_stat_max(Program* program)
+{
+    int maximum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetNpcMaximum(stat, maximum);
+}
+
+static void op_set_npc_stat_min(Program* program)
+{
+    int minimum = programStackPopInteger(program);
+    int stat = programStackPopInteger(program);
+    statSetNpcMinimum(stat, minimum);
+}
+
 // get_pc_base_stat
 static void op_get_pc_base_stat(Program* program)
 {
@@ -1896,11 +1940,17 @@ void sfallOpcodesInit()
     // 0x8246 - void mod_skill_points_per_level(int value)
 
     // 0x81b4 - void set_stat_max(int stat, int value)
+    interpreterRegisterOpcode(0x81B4, op_set_stat_max);
     // 0x81b5 - void set_stat_min(int stat, int value)
+    interpreterRegisterOpcode(0x81B5, op_set_stat_min);
     // 0x81b7 - void set_pc_stat_max(int stat, int value)
+    interpreterRegisterOpcode(0x81B7, op_set_pc_stat_max);
     // 0x81b8 - void set_pc_stat_min(int stat, int value)
+    interpreterRegisterOpcode(0x81B8, op_set_pc_stat_min);
     // 0x81b9 - void set_npc_stat_max(int stat, int value)
+    interpreterRegisterOpcode(0x81B9, op_set_npc_stat_max);
     // 0x81ba - void set_npc_stat_min(int stat, int value)
+    interpreterRegisterOpcode(0x81BA, op_set_npc_stat_min);
 
     // 0x816b - int  input_funcs_available() // deprecated; do not implement
     // 0x816c - int  key_pressed(int dxScancode)

src/stat.cc

@@ -98,14 +98,25 @@ static char* gStatValueDescriptions[PRIMARY_STAT_RANGE];
 // 0x6681AC curr_pc_stat
 static int gPcStatValues[PC_STAT_COUNT];
 
+static int pcStatMaximums[SAVEABLE_STAT_COUNT];
+static int pcStatMinimums[SAVEABLE_STAT_COUNT];
+static int npcStatMaximums[SAVEABLE_STAT_COUNT];
+static int npcStatMinimums[SAVEABLE_STAT_COUNT];
+
 static int unspentApBonus = 4;
 static int unspentApPerkBonus = 4;
 
+static void statResetBounds();
+static int statGetMaximum(Object* critter, int stat);
+static int statGetMinimum(Object* critter, int stat);
+
 // 0x4AED70
 int statsInit()
 {
     MessageListItem messageListItem;
 
+    statResetBounds();
+
     // NOTE: Uninline.
     pcStatsReset();
 
@@ -144,6 +155,7 @@ int statsReset()
 {
     // NOTE: Uninline.
     pcStatsReset();
+    statResetBounds();
     statResetUnspentApBonuses();
 
     return 0;
@@ -208,6 +220,72 @@ int statGetUnspentApPerkBonus()
     return unspentApPerkBonus;
 }
 
+static void statResetBounds()
+{
+    for (int stat = 0; stat < SAVEABLE_STAT_COUNT; stat++) {
+        pcStatMaximums[stat] = gStatDescriptions[stat].maximumValue;
+        pcStatMinimums[stat] = gStatDescriptions[stat].minimumValue;
+        npcStatMaximums[stat] = gStatDescriptions[stat].maximumValue;
+        npcStatMinimums[stat] = gStatDescriptions[stat].minimumValue;
+    }
+}
+
+static int statGetMaximum(Object* critter, int stat)
+{
+    return critter == gDude ? pcStatMaximums[stat] : npcStatMaximums[stat];
+}
+
+static int statGetMinimum(Object* critter, int stat)
+{
+    return critter == gDude ? pcStatMinimums[stat] : npcStatMinimums[stat];
+}
+
+int statGetConfiguredMaximum(int stat, bool npc)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        return npc ? npcStatMaximums[stat] : pcStatMaximums[stat];
+    }
+
+    return 0;
+}
+
+int statGetConfiguredMinimum(int stat, bool npc)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        return npc ? npcStatMinimums[stat] : pcStatMinimums[stat];
+    }
+
+    return 0;
+}
+
+void statSetPcMaximum(int stat, int maximum)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        pcStatMaximums[stat] = maximum;
+    }
+}
+
+void statSetPcMinimum(int stat, int minimum)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        pcStatMinimums[stat] = minimum;
+    }
+}
+
+void statSetNpcMaximum(int stat, int maximum)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        npcStatMaximums[stat] = maximum;
+    }
+}
+
+void statSetNpcMinimum(int stat, int minimum)
+{
+    if (stat >= 0 && stat < SAVEABLE_STAT_COUNT) {
+        npcStatMinimums[stat] = minimum;
+    }
+}
+
 // 0x4AEF48
 int critterGetStat(Object* critter, int stat)
 {
@@ -397,7 +475,15 @@ int critterGetStat(Object* critter, int stat)
             }
         }
 
-        value = std::clamp(value, gStatDescriptions[stat].minimumValue, gStatDescriptions[stat].maximumValue);
+        int minimum = statGetMinimum(critter, stat);
+        if (value < minimum) {
+            value = minimum;
+        } else {
+            int maximum = statGetMaximum(critter, stat);
+            if (value > maximum) {
+                value = maximum;
+            }
+        }
     } else {
         switch (stat) {
         case STAT_CURRENT_HIT_POINTS:
@@ -485,11 +571,11 @@ int critterSetBaseStat(Object* critter, int stat, int value)
             value -= traitGetStatModifier(stat);
         }
 
-        if (value < gStatDescriptions[stat].minimumValue) {
+        if (value < statGetMinimum(critter, stat)) {
             return -2;
         }
 
-        if (value > gStatDescriptions[stat].maximumValue) {
+        if (value > statGetMaximum(critter, stat)) {
             return -3;
         }
 

src/stat.h

@@ -20,6 +20,12 @@ void statSetUnspentApBonus(int multiplier);
 int statGetUnspentApBonus();
 void statSetUnspentApPerkBonus(int multiplier);
 int statGetUnspentApPerkBonus();
+int statGetConfiguredMaximum(int stat, bool npc);
+int statGetConfiguredMinimum(int stat, bool npc);
+void statSetPcMaximum(int stat, int maximum);
+void statSetPcMinimum(int stat, int minimum);
+void statSetNpcMaximum(int stat, int maximum);
+void statSetNpcMinimum(int stat, int minimum);
 int critterGetStat(Object* critter, int stat);
 int critterGetBaseStatWithTraitModifier(Object* critter, int stat);
 int critterGetBaseStat(Object* critter, int stat);