Replace box variants with a moveable adhesion property

Collapse the spiky/sticky/skewer box-variant assets into a single per-
instance `adhesion` property on any moveable block, chosen in the editor
via a dropdown next to the colour picker and stored in the .sav alongside
the class.

- spiky -> sticky: soft grab on every true edge (goopy shader)
- skewer -> gluey: rigid weld on every true edge (spiked outline)
- old trailing-face sticky is removed; its saves fold into new sticky

Move the spike geometry + drawGlueySprite into shaders.lua, fold drawing
and the adhesion flag into GenericMoveable, and delete the three
Generic{Sticky,Spiky,Skewer} classes and box_variants.lua. Room:createEntity
normalises legacy spiky_/skewer_/sticky_ class prefixes so old saves load,
and serialization emits `adhesion`. World/map previews and the movement
proxy follow the rename.

Backfill rooms/*.sav to the new format via tools/backfill_adhesion.lua
(41 objects across 8 files). Update tests to the two-mode model; the two
tests asserting the removed lateral-shear limitation are dropped and a
legacy-load migration test added. 27/27 pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/test_movement.lua

@@ -29,19 +29,16 @@ local function assertNotIn(group, entity, message)
 	if group[entity] then error(message or "expected entity outside movement group", 2) end
 end
 
-local function movable(x, y, sticky, shape, skewer, spiky)
+local function movable(x, y, adhesion, shape)
 	local entity = {
 		x = x, y = y,
-		sticky = sticky or false,
-		skewer = skewer or false,
-		spiky = spiky or false,
+		adhesion = adhesion,
 		shape = shape or {{x = 0, y = 0}},
 	}
 	function entity:canMove() return true end
 	function entity:canPassOver() return false end
-	function entity:isSticky() return self.sticky end
-	function entity:isSkewer() return self.skewer end
-	function entity:isSpiky() return self.spiky end
+	function entity:isSticky() return self.adhesion == "sticky" end
+	function entity:isGluey() return self.adhesion == "gluey" end
 	function entity:bump() end
 	function entity:move(axis, amount) self[axis] = self[axis] + amount end
 	function entity:getGridPos() return {x = self.x, y = self.y} end
@@ -94,7 +91,7 @@ end)
 
 test("a trailing sticky block joins a horizontal pull", function()
 	-- sticky, regular, player; moving right
-	local sticky = movable(2, 3, true)
+	local sticky = movable(2, 3, "sticky")
 	local regular = movable(3, 3)
 	local possible, group = plan({sticky, regular}, {x = 3, y = 3}, {x = 1, y = 0})
 	assertTrue(possible)
@@ -105,7 +102,7 @@ end)
 test("a moving sticky block pulls a regular block behind it", function()
 	-- regular, sticky, player; moving right
 	local regular = movable(2, 3)
-	local sticky = movable(3, 3, true)
+	local sticky = movable(3, 3, "sticky")
 	local possible, group = plan({regular, sticky}, {x = 3, y = 3}, {x = 1, y = 0})
 	assertTrue(possible)
 	assertIn(group, sticky)
@@ -114,7 +111,7 @@ end)
 
 test("sticky pull chains work vertically", function()
 	-- player moves down, pulling the two blocks above it
-	local sticky = movable(4, 2, true)
+	local sticky = movable(4, 2, "sticky")
 	local regular = movable(4, 3)
 	local possible, group = plan({sticky, regular}, {x = 4, y = 3}, {x = 0, y = 1})
 	assertTrue(possible)
@@ -129,7 +126,7 @@ test("sticky pulls are symmetric in all four directions", function()
 	}) do
 		local player = {x = 4, y = 4}
 		local regular = movable(player.x - direction.x, player.y - direction.y)
-		local sticky = movable(player.x - direction.x * 2, player.y - direction.y * 2, true)
+		local sticky = movable(player.x - direction.x * 2, player.y - direction.y * 2, "sticky")
 		local possible, group = plan(
 			{sticky, regular},
 			{x = regular.x, y = regular.y},
@@ -141,19 +138,20 @@ test("sticky pulls are symmetric in all four directions", function()
 	end
 end)
 
-test("a sticky block shears off during orthogonal movement", function()
-	-- The regular block moves right; the sticky block above it stays behind.
+test("a sticky block grabs a free lateral block during orthogonal movement", function()
+	-- The regular block moves right; the sticky block above it is soft-grabbed on
+	-- that lateral face (sticky pulls on every edge) and follows along.
 	local regular = movable(3, 4)
-	local stickyBranch = movable(3, 3, true)
+	local stickyBranch = movable(3, 3, "sticky")
 	local possible, group = plan({regular, stickyBranch}, {x = 3, y = 4}, {x = 1, y = 0})
 	assertTrue(possible)
 	assertIn(group, regular)
-	assertNotIn(group, stickyBranch)
+	assertIn(group, stickyBranch)
 end)
 
-test("a blocked sheared sticky block does not stop movement", function()
+test("a blocked sticky lateral grab does not stop movement", function()
 	local regular = movable(3, 4)
-	local stickyBranch = movable(3, 3, true)
+	local stickyBranch = movable(3, 3, "sticky")
 	local blockingWall = wall(4, 3)
 	local possible, group = plan({regular, stickyBranch, blockingWall}, {x = 3, y = 4}, {x = 1, y = 0})
 	assertTrue(possible)
@@ -161,49 +159,49 @@ test("a blocked sheared sticky block does not stop movement", function()
 	assertNotIn(group, stickyBranch)
 end)
 
-test("a skewer carries an orthogonal branch", function()
+test("a gluey block welds an orthogonal branch", function()
 	local regular = movable(3, 4)
-	local skewerBranch = movable(3, 3, false, nil, true)
-	local possible, group = plan({regular, skewerBranch}, {x = 3, y = 4}, {x = 1, y = 0})
+	local glueyBranch = movable(3, 3, "gluey")
+	local possible, group = plan({regular, glueyBranch}, {x = 3, y = 4}, {x = 1, y = 0})
 	assertTrue(possible)
 	assertIn(group, regular)
-	assertIn(group, skewerBranch)
+	assertIn(group, glueyBranch)
 end)
 
-test("a blocked skewer branch stops its rigid movement group", function()
+test("a blocked gluey branch stops its rigid movement group", function()
 	local regular = movable(3, 4)
-	local skewerBranch = movable(3, 3, false, nil, true)
+	local glueyBranch = movable(3, 3, "gluey")
 	local blockingWall = wall(4, 3)
-	local possible = plan({regular, skewerBranch, blockingWall}, {x = 3, y = 4}, {x = 1, y = 0})
+	local possible = plan({regular, glueyBranch, blockingWall}, {x = 3, y = 4}, {x = 1, y = 0})
 	assertFalse(possible)
 end)
 
-test("a spiky block pulls both orthogonal side blocks", function()
-	local spiky = movable(4, 4, false, nil, false, true)
+test("a sticky block pulls both orthogonal side blocks", function()
+	local sticky = movable(4, 4, "sticky")
 	local upper = movable(4, 3)
 	local lower = movable(4, 5)
 	local possible, group = plan(
-		{spiky, upper, lower}, {x = 4, y = 4}, {x = 1, y = 0}
+		{sticky, upper, lower}, {x = 4, y = 4}, {x = 1, y = 0}
 	)
 
 	assertTrue(possible)
-	assertIn(group, spiky)
+	assertIn(group, sticky)
 	assertIn(group, upper)
 	assertIn(group, lower)
 end)
 
-test("a spiky block releases one blocked side while pulling the other", function()
-	local spiky = movable(4, 4, false, nil, false, true)
+test("a sticky block releases one blocked side while pulling the other", function()
+	local sticky = movable(4, 4, "sticky")
 	local blockedUpper = movable(4, 3)
 	local freeLower = movable(4, 5)
 	local blockingWall = wall(5, 3)
 	local possible, group = plan(
-		{spiky, blockedUpper, freeLower, blockingWall},
+		{sticky, blockedUpper, freeLower, blockingWall},
 		{x = 4, y = 4}, {x = 1, y = 0}
 	)
 
 	assertTrue(possible)
-	assertIn(group, spiky)
+	assertIn(group, sticky)
 	assertNotIn(group, blockedUpper)
 	assertIn(group, freeLower)
 end)
@@ -219,16 +217,16 @@ end)
 
 test("diagonal blocks do not stick", function()
 	local regular = movable(3, 3)
-	local diagonalSticky = movable(2, 2, true)
+	local diagonalSticky = movable(2, 2, "sticky")
 	local possible, group = plan({regular, diagonalSticky}, {x = 3, y = 3}, {x = 1, y = 0})
 	assertTrue(possible)
 	assertIn(group, regular)
 	assertNotIn(group, diagonalSticky)
 end)
 
-test("multi-cell sticky blocks pull from every trailing occupied cell", function()
-	local tallRegular = movable(3, 3, false, {{x = 0, y = 0}, {x = 0, y = 1}})
-	local sticky = movable(2, 4, true)
+test("multi-cell sticky blocks pull from every occupied cell", function()
+	local tallRegular = movable(3, 3, nil, {{x = 0, y = 0}, {x = 0, y = 1}})
+	local sticky = movable(2, 4, "sticky")
 	local possible, group = plan({tallRegular, sticky}, {x = 3, y = 3}, {x = 1, y = 0})
 	assertTrue(possible)
 	assertIn(group, tallRegular)
@@ -245,7 +243,7 @@ test("an L-shaped sticky pulls from its trailing face in every direction", funct
 	}
 
 	for _, case in ipairs(cases) do
-		local stickyL = movable(3, 3, true, lShape)
+		local stickyL = movable(3, 3, "sticky", lShape)
 		local trailing = movable(case.trailing.x, case.trailing.y)
 		local possible, group = plan(
 			{stickyL, trailing}, {x = 3, y = 3}, case.direction
@@ -259,10 +257,10 @@ end)
 test("an L-shaped sticky can release one blocked pull while completing another", function()
 	-- Moving right, the two exposed trailing cells touch separate objects. The
 	-- upper object is pinned against a wall; the lower one is free to follow.
-	local stickyL = movable(3, 3, true, {
+	local stickyL = movable(3, 3, "sticky", {
 		{x = 0, y = 0}, {x = 1, y = 0}, {x = 0, y = 1},
 	})
-	local pinned = movable(2, 2, false, {{x = 0, y = 0}, {x = 0, y = 1}})
+	local pinned = movable(2, 2, nil, {{x = 0, y = 0}, {x = 0, y = 1}})
 	local free = movable(2, 4)
 	local blockingWall = wall(3, 2)
 	local possible, group = plan(
@@ -278,7 +276,7 @@ end)
 
 test("a T-shaped sticky pulls independently across a notched trailing face", function()
 	-- Moving up, three exposed lower faces pull into cells vacated by the T.
-	local stickyT = movable(3, 3, true, {
+	local stickyT = movable(3, 3, "sticky", {
 		{x = 0, y = 0}, {x = 1, y = 0}, {x = 2, y = 0},
 		{x = 1, y = 1},
 	})
@@ -297,54 +295,46 @@ test("a T-shaped sticky pulls independently across a notched trailing face", fun
 	assertIn(group, trailingStem)
 end)
 
-test("an L-shaped spiky block grabs moveables across several exposed faces", function()
-	local spikyL = movable(3, 3, false, {
+test("an L-shaped sticky block grabs moveables across several exposed faces", function()
+	local stickyL = movable(3, 3, "sticky", {
 		{x = 0, y = 0}, {x = 1, y = 0}, {x = 0, y = 1},
-	}, false, true)
+	})
 	local above = movable(3, 2)
 	local below = movable(3, 5)
 	local behind = movable(2, 3)
 	local possible, group = plan(
-		{spikyL, above, below, behind},
+		{stickyL, above, below, behind},
 		{x = 3, y = 3}, {x = 1, y = 0}
 	)
 
 	assertTrue(possible)
-	assertIn(group, spikyL)
+	assertIn(group, stickyL)
 	assertIn(group, above)
 	assertIn(group, below)
 	assertIn(group, behind)
 end)
 
-test("production sticky, skewer, and spiky blocks advertise distinct behavior", function()
+test("production moveables advertise adhesion (regular, sticky, gluey)", function()
 	class = require "libs/middleclass"
 	Color = class("TestColor")
 	function Color:initialize(name) self.name = name end
 	function Color:getname() return self.name end
 
 	require "generic_moveable"
-	require "generic_sticky"
-	require "generic_skewer"
-	require "generic_spiky"
 	local sprite = {getWidth = function() return 16 end, getHeight = function() return 16 end}
 	local regular = GenericMoveable:new(2, 2, "red", sprite, "box")
-	local sticky = GenericSticky:new(3, 2, "red", sprite, "sticky_box")
-	local skewer = GenericSkewer:new(4, 2, "red", sprite, "skewer_box")
-	local spiky = GenericSpiky:new(5, 2, "red", sprite, "spiky_box")
+	local sticky = GenericMoveable:new(3, 2, "red", sprite, "box", nil, "sticky")
+	local gluey = GenericMoveable:new(4, 2, "red", sprite, "box", nil, "gluey")
 
 	assertTrue(regular:canMove())
 	assertFalse(regular:isSticky())
+	assertFalse(regular:isGluey())
 	assertTrue(sticky:canMove())
 	assertTrue(sticky:isSticky())
-	assertFalse(sticky:isSkewer())
-	assertTrue(skewer:canMove())
-	assertFalse(skewer:isSticky())
-	assertTrue(skewer:isSkewer())
-	assertFalse(skewer:isSpiky())
-	assertTrue(spiky:canMove())
-	assertFalse(spiky:isSticky())
-	assertFalse(spiky:isSkewer())
-	assertTrue(spiky:isSpiky())
+	assertFalse(sticky:isGluey())
+	assertTrue(gluey:canMove())
+	assertFalse(gluey:isSticky())
+	assertTrue(gluey:isGluey())
 end)
 
 local function loadRoomClass()
@@ -442,7 +432,7 @@ end)
 
 test("Room applies the sticky-regular-player pull", function()
 	loadRoomClass()
-	local sticky = movable(2, 3, true)
+	local sticky = movable(2, 3, "sticky")
 	local regular = movable(3, 3)
 	local player = movable(4, 3)
 	local room = roomWith(player, {sticky, regular})
@@ -462,8 +452,8 @@ test("Room pulls sticky out of a pinned concave moveable", function()
 	--         mm_          mm_
 	local player = movable(1, 2)
 	local wall = wall(2, 2)
-	local sticky = movable(1, 3, true)
-	local concave = movable(1, 3, false, {
+	local sticky = movable(1, 3, "sticky")
+	local concave = movable(1, 3, nil, {
 		{x = 1, y = 0},
 		{x = 0, y = 1}, {x = 1, y = 1},
 	})
@@ -480,7 +470,7 @@ end)
 test("Room moves an L-shaped sticky and both available trailing pulls", function()
 	loadRoomClass()
 	local player = movable(3, 2)
-	local stickyL = movable(3, 3, true, {
+	local stickyL = movable(3, 3, "sticky", {
 		{x = 0, y = 0}, {x = 1, y = 0}, {x = 0, y = 1},
 	})
 	local trailingLeft = movable(3, 5)
@@ -495,27 +485,13 @@ test("Room moves an L-shaped sticky and both available trailing pulls", function
 	assertTrue(trailingRight.x == 4 and trailingRight.y == 3)
 end)
 
-test("Room shears a lateral sticky contact", function()
-	loadRoomClass()
-	local sticky = movable(3, 2, true)
-	local regular = movable(3, 3)
-	local player = movable(4, 3)
-	local room = roomWith(player, {sticky, regular})
-
-	room:movePlayer("right")
-
-	assertTrue(sticky.x == 3, "lateral sticky block should shear and stay behind")
-	assertTrue(regular.x == 4)
-	assertTrue(player.x == 5)
-end)
-
 test("Room never moves a component found by push and pull twice", function()
 	loadRoomClass()
 	local player = movable(4, 4)
 	local front = movable(5, 4)
-	local bridgeRight = movable(5, 3, false, nil, true)
-	local bridgeMiddle = movable(4, 3, false, nil, true)
-	local bridgeLeft = movable(3, 3, false, nil, true)
+	local bridgeRight = movable(5, 3, "gluey")
+	local bridgeMiddle = movable(4, 3, "gluey")
+	local bridgeLeft = movable(3, 3, "gluey")
 	local rear = movable(3, 4)
 	local component = {front, bridgeRight, bridgeMiddle, bridgeLeft, rear}
 	local room = roomWith(player, component)
@@ -533,74 +509,53 @@ test("Room never moves a component found by push and pull twice", function()
 	assertTrue(player.x == 5)
 end)
 
-test("Room pushes spiky onward while a blocked side shears off", function()
+test("Room pushes sticky onward while a blocked side shears off", function()
 	loadRoomClass()
 	local player = movable(3, 4)
-	local spiky = movable(4, 4, false, nil, false, true)
+	local sticky = movable(4, 4, "sticky")
 	local blockedUpper = movable(4, 3)
 	local freeLower = movable(4, 5)
 	local blockingWall = wall(5, 3)
-	local room = roomWith(player, {spiky, blockedUpper, freeLower, blockingWall})
+	local room = roomWith(player, {sticky, blockedUpper, freeLower, blockingWall})
 
 	room:movePlayer("right")
 
 	assertTrue(player.x == 4 and player.y == 4)
-	assertTrue(spiky.x == 5 and spiky.y == 4)
+	assertTrue(sticky.x == 5 and sticky.y == 4)
 	assertTrue(blockedUpper.x == 4 and blockedUpper.y == 3)
 	assertTrue(freeLower.x == 5 and freeLower.y == 5)
 	assertTrue(blockingWall.x == 5 and blockingWall.y == 3)
 end)
 
-test("every moveable base box gets all three synthetic behavior variants", function()
-	local BoxVariants = require "box_variants"
-	local boxSprites = {red = "box_r.png"}
-	local boxCells = {red = {{x = 1, y = 1}}}
-	local shapeSprites = {blue = "box_shape_b.png"}
-	local shapeCells = {blue = {{x = 1, y = 1}, {x = 2, y = 1}}}
-	local lSprites = {green = "box_l_g.png"}
-	local lCells = {green = {{x = 1, y = 1}, {x = 1, y = 2}, {x = 2, y = 2}}}
-	local assets = {
-		box = {class = "moveable", sprites = boxSprites, cells = boxCells},
-		["box_2x1_11"] = {class = "moveable", sprites = shapeSprites, cells = shapeCells},
-		["box_2x2_10-11"] = {class = "moveable", sprites = lSprites, cells = lCells},
-		box_statue = {class = "immoveable", sprites = {}},
-		beer_mug = {class = "moveable", sprites = {}},
+test("legacy box-variant classes load as adhesion on a plain moveable", function()
+	loadRoomClass()
+	local oldAssets, oldLoadSprite = globalAssetProperties, loadSprite
+	local sprite = {getWidth = function() return 16 end, getHeight = function() return 16 end}
+	globalAssetProperties = {
+		box = { class = "moveable", sprites = {red = "box_r.png"}, cells = {red = {{x = 1, y = 1}}} },
 	}
+	loadSprite = function() return sprite end
+	local room = setmetatable({
+		collideables = {red = {}, green = {}, blue = {}},
+		playerBlockers = {red = {}, green = {}, blue = {}},
+	}, {__index = Room})
 
-	BoxVariants.addTo(assets)
+	-- Old .sav files baked adhesion into the class name; loading must collapse them
+	-- onto the base box carrying the new adhesion property.
+	local fromSpiky = room:createEntity("spiky_box", "red", 2, 2)
+	local fromSkewer = room:createEntity("skewer_box", "red", 3, 2)
+	local fromSticky = room:createEntity("sticky_box", "red", 4, 2)
 
-	assertTrue(assets.sticky_box.class == "sticky")
-	assertTrue(assets.sticky_box.directory == "sticky")
-	assertTrue(assets.sticky_box.synthetic)
-	assertTrue(assets.sticky_box.goopy)
-	assertTrue(assets.sticky_box.sprites == boxSprites, "variant should share base sprites")
-	assertTrue(assets.sticky_box.cells == boxCells, "variant should share collision cells")
-	assertTrue(assets["sticky_box_2x1_11"].sprites == shapeSprites)
-	assertTrue(assets["sticky_box_2x1_11"].cells == shapeCells)
-	assertTrue(assets["sticky_box_2x2_10-11"].sprites == lSprites)
-	assertTrue(assets["sticky_box_2x2_10-11"].cells == lCells)
-	assertTrue(assets.skewer_box.class == "skewer")
-	assertTrue(assets.skewer_box.directory == "skewer")
-	assertTrue(assets.skewer_box.synthetic)
-	assertTrue(assets.skewer_box.skewer)
-	assertTrue(assets.skewer_box.sprites == boxSprites)
-	assertTrue(assets.skewer_box.cells == boxCells)
-	assertTrue(assets["skewer_box_2x1_11"].sprites == shapeSprites)
-	assertTrue(assets["skewer_box_2x2_10-11"].cells == lCells)
-	assertTrue(assets.spiky_box.class == "spiky")
-	assertTrue(assets.spiky_box.directory == "spiky")
-	assertTrue(assets.spiky_box.synthetic)
-	assertTrue(assets.spiky_box.spiky)
-	assertTrue(assets.spiky_box.sprites == boxSprites)
-	assertTrue(assets.spiky_box.cells == boxCells)
-	assertTrue(assets["spiky_box_2x1_11"].sprites == shapeSprites)
-	assertTrue(assets["spiky_box_2x2_10-11"].cells == lCells)
-	assertFalse(assets.sticky_box_statue)
-	assertFalse(assets.sticky_beer_mug)
-	assertFalse(assets.skewer_box_statue)
-	assertFalse(assets.skewer_beer_mug)
-	assertFalse(assets.spiky_box_statue)
-	assertFalse(assets.spiky_beer_mug)
+	assertTrue(fromSpiky:isSticky(), "legacy spiky_ should load as sticky")
+	assertTrue(fromSkewer:isGluey(), "legacy skewer_ should load as gluey")
+	assertTrue(fromSticky:isSticky(), "legacy sticky_ should load as sticky")
+	assertTrue(fromSpiky.saveClass == "box", "class should normalize to the base box")
+
+	-- An explicit adhesion in the object data wins and rides through on a plain box.
+	local placed = room:createEntity("box", "red", 5, 2, { adhesion = "gluey" })
+	assertTrue(placed:isGluey())
+	assertTrue(placed.saveClass == "box")
+	globalAssetProperties, loadSprite = oldAssets, oldLoadSprite
 end)
 
-print("movement/block-variant tests passed: " .. passed)
+print("movement tests passed: " .. passed)