Super Mario World (IsoFrieze/SMWDisX, and measured in Mesen)

On the ground, a fresh press of B (or X) starts Mario's jump and a fresh press of A a spin jump; CODE_00D5F2 takes the take-off speed from DATA_00D2BD at an index set by his horizontal speed. super-mario-world/jump-start

About: Super Mario World Jump

byetudlrFrame carries B and X as fresh presses and axlr0000Frame carries A, so B or X gives a normal jump and A (unless Mario carries an item) a spin jump. The index is |X speed| ÷ 4 with the low bit cleared, one step per 8/16 px/frame; a spin jump adds 1.

Cited by: Jump, Spin jump, Super Mario World

DATA_00D2BD gives a normal jump −80/16 to −97/16 px/frame ($B0–$9F) and a spin jump −74/16 to −90/16 ($B6–$A6), faster for every 0.5 px/frame of horizontal speed. super-mario-world/jump-speed-table

About: Super Mario World Jump

{
 "normal": [
  -80,
  -82,
  -85,
  -87,
  -90,
  -92,
  -95,
  -97
 ],
 "spin": [
  -74,
  -76,
  -78,
  -80,
  -82,
  -85,
  -87,
  -90
 ]
}

Pairs of (normal, spin) by |X speed| band: 0–7, 8–15, 16–23, 24–31, 32–39, 40–47, 48–55, and 56–63 sixteenths per frame. Speeds are the high byte of PlayerYSpeed, in 1/16 px/frame, negative up.

Cited by: Jump, Spin jump, Super Mario World, Variable jump height

Each frame CODE_00D928 adds 3/16 px/frame to Mario's vertical speed while A or B is held and 6/16 otherwise, rising or falling. super-mario-world/gravity

About: Super Mario World Gravity

{
 "held": 3,
 "released": 6
}

Other paths through the same routine, for the cape and for winged Yoshi, use the table's other entries. Swimming has its own routine (CODE_00D988). The probe measured both steps (fall-speed).

Cited by: Gravity, Super Mario World, Variable jump height

Gravity's routine cuts a downward speed above $40 (4 px/frame) back to $40 before adding gravity, so Mario falls at most 70/16 px/frame, or 67/16 holding the button. super-mario-world/fall-speed

About: Super Mario World Gravity

{
 "clamp": 64,
 "held": 67,
 "released": 70
}

Every value is stored after gravity, so $40 itself never moves Mario.

Cited by: Gravity, Super Mario World, Variable jump height

Each frame the player routine moves Mario by his current speed (CODE_00DC2D), then handles a jump press (CODE_00D5F2), then adds gravity (CODE_00D7E4), so the press frame doesn't lift him and his first step up is the take-off speed plus held gravity. super-mario-world/motion-order

About: Super Mario World Gravity

Cited by: Gravity, Jump, Super Mario World, Variable jump height

CODE_00DC4F adds a speed's low nybble to a subpixel byte and its high nybble, sign-extended, plus the carry to the 16-bit position, so Mario moves in sixteenths of a pixel. super-mario-world/subpixel-motion

About: Super Mario World Gravity

Called with X = 2, the same routine moves Y, through the byte after PlayerXPosSpx that the RAM map labels PlayerYPosSpx ($13DC). Landing doesn't clear that subpixel, so Mario leaves the ground with whatever fraction he had, and a jump's drawn height can differ by a pixel between take-offs.

Cited by: Fixed-point arithmetic, Gravity, Super Mario World, Variable jump height

Measured in the game, Mario climbs 64.2 px held and 33.3 px tapped from a standstill, 72.6 px held at walking speed, 81.6 px held running, and 85.3 or 91.1 px held sprinting. super-mario-world/rise-by-speed

About: Super Mario World Variable jump height

{
 "stand": {
  "xspeed": 0,
  "tap": {
   "rise16": 533,
   "at": 14,
   "sub": 4,
   "apex": 34,
   "apexAt": 14,
   "airtime": 28
  },
  "full": {
   "rise16": 1027,
   "at": 27,
   "sub": 4,
   "apex": 64,
   "apexAt": 25,
   "airtime": 54
  }
 },
 "walk": {
  "xspeed": 20,
  "tap": {
   "rise16": 602,
   "at": 15,
   "sub": 7,
   "apex": 38,
   "apexAt": 15,
   "airtime": 30
  },
  "full": {
   "rise16": 1162,
   "at": 29,
   "sub": 15,
   "apex": 72,
   "apexAt": 27,
   "airtime": 58
  }
 },
 "run": {
  "xspeed": 36,
  "tap": {
   "rise16": 675,
   "at": 16,
   "sub": 14,
   "apex": 42,
   "apexAt": 15,
   "airtime": 32
  },
  "full": {
   "rise16": 1305,
   "at": 30,
   "sub": 11,
   "apex": 81,
   "apexAt": 28,
   "airtime": 61
  }
 },
 "sprint47": {
  "xspeed": 47,
  "tap": {
   "rise16": 705,
   "at": 16,
   "sub": 13,
   "apex": 44,
   "apexAt": 16,
   "airtime": 33
  },
  "full": {
   "rise16": 1365,
   "at": 31,
   "sub": 10,
   "apex": 85,
   "apexAt": 29,
   "airtime": 63
  }
 },
 "sprint48": {
  "xspeed": 48,
  "tap": {
   "rise16": 752,
   "at": 17,
   "sub": 2,
   "apex": 47,
   "apexAt": 15,
   "airtime": 34
  },
  "full": {
   "rise16": 1457,
   "at": 32,
   "sub": 12,
   "apex": 91,
   "apexAt": 31,
   "airtime": 65
  }
 }
}

rise16 is the climb in 1/16 px from where Mario stands after the press frame, reached on frame at; it is exact and the same on every take-off. apex, apexAt, and airtime are whole drawn pixels and frames for the take-off subpixel sub, and can differ by one with another subpixel. The tap's sprint48 take-off read 49, the same band. Walking is $14, running $24.

Cited by: Super Mario World, Variable jump height

Measured in the game from a standstill, Mario's climb grows with each frame B is held, from 33.3 px tapped to 64.2 px at 28 frames or more. super-mario-world/rise-by-hold

About: Super Mario World Variable jump height

{
 "1": 533,
 "2": 571,
 "4": 642,
 "8": 766,
 "12": 866,
 "16": 942,
 "20": 994,
 "24": 1022,
 "28": 1027,
 "32": 1027,
 "40": 1027,
 "60": 1027
}

Holding past the top changes the fall instead: gravity stays at 3/16 while B is down, so the airtime keeps growing (54 frames for a 60-frame hold against 49 for 28).

Cited by: Super Mario World, Variable jump height

Measured in the game, a standing spin jump climbs 54.8 px with A held and 28.5 px tapped, against 64.2 and 33.3 for a normal jump. super-mario-world/spin-rise

About: Super Mario World Jump

{
 "tap": {
  "rise16": 456,
  "at": 13
 },
 "full": {
  "rise16": 876,
  "at": 25
 }
}

Cited by: Jump, Spin jump, Super Mario World

Measured on flat ground, Mario's top speed is 20/16 px/frame walking, 36/16 holding Y, and 47/16 to 49/16 once the P-meter is full, near DATA_00D535's $14, $24, and $30. super-mario-world/top-speeds

About: Super Mario World Running

{
 "walk": 20,
 "run": 36,
 "sprint": [
  47,
  49
 ]
}

At a full P-meter the speed wobbles across the jump table's step at 48, so a sprinting jump takes off at −92/16 or −95/16 px/frame depending on the frame (rise-by-speed, sprint47 and sprint48).

Cited by: Super Mario World, Variable jump height

In the air with neither Left nor Right held, Mario's horizontal routine returns before friction, so he keeps his speed. super-mario-world/air-coast

About: Super Mario World Air control

Cited by: Super Mario World, Variable jump height

Holding a direction in the air accelerates Mario by MarioAccel_'s 1.5/16 px/frame each frame up to his top speed, or by 5/16 (2.5/16 without Y) while he still moves the other way. super-mario-world/air-steer

About: Super Mario World Air control

{
 "accel": 24,
 "turnRun": 80,
 "turnWalk": 40
}

The same code runs on the ground; only the air skips friction (air-coast). PlayerXSpeed is 16-bit, so 1.5/16 px/frame² is $0180 = 384/256 of a sixteenth. "Up to his top speed" is approximate: the add is unclamped and a speed at or past the cap brakes by 1/16 instead (cap-test), and the turning rate holds while the speed's high byte is nonzero and points the other way (turning). air-rule gives the exact frame step.

Cited by: Air control, Super Mario World, Variable jump height

Measured in the game, a running jump keeps 36/16 px/frame when Right is let go, and turning Left in the air reverses it within 8 frames and reaches 36/16 the other way 29 frames after the turn. super-mario-world/air-measured

About: Super Mario World Air control

{
 "coast": 36,
 "turnFrames": 8,
 "reverseFrames": 29
}

Each frame's move uses the previous frame's speed (frame-order), so the counts are of speed updates. From exactly 36.0/16 the 8th turning step overshoots zero to −4/16, and the high byte reads −36 once the 16-bit speed passes below −35/16, which the 21st plain step does; so 29, where a model that stops the turn at zero and waits for −36.0 predicts 32 (air-rule).

Cited by: Super Mario World

Each frame the player routine moves Mario by last frame's speed, runs block collision (which lands him), then CODE_00D5F2 updates his horizontal speed, so a speed change first moves him on the next frame and a landing frame already uses the ground rules. super-mario-world/frame-order

About: Super Mario World Running

[
 "move",
 "collision",
 "duck-jump-horizontal",
 "gravity"
]

CODE_00E92B is the block collision; CODE_00EF60 clears PlayerInAir when Mario lands. The jump press and the horizontal speed update share CODE_00D5F2 (jump-start), and gravity comes last (motion-order).

PlayerXSpeed is 16 bits, a high byte in 1/16 px/frame and a low byte below it, so acceleration works in 1/4096 px/frame; position moves by the high byte alone. super-mario-world/x-speed-format

About: Super Mario World Running

The high byte of a negative speed is its floor: −35.5/16 px/frame is $DC80, whose high byte reads −36. Every test in the horizontal code (cap, turning) and every move reads that byte.

On flat ground MarioAccel_ speeds Mario toward a held direction by $0180 (1.5/16 px/frame) a frame, with or without Y; holding against his motion uses its turning row, $0280 (2.5/16) walking and $0500 (5/16) with Y. super-mario-world/ground-accel

About: Super Mario World Running

{
 "accel": 384,
 "turnWalk": 640,
 "turnRun": 1280
}

Rows are per slope (SlopeType, 8 bytes a row); row 0 is flat ground and the turning rows start 144 bytes ($90) in. Slippery ground uses DATA_00D43D instead.

DATA_00D535 caps Mario's ground speed at $14 walking and $24 holding Y, and at $30 while the P-meter is full and charging. super-mario-world/caps

About: Super Mario World Running

{
 "walk": 20,
 "run": 36,
 "sprint": 48,
 "runTakeoff": 35,
 "pmeterFull": 112,
 "pmeterUp": 2,
 "pmeterDown": 1
}

The cap index is 0 walking, 1 with Y, and 2 with Y at $23 or more on the ground (or in a jump that left at full P-meter, PlayerInAir $0C); index 2 adds 2 to the P-meter and the others take 1 away, and a P-meter that reaches $70 bumps the index once more, to the sprint cap. So the sprint cap lasts only while Mario keeps charging. Index 2's cap is $24 again.

CODE_00D742 compares only the speed's high byte with the cap; below it the frame adds the full acceleration, unclamped, and at or past it the frame applies friction instead, so Mario's top speed cycles around the cap. super-mario-world/cap-test

About: Super Mario World Running

The walking cycle averages 20/16 px/frame and the running one 36/16, which is why the measured top speeds wobble by a sixteenth (top-speeds).

Cited by: Running

With no direction held on the ground, CODE_00D76B moves Mario's speed 1/16 px/frame a frame toward the slope's target speed, 0 on flat ground, and stops exactly on it. super-mario-world/friction

About: Super Mario World Running

Value: 256 1/4096 px/frame²

The same routine brakes a speed past the cap (cap-test), on the ground and in the air. In 16-bit mode BIT.B LevelIsWater reads $85 and $86 together, so its sign bit is bit 7 of LevelIsSlippery; slippery ground brakes by DATA_00D309's $0020 (1/128 px/frame²). Each frame with no direction also drains the P-meter by 1.

Mario turns at the turning row's rate while his speed's high byte is nonzero and points against the held direction; the step is not clamped at zero, so the last one overshoots into the new direction. super-mario-world/turning

About: Super Mario World Running

A high byte of 0 counts as no motion, so a speed between 0 and 1/16 px/frame accelerates at the plain rate. The test runs in the air too (air-rule). SkidTurnTimer, when running, suppresses the turning rate.

A held Left or Right turns Mario to face it on the same frame, on the ground and in the air, unless he carries an item. super-mario-world/facing

About: Super Mario World Running

PlayerDirection is 0 left, 1 right. Right wins when both are held. Carrying an item, Mario turns only when FaceScreenTimer is 0, which then runs for 8 frames.

On flat ground, Down makes Mario duck, and a ducking Mario ignores Left and Right, so friction alone slows him; the duck flag is set only on the ground, so a duck jump stays ducked and steers. super-mario-world/duck

About: Super Mario World Running

A jump press is checked before the duck branch, so Mario can jump from a duck. Small Mario ducks too; ducking also shrinks his box (clipping).

Measured from a standstill on Yoshi's Island 1, Mario first passes $14 on frame 14 walking and reaches $24 on frame 24 holding Y; with Y held his P-meter fills 56 frames later. super-mario-world/ground-measured

About: Super Mario World Running

{
 "walkPass": 14,
 "runReach": 24,
 "pmeterFrames": 56,
 "walkStop": 20
}

Released at 20/16 px/frame, he stops 20 frames later (walkStop).

In the air Mario's horizontal speed follows the ground's code except that a released d-pad keeps the speed and the cap index never reaches 2 unless he left at full P-meter; a frame-by-frame model of these rules reproduces every probed frame. super-mario-world/air-rule

About: Super Mario World Air control

{
 "accel": 384,
 "turnWalk": 640,
 "turnRun": 1280,
 "friction": 256,
 "caps": [
  20,
  36,
  36,
  48
 ],
 "runTakeoff": 35,
 "pmeterFull": 112
}

One frame, with v the 16-bit speed, hi its high byte (floor), and d the held direction (+1 Right, −1 Left, Right first): with no d, the air keeps v and the ground brakes it (friction). Otherwise the turning row applies if hi ≠ 0 and its sign is not d; the cap index is 0, or 1 with Y, or 2 with Y and |hi| ≥ $23 (ground, or a full-P-meter jump), plus 1 when the P-meter fills; then if hi − cap is 0 or has the cap's sign, v moves $0100 toward 0 (clamped there), else v += the acceleration, unclamped. The measured air turn of air-measured follows: from exactly 36/16 ($2400) the turning steps give 31, 26 … 1, then −4 on the 8th frame, overshooting zero; 21 plain steps of −1.5/16 then reach −35.5/16 ($DC80), whose high byte reads −36, on the 29th frame. A model that stops the turn at zero, or that waits for the full −36.0, gets 30 to 32.

Cited by: Air control

Measured frame by frame, a running jump turned with Left and Y held drops from 35/16 px/frame to exactly 0 in 7 frames of −5/16, then gains −1.5/16 a frame and reads −36/16 on the 31st frame of the turn. super-mario-world/air-turn-trace

About: Super Mario World Air control

{
 "from": 8960,
 "turnFrames": 7,
 "reachFrames": 31
}

The count depends on the 16-bit speed at the turn: from 35.0 the turning steps land exactly on 0, so no overshoot, while from 36.0 (air-measured) they overshoot to −4/16 and the turn takes 29 frames. At a held run the speed cycles through 35.0, 36.5, 35.5, 37.0, and 36.0 (cap-test), so a turn takes 29 to 31 frames depending on the frame it starts.

The jump press sets only Mario's vertical speed and air state, then falls into the horizontal code, so the press frame already uses the air rules and his speed carries over unchanged. super-mario-world/takeoff-x

About: Super Mario World Jump

PlayerInAir is $0B for a jump, or $0C when the P-meter is full (which keeps the sprint cap in the air, caps); $24 means falling. The speed picks the jump's vertical speed (jump-start).

Landing clears PlayerInAir during block collision, before the frame's speed update, so the landing frame already brakes or accelerates by the ground rules; the jump itself leaves the horizontal speed alone. super-mario-world/landing

About: Super Mario World Jump

It also clears the spin-jump flag. The vertical speed is set from a table there, then gravity adds to it, so a standing Mario shows a downward speed of 6/16 px/frame every frame.

GetMarioClipping gives Mario a box for touching sprites 12 px wide from x+2, 26 px tall from y+6 when big, and 12 px tall from y+20 when small or ducking. super-mario-world/clipping

About: Super Mario World Hitbox

{
 "big": {
  "x": 2,
  "y": 6,
  "width": 12,
  "height": 26
 },
 "small": {
  "x": 2,
  "y": 20,
  "width": 12,
  "height": 12
 },
 "bigYoshi": {
  "x": 2,
  "y": 16,
  "width": 12,
  "height": 32
 },
 "smallYoshi": {
  "x": 2,
  "y": 24,
  "width": 12,
  "height": 24
 }
}

Offsets are from PlayerXPosNext/PlayerYPosNext, the top-left of Mario's 16×32 px frame for big and small alike.

Cited by: Hitbox

Against blocks Mario tests six points, a center, two side points, a head, and two feet at x+5 and x+11, y+32; big Mario's head point is at y+8 and small Mario's at y+16. super-mario-world/block-points

About: Super Mario World Hitbox

{
 "small": {
  "center": [
   8,
   24
  ],
  "side": [
   [
    14,
    26
   ],
   [
    14,
    22
   ]
  ],
  "head": [
   8,
   16
  ],
  "feet": [
   [
    5,
    32
   ],
   [
    11,
    32
   ]
  ]
 },
 "big": {
  "center": [
   8,
   18
  ],
  "side": [
   [
    14,
    26
   ],
   [
    14,
    15
   ]
  ],
  "head": [
   8,
   8
  ],
  "feet": [
   [
    5,
    32
   ],
   [
    11,
    32
   ]
  ]
 },
 "rightSideX": 2
}

Points are [x, y] offsets from PlayerXPosNext/PlayerYPosNext. These are for Mario's x in the left half of a 16 px block column; in the right half (the index plus 12 bytes) the side points move to x+2 (rightSideX) and the feet swap order. Small and ducking share a set; Yoshi has two more. The middle of his 16 px frame is x+8, so the feet sit 3 px to either side of it and the side points 6 px; the movement lab centers his box there. NormalCollision tests the points in the order listed, after the frame's move (frame-order), and pushes him out of a wall only after all six (side-push).

Cited by: Hitbox

HurtMario returns at once while IFrameTimer is nonzero. After the power-down animation Super Mario World sets it to $7F, and the timer loop counts it down on every frame the sprites aren't locked. super-mario-world/iframes

About: Super Mario World Invincibility frames

Value: 127 frames

GetBlockAtPlayer adds a point's offsets to Mario's position and reads the block holding that pixel, x ÷ 16 for the column and y with its low 4 bits cleared for the row; in a horizontal level's layer 1, every point below y $1B0 (432 px) reads as air. Side points stop at blocks $111–$16D, and a falling foot lands on $100–$16D. super-mario-world/block-lookup

About: Super Mario World Hitbox

{
 "blockSize": 16,
 "levelBottom": 432
}

Vertical levels and layer 2 have their own branches of the lookup. A point past the level's last screen also reads as air. In the movement lab, every column is solid like a $130 cement block: the lab's stages keep the game's 16 px rows (a column top is a block top), and the model takes the block grid in x through the stage's first column edge.

With Mario's x in the left half of a block column (PlayerBlockXSide 0), collision tests his side points at x+14, and unless he's flush at x mod 16 = 2 marks him blocked on the right; in the right half (1), it tests those at x+2, flush at 13, blocked on the left. After all six points, it moves him 1 px back out of the wall and, if his speed points into the wall, zeroes its high byte but not its low byte. super-mario-world/side-push

About: Super Mario World Hitbox

{
 "flush": [
  2,
  13
 ],
 "step": 1
}

From the code alone (T3): a solid block at Mario's center point skips the side points and marks him blocked right with bit $11 (CODE_00EBC9, Y = 2), so he is pushed left; the probe doesn't reach that case. Blocked right is bit $01 and pushes −1 px (the word $FFFF at DATA_00E90D), blocked left $02 and +1 px. A speed pointing away from the wall, or a push from the screen edge (bit $80), keeps its high byte. Flush, the side point sits on the wall's outermost column of pixels; between pushes his speed moves only his subpixel. The probe's 16 px step stops him at x 370 too: the side body point is 6 px above his feet.

When neither foot point finds a block and Mario isn't in the air, collision sets PlayerInAir to $24 (falling). Collision follows the move, so he counts as airborne on the frame whose move carries his trailing foot past the edge, already moved by the ground's vertical speed, 6/16 px/frame (3/16 with B held); gravity then adds 6/16 a frame (3/16 held) up to 70/16. super-mario-world/walk-off

About: Super Mario World Coyote time

{
 "inAir": 36,
 "fall": [
  6,
  12,
  18,
  24,
  30,
  36,
  42,
  48,
  54,
  60,
  66,
  70,
  70
 ],
 "fallHeld": [
  3,
  6,
  9
 ]
}

The trailing foot is x+5 walking right and x+11 walking left (block-points), 3 px behind the middle of his frame. Either foot on a block keeps him on it: the foot code checks the second foot only when the first finds nothing. A jump's own $0B turns to $24 at its peak, in gravity's routine (CODE_00D928); the walk-off's $24 isn't $0C, so it doesn't keep the sprint cap in the air (caps).

Mario gets no grace window after walking off a ledge; CODE_00D5F2 starts a jump only while PlayerInAir is 0, and block collision, earlier in the same frame, has already set it to $24. super-mario-world/no-coyote-time

About: Super Mario World Coyote time

CODE_00D682 is the horizontal code, so the press frame still steers. A spin jump (A) takes the same branch.

Cited by: Coyote time

A foot point in a block's top half lands Mario unless he is moving up; CODE_00EE11 takes the point's row within the block, and below 8 the landing subtracts it from his y, keeping the subpixel, which stands him on the block's top. In the lower half the point doesn't land him. super-mario-world/foot-landing

About: Super Mario World Jump

{
 "landAbove": 8
}

At most 70/16 px/frame (fall-speed), a falling foot can't pass a block's top half in one frame, so he lands on any top he falls onto. The vertical speed is then set from a table (0 for a flat block) and gravity adds to it (landing). Tiles $159–$15B in tilesets 3 and E skip the landing.

Right after block collision, CODE_00F595 starts Mario's death once his y measured from the top of the screen reaches 256 px, 32 px below the bottom of the 224-line picture, unless YoshiHeavenFlag is set, when it jumps to CODE_00C95B instead. super-mario-world/pit-death

A high byte of 0 (on screen) or $FF (above it) goes negative at the DEC and returns; 1 or more is 256 px down. In the stage probe, small Mario walking off a ledge in Yoshi's Island 1 stops moving 28 frames later, the death animation's freeze. The movement lab has no screen, and lets him fall.

Mario's head point (x+8, and y+8 big or y+16 small; block-points) is the fourth of collision's six points, after the center and side points and before the feet. In the air, when it is in a solid block, collision moves him down by 15 minus the point's row in the block, keeping the subpixel, so the point ends on the block's bottom row, and zeroes his vertical speed if he was rising. Gravity then acts on that frame as usual. A turn block hit this way skips the move on that frame (turn-block-hit). super-mario-world/head-hit

About: Super Mario World Hitbox

{
 "row": 15
}

The move is an 8-bit add to y's low byte, with the carry into its high byte. The point can stay inside the block on its bottom row for a few frames as he starts to fall; each of those frames moves him by 0 and sets the top-blocked bit. The bonk sound plays only when no other sound is queued that frame. Slopes ($16E up) take the same code with their own heights.

On the ground, a head point in a solid block's upper 9 rows (0–8) ejects Mario left: collision marks him blocked on the right and zeroes his horizontal speed's high byte, and the wall push then moves him 1 px left a frame (side-push). In rows 9–15 he isn't moved. Either way it sets the top-blocked bit, and while that bit is set a jump press on the ground doesn't jump. super-mario-world/head-ground

About: Super Mario World Hitbox

{
 "ejectBelow": 9,
 "step": 1
}

The game reaches this only when he is already under a low block: walking in, his side head point (y+15 big) stops him at the block's side first. A press made while blocked isn't remembered, so holding B on through the eject never jumps.

A turn block ($11E) under the head point is hit from below like any functional block: it becomes bounce sprite 7, the turning turn block. That path doesn't read Powerup, and it breaks a block only when the block's IntBlk_BounceSprite entry is 7; the turn block's entry is 6 (its sprite number is 7), so a plain head hit never breaks a turn block, big or small. On the hit frame collision skips the head's downward move and only zeroes a rising speed. super-mario-world/turn-block-hit

About: Super Mario World Destructible terrain

{
 "breaks": false
}

_6, the side, is 0 (below) from the head, which the turn block's activation mask ($08) accepts.

A block hit from below becomes a bounce sprite with an 8-frame timer and a vertical speed of $C0 (−4 px/frame), and on its first frame, the hit frame, the block's cell becomes an invisible solid tile ($152) under it. Each frame the sprite moves by its speed's high nybble plus the carry of its low nybble into a fraction byte, then adds $10 to the speed (a ? block) or $13 (a turn block). Nothing clears that fraction, so a slot's leftover from its last bounce carries into the next. super-mario-world/block-bounce

About: Super Mario World Destructible terrain

{
 "speed": -64,
 "accel": {
  "question": 16,
  "turn": 19
 },
 "timer": 8,
 "slots": 4
}

The ? block's speed steps by $10, so its fraction never changes and its path is always the same; the turn block's $13 leaves a fraction. The timer runs down 7, 6, … from the hit frame. The game has four bounce sprite slots, searched from slot 3 down.

After a head hit, a turn block bounces through the hit frame and the five after it; on the sixth it snaps back to its cell as the always-turning tile ($048), which nothing collides with, so Mario passes through it. Its spin timer, $FF at the hit, runs down by one a frame, and 255 frames after the hit frame the cell becomes a turn block again. super-mario-world/turn-block-spin

About: Super Mario World Destructible terrain

{
 "from": 6,
 "back": 255
}

The bounce timer counts 7 on the hit frame (CODE_02904D decrements it before each run), so it reaches 1 on the sixth frame after.

A ? block under the head point (tile $124, a coin, in the probe) is hit from below: it gives its contents and bounces (block-bounce), and collision then treats it as solid, moving Mario down onto its bottom row and stopping his rise on the same frame (head-hit). When the bounce timer runs out, 7 frames after the hit frame, the cell becomes a used block ($132), which is solid and is never hit again. super-mario-world/question-block-hit

About: Super Mario World Hitbox

{
 "usedAt": 7
}

The lab's ? block holds nothing; the game's coin, item, or vine comes out on the hit.