mirror of
https://github.com/bryanthaboi/gen1recomp
synced 2026-09-26 13:33:27 -04:00
bryanthaboi
119 lines
4.3 KiB
Lua
119 lines
4.3 KiB
Lua
-- engine/overworld/healing_machine.asm:74
|
|
-- color/data/spritepalettes.asm:2
|
|
|
|
package.path = "./?.lua;./?/init.lua;" .. package.path
|
|
if not _G.love then _G.love = require("tests.love_stub") end
|
|
|
|
local S = require("tests.harness").suite("heal machine palette #1986")
|
|
local check, eq = S.check, S.eq
|
|
|
|
local GameVersion = require("src.core.GameVersion")
|
|
local PaletteFX = require("src.render.PaletteFX")
|
|
local OW = require("src.world.OverworldController")
|
|
|
|
local function upvalue(fn, want)
|
|
local i = 1
|
|
while true do
|
|
local n, v = debug.getupvalue(fn, i)
|
|
if not n then return nil end
|
|
if n == want then return v end
|
|
i = i + 1
|
|
end
|
|
end
|
|
|
|
local prevVer = GameVersion.get()
|
|
local prevMode = PaletteFX.mode
|
|
|
|
GameVersion.set("red")
|
|
PaletteFX.setMode("redpp")
|
|
|
|
eq(PaletteFX.HEAL_MACHINE_GROUP, 4, "the heal machine wears OBJ palette 4")
|
|
|
|
local obp = PaletteFX.healMachineObp and PaletteFX.healMachineObp()
|
|
check(type(obp) == "table" and #obp == 4,
|
|
"Advanced resolves a 4-color heal-machine palette")
|
|
obp = obp or { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }
|
|
eq(obp[1][1], 222, "shade 0 is the pack's light green (R)")
|
|
eq(obp[2][1], 255, "shade 1 is orange (R)")
|
|
eq(obp[2][2], 156, "shade 1 is orange (G)")
|
|
eq(obp[2][3], 82, "shade 1 is orange (B)")
|
|
eq(obp[3][1], 247, "shade 2 is red (R)")
|
|
eq(obp[3][2], 82, "shade 2 is red (G)")
|
|
eq(obp[3][3], 49, "shade 2 is red (B)")
|
|
eq(obp[4][1], 0, "shade 3 stays black")
|
|
check(obp[2][1] ~= obp[3][1] or obp[2][2] ~= obp[3][2],
|
|
"the two ball shades are not the same color")
|
|
|
|
local grays = PaletteFX.GRAYS
|
|
for i = 1, 4 do
|
|
check(obp[i][1] ~= grays[i][1] or obp[i][2] ~= grays[i][2]
|
|
or obp[i][3] ~= grays[i][3] or i == 4,
|
|
"shade " .. (i - 1) .. " is not a DMG gray")
|
|
end
|
|
|
|
local healShader = upvalue(OW.drawWorld, "healMachineShader")
|
|
check(type(healShader) == "function",
|
|
"the heal overlay picks its palette through healMachineShader")
|
|
|
|
local realShader, realSend = PaletteFX.shader, PaletteFX.sendColors
|
|
local realSetShader = love.graphics.setShader
|
|
local STUB = { stub = true }
|
|
local sent, bound
|
|
PaletteFX.shader = function() return STUB end
|
|
PaletteFX.sendColors = function(_, colors) sent = colors end
|
|
love.graphics.setShader = function(s) bound = s end
|
|
|
|
local function beat(visible)
|
|
sent, bound = nil, nil
|
|
local s = healShader(visible)
|
|
return s, sent, bound
|
|
end
|
|
|
|
local ok, err = pcall(function()
|
|
PaletteFX.setMode("redpp")
|
|
|
|
local s, lit, bnd = beat(true)
|
|
eq(s, STUB, "Advanced shades the machine on a lit beat")
|
|
eq(bnd, STUB, "and binds that shader before the sprites are drawn")
|
|
check(type(lit) == "table", "a lit beat sends a palette")
|
|
eq(lit[2][1], obp[2][1], "the lit ball keeps the pack's orange (R)")
|
|
eq(lit[2][2], obp[2][2], "the lit ball keeps the pack's orange (G)")
|
|
eq(lit[3][1], obp[3][1], "the lit ball keeps the pack's red (R)")
|
|
eq(lit[3][2], obp[3][2], "the lit ball keeps the pack's red (G)")
|
|
check(lit[2][1] ~= PaletteFX.GRAYS[2][1],
|
|
"a lit beat is not the DMG gray ramp")
|
|
|
|
-- engine/overworld/healing_machine.asm:54
|
|
local _, flashed = beat(false)
|
|
check(type(flashed) == "table", "a flashed half-beat sends a palette")
|
|
eq(flashed[2][1], obp[1][1], "the flash beat lifts shade 1 to shade 0")
|
|
eq(flashed[3][1], obp[2][1], "the flash beat lifts shade 2 to shade 1")
|
|
eq(flashed[4][1], obp[3][1], "the flash beat lifts shade 3 to shade 2")
|
|
check(flashed[2][1] ~= obp[3][1],
|
|
"the Advanced flash lifts brightness instead of swapping the middle shades")
|
|
|
|
for _, mode in ipairs({ "gbc", "og", "classic" }) do
|
|
PaletteFX.setMode(mode)
|
|
check(not PaletteFX.usesGbcPack(), mode .. " is not the Advanced pack")
|
|
local ds, dlit, dbnd = beat(true)
|
|
eq(ds, nil, mode .. " leaves a lit beat unshaded")
|
|
eq(dlit, nil, mode .. " sends no palette on a lit beat")
|
|
eq(dbnd, nil, mode .. " binds no shader on a lit beat")
|
|
local _, dflash = beat(false)
|
|
check(type(dflash) == "table", mode .. " still shades the flashed half-beat")
|
|
eq(dflash[2][1], PaletteFX.GRAYS[3][1],
|
|
mode .. " swaps the two middle DMG grays on the flash beat")
|
|
eq(dflash[3][1], PaletteFX.GRAYS[2][1],
|
|
mode .. " swaps them back for shade 2")
|
|
end
|
|
end)
|
|
|
|
PaletteFX.shader, PaletteFX.sendColors = realShader, realSend
|
|
love.graphics.setShader = realSetShader
|
|
check(ok, "the heal palette pass ran: " .. tostring(err))
|
|
|
|
PaletteFX.setMode(prevMode)
|
|
GameVersion.set(prevVer)
|
|
|
|
S.finish()
|