add third person mode

tests/tp_shots.lua

@@ -0,0 +1,198 @@
+-- Scratch driver: shots of the 3RD (third-person) rung -- the eye boomed
+-- off the back of the player's head, the player's own card drawn and turned
+-- to face it, the boom shortening against walls indoors, and the body
+-- turning to face where it walks.
+--
+--   POKEPORT_DRIVER=mods/DramaticShapeVoxelMod/tests/tp_shots.lua \
+--   SHOT_DIR=.scratchpad/tpshots lovec.exe .
+return function(game)
+  local U = dofile("tests/drivers/util.lua")
+  local Pipelines = require("src.render.Pipelines")
+
+  local ROOT = (os.getenv("SHOT_DIR") or "shots/tp")
+
+  local handle = game.mods.exports["DRAMATIC_SHAPE"]
+  if not (handle and handle.lib) then
+    print("[tp] DRAMATIC_SHAPE mod not loaded")
+    return love.event.quit()
+  end
+  local V = handle.lib
+  local FirstPerson = V.require("FirstPerson")
+  local ThirdPerson = V.require("ThirdPerson")
+  local ChunkMesher = V.require("ChunkMesher")
+  local Voxel = V.require("VoxelState")
+  local DayNight = V.require("DayNight")
+
+  pcall(os.execute, 'mkdir -p "' .. ROOT .. '" 2>/dev/null')
+  pcall(os.execute, 'mkdir "' .. ROOT:gsub("/", "\\") .. '" 2>nul')
+
+  require("src.world.OverworldController").rollEncounter = function() return nil end
+  local TileRenderer = require("src.render.TileRenderer")
+  TileRenderer.tick = function() end
+  TileRenderer.animFrame = function() return 0 end
+  DayNight.setting:sync("day")
+
+  local Zoom = require("src.render.Zoom")
+  pcall(function()
+    game.save.options.zoom = 0
+    Zoom.applyOptions(game.save.options)
+  end)
+
+  local function settle()
+    for _ = 1, 900 do
+      if ChunkMesher.pending() == 0 then break end
+      U.wait(1)
+    end
+    for _ = 1, 300 do
+      if FirstPerson.blend >= 1 and Voxel.ready
+         and ChunkMesher.pending() == 0 then break end
+      U.wait(1)
+    end
+    U.wait(40)
+  end
+
+  -- the nearest WALKABLE cell (fp_shots' helper): a guessed coordinate
+  -- inside a building footprint buries the pivot in the geometry
+  local function place(mapId, x, y)
+    U.teleport(game, mapId, x, y, "down")
+    local ow = game.stack:top()
+    local map = ow and ow.map
+    if not map or map:isWalkableCell(x, y) then return end
+    for r = 1, 8 do
+      for dy = -r, r do
+        for dx = -r, r do
+          if math.max(math.abs(dx), math.abs(dy)) == r then
+            local cx, cy = x + dx, y + dy
+            if map:inBounds(cx, cy) and map:isWalkableCell(cx, cy) then
+              U.teleport(game, mapId, cx, cy, "down")
+              print(("[tp] (%d,%d) not walkable; standing at (%d,%d)")
+                    :format(x, y, cx, cy))
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+
+  -- yaw is a world bearing: 0 south, pi/2 east, pi north, -pi/2 west
+  local SCENES = {
+    -- Pallet Town, mid-street: the player's own card seen from behind, in
+    -- each compass direction plus a diagonal (the off-grid case, where a
+    -- south-facing card would be edge-on to any orbit camera)
+    { map = "PALLET_TOWN", x = 13, y = 14, yaw = math.pi, label = "pallet_north" },
+    { map = "PALLET_TOWN", x = 13, y = 14, yaw = 0, label = "pallet_south" },
+    { map = "PALLET_TOWN", x = 9, y = 7, yaw = math.pi / 2, label = "pallet_east" },
+    { map = "PALLET_TOWN", x = 9, y = 7, yaw = 3 * math.pi / 4,
+      label = "pallet_diag" },
+    -- the shoreline: the boom over water, reflecting the player
+    { map = "PALLET_TOWN", x = 9, y = 12, yaw = 0, label = "pallet_water" },
+    -- pitched down, the classic third-person framing; and up, where the
+    -- boom has to shorten rather than bury the eye in the ground
+    { map = "PALLET_TOWN", x = 13, y = 14, yaw = math.pi,
+      pitch = math.rad(35), label = "pallet_down" },
+    { map = "PALLET_TOWN", x = 13, y = 14, yaw = math.pi,
+      pitch = -math.rad(40), label = "pallet_skyward" },
+    -- Route 1: grass and ledges, with the character in frame for scale
+    { map = "ROUTE_1", x = 10, y = 28, yaw = math.pi, label = "route1_north" },
+    -- interiors: the one place a 48px boom cannot fit, so the collision
+    -- march is the whole shot
+    { map = "VIRIDIAN_POKECENTER", x = 3, y = 5, yaw = math.pi,
+      label = "center_north" },
+    { map = "REDS_HOUSE_1F", x = 3, y = 4, yaw = math.pi,
+      label = "reds_house" },
+  }
+
+  local shots = 0
+  for _, s in ipairs(SCENES) do
+    place(s.map, s.x, s.y)
+    Pipelines.setLevel("voxel", Voxel.TP_LEVEL)
+    Pipelines.setLevel("tiltshift", 0)
+    settle()
+    FirstPerson.yaw = s.yaw
+    FirstPerson.pitch = s.pitch or FirstPerson.PITCH_DEFAULT
+    U.wait(20)
+    print(("[tp] %-16s boom %.1f of %.1f"):format(s.label, ThirdPerson.len,
+                                                  ThirdPerson.BOOM))
+    if U.shot(game, ("%s/%s.png"):format(ROOT, s.label)) then
+      shots = shots + 1
+    end
+  end
+
+  -- the slide from 1ST to 3RD: the eye walks out of the head rather than
+  -- cutting, so the halfway frame is a real camera position
+  place("PALLET_TOWN", 13, 14)
+  Pipelines.setLevel("voxel", Voxel.FP_LEVEL)
+  settle()
+  if U.shot(game, ROOT .. "/from_1st.png") then shots = shots + 1 end
+  Pipelines.setLevel("voxel", Voxel.TP_LEVEL)
+  for _ = 1, 300 do
+    if ThirdPerson.out >= 0.5 then break end
+    U.wait(1)
+  end
+  if U.shot(game, ROOT .. "/boom_mid.png") then shots = shots + 1 end
+  U.wait(60)
+  if U.shot(game, ROOT .. "/boom_out.png") then shots = shots + 1 end
+
+  -- ------- the free walk, with the body turning
+  --
+  -- Hold forward with the head yawed off-grid: the player must GLIDE (off
+  -- the 16px grid, which no grid step can do) and the body must end up
+  -- facing its own travel rather than the lens.
+  place("PALLET_TOWN", 13, 14)
+  Pipelines.setLevel("voxel", Voxel.TP_LEVEL)
+  settle()
+  local ow = game.stack:top()
+  local p = ow.player
+  FirstPerson.yaw = 3 * math.pi / 4       -- northeast, deliberately off-grid
+  FirstPerson.pitch = FirstPerson.PITCH_DEFAULT
+  local x0, y0 = p.px, p.py
+  U.hold(game, "up", 90)
+  local moved = math.abs(p.px - x0) + math.abs(p.py - y0)
+  print(("[tp] walk moved %.1f px; off-grid: %s; body faces %s (camera %s)")
+        :format(moved,
+                tostring(p.px % 16 ~= 0 or p.py % 16 ~= 0),
+                tostring(p.facing), tostring(FirstPerson.compassFacing())))
+  if U.shot(game, ROOT .. "/walked.png") then shots = shots + 1 end
+
+  -- strafing: the one case the body facing exists for. Hold RIGHT with the
+  -- head due north and the character must walk east showing its flank.
+  place("PALLET_TOWN", 13, 14)
+  settle()
+  FirstPerson.yaw = math.pi
+  U.hold(game, "right", 40)
+  print(("[tp] strafe: body faces %s, camera looks %s")
+        :format(tostring(p.facing), tostring(FirstPerson.compassFacing())))
+  if U.shot(game, ROOT .. "/strafe.png") then shots = shots + 1 end
+
+  -- ------- the spin, sampled
+  --
+  -- Stand still and turn the camera fast, sampling the frame the player's
+  -- own card actually draws every rendered frame. A standing body is
+  -- pointed along the camera's own yaw, so it must show its back the whole
+  -- way round; anything else is the sideways flick. Sampled through the
+  -- live rig, so this measures the real thing rather than the arithmetic.
+  place("PALLET_TOWN", 13, 14)
+  Pipelines.setLevel("voxel", Voxel.TP_LEVEL)
+  settle()
+  ow = game.stack:top()
+  p = ow.player
+  local seen, frames = {}, 0
+  for _ = 1, 240 do
+    FirstPerson.lookBy(math.rad(7), 0)      -- ~420 deg/s, a hard flick
+    U.wait(1)
+    local f = FirstPerson.playerFacing(p.facing, p.px + 8, p.py + 8)
+    seen[f] = (seen[f] or 0) + 1
+    frames = frames + 1
+  end
+  local report = {}
+  for f, n in pairs(seen) do
+    report[#report + 1] = ("%s x%d"):format(f, n)
+  end
+  table.sort(report)
+  print(("[tp] spin: %d frames, card frames seen: %s")
+        :format(frames, table.concat(report, ", ")))
+
+  print(("[tp] %d shots into %s"):format(shots, ROOT))
+  love.event.quit()
+end