Merge pull request #45 from MHFU-ModKit/fix/port-hit-reload

fix(framework): a re-exported hit table applies as a new export

Author: sp00ktober

framework/lua/lib/mhfu_port.lua

@@ -174,6 +174,10 @@ P.act_set = act_set
 local Port = {}
 Port.__index = Port
 
+-- What a redefine keeps: the spawn event that bound `ent` will not fire again (ent = 0 would stop
+-- the brain), and the hit tables in the game belong to the entity, not to the declaration.
+local KEEP = { "ent", "_hit_id", "_hit_last", "_hit_cap", "_atk_caps" }
+
 --- Declare a ported monster.
 --
 --   name    identifier, also the hot-reload key
@@ -190,16 +194,14 @@ Port.__index = Port
 --
 -- Returns a port handle. Safe to call again (hot reload): the injector is armed once per boot.
 function P.define(spec)
-  -- a redefine keeps the bound entity: the spawn event that bound it will not fire again, and
-  -- ent = 0 would stop the brain. The rest of the state resets.
   local prev = P.ports[spec.name]
   local self = setmetatable({
     name    = spec.name,
     species = spec.species,
     clips   = spec.clips or {},
     moves   = spec.moves or {},
     replace = spec.replace or {},
-    ent     = prev and prev.ent or 0,
+    ent     = 0,
     clip    = nil,      -- currently latched executor a1, nil = hands off
     move    = nil,      -- currently scripted move name
     pinned  = nil,      -- {x, y, z} while the coordinate lock is on
@@ -214,6 +216,7 @@ function P.define(spec)
     _native_armed = false,
     _req    = nil,      -- a play() issued through the seam, until it lands
   }, Port)
+  if prev then for _, k in ipairs(KEEP) do self[k] = prev[k] end end
   -- declared pairs the engine enters on its own get the port's clip too (the action hook paints
   -- them), so the mapping holds whoever picked the move; first name wins for a pair declared twice
   local names = {}
@@ -511,7 +514,8 @@ end
 -- in the quest, but beside a native of the same species this re-skins the native too.
 --
 -- Applied once the entity is live in-area, re-checked every tick against one record and one grid
--- byte, and re-applied with a log line if either changed (an overlay reload shows up here).
+-- byte, and re-applied with a log line if either changed (an overlay reload shows up here) or a
+-- re-export registers a new content id.
 --
 -- Attacks go the other way: a handler spawns an attack by id, and ATTACK_RECORD `id` at
 -- attack_tables.records names a volume set (VOLUME_SET), reached through the overlay's pointer
@@ -541,9 +545,7 @@ P._hit = P._hit or {}         -- port name -> table, from the generated module
 --- x states} | nil }. Keyed by PORT name so the data module and the brain module
 --- can load in either order; the tick joins them.
 function P.hit(name, tbl)
-  P._hit[name] = tbl
-  local port = P.ports[name]
-  if port then port._hit_id = nil end       -- a re-export applies on the next tick
+  P._hit[name] = tbl            -- a new id applies on the next tick (hit_tick)
   local nsets = 0
   if tbl.attack_sets then for _ in pairs(tbl.attack_sets) do nsets = nsets + 1 end end
   log("[port:%s] hit tables registered: %s volume(s), %s grid state(s), %d attack "
@@ -776,18 +778,20 @@ local function hit_apply(port, tbl)
 end
 
 --- Called from the tick for a live, in-area port. Applies on the first
---- opportunity and whenever the live bytes stop matching.
+--- opportunity, on a new export id and whenever the live bytes stop matching.
 local function hit_tick(port)
   local tbl = P._hit[port.name]
   if not tbl then return end
   if port._hit_id == tbl.id and hit_intact(port, tbl) then return end
-  local why = port._hit_id == tbl.id and "live table changed under us"
-           or (port._hit_id and "new export" or "first contact")
+  -- _hit_id is what is in place (nil after a failed apply, so it retries); _hit_last names
+  -- what got in last, for the log
+  local id = tostring(tbl.id)
+  local why = port._hit_last == nil and "first contact"
+           or (port._hit_last == id and "live table changed under us" or "new export")
   local ok, what = hit_apply(port, tbl)
   if ok then
-    port._hit_id = tbl.id
-    log("[port:%s] HIT TABLES APPLIED (%s): %s  id=%s", port.name, why, what,
-        tostring(tbl.id))
+    port._hit_id, port._hit_last = tbl.id, id
+    log("[port:%s] HIT TABLES APPLIED (%s): %s  id=%s", port.name, why, what, id)
   else
     port._hit_id = nil
     if (port._hit_fail or 0) % 20 == 0 then
@@ -822,6 +826,7 @@ P._once.events = true
 mhfu.on_quest_targets_building(function(quest)
   if quest == 0 then return end
   for name, port in pairs(P.ports) do
+    port._hit_last = nil        -- the quest's first hit apply logs as first contact
     for _, victim in ipairs(port.replace) do
       if mhfu.quest_has(quest, victim) then
         local ok = mhfu.quest_replace_monster(quest, victim, port.species)

framework/tests/test_mhfu_port.py

@@ -101,6 +101,12 @@ def memory(lua: Any) -> None:
         mhfu.write_u16 = function(x, v) wr(x, v); wr(x + 1, v >> 8) end
         mhfu.read_u32 = function(x) return mhfu.read_u16(x) | mhfu.read_u16(x + 2) << 16 end
         mhfu.write_u32 = function(x, v) mhfu.write_u16(x, v); mhfu.write_u16(x + 2, v >> 16) end
+        mhfu.read_f32 = function(x)
+          return (string.unpack("<f", string.pack("<I4", mhfu.read_u32(x))))
+        end
+        mhfu.write_f32 = function(x, v)
+          mhfu.write_u32(x, (string.unpack("<I4", string.pack("<f", v))))
+        end
         mhfu.mem_valid = function(x) return x >= {RAM.start} and x < {RAM.stop} end
         mhfu.get_screen_state = function() return 17 end
         mhfu.get_area_index = function() return 99 end
@@ -351,6 +357,64 @@ def test_native_seam(lua: Any) -> None:
     lua.execute(NATIVE)
 
 
+HIT_RELOAD = """
+local QUEST
+mhfu.on_quest_targets_building = function(fn) QUEST = fn end
+local P = require("mhfu_port")
+local HV = mhfu.addr.HIT_VOLUME
+-- a host hurtbox set of 3 records and one attack set of 2, each sentinel-terminated
+local SET, VT, ASET = ENT + 0x4000, ENT + 0x5000, ENT + 0x6000
+local row = mhfu.addr.SPECIES_TABLE + 75 * mhfu.addr.SPECIES.STRIDE
+mhfu.write_u32(row + mhfu.addr.SPECIES.HURTBOX_SET, SET)
+mhfu.write_u32(VT, ASET)
+for i = 0, 2 do mhfu.write_u16(SET + i * HV.SIZE, 1) end
+mhfu.write_u16(SET + 3 * HV.SIZE, 0xFFFF)
+for i = 0, 1 do mhfu.write_u16(ASET + i * HV.SIZE, 1) end
+mhfu.write_u16(ASET + 2 * HV.SIZE, 0xFFFF)
+local zin = P.define{ name = "zinogre", species = 75 }
+zin.ent = ENT
+-- a hot-reloaded <name>_hit.lua re-runs this; 4 volumes over a cap of 3 are truncated
+local function export(id, radius)
+  local v = { 2, 0, 0, 1, 0, radius, 0, 0, 0, 0, 0, 0 }
+  P.hit("zinogre", { species = 75, id = id, volumes = { v, v, v, v },
+                     attack_tables = { volumes = VT, n_sets = 1 },
+                     attack_sets = { [0] = { cap = 2, volumes = { v } } } })
+end
+local function radius() return mhfu.read_f32(SET + HV.RADIUS) end
+
+export("599b6933", 100.0); ticks(2)
+assert(count("APPLIED %(first contact%).*id=599b6933") == 1 and radius() == 100.0)
+export("73527c5b", 200.0); ticks(2)
+assert(count("APPLIED %(new export%).*id=73527c5b") == 1 and radius() == 200.0)
+export("73527c5b", 200.0); ticks(2)
+assert(count("APPLIED") == 2, "the same id is not re-applied")
+export("599b6933", 100.0); ticks(1)
+assert(count("APPLIED %(new export%).*id=599b6933") == 1 and radius() == 100.0)
+mhfu.write_f32(SET + HV.RADIUS, 5.0); ticks(1)
+assert(count("APPLIED %(live table changed under us%)") == 1 and radius() == 100.0)
+assert(count("first contact") == 1)
+
+-- a brain-mod reload redefines the port: what is in place stays in place
+local before = zin
+zin = P.define{ name = "zinogre", species = 75 }
+for _, k in ipairs({ "ent", "_hit_id", "_hit_last", "_hit_cap", "_atk_caps" }) do
+  assert(zin[k] ~= nil and zin[k] == before[k], k)
+end
+ticks(2)
+assert(count("APPLIED") == 4, "not re-applied after a redefine")
+
+-- the next quest loads the overlay afresh: its first apply is first contact again
+QUEST(1)
+mhfu.write_f32(SET + HV.RADIUS, 5.0); ticks(1)
+assert(count("APPLIED %(first contact%).*id=599b6933") == 2 and radius() == 100.0)
+"""
+
+
+def test_hit_reload(lua: Any) -> None:
+    memory(lua)
+    lua.execute(HIT_RELOAD)
+
+
 def test_fits_the_file_buffer() -> None:
     """lua_host reads a script through one buffer and skips a bigger one at boot."""
     import re