From 9ddb940bc8634c933ba1c19f9533591a93b33168 Mon Sep 17 00:00:00 2001 From: DramaticShape Date: Sat, 8 Aug 2026 18:51:01 -0400 Subject: [PATCH] update 2d shiny sprites and shiny animation --- data/voxel_heights.lua | 80 ++++++++- lib/ChunkMesher.lua | 35 +++- lib/OverworldBattle.lua | 62 +++---- lib/ShinyFlash.lua | 323 ++++++++++++++++++++++++++++++++++ lib/ShinyPalette.lua | 125 ++++++++++++- lib/ShinyPics.lua | 156 ++++++++++++++++ lib/ShinyUI.lua | 67 +++---- lib/Structures.lua | 89 +++++++++- lib/TileShape.lua | 45 +++++ main.lua | 27 ++- tests/shiny_flat.lua | 119 +++++++++++++ tools/shiny_palette_sheet.lua | 188 ++++++++++++++++++++ tools/shiny_pic_dump.lua | 75 ++++++++ tools/shiny_pic_sheet.py | 155 ++++++++++++++++ 14 files changed, 1448 insertions(+), 98 deletions(-) create mode 100644 lib/ShinyFlash.lua create mode 100644 lib/ShinyPics.lua create mode 100644 tests/shiny_flat.lua create mode 100644 tools/shiny_palette_sheet.lua create mode 100644 tools/shiny_pic_dump.lua create mode 100644 tools/shiny_pic_sheet.py diff --git a/data/voxel_heights.lua b/data/voxel_heights.lua index 6af0a03..a963ab3 100644 --- a/data/voxel_heights.lua +++ b/data/voxel_heights.lua @@ -906,11 +906,13 @@ return { -- two flanks -- see `prop` below. wall = { 2, 3, 4, 5, 6, 16, 18, 19, 20, 21, 22, 40, 41, 76, 77, 92, 93, 94, 95 }, - -- the counters, half a cell high: top band (8) with the nurse's - -- tray (10), front face (24/25, the game's counterTiles), left end - -- cap (56) and the Cable Club's light sections (90/91). 8px is - -- one clean band, so the drawn front panel stands up and the - -- counter top stays on top; at 12 they read as wall stubs + -- the counters, half a cell high: top band (8) and the one cell of + -- it that carries the push bell (10, lifted off as a figure below -- + -- the pin stays as the degradation path), front face (24/25, the + -- game's counterTiles), left end cap (56) and the Cable Club's light + -- sections (90/91). 8px is one clean band, so the drawn front panel + -- stands up and the counter top stays on top; at 12 they read as + -- wall stubs counter = { 8, 10, 24, 25, 56, 90, 91, -- and the lounge couch's SEAT column with the man -- sitting on it. Same half-cell box: its bottom row @@ -1035,6 +1037,74 @@ return { -- on the arm. The background corners around his head and the -- cushion wedge under his legs are the only pixels given back. figures = { + -- THE PUSH BELL on the reception counter. One tile, $0A, drawn in + -- the counter's TOP tile row at cell (3,2) -- the same cell in all + -- eleven Centers and nowhere else on this id (scan: 11 hits, all + -- tile (7,4)). Every other counter cell in the game runs 8 over + -- 24/25; this one runs 8/10 over 24/25, and 10 is 8 with the bell + -- painted into its east half. + -- + -- It could not be a class pin: a pin resolves a whole 8x8 tile, and + -- the tile is three quarters counter top. Pinned with the counter + -- (which is what it was) the bell was just ink lying on the + -- surface -- and lying on it TWICE, because the counter's one top + -- row had to cover a 16px-deep plot and the mesher repeated it (see + -- the half-cell rule in ChunkMesher: fixed, and the two stacked + -- bells were what showed it). + -- + -- So it is lifted off by mask, exactly like the Marts' till, and + -- `under` puts plain 8 back -- the counter top the artist drew for + -- every other cell of the same run, so nothing is synthesized and + -- the surface closes up seamlessly. + -- + -- Unlike the till it is NOT an extrusion of its drawing. Seven + -- pixels by six of ¾-view dome state a round object and nothing + -- else usable: every reading that turns six rows into geometry + -- invents more than it measures. So the solid is AUTHORED (see + -- TileShape's `model`) -- a 5x3 puck with its corners taken off, + -- one voxel proud of the counter, with a single button voxel at + -- its centre. `pixels` stays as the segmentation: it is what says + -- where on the tile the bell is, and the model centres on it. + -- + -- COLOUR is still not authored. Each layer names the texel its + -- faces wear, and all four come off tile 8 -- the counter's own + -- plain top, whose first rows are one flat shade each: row 0 its + -- black back edge, row 1 its white highlight, row 5 its light + -- band. So the puck's sides are the desk's own light shade, its + -- top the desk's own white, and the button's sides the desk's own + -- black, and all four follow every palette bake with it. + -- + -- It stands at the FRONT of the counter cell: a service bell is on + -- the customer's side of the desk, and this is the only object in + -- the profile whose depth its drawing does not state. `inset` 2 + -- backs it off the counter's own front lip -- flush read as balanced + -- on the edge; this is the number to move to slide it either way. + { + w = 1, + inset = 2, + tiles = { 10 }, + under = { 8 }, + model = { + { plan = { "0xxx0", + "xxxxx", + "0xxx0" }, + top = { 8, 1 }, side = { 8, 5 } }, + { plan = { "00000", + "00x00", + "00000" }, + top = { 8, 1 }, side = { 8, 0 } }, + }, + pixels = { + "........", + "........", + "...XXX..", + "..XXXXX.", + ".XXXXXXX", + ".XXXXXXX", + "..XXXXX.", + "...XXX..", + }, + }, { w = 3, tiles = { 36, 37, 57, diff --git a/lib/ChunkMesher.lua b/lib/ChunkMesher.lua index 175c648..4167656 100644 --- a/lib/ChunkMesher.lua +++ b/lib/ChunkMesher.lua @@ -423,8 +423,12 @@ local function runGeometry(map, bodyOnly, masks, sink, waterSink) -- `to` routes the quad somewhere other than the main sink -- the water -- surface is the only caller that ever does (see runGeometry's header). - local function topQuad(x0, z0, h, tile, shade, to) - local u0, u1, v0, v1 = uvRect(tile, 0, 8) + -- `vTop`/`vBot` crop the art to a row range of the tile, which only the + -- half-cell furniture rule below ever asks for: a top band that has to + -- cover more depth than it was drawn with hands each 8px cell its own + -- slice of the band instead of the whole of it. + local function topQuad(x0, z0, h, tile, shade, to, vTop, vBot) + local u0, u1, v0, v1 = uvRect(tile, vTop or 0, vBot or 8) ;(to or push)({ { x0, h, z0 }, { x0 + 8, h, z0 }, { x0 + 8, h, z0 + 8 }, { x0, h, z0 + 8 } }, { { u0, v0 }, { u1, v0 }, { u1, v1 }, { u0, v1 } }, @@ -585,6 +589,7 @@ local function runGeometry(map, bodyOnly, masks, sink, waterSink) topQuad(x0, z0, h, topTile, VOLUME_TOP_SHADE) else local topTile = tile + local vTop, vBot = nil, nil if s.art == "upright" and s.authored then -- Top art for a pinned box. A furniture drawing is top-view -- rows over floor(h/8) face-on rows the fold stands upright; @@ -611,6 +616,30 @@ local function runGeometry(map, bodyOnly, masks, sink, waterSink) end end local row = math.min(ty, front - math.floor(h / 8)) + -- HALF-CELL FURNITURE, one cell of plot: the drawing gives ONE + -- tile row of top view (the counter's surface) over one that + -- folds up as the face (its front panel), and the plot under it + -- is 16px deep. Repeating the top row over both depth rows -- + -- what `row` above resolves to, since the face row has no top + -- art of its own to wear -- draws the surface TWICE: the + -- Centers' counters ran a black back edge and its white + -- highlight down the middle of every counter, and the push bell + -- drawn on one of them came out as two bells stacked front to + -- back. The band is foreshortened, not tiled, so each depth row + -- takes HALF of it and the one drawing covers the whole top. + -- + -- Deliberately narrow: only a run that is exactly one cell deep + -- with exactly one top row. A deeper run states its own depth + -- 1:1 already (the lounge couch is four tile rows over two + -- cells, and its cushions must stay cushion-sized), and only the + -- last of its rows repeats -- which is the drawing tiling, not + -- a surface drawn once and stretched. + local face = math.floor(h / 8) + if front - face - north == 0 and front - north == 1 then + local k = ty - north + row = north + vTop, vBot = k * 4, k * 4 + 4 + end if row < north then -- the whole run folded onto the face: top with the drawn -- row just above it when that row is furniture too (a @@ -629,7 +658,7 @@ local function runGeometry(map, bodyOnly, masks, sink, waterSink) -- on the pond. topQuad(x0, z0, h, topTile, s.art == "upright" and VOLUME_TOP_SHADE or 1, - (s.class == "water") and waterPush or nil) + (s.class == "water") and waterPush or nil, vTop, vBot) end -- sides: 8px bands wherever the neighbour is lower. Band k spans diff --git a/lib/OverworldBattle.lua b/lib/OverworldBattle.lua index 447d45a..7129d96 100644 --- a/lib/OverworldBattle.lua +++ b/lib/OverworldBattle.lua @@ -1101,43 +1101,20 @@ function OverworldBattle.sideTexture(battle, side) for k, v in pairs(OFF[side]) do saved[k] = battle[k]; battle[k] = v end texturing = side - -- A SHINY on this side, tinted here rather than in ShinyUI's flat-path - -- wrap. This is the one place a pic is rendered for ONE side at a time, - -- so it is the only place the two sides can be tinted differently -- a - -- shiny facing an ordinary mon gets its own colour and leaves the other - -- alone, which the engine's both-sides-at-once pic layer cannot do. - local shinyTint = nil - do - -- NOT when this side is showing a PERSON. Both sides can be holding a - -- trainer pic rather than a Pokemon -- the foe's portrait before the - -- send-out, and the player's own back until "Go!" -- and a shiny is a - -- fact about a Pokemon, not about its owner. Tinting through it turned - -- the player's trainer sprite a different colour for the whole intro, - -- which is what a shiny Pokemon in the party looks like if you do not - -- ask this question. The two tests are the same ones sideTexture already - -- uses to label the finished texture, asked here instead of after. - local person = (side == "enemy" - and battle.showEnemyTrainer and battle.trainerPic) - or (side == "player" - and battle.showPlayerBack and battle.playerBackPic) - if not person then - local battler = (side == "player") and battle.player or battle.enemy - local g2 = game() - shinyTint = battler and V.require("ShinyUI") - .tintFor(battler.mon, g2 and g2.data) or nil - end - end - + -- ------- no shiny tint here any more + -- + -- This used to bracket the draw below with that side's shiny tint, on the + -- grounds that rendering one side at a time is the only place the two can + -- be coloured differently. True, and no longer needed: the PIC itself is + -- now built from a shiny palette (lib/ShinyPics.lua), which is per-mon + -- rather than per-side and gets the colour right instead of approximating + -- it with a multiply. Tinting on top of that would apply the shift twice. local ok, err = pcall(function() g.setCanvas(canvas) g.clear(0, 0, 0, 0) g.setBlendMode("alpha") g.setColor(1, 1, 1, 1) - if shinyTint then - V.require("ShinyUI").withTint(shinyTint, innerPics, battle, 0, 0, 0) - else - innerPics(battle, 0, 0, 0) - end + innerPics(battle, 0, 0, 0) end) texturing = nil @@ -1288,6 +1265,22 @@ function OverworldBattle.install() return TEX_AX - w * scale / 2, TEX_AY - h * scale, s end + -- ------- the shiny arrival sparkle, on every rung this file draws + -- + -- Called from BOTH branches below, because both are a complete battle + -- frame: the `not shot` branch is the engine's own screen (3D-BTL OFF, and + -- any battle the mod does not stage), and the other is the staged shot. + -- + -- It lives here rather than on a hook or a monkeypatch of its own because + -- this override IS the battle's draw -- every rung, every frame. The two + -- other seams were tried and measured at zero calls: BattleState:update is + -- never reached (the battle is not the top of the stack during its own + -- intro), and the engine's `battle.overlay` hook is only reached through + -- the tail of the engine's draw. See lib/ShinyFlash.lua. + local function shinyFlash(battle) + pcall(function() V.require("ShinyFlash").render(battle) end) + end + local innerDraw = BattleState.draw function BattleState:draw() local shot = OverworldBattle.shot() @@ -1298,7 +1291,9 @@ function OverworldBattle.install() -- that loses its arena mid-fight goes back to white voids self.letterboxWhite = nil self.dramaticShapeShot = nil - return innerDraw(self) + local out = innerDraw(self) + shinyFlash(self) + return out end self.dramaticShapeShot = shot -- The world reaches the screen through the seam a render pipeline's @@ -1325,6 +1320,7 @@ function OverworldBattle.install() -- own HUD drew in, so it letterboxes and chunks identically local cap = BattleScene.capture if cap and cap.drawGB then pcall(cap.drawGB, self) end + shinyFlash(self) end -- The mons are geometry standing on the map now, drawn in the 3D pass diff --git a/lib/ShinyFlash.lua b/lib/ShinyFlash.lua new file mode 100644 index 0000000..5b45b21 --- /dev/null +++ b/lib/ShinyFlash.lua @@ -0,0 +1,323 @@ +-- The arrival sparkle, on the FLAT battle screen. +-- +-- ------- why ShinyFx could not be reused +-- +-- lib/ShinyFx.lua is the sparkle for the STADIUM rungs, and every line of it +-- is about the 3D arena: it is armed from Stadium.update on the frame a +-- side's model changes, it is sized from the model's own world height and +-- radius, and it draws additive quads into the voxel scene through +-- Voxel3D.blend. None of that exists on the other rungs -- 3D-BTL OFF has no +-- arena at all, and the two 2D-3D rungs stand flat PICS up as billboards +-- rather than building a model to measure. +-- +-- So the effect was Stadium-only, and had been since it was written: ShinyFx +-- .arm is called from exactly one file. On every other rung a shiny simply +-- appeared, with no announcement. This is the announcement, in the one +-- coordinate space those rungs share -- the Game Boy's own 160x144 grid, +-- where the pic itself is drawn. +-- +-- ------- the two slots +-- +-- Both are the engine's, and neither moves: the enemy's front pic lives in +-- the 7x7 tile slot at hlcoord 12,0 (x 96..152, y 0..56) and the player's +-- back pic stands at x=8 with its feet on the text box at y=96, two-times +-- scaled, so it fills y 32..96. The burst springs from a point inside each, +-- a little above centre, which is roughly where a Pokemon's chest is in art +-- drawn to fill its box. +-- +-- Deliberately NOT measured off the drawn image. resolveBattleScale can +-- rescale a pic per species, the send-out grow animates the scale from zero, +-- and following either would make the burst jump around during exactly the +-- moment it is playing. The slot is fixed; the sparkle uses the slot. +-- +-- ------- black AND white, both +-- +-- Each spark is drawn twice: a wider near-black cross, then a white one +-- inside it. One colour alone would be invisible half the time -- the battle +-- screen's field is white, so a white spark vanishes on OFF, and the 2D-3D +-- rungs composite the same pic over a sky or a map, where a black one does. +-- The pair reads on both, and costs ten extra rectangles. + +-- the mod namespace (see main.lua): V.require loads a sibling module +local V = ... + +local Shiny = V.require("Shiny") + +local ShinyFlash = {} + +ShinyFlash.LIFE = 0.75 -- seconds, matching ShinyFx +ShinyFlash.SPARKS = 9 + +-- The two slots, in GB pixels: where the burst starts and how far it travels. +ShinyFlash.SLOTS = { + enemy = { x = 124, y = 24, rx = 34, ry = 26 }, + player = { x = 40, y = 62, rx = 34, ry = 30 }, +} + +-- Where each spark sits on the ring, as a fraction of a turn. Spread by hand +-- rather than randomly: nine sparks on an even ring reads as a ring, and nine +-- random ones read as a mess at this size. The half-step offset on alternate +-- sparks keeps it from looking like a clock face. +local ANGLES = {} +for i = 1, ShinyFlash.SPARKS do + ANGLES[i] = (i - 1) / ShinyFlash.SPARKS + (i % 2 == 0 and 0.5 or 0) + / ShinyFlash.SPARKS +end + +-- ------- why the clock is the WALL clock +-- +-- Everything here happens on the DRAW side (see install), and a draw is +-- handed no dt. Rather than accumulate one nobody offers, a burst records +-- the time it started and its age is read back off love.timer. +-- +-- That also makes it immune to being asked to draw more than once in a +-- frame, which the wide layout does -- once per side -- and which a +-- per-call dt accumulator would age at double speed. +local function now() + return (love.timer and love.timer.getTime and love.timer.getTime()) or 0 +end + +-- live bursts: side -> the time it started +local live = {} + +-- what each side's pic was showing last frame, so an arrival is an EDGE +local showing = {} + +-- for the tests and the shot drivers, the way ShinyFx.debug is +ShinyFlash.debug = { renders = 0, follows = 0, occupied = 0, + armed = 0, draws = 0, sparks = 0, err = "" } + +function ShinyFlash.arm(side) + live[side] = now() + ShinyFlash.debug.armed = ShinyFlash.debug.armed + 1 +end + +function ShinyFlash.clear(side) + live[side] = nil +end + +function ShinyFlash.reset() + live, showing = {}, {} +end + +-- How far through its life this side's burst is, 0..1, or nil when there +-- isn't one (or it has finished, which retires it on the way past). +function ShinyFlash.age(side) + local started = live[side] + if not started then return nil end + local u = (now() - started) / ShinyFlash.LIFE + if u >= 1 then + live[side] = nil + return nil + end + return u +end + +function ShinyFlash.active(side) + return ShinyFlash.age(side) ~= nil +end + +-- ------- is a Pokemon's own pic on screen for this side +-- +-- The conditions are the engine's, read off drawPicsLayer rather than +-- guessed: a side showing a TRAINER is showing a person and not a Pokemon, +-- and the send-out, the faint fade and the safari/demo cases each have their +-- own reason for the slot to be empty. +-- +-- Returns the mon whose pic is up, or nil. +function ShinyFlash.occupant(battle, side) + if type(battle) ~= "table" then return nil end + if side == "enemy" then + if battle.showEnemyTrainer and battle.trainerPic then return nil end + local b = battle.enemy + if not (b and b.sprite) then return nil end + if battle.enemyHidden or battle.enemySendingOut then return nil end + if battle.fxHidden and battle:fxHidden(b) then return nil end + return b.mon + end + if battle.showPlayerBack and battle.playerBackPic then return nil end + if battle.safari or battle.demo then return nil end + local b = battle.player + if not (b and b.sprite) then return nil end + if battle.sendingOut then return nil end + if battle.fxHidden and battle:fxHidden(b) then return nil end + return b.mon +end + +-- Arm on the frame a side's occupant CHANGES to a shiny -- a send-out, a +-- switch and a wild foe's first appearance alike, which is the same edge +-- ShinyFx picks for the models. +function ShinyFlash.follow(battle) + ShinyFlash.debug.follows = ShinyFlash.debug.follows + 1 + for _, side in ipairs({ "enemy", "player" }) do + local mon = ShinyFlash.occupant(battle, side) + if mon then ShinyFlash.debug.occupied = ShinyFlash.debug.occupied + 1 end + if mon ~= showing[side] then + showing[side] = mon + if mon and Shiny.isShiny(mon) then + ShinyFlash.arm(side) + else + ShinyFlash.clear(side) + end + end + end +end + +-- ------- drawing +-- +-- Whole pixels. The screen this lands on is 160x144 and everything else in +-- it is on the pixel grid, so a spark at x=41.37 would be the one soft thing +-- on a hard-edged frame. +local function spark(px, py, arm) + local g = love.graphics + px, py = math.floor(px + 0.5), math.floor(py + 0.5) + -- the dark cross first, one pixel proud of the light one on every side + g.setColor(0, 0, 0, 1) + g.rectangle("fill", px - arm - 1, py - 1, arm * 2 + 3, 3) + g.rectangle("fill", px - 1, py - arm - 1, 3, arm * 2 + 3) + g.setColor(1, 1, 1, 1) + g.rectangle("fill", px - arm, py, arm * 2 + 1, 1) + g.rectangle("fill", px, py - arm, 1, arm * 2 + 1) +end + +-- One side's burst, if it has one. +function ShinyFlash.draw(side, sx, sy) + local u = ShinyFlash.age(side) + if not u then return end + local slot = ShinyFlash.SLOTS[side] + if not slot then return end + local g = love.graphics + local r, gg, b, a = g.getColor() + + -- Out and fading. The ring eases OUT rather than travelling at a constant + -- speed -- fast off the mark, slow at the edge -- because a burst that + -- decelerates reads as thrown and one that does not reads as a wipe. + local ease = 1 - (1 - u) * (1 - u) + local fade = 1 - u + g.setColor(1, 1, 1, 1) + ShinyFlash.debug.draws = ShinyFlash.debug.draws + 1 + + for i = 1, ShinyFlash.SPARKS do + -- every third spark is held back a little, so the ring has some depth + -- rather than nine points on one circle + local lag = (i % 3 == 0) and 0.78 or 1 + local ang = ANGLES[i] * math.pi * 2 + local px = (sx or 0) + slot.x + math.cos(ang) * slot.rx * ease * lag + local py = (sy or 0) + slot.y - math.sin(ang) * slot.ry * ease * lag + -- arms shrink as the spark fades, so it goes out rather than vanishing + local arm = 1 + math.floor(fade * 2.5) + spark(px, py, arm) + ShinyFlash.debug.sparks = ShinyFlash.debug.sparks + 1 + end + + g.setColor(r, gg, b, a) +end + +-- ------- BEHIND the Pokemon, not over it +-- +-- The burst springs from inside the mon and flies outward, so the frames that +-- matter most are the ones where the ring is still small and sitting ON the +-- body. Drawn from the overlay hook -- the end of the battle draw -- every one +-- of those lands in FRONT of the pic, and the sparkle reads as stuck to the +-- glass rather than as coming from the Pokemon. +-- +-- So it is drawn from the PICS LAYER instead, before the engine's own pics go +-- down. That is the only place in the frame that is behind the mon and in +-- front of the field. +-- +-- The overlay hook stays, and is still the only seam the 3D rungs have: +-- OverworldBattle captured drawPicsLayer at install time and its battle draw +-- calls the captured copy, so the wrap below never runs there. Whichever seam +-- fires first draws; the other one sees the side already spent and leaves it +-- alone. `spent` is cleared by the overlay, which is the one call guaranteed +-- to happen exactly once per battle draw. +local spent = {} + +-- One side, unless it has already been drawn this frame. +local function once(side, sx, sy) + if spent[side] then return end + spent[side] = true + ShinyFlash.draw(side, sx, sy) +end + +-- The pics layer, BEFORE the engine's pics. `onlySide` is the wide layout +-- drawing one side per call, and is honoured so the burst lands in the same +-- pass its Pokemon does. +-- +-- Skipped while the layer is SLIDING (the intro walks the whole battle in +-- from the side): the slot this draws to is fixed, so a burst during the +-- slide would sit still while the mon travelled past it. Nothing is lost -- +-- the arrival edge that arms it is after the slide is over. +function ShinyFlash.renderBehind(battle, slide, sx, sy, onlySide) + ShinyFlash.debug.behinds = (ShinyFlash.debug.behinds or 0) + 1 + ShinyFlash.follow(battle) + if (slide or 0) ~= 0 then return end + if onlySide ~= "player" then once("enemy", sx, sy) end + if onlySide ~= "enemy" then once("player", sx, sy) end +end + +-- Follow the occupants and draw whatever the pics layer did not, in one call. +function ShinyFlash.render(battle) + ShinyFlash.debug.renders = ShinyFlash.debug.renders + 1 + ShinyFlash.follow(battle) + once("enemy", 0, 0) + once("player", 0, 0) + spent = {} -- one battle draw ends here; the next is new +end + +-- ------- install +-- +-- Through the engine's own `battle.overlay` hook, whose comment at the call +-- site names this exact use ("shiny sparkles, custom HUD chrome"). It fires +-- at the very end of BattleState:draw, in the Game Boy's own 160x144 space, +-- with the battle as its argument -- which is all this needs. +-- +-- A MONKEYPATCH ON UPDATE WAS TRIED FIRST AND DOES NOT WORK, which is worth +-- recording so it is not tried again: BattleState:update never fires during +-- the intro, because the battle is not the top of the stack there and +-- StateStack:update only calls the top. Measured -- installed, confirmed live +-- on the class, zero calls -- rather than reasoned about. +-- +-- The hook has no shake offset to give, and does not need one: it is called +-- after the screen-shake translate has been popped, so nominal coordinates +-- are the right ones. +-- +-- ------- and the second seam, for depth +-- +-- The overlay alone draws the burst OVER the Pokemon. The pics layer is +-- wrapped as well so it can go down BEHIND it (see renderBehind), on every +-- rung where the engine's own method is the one called. On the 3D rungs it is +-- not -- OverworldBattle captured drawPicsLayer at install time and calls the +-- captured copy -- and there the overlay is still the seam, which is why both +-- are installed rather than one replacing the other. +function ShinyFlash.install() + local mod = V.mod + if not (mod and mod.hooks and mod.hooks.wrap) then return false end + if ShinyFlash.installed then return true end + mod.hooks:wrap("battle.overlay", function(next, battle) + local out = next(battle) + local ok, err = pcall(ShinyFlash.render, battle) + if not ok then ShinyFlash.debug.err = tostring(err) end + return out + end) + + local okBS, BattleState = pcall(require, "src.battle.BattleState") + if okBS and type(BattleState) == "table" + and type(BattleState.drawPicsLayer) == "function" + and not BattleState.dramaticShapeShinyFlash then + local inner = BattleState.drawPicsLayer + function BattleState:drawPicsLayer(slide, sx, sy, onlySide, ...) + ShinyFlash.debug.picsCalls = (ShinyFlash.debug.picsCalls or 0) + 1 + local ok, err = pcall(ShinyFlash.renderBehind, self, slide, sx, sy, + onlySide) + if not ok then ShinyFlash.debug.err = tostring(err) end + return inner(self, slide, sx, sy, onlySide, ...) + end + BattleState.dramaticShapeShinyFlash = true + end + + ShinyFlash.installed = true + return true +end + +return ShinyFlash diff --git a/lib/ShinyPalette.lua b/lib/ShinyPalette.lua index a7747c1..8614f04 100644 --- a/lib/ShinyPalette.lua +++ b/lib/ShinyPalette.lua @@ -368,17 +368,128 @@ end -- So: slide species use the slide, which is defined on all colours. Table -- species fall back to their tint multiplier, which IS derived from the -- table and does carry its direction. +-- ------- reading a SLIDE back out of a lookup table +-- +-- A multiply was the first answer here and it is not good enough. Gyarados is +-- the whole argument: its shiny is BLUE TURNING RED, and no multiply reaches +-- red from blue -- it can only darken what is already there, so the most +-- dramatic shiny in the game came out a dull mauve. That is the same ceiling +-- the flat tint hit (see lib/ShinyPics.lua), reached from the other side. +-- +-- But the table is not just a direction, it is the ANSWER: 1857 exact +-- (normal -> shiny) pairs lifted from Stadium's own alternate textures. Read +-- as HSL, each pair is a hue rotation, a saturation scale and a lightness +-- step -- which is precisely the shape of a slide. So the five table species +-- get a slide MEASURED from their own table rather than declared, and the one +-- transform serves all 151. +-- +-- Averaged over the pairs because a real alternate texture is not a perfect +-- slide -- that is why it is a texture -- but it is close enough to one that +-- the mean carries the change a player actually sees. +-- +-- hue circularly (sum the unit vectors), or opposite rotations +-- would cancel to "no change" +-- saturation as GIMP's k, s2 = s1 * (1 + k), skipping near-grey pairs +-- where the ratio is noise +-- lightness as GIMP's two-sided k, matching shiftLight +local slideCache = {} + +local function slideFromLut(lut) + local sx, sy, hueN = 0, 0, 0 + local sk, sn, lk, ln = 0, 0, 0, 0 + for key, val in pairs(lut) do + local r1 = floor(key / 65536) % 256 + local g1 = floor(key / 256) % 256 + local b1 = key % 256 + local r2 = floor(val / 65536) % 256 + local g2 = floor(val / 256) % 256 + local b2 = val % 256 + local h1, s1, l1 = rgbToHsl(r1, g1, b1) + local h2, s2, l2 = rgbToHsl(r2, g2, b2) + -- an achromatic end has no hue, so the pair says nothing about rotation + if s1 > 0.08 and s2 > 0.08 then + -- DEGREES, both of them: rgbToHsl returns h*60 and hslToRgb takes + -- `h % 360`, so the declared slides are in degrees too (-136 for + -- Charizard) and a measured one has to come out in the same unit. It + -- did not at first, and a rotation of 0.13 TURNS read as 0.13 degrees: + -- Gyarados stayed blue and the whole point of measuring was lost. + local d = math.rad(h2 - h1) + sx, sy = sx + math.cos(d), sy + math.sin(d) + hueN = hueN + 1 + sk, sn = sk + (s2 / s1 - 1), sn + 1 + end + if l1 > 0.02 and l1 < 0.98 then + lk = lk + (l2 < l1 and (l2 / l1 - 1) or ((l2 - l1) / (1 - l1))) + ln = ln + 1 + end + end + local dh = 0 + if hueN > 0 and (sx * sx + sy * sy) > 1e-9 then + dh = math.deg(math.atan2(sy, sx)) + end + -- back into the -8..+8 STEPS the slide fields are in, so the value that + -- comes out of here is the same kind of number as the 146 declared ones + return { + h = dh, + s = sn > 0 and (sk / sn) / 0.125 or 0, + l = ln > 0 and (lk / ln) / 0.125 or 0, + } +end + +-- A transform for PALETTE colours rather than texture texels. +-- +-- The two are not the same job. A lookup table answers only the colours that +-- are IN it -- the ones its model is painted with -- and the engine's palettes +-- are a different set entirely (BLUEMON's blue is not any blue on the +-- Gyarados model), so the table asked to shift a palette returns it unchanged +-- and the most dramatic shiny in the game comes out identical. +-- +-- So: slide species use their declared slide, and table species use one +-- measured out of their table by slideFromLut above. Both end up in the same +-- HSL transform, which is the only kind that can rotate a hue. +-- ------- and why the LIGHTNESS step is damped on a palette +-- +-- A slide's l is authored against a TEXTURE: thousands of texels spread +-- across the middle of the range, where "six steps darker" reads as a shadow +-- falling over the animal. A Game Boy palette is not that. It is a four-shade +-- RAMP from paper to ink, and only the middle two shades are the Pokemon -- +-- both already dark relative to the white they sit on, and both needing to +-- stay clear of the fixed ink below them. +-- +-- Applied whole, Golbat's -6 took its two shades to 27,42,37 and 34,58,52: +-- correct green, and a green nobody can see against a 25,16,16 outline. Half +-- the step keeps the direction and keeps the pic readable, which is the trade +-- the ramp forces. Hue and saturation are untouched -- they are what makes a +-- shiny recognisable as one, and neither collides with the paper or the ink. +ShinyPalette.PALETTE_LIGHT_DAMP = 0.5 + function ShinyPalette.paletteTransform(dex) local spec = ShinyPalette.forDex(dex) + local slide = spec and spec.slide if not spec then return nil end - if not spec.lut then return ShinyPalette.transform(spec) end - local t = ShinyPalette.tintFor(dex) - if not t then return nil end - return function(r, g, b) - return floor(min(255, r * t[1]) + 0.5), - floor(min(255, g * t[2]) + 0.5), - floor(min(255, b * t[3]) + 0.5) + if spec.lut then + if slideCache[dex] == nil then + slideCache[dex] = slideFromLut(spec.lut) or false + end + slide = slideCache[dex] or nil end + if not slide then return nil end + return slideFn({ + h = slide.h or 0, + s = slide.s or 0, + l = (slide.l or 0) * ShinyPalette.PALETTE_LIGHT_DAMP, + }) +end + +-- The measured slide itself, for the tests and for anyone checking the five +-- against Stadium's own textures. +function ShinyPalette.lutSlide(dex) + local spec = ShinyPalette.forDex(dex) + if not (spec and spec.lut) then return nil end + if slideCache[dex] == nil then + slideCache[dex] = slideFromLut(spec.lut) or false + end + return slideCache[dex] or nil end -- ------- the pass over one species' whole texture array diff --git a/lib/ShinyPics.lua b/lib/ShinyPics.lua new file mode 100644 index 0000000..2e102c5 --- /dev/null +++ b/lib/ShinyPics.lua @@ -0,0 +1,156 @@ +-- A shiny's battle pic, genuinely recoloured. +-- +-- ------- why the tint had to go +-- +-- The first answer to "a shiny on the flat art" was a MULTIPLY at draw time, +-- and it was the wrong shape twice over: +-- +-- * A multiply can only DARKEN. Shiny Gyarados is blue turning RED; the +-- nearest a multiply gets is a dimmer blue. Every species whose shiny is +-- lighter, or is a hue rotation rather than a dimming, came out looking +-- like the ordinary one with the brightness down -- which is exactly what +-- "shinies don't work in 2D" describes. +-- * It tinted the whole PICS LAYER, both sides at once, because that is the +-- granularity the engine's own draw has. A shiny facing an ordinary mon +-- dimmed its opponent too. +-- +-- ------- where the colour actually lives +-- +-- The battle pic is not drawn from four-shade art at play time. getImage +-- (src/battle/BattleState.lua:147) snaps the four DMG shades to the species' +-- palette ONCE, with mapPixel, and caches the finished image under +-- `path .. "#" .. pal.name`. By the time anything is drawn the colour is +-- already baked in, and the only way to change it is to hand that bake a +-- different palette -- which also means a different cache NAME, or the shiny +-- and the ordinary pic fight over one cache slot. +-- +-- That is the whole of this file. It is the same conclusion ShinyUI reached +-- for the status screen ("the palette is what has to move"), applied to the +-- one other place a Pokemon is drawn flat. +-- +-- ------- the seam +-- +-- monPalette (BattleState.lua:216) is a local, so it cannot be wrapped. What +-- it calls -- PaletteFX.monPal and PaletteFX.monPalName -- are not, and they +-- are asked in that order for every battle pic the game builds. +-- +-- Neither is told WHICH Pokemon is being drawn; both take a species. The +-- individual arrives one call earlier, at the engine's own `pokemon.sprite` +-- hook, which carries ctx.mon -- so the hook notes "the pic about to be built +-- is this shiny mon's" and the two palette wraps consume that note. A flag +-- rather than an argument, because the argument does not exist. +-- +-- It is consumed ONCE, and matched on species as well, so a leak (monPalette +-- returns early when a species has no palette at all, and then never asks for +-- the name) cannot recolour somebody else's pic -- the worst case is one +-- extra ordinary pic built under a shiny cache key, which the next call +-- corrects. + +-- the mod namespace (see main.lua): V.require loads a sibling module +local V = ... + +local Shiny = V.require("Shiny") +local ShinyPalette = V.require("ShinyPalette") + +local ShinyPics = {} + +-- { species = , dex = } while a shiny's pic is being built +local pending = nil + +-- The suffix that makes the shiny pic its own cache entry. Part of the +-- palette NAME rather than the path, because the name is what getImage keys +-- on and the path is real art on disk that this mod does not add to. +ShinyPics.SUFFIX = "-SHINY" + +-- ------- what the sprite hook notices +-- +-- Called for every battle pic the engine resolves. Returns nothing: the point +-- is the note it leaves. +function ShinyPics.note(ctx) + pending = nil + if type(ctx) ~= "table" or ctx.kind ~= "battle" then return end + local mon = ctx.mon + if not (mon and Shiny.isShiny(mon)) then return end + local def = ctx.data and ctx.data.pokemon and ctx.data.pokemon[ctx.species] + local dex = def and def.dex + if not dex then return end + pending = { species = ctx.species, dex = dex } +end + +-- Whether the pic currently being built is a shiny's -- for a test, and for +-- the palette wraps below. +function ShinyPics.pendingDex(species) + if pending and pending.species == species then return pending.dex end + return nil +end + +-- ------- the palette wraps +-- +-- Idempotent by sentinel, the pattern every wrap in this mod uses. +function ShinyPics.install() + local ok, PaletteFX = pcall(require, "src.render.PaletteFX") + if not ok or type(PaletteFX) ~= "table" then return false end + if PaletteFX.dramaticShapeShiny then return true end + local innerPal = PaletteFX.monPal + local innerName = PaletteFX.monPalName + if type(innerPal) ~= "function" or type(innerName) ~= "function" then + return false + end + + function PaletteFX.monPal(data, species, transformed, ...) + local cols = innerPal(data, species, transformed, ...) + local dex = ShinyPics.pendingDex(species) + if not (cols and dex) then + -- nothing to recolour, and monPalette's early return means the name + -- wrap below may never run: drop the note here rather than leave it + -- for whoever asks next + if not cols then pending = nil end + return cols + end + local fn = ShinyPalette.paletteTransform(dex) + if not fn then return cols end + -- ------- the first and last shades DO NOT MOVE + -- + -- A Game Boy mon palette is four shades and only the middle two are the + -- Pokemon. The first is the PAPER -- 255,239,255 in every species' + -- palette in the dataset, the white the pic sits on -- and the last is + -- the INK, 25,16,16, the outline every pic is drawn with. Both are shared + -- constants, not colours anybody chose for this animal. + -- + -- Sliding them is what a shiny looks like when it is broken: shiny Golbat + -- rotates far enough that its white became NAVY (31,34,93) and the pic + -- read as a mon on a blue card rather than a green Golbat. Stadium's + -- slides were authored for model textures, which have no paper and no + -- outline in them, so there was nothing there to warn against it. + -- + -- COPIED, never written through, for the rest. monPal hands back the + -- dataset's own palette table, and mutating it would recolour every + -- Pokemon of the species everywhere for the rest of the process -- the + -- same trap ShinyUI's summary wrap documents. + local last = #cols + local out = {} + for i, c in ipairs(cols) do + if type(c) == "table" and c[1] and i > 1 and i < last then + local r, g, b = fn(c[1], c[2], c[3]) + out[i] = { r, g, b } + else + out[i] = c + end + end + return out + end + + function PaletteFX.monPalName(data, species, ...) + local name = innerName(data, species, ...) + local dex = ShinyPics.pendingDex(species) + pending = nil -- consumed: one pic, one note + if not (name and dex) then return name end + if not ShinyPalette.paletteTransform(dex) then return name end + return name .. ShinyPics.SUFFIX + end + + PaletteFX.dramaticShapeShiny = true + return true +end + +return ShinyPics diff --git a/lib/ShinyUI.lua b/lib/ShinyUI.lua index a4ca0f3..a75d578 100644 --- a/lib/ShinyUI.lua +++ b/lib/ShinyUI.lua @@ -97,7 +97,6 @@ end function ShinyUI.install() ShinyUI.installSummary() - ShinyUI.installBattlePics() end -- The status page. Wraps the draw and adds the star afterwards, so the @@ -177,51 +176,25 @@ function ShinyUI.installSummary() SummaryMenu.dramaticShapeShiny = true end --- The battle pics. The engine's pic layer is reached through --- BattleState:drawPicsLayer, which draws BOTH sides in one call -- so a --- per-side tint has to bracket each side separately, which is exactly what --- OverworldBattle.sideTexture already does when it renders one side at a --- time into its own canvas. That is where the tint belongs on the 3D path; --- this wrap covers the FLAT path, where the engine draws the battle itself. -function ShinyUI.installBattlePics() - local ok, BattleState = pcall(require, "src.battle.BattleState") - if not ok or type(BattleState) ~= "table" then return end - if BattleState.dramaticShapeShinyPics then return end - local inner = BattleState.drawPicsLayer - if type(inner) ~= "function" then return end - - function BattleState:drawPicsLayer(...) - -- THE 3D PATH HAS ALREADY DONE THIS, per side and better: when the mod - -- is rendering one side into its own canvas it brackets that draw with - -- that side's own tint (OverworldBattle.sideTexture). Tinting again here - -- would square it. Asked as a question rather than left to install - -- order, because both wraps are installed from main.lua and whichever - -- ran first would otherwise silently decide the outcome. - local okOw, Ow = pcall(V.require, "OverworldBattle") - if okOw and Ow and Ow.texturingSide and Ow.texturingSide() then - return inner(self, ...) - end - - -- Both sides at once, so when they disagree the tint cannot be applied - -- per-side here without splitting the engine's own draw. When only ONE - -- side is shiny we tint the whole layer by it: the other side's pic is - -- dimmed slightly, which is far less wrong than a shiny drawn in its - -- ordinary colours -- and when both are shiny each gets the mean. - local data = self.game and self.game.data - local a = self.player and ShinyUI.tintFor(self.player.mon, data) - local b = self.enemy and ShinyUI.tintFor(self.enemy.mon, data) - local tint = a or b - if a and b then - tint = { (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, (a[3] + b[3]) / 2 } - end - if not tint then return inner(self, ...) end - local args = { ... } - local out - ShinyUI.withTint(tint, function() out = { inner(self, unpack(args)) } end) - return unpack(out or {}) - end - - BattleState.dramaticShapeShinyPics = true -end +-- ------- the battle pics are NOT tinted here any more +-- +-- There used to be a third wrap in this file: a multiply over +-- BattleState:drawPicsLayer, with the tint above. It is gone, and the reason +-- is worth keeping so it is not put back. +-- +-- A multiply can only DARKEN. Shiny Gyarados is blue turning red, and the +-- nearest a multiply gets to that is a dimmer blue -- so every species whose +-- shiny is lighter, or is a rotation rather than a dimming, read as the +-- ordinary one with the brightness down. And the engine's pic layer draws +-- BOTH sides in one call, so a shiny also dimmed the ordinary mon opposite it. +-- +-- lib/ShinyPics.lua replaces it by moving the PALETTE instead, which is where +-- a battle pic's colour actually lives: getImage bakes the four DMG shades +-- into the species palette once and caches the result, so handing that bake a +-- shiny palette (under a cache name of its own) gives a genuinely recoloured +-- pic -- brightening included -- for one side alone. +-- +-- ShinyUI.withTint and ShinyUI.tintFor stay: the 3D path still uses them for +-- the per-side canvas, and they are the only tint left in the mod. return ShinyUI diff --git a/lib/Structures.lua b/lib/Structures.lua index cda30a4..2f6ee1b 100644 --- a/lib/Structures.lua +++ b/lib/Structures.lua @@ -3089,6 +3089,80 @@ local function maskPlate(quads, m, perRow, atlasW, atlasH, x0, r, y, z0, D) end end +-- An AUTHORED solid standing on furniture, given as plan layers instead of +-- extruded from the drawing (see TileShape's `model`). The one thing it +-- shares with the mask paths is that nothing here is a colour: each layer +-- names the atlas texels its top and its sides wear, and every quad below +-- samples one of them, so the Centers' bell is painted out of the counter's +-- own pixels and recolours with it. +-- +-- Placement is by CELL, not by drawn row. A model exists because the +-- drawing was too small to un-project, so its drawn row says nothing about +-- depth worth keeping -- what says something is which piece of furniture it +-- is on and which end of it a person reaches: the solid is centred on the +-- mask's own columns and pushed to the SOUTH edge of the support cell, the +-- face the aisle is on, less the entry's `inset` -- the one number here +-- taste can move, because flush against the counter's own front lip is a +-- real position and so is a couple of voxels back from it. +local function maskModel(quads, m, perRow, atlasW, atlasH, xMid, zSouth, y0) + local function uvOf(t) + local tile, row, col = t[1], t[2], t[3] or 0 + return ((tile % perRow) * 8 + col + 0.5) / atlasW, + (math.floor(tile / perRow) * 8 + row + 0.5) / atlasH + end + + for k, L in ipairs(m) do + local u, v = uvOf(L.side) + local ut, vt = uvOf(L.top) + local above = m[k + 1] + local x0 = xMid - math.floor(L.w / 2) + local z0 = zSouth - L.d + local function solid(layer, dx, dz) + if not layer or dx < 0 or dx >= layer.w or dz < 0 or dz >= layer.d then + return false + end + return layer.cells[dz * layer.w + dx] or false + end + for dz = 0, L.d - 1 do + for dx = 0, L.w - 1 do + if solid(L, dx, dz) then + local x, y, z = x0 + dx, y0 + k - 1, z0 + dz + local function quad(c1, c2, c3, c4, uu, vv, shade) + quads[#quads + 1] = { c1, c2, c3, c4, u = uu, v = vv, + shade = shade } + end + -- a layer's own plan is what closes it: a face is drawn wherever + -- the neighbouring cell of this layer is empty, and the top + -- wherever the layer ABOVE does not stand on it. Nothing needs a + -- bottom -- layer 1 rests on the furniture and the rest rest on + -- each other. + if not solid(above, dx, dz) then + quad({ x, y + 1, z }, { x + 1, y + 1, z }, { x + 1, y + 1, z + 1 }, + { x, y + 1, z + 1 }, ut, vt, OBJ_SHADE.top) + end + if not solid(L, dx, dz + 1) then + quad({ x, y, z + 1 }, { x + 1, y, z + 1 }, + { x + 1, y + 1, z + 1 }, { x, y + 1, z + 1 }, u, v, + OBJ_SHADE.front) + end + if not solid(L, dx, dz - 1) then + quad({ x + 1, y, z }, { x, y, z }, { x, y + 1, z }, + { x + 1, y + 1, z }, u, v, OBJ_SHADE.back) + end + if not solid(L, dx - 1, dz) then + quad({ x, y, z }, { x, y, z + 1 }, { x, y + 1, z + 1 }, + { x, y + 1, z }, u, v, OBJ_SHADE.side) + end + if not solid(L, dx + 1, dz) then + quad({ x + 1, y, z + 1 }, { x + 1, y, z }, { x + 1, y + 1, z }, + { x + 1, y + 1, z + 1 }, u, v, OBJ_SHADE.side) + end + end + end + end + end +end + -- ---- figures: a thing drawn INTO furniture, cut out and stood up ---- -- One authored figure at one matched position. @@ -3171,7 +3245,20 @@ local function buildFigure(S, map, fig, tx, ty, perRow) local atlasW = map.tileset.imageWidth or 128 local atlasH = map.tileset.imageHeight or 48 - if fig.depth then + if fig.model then + -- An authored solid: centred on the mask's own columns, standing on + -- the furniture's top plane at the front of its cell. + local maxX = minX + for ly = 0, bh - 1 do + for lx = 0, bw - 1 do + if at(lx, ly) and lx > maxX then maxX = lx end + end + end + local xMid = tx * 8 + math.floor((minX + maxX + 1) / 2) + local zSouth = (math.floor((ty + fig.h - 1) / 2) + 1) * 16 - (fig.inset or 0) + maskModel(S.objectQuads, fig.model, perRow, atlasW, atlasH, + xMid, zSouth, baseY) + elseif fig.depth then -- An OBJECT: the standee slab, standing on the FRONT edge of the tile -- row its feet are drawn in -- the south face of the 8px band a -- character card would have pivoted in. It is anchored there and diff --git a/lib/TileShape.lua b/lib/TileShape.lua index f9e041e..c4c372f 100644 --- a/lib/TileShape.lua +++ b/lib/TileShape.lua @@ -469,6 +469,8 @@ end -- -- figures = { { w = , -- depth = , +-- model = { ...authored plan layers, bottom first... }, +-- inset = , -- thin = { rows = , depth = }, -- flat = { x = { , }, rows = { , } }, -- tiles = { ...w*h tile ids, row-major... }, @@ -488,6 +490,16 @@ end -- same furniture the card would have stood on. The Marts' cash -- register is the case: a machine on a counter is a box, not an icon. -- +-- `model` is the third answer, and the only one that is not an extrusion +-- of the drawing at all: an AUTHORED solid, given as plan layers bottom +-- first, standing at the FRONT of the support cell. It exists for a +-- drawing too small to un-project -- the Centers' push bell is 7x6 pixels +-- of ¾-view dome, and no reading of six rows produces a shape a mask can +-- extrude without inventing more than it measures. What it still may not +-- invent is COLOUR: each layer names the atlas texel its top and its +-- sides wear, so the solid is painted out of the drawing it replaces and +-- follows every palette bake exactly like the rest of this file. +-- -- Two fields say which parts of such a drawing are NOT the extrusion, -- because a solid drawn in one 16x16 GB cell still packs more than one -- facing: @@ -557,10 +569,43 @@ local function authoredMasks(list) r0 = math.floor(f.flat.rows[1]), r1 = math.floor(f.flat.rows[2]) } end + -- an AUTHORED model: plan layers bottom-first, each with the atlas + -- texel its top and its sides wear. Dropped whole on any malformed + -- layer, like every other field here -- a typo should leave the + -- drawing lying flat, not build half a solid. + local model = nil + if type(f.model) == "table" and #f.model > 0 then + model = {} + for _, L in ipairs(f.model) do + local plan = type(L) == "table" and L.plan + local mw = (type(plan) == "table" and type(plan[1]) == "string") + and #plan[1] or 0 + local okL = mw > 0 and type(L.top) == "table" + and type(L.side) == "table" + if okL then + for _, r in ipairs(plan) do + if type(r) ~= "string" or #r ~= mw then okL = false break end + end + end + if not okL then model = nil break end + local cells = {} + for dz = 0, #plan - 1 do + local r = plan[dz + 1] + for dx = 0, mw - 1 do + if r:sub(dx + 1, dx + 1) ~= "0" then cells[dz * mw + dx] = true end + end + end + model[#model + 1] = { w = mw, d = #plan, cells = cells, + top = L.top, side = L.side } + end + end if n > 0 then out[#out + 1] = { w = w, h = h, n = n, mask = mask, tiles = f.tiles, under = f.under, depth = depth and math.floor(depth) or nil, + model = model, + inset = model and math.floor(tonumber(f.inset) or 0) + or nil, thin = thin, flat = flat } end end diff --git a/main.lua b/main.lua index 33d1842..2cb7903 100644 --- a/main.lua +++ b/main.lua @@ -91,6 +91,8 @@ local BattleExit = V.require("BattleExit") local Shiny = V.require("Shiny") local ShinyBattle = V.require("ShinyBattle") local ShinyUI = V.require("ShinyUI") +local ShinyPics = V.require("ShinyPics") +local ShinyFlash = V.require("ShinyFlash") local DayNight = V.require("DayNight") local DayTint = V.require("DayTint") local Water = V.require("Water") @@ -1185,14 +1187,35 @@ OverworldBattle.install() -- ShinyBattle wraps Pokemon.new, which is where every wild, gift, -- starter and traded mon is built, so the roll lands before -- the sprite is baked --- ShinyUI the battle pics' tint and the status page's mark --- ShinyFx the arrival sparkle (armed from Stadium.update) +-- ShinyUI the status page's mark, and the summary pic's palette +-- ShinyPics the battle pic's palette -- a real recolour, baked into the +-- image cache under a shiny key, on every rung that draws a +-- pic (OFF, both 2D-3D rungs, and the cards a STADIUM battle +-- still uses for a species with no model) +-- ShinyFx the arrival sparkle for the STADIUM rungs (3D, armed from +-- Stadium.update) +-- ShinyFlash the same announcement for every OTHER rung, drawn in the +-- Game Boy's own pixel grid over the pic -- -- The Stadium models need no seam here at all: their recolour happens at -- extraction (lib/StadiumBuild.lua), and the battle simply asks for the -- shiny pack. ShinyBattle.install() ShinyUI.install() +ShinyPics.install() +ShinyFlash.install() + +-- ShinyPics needs to know WHICH Pokemon a pic is being built for, and the +-- two palette functions it wraps are told only the species. The individual +-- passes through here one call earlier: `pokemon.sprite` carries ctx.mon. +-- +-- next() first and the return value untouched -- this reads the context and +-- changes nothing about which art is chosen. +mod.hooks:wrap("pokemon.sprite", function(next, path, ctx) + local out = next(path, ctx) + pcall(ShinyPics.note, ctx) + return out +end) -- A save opened for the first time under this mod has shiny Pokemon in it -- already -- they always did -- so refresh the cached flag across the party diff --git a/tests/shiny_flat.lua b/tests/shiny_flat.lua new file mode 100644 index 0000000..8789e3c --- /dev/null +++ b/tests/shiny_flat.lua @@ -0,0 +1,119 @@ +-- Driver: is a shiny visible on the FLAT paths -- the engine's own battle +-- screen (3D-BTL OFF) and the cards rung (2D-3D A)? +-- +-- DS_SHOTS=mods/DramaticShapeVoxelMod/.claude/shiny_update/flat \ +-- POKEPORT_DRIVER=mods/DramaticShapeVoxelMod/tests/shiny_flat.lua \ +-- "/c/Program Files/LOVE/lovec.exe" . +-- +-- The other shot driver covers the cards rung and the STADIUM rungs and NOT +-- 3D-BTL OFF -- which is the rung a player who has never touched the mod's +-- battle row is on, and so the one place a regression can sit unseen. It sat +-- there: the pic tint was a multiply that could only darken, and the arrival +-- sparkle was armed from Stadium.update and therefore never played here. +-- +-- Each rung is shot TWICE, shiny and ordinary, from the same species at the +-- same spot, as a STRIP -- the intro flashes the pic through palette variants +-- on its way in, so a single frame lands wherever the pacing put it. +-- +-- Reports, per rung: whether the roll landed, the PALETTE the pic was baked +-- under (which is where the recolour now lives), and whether the flat-path +-- sparkle armed and drew. +return function(game) + local U = dofile("tests/drivers/util.lua") + local BattleState = require("src.battle.BattleState") + local PaletteFX = require("src.render.PaletteFX") + local Pokemon = require("src.pokemon.Pokemon") + + local SPECIES = os.getenv("DS_SPECIES") or "GYARADOS" + local LEVEL = tonumber(os.getenv("DS_LEVEL") or "") or 40 + local DIR = os.getenv("DS_SHOTS") or ".claude/shiny_update/flat" + + local exports = game.mods and game.mods.exports + local lib = exports and exports.DRAMATIC_SHAPE and exports.DRAMATIC_SHAPE.lib + if not lib then U.log("DRAMATIC_SHAPE is not loaded") return end + local Shiny = lib.require("Shiny") + local ShinyPics = lib.require("ShinyPics") + local ShinyFlash = lib.require("ShinyFlash") + local OverworldBattle = lib.require("OverworldBattle") + + U.log(("wraps: pics=%s flash=%s"):format( + tostring(PaletteFX.dramaticShapeShiny == true), + tostring(ShinyFlash.installed == true))) + + -- ------- what the palette wrap hands the image cache + -- + -- The recolour is baked ONCE, at build time, so counting draws says nothing + -- about it. What matters is the cache key and the colours behind it: ask + -- PaletteFX the same two questions monPalette asks, with the note the + -- sprite hook would have left a moment earlier. + local function palReport(mon) + ShinyPics.note({ kind = "battle", species = SPECIES, mon = mon, + data = game.data }) + local cols = PaletteFX.monPal(game.data, SPECIES) + local name = PaletteFX.monPalName(game.data, SPECIES) + local out = { "pal=" .. tostring(name) } + for i = 1, math.min(3, cols and #cols or 0) do + local c = cols[i] + if type(c) == "table" and c[1] then + out[#out + 1] = ("c%d=%d,%d,%d"):format(i, c[1], c[2], c[3]) + end + end + return table.concat(out, " ") + end + + -- The party is built at ORDINARY odds and pinned afterwards, so the + -- player's own Pikachu stays common: this run is about the foe. + game.save.player.name = "RED" + game.save.party = { Pokemon.new(game.data, "PIKACHU", 50) } + + local function leave() + while game.stack:top() and game.stack:top() ~= game.overworld do + game.stack:pop() + end + U.wait(10) + end + + local function shoot(rung, label, shiny) + OverworldBattle.setting:setValue(rung, game) + Shiny.setOdds(shiny and 1 or 100000000) + for k in pairs(ShinyFlash.debug) do ShinyFlash.debug[k] = 0 end + + U.teleport(game, "ROUTE_1", 5, 8, "down") + U.wait(60) + + local battle = BattleState.newWild(game, SPECIES, LEVEL) + battle.onFinish = function() end + game.overworld:pushBattle(battle) + + local mon = battle.enemy and battle.enemy.mon + U.log(("%s %s: 3D-BTL=%s isShiny=%s %s"):format( + label, shiny and "shiny" or "normal", + tostring(OverworldBattle.setting:get()), tostring(Shiny.isShiny(mon)), + palReport(mon))) + + -- The WIPE has to be walked through first. A driver run with no input at + -- all sits on BattleTransition forever -- the battle is never pushed, so + -- nothing about it draws and every counter below reads zero, which is + -- exactly the false negative this probe produced before the taps went in. + for _ = 1, 8 do U.tap(game, "a") U.wait(10) end + + -- the sparkle is three quarters of a second long and starts on the frame + -- the pic appears, so the strip is TIGHT + for k = 1, 10 do + U.shot(game, ("%s/%s_%s_%02d.png"):format(DIR, label, + shiny and "shiny" or "normal", + k)) + U.wait(9) + end + local d = ShinyFlash.debug + U.log((" flash: renders=%s armed=%d draws=%d sparks=%d follows=%d occ=%d %s") + :format(tostring(d.renders), d.armed, d.draws, d.sparks, + d.follows, d.occupied, tostring(d.err))) + leave() + end + + shoot(false, "off", false) + shoot(false, "off", true) + shoot(true, "cards", false) + shoot(true, "cards", true) +end diff --git a/tools/shiny_palette_sheet.lua b/tools/shiny_palette_sheet.lua new file mode 100644 index 0000000..b7151c3 --- /dev/null +++ b/tools/shiny_palette_sheet.lua @@ -0,0 +1,188 @@ +-- Every species' battle palette, normal beside shiny, as one HTML page. +-- +-- luajit mods/DramaticShapeVoxelMod/tools/shiny_palette_sheet.lua +-- +-- Run from the PROJECT ROOT. Writes +-- mods/DramaticShapeVoxelMod/.claude/shiny_update/palettes.html +-- +-- ------- what it is actually showing +-- +-- Not the shiny COLOURS table (data/shiny_colors.lua) -- that is Stadium's +-- values for a model's texels, and it is already checked against the Python +-- that produced it. This is the other end: what those values become after +-- ShinyPics puts them through the engine's four-shade battle palette, which +-- is where the flat art gets its colour and the only place a mistake there +-- shows up. +-- +-- Two rules are visible in the output and both were bugs first: +-- +-- * shade 1 and shade 4 never move. They are the shared paper (255,239,255) +-- and the shared ink (25,16,16), not colours anybody chose for this +-- animal, and sliding them turned shiny Golbat's white navy. +-- * the five TABLE species rotate hue like everyone else, because their +-- slide is measured back out of their lookup table rather than falling +-- back to a multiply that can only darken. +-- +-- The COLORS pack is whatever PaletteFX defaults to in a headless process +-- (the GBC pack). The RED++ pack is a different set of four colours per +-- species and would want its own sheet. + +package.path = "./?.lua;./?/init.lua;" .. package.path + +local MOD = "mods/DramaticShapeVoxelMod" +local OUT = MOD .. "/.claude/shiny_update/palettes.html" + +-- ------- the mod namespace, enough of it (see tests/shiny_test.lua) +local loaded, V = {}, {} +function V.require(n) + if loaded[n] == nil then + loaded[n] = assert(loadfile(MOD .. "/lib/" .. n .. ".lua"))(V) + end + return loaded[n] +end +function V.data(n) return assert(loadfile(MOD .. "/data/" .. n .. ".lua"))(V) end +V.path = MOD +V.mod = { id = "DRAMATIC_SHAPE", + log = { warn = function() end, info = function() end } } + +local ShinyPics = V.require("ShinyPics") +local ShinyPalette = V.require("ShinyPalette") +local PaletteFX = require("src.render.PaletteFX") + +local Data = { + pokemon = dofile("data/generated/pokemon.lua"), + palettes = dofile("data/generated/palettes.lua"), +} + +assert(ShinyPics.install(), "the palette wrap did not install") + +-- Def/Spd/Spc all 10 and Atk 10 is the Gen 2 pattern src/pokemon/Stats.lua +-- reads; any mon carrying it is shiny as far as the engine is concerned. +local SHINY = { dvs = { attack = 10, defense = 10, speed = 10, + special = 10, hp = 15 } } + +-- ------- collect, in dex order +local rows = {} +for name, def in pairs(Data.pokemon) do + if type(def) == "table" and def.dex and def.dex >= 1 and def.dex <= 151 then + rows[#rows + 1] = { name = name, dex = def.dex } + end +end +table.sort(rows, function(a, b) return a.dex < b.dex end) + +local function hex(c) + return ("#%02x%02x%02x"):format(c[1] or 0, c[2] or 0, c[3] or 0) +end + +local moved, still, missing = 0, 0, 0 + +for _, row in ipairs(rows) do + row.normal = PaletteFX.monPal(Data, row.name) + row.palName = PaletteFX.monPalName(Data, row.name) + ShinyPics.note({ kind = "battle", species = row.name, mon = SHINY, + data = Data }) + row.shiny = PaletteFX.monPal(Data, row.name) + row.shinyName = PaletteFX.monPalName(Data, row.name) + + local spec = ShinyPalette.forDex(row.dex) + row.kind = spec and (spec.lut and "table" or "slide") or "none" + local slide = spec and (spec.lut and ShinyPalette.lutSlide(row.dex) + or spec.slide) + row.slide = slide + + if not (row.normal and row.shiny) then + missing = missing + 1 + else + -- how far the two middle shades actually travelled, as the largest + -- per-channel step: a row that reads 0 is a shiny nobody can see + local d = 0 + for i = 2, #row.normal - 1 do + local a, b = row.normal[i], row.shiny[i] + if type(a) == "table" and type(b) == "table" then + for k = 1, 3 do d = math.max(d, math.abs((a[k] or 0) - (b[k] or 0))) end + end + end + row.delta = d + if d >= 8 then moved = moved + 1 else still = still + 1 end + end +end + +-- ------- the page +local out = {} +local function w(s) out[#out + 1] = s end + +w([[ + +Shiny battle palettes + +

Shiny battle palettes — normal beside shiny

+

What ShinyPics hands the battle pic cache, per +species. The first and last shades are the shared paper and ink and are held +still on purpose (shown faded); only the two middle shades are the Pokemon. +slide species use Stadium's declared values; +the five table species use a slide measured +back out of their own lookup table, which is what lets Gyarados reach red. +Δ is the largest per-channel step across the two middle shades — +a row in red barely moved.

+]]) + +w(("

%d species · %d visibly recoloured · " + .. "%d barely moved · %d with no palette

\n") + :format(#rows, moved, still, missing)) + +w("" + .. "" + .. "\n") + +for _, row in ipairs(rows) do + local function swatches(cols) + if not cols then return "—" end + local o = {} + for i, c in ipairs(cols) do + local fixed = (i == 1 or i == #cols) and " fixed" or "" + if type(c) == "table" and c[1] then + o[#o + 1] = ("") + :format(fixed, hex(c), c[1], c[2], c[3]) + end + end + return table.concat(o) + end + local s = row.slide + w(("" + .. "" + .. "\n") + :format(row.dex, row.name, tostring(row.palName), row.kind, row.kind, + s and ("%.0f° / %+.1f / %+.1f"):format(s.h or 0, s.s or 0, + s.l or 0) or "—", + swatches(row.normal), swatches(row.shiny), + (row.delta and row.delta < 8) and " flat" or "", + row.delta and tostring(row.delta) or "—")) +end + +w("
#speciespalkindslide h / s / lnormalshinyΔ
%03d%s%s%s%s%s%s%s
\n") + +local f = assert(io.open(OUT, "wb")) +f:write(table.concat(out)) +f:close() + +print(("%s -- %d species, %d recoloured, %d barely moved, %d no palette") + :format(OUT, #rows, moved, still, missing)) diff --git a/tools/shiny_pic_dump.lua b/tools/shiny_pic_dump.lua new file mode 100644 index 0000000..fcd75ab --- /dev/null +++ b/tools/shiny_pic_dump.lua @@ -0,0 +1,75 @@ +-- Emit what tools/shiny_pic_sheet.py needs to bake the battle pics. +-- +-- luajit mods/DramaticShapeVoxelMod/tools/shiny_pic_dump.lua > pics.tsv +-- +-- Run from the PROJECT ROOT. One species per line, tab separated: +-- +-- dex name spriteFront kind n1 n2 n3 n4 s1 s2 s3 s4 +-- +-- where each colour is r,g,b. TSV rather than JSON because there is no JSON +-- encoder in this tree and the payload is eight colours and a path. +-- +-- The COLOURS are the point: they come from the real wrap (ShinyPics over +-- PaletteFX.monPal), not from a second implementation of it, so what the +-- sheet shows is what the game bakes. + +package.path = "./?.lua;./?/init.lua;" .. package.path + +local MOD = "mods/DramaticShapeVoxelMod" + +local loaded, V = {}, {} +function V.require(n) + if loaded[n] == nil then + loaded[n] = assert(loadfile(MOD .. "/lib/" .. n .. ".lua"))(V) + end + return loaded[n] +end +function V.data(n) return assert(loadfile(MOD .. "/data/" .. n .. ".lua"))(V) end +V.path = MOD +V.mod = { id = "DRAMATIC_SHAPE", + log = { warn = function() end, info = function() end } } + +local ShinyPics = V.require("ShinyPics") +local ShinyPalette = V.require("ShinyPalette") +local PaletteFX = require("src.render.PaletteFX") + +local Data = { + pokemon = dofile("data/generated/pokemon.lua"), + palettes = dofile("data/generated/palettes.lua"), +} + +assert(ShinyPics.install(), "the palette wrap did not install") + +local SHINY = { dvs = { attack = 10, defense = 10, speed = 10, + special = 10, hp = 15 } } + +local rows = {} +for name, def in pairs(Data.pokemon) do + if type(def) == "table" and def.dex and def.dex >= 1 and def.dex <= 151 + and def.spriteFront then + rows[#rows + 1] = { name = name, dex = def.dex, path = def.spriteFront } + end +end +table.sort(rows, function(a, b) return a.dex < b.dex end) + +local function cols(t) + local o = {} + for i = 1, 4 do + local c = t and t[i] + o[i] = (type(c) == "table" and c[1]) + and ("%d,%d,%d"):format(c[1], c[2], c[3]) or "0,0,0" + end + return table.concat(o, "\t") +end + +for _, row in ipairs(rows) do + local normal = PaletteFX.monPal(Data, row.name) + ShinyPics.note({ kind = "battle", species = row.name, mon = SHINY, + data = Data }) + local shiny = PaletteFX.monPal(Data, row.name) + local spec = ShinyPalette.forDex(row.dex) + local kind = spec and (spec.lut and "table" or "slide") or "none" + io.write(("%d\t%s\t%s\t%s\t%s\t%s\n") + :format(row.dex, row.name, row.path, kind, cols(normal), + cols(shiny))) +end diff --git a/tools/shiny_pic_sheet.py b/tools/shiny_pic_sheet.py new file mode 100644 index 0000000..5de6239 --- /dev/null +++ b/tools/shiny_pic_sheet.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +"""Every battle pic, baked normal beside baked shiny, as one HTML page. + + luajit mods/DramaticShapeVoxelMod/tools/shiny_pic_dump.lua > /tmp/pics.tsv + python mods/DramaticShapeVoxelMod/tools/shiny_pic_sheet.py /tmp/pics.tsv + +Run from the PROJECT ROOT. Writes +mods/DramaticShapeVoxelMod/.claude/shiny_update/sprites.html, self-contained +(every pic is a data: URI), so it can be opened or sent on its own. + +------- the bake is the engine's, exactly + +src/battle/BattleState.lua:147 getImage() is the only place a battle pic gets +its colour, and it does it ONCE at load with mapPixel: + + col = r > 0.83 and c[1] or r > 0.5 and c[2] or r > 0.17 and c[3] or c[4] + +Four-shade DMG art, keyed on the RED channel alone, snapped to the species +palette. That line is reproduced below rather than approximated, because the +whole question this sheet answers is what the player will actually see -- an +approximation of the bake would be answering a different one. + +The colours come from tools/shiny_pic_dump.lua, which runs the real +ShinyPics wrap over the real PaletteFX, so nothing here re-derives them. +""" + +import base64 +import io +import os +import sys + +from PIL import Image + +ROOT = os.getcwd() +MOD = "mods/DramaticShapeVoxelMod" +OUT = os.path.join(MOD, ".claude/shiny_update/sprites.html") +SCALE = 3 # nearest-neighbour, so the pixels stay pixels + + +def parse_color(s): + r, g, b = (int(v) for v in s.split(",")) + return (r, g, b) + + +def bake(img, pal): + """getImage's mapPixel: red channel picks the shade, alpha is kept.""" + img = img.convert("RGBA") + px = img.load() + w, h = img.size + for y in range(h): + for x in range(w): + r, g, b, a = px[x, y] + if a == 0: + continue + f = r / 255.0 + if f > 0.83: + c = pal[0] + elif f > 0.5: + c = pal[1] + elif f > 0.17: + c = pal[2] + else: + c = pal[3] + px[x, y] = (c[0], c[1], c[2], a) + return img + + +def data_uri(img): + img = img.resize((img.width * SCALE, img.height * SCALE), Image.NEAREST) + buf = io.BytesIO() + img.save(buf, format="PNG") + return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode() + + +def main(): + src = sys.argv[1] if len(sys.argv) > 1 else "-" + stream = sys.stdin if src == "-" else open(src, encoding="utf-8") + rows = [] + with stream: + for line in stream: + line = line.rstrip("\n") + if not line: + continue + f = line.split("\t") + rows.append({ + "dex": int(f[0]), + "name": f[1], + "path": f[2], + "kind": f[3], + "normal": [parse_color(c) for c in f[4:8]], + "shiny": [parse_color(c) for c in f[8:12]], + }) + + cards, missing = [], 0 + for row in rows: + path = os.path.join(ROOT, row["path"]) + if not os.path.exists(path): + missing += 1 + continue + art = Image.open(path) + n = data_uri(bake(art.copy(), row["normal"])) + s = data_uri(bake(art.copy(), row["shiny"])) + cards.append( + '
' + '
{name} normal' + '{name} shiny
' + '
{dex:03d} {name}{kind}
' + "
".format(kind=row["kind"], n=n, s=s, + name=row["name"], dex=row["dex"]) + ) + + html = """ +Shiny battle pics + +

Shiny battle pics — normal on the left, shiny on the right

+

Each pair is the same four-shade art baked twice, through the +palette the game itself would use: getImage keys on the red +channel alone and snaps to the species palette, once, at load. The colours +come from the live ShinyPics wrap, so this is what the flat +battle screen draws — not a preview of it. Bordered cards are the five +species Stadium gives a real alternate texture, whose slide is measured back +out of that texture rather than declared.

+

%d species%s

+
%s
+ +""" % (len(cards), + "" if not missing else " · %d with no art on disk" % missing, + "\n".join(cards)) + + os.makedirs(os.path.dirname(OUT), exist_ok=True) + with open(OUT, "w", encoding="utf-8") as f: + f.write(html) + size = os.path.getsize(OUT) / 1024.0 + print("%s -- %d pairs, %d missing, %.0f KB" % (OUT, len(cards), missing, + size)) + + +if __name__ == "__main__": + main()