Konami's Baseball (antxiko's commented disassembly of the MSX cartridge)

In Konami's Baseball a meter runs on every frame of a match until the pitch starts: a three-digit decimal count that starts at 70, rises by one per frame to 160, then falls by one per frame, and is reset to 70 and rising when it falls back to 70. A speed index starts at 0, rises by one each time the count passes a ten on the way up, and falls by one each time the count's units digit wraps from 0 to 9 on the way down (80 to 79), so it is the count's tens less 7: 0 at 70 to 79, 8 at 150 to 159, and 9 only at the peak of 160 (computed). Pressing a button with no direction, or with down (bit 1, which the disassembly's comment on the arrow-key table names as down), starts the wind-up, which stops the meter. The speed index then picks the ball's step from a 12-entry table, 358 to 910 in 1/256 pixel (about 1.40 to 3.55 pixels), added toward the plate each time the pitch routine runs, which is on even frames only; the meter alone gives indexes 0 to 9. In flight a first counter (0xE127) is lowered by the pixels moved each run and reloaded with 3 more when it wraps; only on runs where it has just wrapped, a second counter (0xE128, starting at 10) is lowered too, and when that one wraps it is reset to 10 and the index falls by one, not below 0, and the step is re-read, so the pitch slows on its way (the atlas's reading). konamis-baseball/pitch-speed

About: Konami's Baseball Pitch control

{
 "meter": [
  70,
  160
 ],
 "speed_index": [
  0,
  9
 ],
 "steps_256ths": [
  358,
  404,
  464,
  534,
  578,
  613,
  648,
  706,
  780,
  820,
  860,
  910
 ]
}

The count is two BCD bytes, 0xE362 (hundreds) and 0xE361; the index is 0xE363. The step is 8.8 fixed point with the whole pixels in the high byte, so the pixel figures are the steps over 256; the table's comment calls them per frame, but the routine that adds them runs on even frames only. A button with up, left, or right takes a different branch, which the disassembly's comment says cancels the pitch; the atlas hasn't read what it does. 0xE364, which the comments call the chosen break (efecto), rises and falls with the count (it starts at 70) and is copied to 0xE121 at the wind-up, and the flight lowers it as it goes; the atlas found no other read of it by address. After the pitch, escribe_la_cuenta draws the count's three digits followed by three fixed tiles (0xA2 to 0xA4), which the atlas hasn't seen. The computer's pitcher (suelta_el_lanzamiento) waits for 0xE364's high nibble to match a value from its own table and then writes a button press into its controller byte.

Cited by: Konami's Baseball, Pitch control

In Konami's Baseball, once the pitch is in the air the routine that moves the ball also reads a controller and moves the ball's row, across its path to the plate. The disassembly's labels and comments call this part the bat; the atlas reads it as the pitcher's, because it calls the same controller routine (el_mando_del_que_ataca) as the code that starts the pitch, while the batter's routine calls the other one (el_mando_del_que_defiende). The first press of bit 1, 2, or 3 of the controller byte fixes the direction: bit 3 moves the row by +1, bit 1 or 2 alone by -1. The disassembly's comment on the arrow-key table names those bits down (1), left (2), and right (3), which makes it right for +1 and down or left for -1. The row then moves one pixel every n runs of the routine, which runs on even frames. For speed indexes 0 to 7, n starts at 8 and, while one of those directions stays held, becomes 4 after 8 runs, 3 after 4 more, and 2 after 3 more, where it stays; letting go keeps the current n (computed). The values come from four identical table rows of 8, 4, 3, 2, 1 (the 1 is never reached), the row picked by the pitch's speed index halved and capped at 4. At speed index 8 or 9 that is a fifth row, past the table's end, so n is read from the first bytes of the next routine: 33 runs per pixel at first, then a 0, which the countdown treats as 256, so the fastest pitches barely move across (the atlas's reading, computed). konamis-baseball/pitch-steer

About: Konami's Baseball Pitch control

{
 "n_runs_per_pixel": [
  8,
  4,
  3,
  2
 ],
 "runs_before_next_n": [
  8,
  4,
  3
 ],
 "speed_8_9_n": [
  33,
  256
 ]
}

The routine stores n in three bytes: 0xE12B counts the runs held before the next step, 0xE12C counts down to the next pixel (set only when it is empty, so a new n takes effect at the next pixel), and 0xE12D reloads 0xE12C. The fifth row starts at 0x4fc3, the first instruction of lleva_el_medidor (ld hl,0e100h, then ld a,(hl)), whose bytes 0x21, 0x00, 0xE1, 0x7E give n = 33, 0 (256), 225, 126 in turn. The controller byte both routines read is written by calcula_flancos only when a reading matches the previous frame's, so it holds a held direction; its comment calls it newly pressed bits. Up isn't in the mask. Which screen direction the row's +1 is hasn't been checked.

Cited by: Konami's Baseball, Pitch control

In Konami's Baseball a swing starts on a button press and, while a button is held, steps to the next bat pose every 3 runs of the batter routine, which runs on odd frames. A hit needs the bat in pose 2, 3, or 4 and the ball inside a contact box around the bat's position, one box per batting side, so a held swing can hit for 9 runs (computed). Letting go leaves the bat in its pose, and unless that is the fifth the contact test goes on (the routine's comment says letting go ends the swing). The angle the ball flies off at comes from a table by pose and by the pose's step counter, 3, 2, or 1 while the button is held, plus 0 to 3 from the Z80's R register. On one batting side, pose 2 gives 48 to 56, pose 3 28 to 36, and pose 4 8 to 16 (before the random part); the other side's table is the mirror image, so early and late contact send the ball toward opposite ends of the range. A second value is the ball's row plus 3 less the bat's point at 0xE144 plus an offset (16 on one side, 2 on the other), negated on the second side: 0 to 9 hits, and anything else misses. It picks the value the comment calls the ball's starting height, highest at 4. When the computer bats, a value of 0 or of 8 and over, including one that would miss, becomes 6. konamis-baseball/batting

About: Konami's Baseball Batting timing

{
 "pose_runs": 3,
 "hit_poses": [
  2,
  3,
  4
 ],
 "angles_side_a": {
  "pose2": [
   48,
   52,
   56
  ],
  "pose3": [
   28,
   32,
   36
  ],
  "pose4": [
   8,
   12,
   16
  ]
 },
 "random_add": [
  0,
  3
 ],
 "heights_by_value": [
  272,
  304,
  344,
  424,
  512,
  472,
  360,
  328,
  272,
  240
 ]
}

The angle row is found by adding 5 per pose (pose 2 lands on 0x728a, the table's start); the column is 0xE141, which the comment calls the bat's column and which the swing routine reloads with 3 at each pose step and counts down. Columns 0 and 4 (60 and 44, 24 and 4 on the first side) aren't reached with the button held. Heights are 16-bit values (0x0110 to 0x0200); the tenth comes from the next table's first bytes, as the comment says. The value's low two bits and one more random bit then pick a pair the comments call the ball's two components (0x72ba). The contact boxes are at 0x730a (12 bytes, three boxes; the third isn't used here). Which end of the angle range is the pull side hasn't been checked. A separate routine, ajusta_el_golpe_de_la_maquina, changes the computer's hits when the score is level; the atlas hasn't claimed it.

Cited by: Batting timing, Konami's Baseball

Konami's Baseball ends a match when the inning counter at 0xE40B reaches 9. The counter rises by one each time the second team's half ends, and no branch lets a tie go on, so a level score after nine innings ends the match (the atlas's reading). When the counter reads 8, the index of the ninth cell in each team's scoreboard row, two checks end the match early. At the end of the first team's half, if the second team's total is higher, the game writes tile 0xE7 into the second team's ninth cell and ends the match without the bottom half. While the second team bats in that inning, the match ends as soon as a run puts it ahead. Both checks compare the totals' tens and then their units. The disassembly's comment on the first check reads it as extra innings on a tie; the code continues on a tie and ends the match when the second team leads. konamis-baseball/innings

{
 "innings": 9,
 "extra_innings": false,
 "skip_bottom_ninth_when_ahead": true,
 "walk_off": true
}

Each team's row is 12 bytes, a digit tile per inning at the counter's index (0xE410 and 0xE420) and the total's tens and units at offsets 10 and 11 (0xE41A, 0xE42A), so 0xE428 is the second team's ninth cell. mira_si_hay_empate returns carry on equal totals and, from the same cp, when the second team's is lower; it returns no carry only when the second team's is higher. Bit 0 of 0xE402 marks the second team's turn: after it flips, set means the first team's half has just ended. The repository's write-up (docs/THE-GAME.md, "How many innings") also reads the check as extra innings on a tie and marks it as an assumption, since nobody has played a match through. What tile 0xE7 shows hasn't been checked. In the demo, a change of sides ends the match.

Cited by: Konami's Baseball