G2 support

src/world/gen2/Map.lua

@@ -0,0 +1,304 @@
+-- Gen 2 runtime map: block grid + COLL_* quads (not Gen 1 walkable lists).
+-- Coordinates are unpadded cells (extract stores width×height blocks as-is;
+-- WRAM's 3-block border is not mirrored here).
+
+local Permissions = require("src.world.gen2.Permissions")
+
+local Map = {}
+Map.__index = Map
+
+local DELTA = { up = { 0, -1 }, down = { 0, 1 }, left = { -1, 0 }, right = { 1, 0 } }
+Map.DELTA = DELTA
+
+function Map.new(def, tileset)
+  local self = setmetatable({}, Map)
+  self.def = def
+  self.id = def.id
+  self.tileset = tileset
+  self.width = def.width
+  self.height = def.height
+  self.widthCells = def.width * 2
+  self.heightCells = def.height * 2
+  self.blocks = def.blocks
+  self.borderBlock = def.borderBlock or 0
+  self.collision = tileset.collision
+  self.warps = def.warps or {}
+  self.connections = def.connections or {}
+  -- A Gen 1 mod reads conn.map; a Gold extraction may only carry conn.mapId,
+  -- which is why World.computeNeighbors:514 reads both.  Normalise here so
+  -- one read answers on either cache.
+  for _, conn in pairs(self.connections) do
+    if type(conn) == "table" and conn.map == nil then conn.map = conn.mapId end
+  end
+  -- Warp lookup by cell.
+  self._warpAt = {}
+  for i, w in ipairs(self.warps) do
+    self._warpAt[w.y * 1024 + w.x] = { index = i, def = w }
+  end
+  return self
+end
+
+function Map:inBounds(cx, cy)
+  return cx >= 0 and cy >= 0
+     and cx < self.widthCells and cy < self.heightCells
+end
+
+function Map:blockId(bx, by)
+  if bx < 0 or by < 0 or bx >= self.width or by >= self.height then
+    return self.borderBlock
+  end
+  return self.blocks[by * self.width + bx + 1] or 0
+end
+
+-- COLL_* byte for cell (cx, cy).  Block id 0 is impassable sentinel
+-- (GetCoordTileCollision .nope → $ff).
+function Map:cellCollision(cx, cy)
+  local bx, by = math.floor(cx / 2), math.floor(cy / 2)
+  local id = self:blockId(bx, by)
+  if id == 0 then return 0xff end
+  local quad = self.collision and self.collision[id + 1]
+  if not quad then return 0xff end
+  local lx, ly = cx % 2, cy % 2
+  return quad[ly * 2 + lx + 1] or 0xff
+end
+
+function Map:isWalkable(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isWalkable(self:cellCollision(cx, cy))
+end
+
+-- ------- the shared cell vocabulary a mod binds to
+--
+-- Same four names src/world/Map.lua answers, so one mod's placement and
+-- behaviour code reads either generation's map (mod.world hands this object
+-- out, and a mod that guards on `map.isWalkableCell and ...` otherwise
+-- silently concludes every cell is walkable, dry and grassless).  Gen 1
+-- answers from tile ids and a per-tileset set; Gold answers from the COLL_*
+-- byte, which is the same question asked of a different grid.
+
+-- The Gen 1 name for "the byte that decides this cell".  Gold's is the
+-- collision quad entry, not a tile id, so the ids are NOT comparable across
+-- generations: use the predicates, not the number.
+local warnedCellTile = false
+
+function Map:cellTile(cx, cy)
+  -- Loud once, because the call SUCCEEDS and the number is plausible: a mod
+  -- comparing it to 0x52 (Gen 1 grass) or 0x14 (water) gets a wrong answer
+  -- with nothing to show for it.  No Gen 2 caller reaches this name.
+  if not warnedCellTile then
+    warnedCellTile = true
+    require("src.core.Logger").warn(
+      "Map:cellTile on Gold returns a COLL_* byte, not a Gen 1 tile id; the "
+      .. "two number spaces are unrelated -- use the cell predicates")
+  end
+  return self:cellCollision(cx, cy)
+end
+
+function Map:isWalkableCell(cx, cy)
+  return self:isWalkable(cx, cy)
+end
+
+function Map:isWaterCell(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isWater(self:cellCollision(cx, cy))
+end
+
+-- Off-map cells never count as grass, for the reason Gen 1 guards the same
+-- way (src/world/Map.lua:224): the border block is filler scenery.
+function Map:isGrassCell(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isGrass(self:cellCollision(cx, cy))
+end
+
+function Map:warpAt(cx, cy)
+  return self._warpAt[cy * 1024 + cx]
+end
+
+-- Three more Gen 1 spellings, for the reason the four above exist: a mod
+-- guarding on `map.isCounterCell and ...` otherwise sees no counter anywhere.
+function Map:warpAtCell(cx, cy)
+  return self:warpAt(cx, cy)
+end
+
+function Map:isCounterCell(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isCounter(self:cellCollision(cx, cy))
+end
+
+-- Gen 1 asks this of a def plus the outdoor tileset set; Gold's header says
+-- so outright, so the second argument is ignored.
+function Map.isOutside(def, _tilesets)
+  local env = def and def.environment
+  return env == "TOWN" or env == "ROUTE"
+end
+
+-- Gen 1 keeps isOutdoor NARROWER than isOutside (src/world/Map.lua:148, :155);
+-- Gold decides both from the header's environment byte, so they collapse.
+function Map.isOutdoor(def)
+  if def and def.outdoor ~= nil then return def.outdoor end
+  return Map.isOutside(def)
+end
+
+-- src/world/Map.lua:176 verbatim: def.region, else the id prefix.  Gold's
+-- defs carry no region, so the prefix arm is the live one.
+function Map.inRegion(def, region, prefix)
+  if not def then return false end
+  if def.region ~= nil then return def.region == region end
+  return prefix ~= nil and def.id ~= nil and def.id:find(prefix, 1, true) == 1
+end
+
+-- Gen 1 asks the SPRITE NAME (src/world/Map.lua:191); on Gold a boulder is
+-- the STRENGTH_BOULDER movement byte (src/world/gen2/Npc.lua:56), so a
+-- sprite-name test here would answer false for every real boulder.
+function Map.isPushable(objDef)
+  if not objDef then return false end
+  if objDef.pushable ~= nil then return objDef.pushable end
+  return objDef.movement == 0x19
+end
+
+-- ------- the Gen 1 spellings that read a raw def
+--
+-- Gen 1 answers these from tile ids and the tileset's walkable list; Gold
+-- answers from the COLL_* quad, which lives on the TILESET either way, so an
+-- unloaded neighbour (a connection crossing) can be asked without a Map.
+
+-- The cell's COLL_* byte off a raw def.  NOT a tile id: the number space is
+-- unrelated to Gen 1's, so compare with the predicates below, never a literal.
+function Map.defCellTile(def, tilesetDef, cx, cy)
+  if not (def and tilesetDef and tilesetDef.collision and def.blocks) then
+    return nil
+  end
+  local bx, by = math.floor(cx / 2), math.floor(cy / 2)
+  local id
+  if bx < 0 or by < 0 or bx >= def.width or by >= def.height then
+    id = def.borderBlock or 0
+  else
+    id = def.blocks[by * def.width + bx + 1] or 0
+  end
+  if id == 0 then return 0xff end
+  local quad = tilesetDef.collision[id + 1]
+  if not quad then return 0xff end
+  return quad[(cy % 2) * 2 + (cx % 2) + 1] or 0xff
+end
+
+function Map.defIsWalkableCell(def, tilesetDef, cx, cy)
+  local coll = Map.defCellTile(def, tilesetDef, cx, cy)
+  if coll == nil then return false end
+  return Permissions.isWalkable(coll)
+end
+
+function Map.defIsWaterCell(def, tilesetDef, cx, cy)
+  local coll = Map.defCellTile(def, tilesetDef, cx, cy)
+  if coll == nil then return false end
+  return Permissions.isWater(coll)
+end
+
+-- Fails CLOSED on missing data, for the reason src/world/Map.lua:104 does:
+-- no data means we cannot prove the landing is safe, so the step bumps.
+function Map.defPassable(def, tilesetDef, cx, cy, surfing)
+  if not (def and tilesetDef and tilesetDef.collision and def.blocks) then
+    return false
+  end
+  if Map.defIsWalkableCell(def, tilesetDef, cx, cy) then return true end
+  if surfing then
+    local coll = Map.defCellTile(def, tilesetDef, cx, cy)
+    return coll ~= nil and Permissions.surfable(coll) ~= nil
+  end
+  return false
+end
+
+-- ------- the Gen 1 instance spellings a mod calls on world.map
+
+-- Gen 1's name for blockId, same border extension (src/world/Map.lua:196).
+function Map:blockAt(bx, by)
+  return self:blockId(bx, by)
+end
+
+-- Writes the block grid in place and nothing else, exactly as
+-- src/world/Map.lua:247 does.  The VISIBLE edit is World:changeBlock, which
+-- also records the blockEdits undo a map reload restores from -- a bare write
+-- here leaves a Cut tree gone forever.
+function Map:setBlock(bx, by, block)
+  if bx < 0 or by < 0 or bx >= self.width or by >= self.height then return end
+  self.blocks[by * self.width + bx + 1] = block
+end
+
+-- Graphics tile id on the 8px grid, border-extended: the same math
+-- World:bgTileAt (src/world/gen2/World.lua:7728) does in pixels.  Gen 2
+-- blocks are 4x4 tiles too, so src/world/Map.lua:204's index math ports
+-- unchanged.  Border cells read the border block, not BorderFill.blockFor.
+function Map:tileAt(tx, ty)
+  local blocks = self.tileset and self.tileset.blocks
+  if not blocks then return nil end
+  local id = self:blockId(math.floor(tx / 4), math.floor(ty / 4))
+  local block = blocks[id + 1]
+  if not block then return nil end
+  return block[(ty % 4) * 4 + (tx % 4) + 1]
+end
+
+-- Gold has no door TILE set: a door is a warp collision kind.  This is the
+-- narrow arm (a door walked INTO), so a floor mat does not answer true.
+function Map:isDoorTileCell(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isImmediateWarp(self:cellCollision(cx, cy))
+end
+
+-- Gen 1 spells this as two sets (doors OR warp-activating tiles); Gold's
+-- warp collision kinds are that union already.
+function Map:isWarpTileCell(cx, cy)
+  if not self:inBounds(cx, cy) then return false end
+  return Permissions.isWarpCollision(self:cellCollision(cx, cy))
+end
+
+-- Coordinate-only, so it cannot apply the facing and event filters
+-- World:bgEventAt (src/world/gen2/World.lua:7084) applies: it reports bg
+-- events the engine would not read.  The record is a bgEvent, not a Gen 1
+-- sign -- sign.text is nil on Gold.
+function Map:signAtCell(cx, cy)
+  for _, ev in ipairs(self.def and self.def.bgEvents or {}) do
+    if ev.x == cx and ev.y == cy then return ev end
+  end
+  return nil
+end
+
+-- GetMovementPermissions (home/map.asm): may a step `dir` LEAVE (cx, cy)?
+--
+-- Two refusals, both invisible to a plain walkable test.  The STANDING tile's
+-- side-wall kind blocks its own directions (on an UP_WALL you cannot move up).
+-- And Gold's four neighbour arms each set the FACE_DOWN bit when the adjacent
+-- tile is their wall kind, so a matching neighbour -- on real maps, an UP_WALL
+-- below -- forbids the DOWN step.  This is what ends an Ice Path slide on the
+-- last ice cell above the $b2 strip instead of gliding onto it, and that rest
+-- chain is the only route to HM07 WATERFALL.  See Permissions.sideBlocks /
+-- neighborBlocksDown for the cart derivation.
+function Map:stepPermitted(cx, cy, dir)
+  return Permissions.stepPermitted(
+    function(x, y) return self:cellCollision(x, y) end, cx, cy, dir)
+end
+
+function Map:connection(dir)
+  return self.connections[dir]
+end
+
+-- Destination cell after stepping off this edge onto a connected map.
+-- Same strip math as Gen 1 (offset is in blocks).  Returns nil if no conn.
+function Map.connectionLanding(def, conn, dir, fromCx, fromCy)
+  if not (def and conn) then return nil end
+  local destW, destH = def.width * 2, def.height * 2
+  local offset = conn.offset or 0
+  local x, y
+  if dir == "up" then
+    x, y = fromCx - offset * 2, destH - 1
+  elseif dir == "down" then
+    x, y = fromCx - offset * 2, 0
+  elseif dir == "left" then
+    x, y = destW - 1, fromCy - offset * 2
+  else
+    x, y = 0, fromCy - offset * 2
+  end
+  x = math.max(0, math.min(destW - 1, x))
+  y = math.max(0, math.min(destH - 1, y))
+  return x, y
+end
+
+return Map