What does clicking a cell do in this game? It looks a little like Lights Out but seems to be doing something different. (I ask because typically in Light's Out -likes clicking the same cell twice in a solution is meaningless, as the order of your inputs doesn't matter, and making an input twice just undoes itself - but I don't know if that applies here.)

The article states the starting boards are randomly generated, with "over 500 possible initial configurations for each pattern." Is this true? If so, can RNG be manipulated to get a quicker-to-solve board? I glanced at the code but my C64 BASIC skills aren't good enough to follow the logic.

Well, you got me thinking all day. Came up with another plan and was able to find an RNG seed that cut 290 more frames.

The article states the starting boards are randomly generated, with "over 500 possible initial configurations for each pattern." Is this true? If so, can RNG be manipulated to get a quicker-to-solve board? I glanced at the code but my C64 BASIC skills aren't good enough to follow the logic.

Well, you got me thinking all day. Came up with another plan and was able to find an RNG seed that cut 401 more frames. I'm going to continue seeing if I can find another one, but this program is written in B.A.S.I.C. and its much harder to do this kind of manipulation, as it is very slow.

The article states the starting boards are randomly generated, with "over 500 possible initial configurations for each pattern." Is this true? If so, can RNG be manipulated to get a quicker-to-solve board? I glanced at the code but my C64 BASIC skills aren't good enough to follow the logic.

Well, you got me thinking all day. Came up with another plan and was able to find an RNG seed that cut 401 more frames. I'm going to continue seeing if I can find another one, but this program is written in B.A.S.I.C. and its much harder to do this kind of manipulation, as it is very slow.

Let me know when you need a file replacement.

The lit-only game is solved in nearly the same manner as the normal game. Simply figure out whether any of the lit buttons need to be pressed, and then press them. If any unlit button needs to be pressed, you will need to delay pressing it until other button presses have lit it. Occasionally all buttons that remain in the solution are unlit, so then some lit button has to be pressed first to allow you to move on. Later that same button will have to be pressed again, since it wouldn't have been part of the solution if you hadn't been forced to press it the first time. This situation can usually be avoided.

There's a way to model "lights out" problems like this as linear algebra, with 0/1 matrices and vectors. You have a vector p that represents the current state of the board (in this case a 9-vector), a vector r that represents the desired end state of the board (another 9-vector), and a matrix A that represents which lights get flipped when you press each of the lights (a 9×9 matrix). Then the vector x that tells you which lights to press can be computed as x = (r − p)A⁻¹. Here's a youtube video about it: Solving the "Lights Out" Problem And here's a good web page: The Mathematics of Lights Out. The technique isn't exactly applicable to Match Blox, because of this restriction: "Only the orange squares may be changed. If you press the fire button while on a blue square, nothing happens." But it's pretty close. Jaap's Puzzle Page also has discussion of "lit-only games":

The lit-only game is solved in nearly the same manner as the normal game. Simply figure out whether any of the lit buttons need to be pressed, and then press them. If any unlit button needs to be pressed, you will need to delay pressing it until other button presses have lit it. Occasionally all buttons that remain in the solution are unlit, so then some lit button has to be pressed first to allow you to move on. Later that same button will have to be pressed again, since it wouldn't have been part of the solution if you hadn't been forced to press it the first time. This situation can usually be avoided.

What this means is that the order of presses is important (you have to make sure that each square is lit at the time to press it), and in some cases you may need to press a light that's not in the vector solution, then press it again later. The other aspect of the game that this doesn't capture is the time required for cursor movement. Your bot is likely a more straightforward solution, given these additional complications. But just for interest, here's a way of doing the matrix computations using SageMath. You can run the program at https://sagecell.sagemath.org/. This is for the first batch of solutions (not the updated batch).

Language: python
# Each row shows which squares are affected by pressing the square that
# corresponds to the number of that row. For example, pressing square 1 flips
# squares 1, 2, 4, and 5 (first row of the matrix).
# https://archive.org/details/1986-11-computegazette/page/n57/mode/2up
# "Choosing one of the four corner squares (1, 3, 7, or 9) reverses the color of
# that square and the three adjacent squares. Choosing an edge square
# (2, 4, 6, or 8) reverses its color as well as the two adjoining corner
# squares. If you select the center square, its color is reversed and so are the
# colors of the four edge squares."
A = matrix(GF(2), [
    [1,1,0,1,1,0,0,0,0],
    [1,1,1,0,0,0,0,0,0],
    [0,1,1,0,1,1,0,0,0],
    [1,0,0,1,0,0,1,0,0],
    [0,1,0,1,1,1,0,1,0],
    [0,0,1,0,0,1,0,0,1],
    [0,0,0,1,1,0,1,1,0],
    [0,0,0,0,0,0,1,1,1],
    [0,0,0,0,1,1,0,1,1],
])
Ainv = A.inverse()

# https://www.jaapsch.net/puzzles/lomath.htm#linalg
def solve(p, r):
    return (p - r) * Ainv

# Target patterns, each square numbered in the natural way.
UNI_COLOR    = vector(GF(2), [0,0,0,0,0,0,0,0,0])
CROSS        = vector(GF(2), [1,0,1,0,0,0,1,0,1])
NO_CENTER    = vector(GF(2), [0,0,0,0,1,0,0,0,0])
FOUR_CORNERS = vector(GF(2), [0,1,0,1,1,1,0,1,0])
FIVE_POINTS  = vector(GF(2), [0,1,0,1,0,1,0,1,0])

for p, r, name in (
    ([1,1,0,1,0,1,0,0,1], FIVE_POINTS,  "5 POINTS"),
    ([0,0,1,0,0,0,1,1,0], FOUR_CORNERS, "4 CORNERS"),
    ([0,0,0,1,1,1,1,1,0], NO_CENTER,    "NO CENTER"),
    ([1,0,0,1,0,0,1,1,1], UNI_COLOR,    "UNI-COLOR"),
    ([1,1,1,1,1,0,1,0,0], CROSS,        "CROSS"),
):
    p = vector(GF(2), p)
    x = solve(p, r)
    print(f"{name:9}", p, x, "->", [i+1 for (i, xi) in enumerate(x) if xi != 0])

Here's the output:

r=5 POINTS  p=(1, 1, 0, 1, 0, 1, 0, 0, 1) x=(0, 1, 1, 0, 0, 0, 0, 0, 1) -> [2, 3, 9]
r=4 CORNERS p=(0, 0, 1, 0, 0, 0, 1, 1, 0) x=(1, 1, 0, 0, 1, 0, 1, 0, 0) -> [1, 2, 5, 7]
r=NO CENTER p=(0, 0, 0, 1, 1, 1, 1, 1, 0) x=(1, 0, 0, 1, 1, 0, 0, 0, 0) -> [1, 4, 5]
r=UNI-COLOR p=(1, 0, 0, 1, 0, 0, 1, 1, 1) x=(1, 0, 0, 0, 1, 0, 1, 0, 1) -> [1, 5, 7, 9]
r=CROSS     p=(1, 1, 1, 1, 1, 0, 1, 0, 0) x=(0, 1, 0, 1, 0, 1, 0, 1, 1) -> [2, 4, 6, 8, 9]

The solutions match what your bot found, except that they may be out of order. The exception is CROSS, which is one of those cases where none of the square you need to press is lit, so you need to press some other square (5 in this case) and press it again later: [2, 4, 5, 6, 9, 5, 8].