I said it might be possible to use a SAT solver for this game. I took some time to think about it how that game can be modeled.
I try to write down ALL rules which decide which block can be moved to the right side on the first turn. It shouldn't be any problem to do the same for left, up, down.
If everything works well, all what needs to be done in the next step is to write these rules for each move.
We need a few variables.

```
1 <= i <= total rows
1 <= j <= total columns
1 <= c <= number of different colors
1 <= d <= 4, d = direction, 1 = right, 2 = left, 3 = up, 4 = down (for example)
M_{i,j,d} <=> The tile which is located in row i, column j can be !M!oved in direction d
C_{i,j,c} <=> The tile at {i,j} has the !C!olor c.
F_{i,j} <=> There is no tile at {i,j} (!F!ree)
RSC_{i,j} <=> tiles {i,j} and {i,j+1} (one !R!ight) have the !S!ame !C!olor
DSC_{i,j} <=> tiles {i,j} and {i+1,j} (one !D!own) have the !S!ame !C!olor
```

Some of these are obvious, some are not. Let's start with the more obvious.

```
RSC_{i,j} <=> (not F_{i,j} AND (not F_{i,j+1}) AND (forall c: C_{i,j,c} == C_{i,j+1,c})
DSC_{i,j} <=> (not F_{i,j}) AND (not F_{i+1,j}) AND (forall c: C_{i,j,c} == C_{i+1,j,c})
```

if there is a non-movable tile at {x,y} then all the following boolean values must be false:

```
M_{x,y,1}, M_{x,y,2}, M_{x,y,3}, M_{x,y,4}
M_{x,y-1,1}
M_{x,y+1,2}
M_{x+1,y,3}
M_{x-1,y,4}
```

The real difficulty is to determine the correct value of M_{i,j} in all the other cases. If X is a non-movable tile, the following cases are easy:

```
_ _ 1 _ X _ _
..............
_ _ 1 X _ _ _
```

but we also need to make sure that it works well in the following cases:

```
1 1 1 _ _ _ _
_ _ 1 _ _ _ _
_ 1 1 1 1 1 _
_ 1 2 1 _ _ _
_ 1 1 1 _ _ _
..............
1 1 1 _ _ _ _
_ _ 1 _ _ _ _
_ 1 1 1 1 1 _
_ 1 2 1 _ _ _
_ 1 1 1 X _ _
..............
1 1 1 _ _ _ _
_ _ 3 _ _ _ _
_ 1 1 1 1 1 _
_ 1 2 1 _ _ _
_ 1 1 1 _ _ _
```

I'm not sure how to code that in such a way that every movable thing gets moved. I take the following guess:

```
M_{i,j,1} if (and only if???) ALL of the following conditions are met:
1) either F_{i,j+1} or M_{i,j+1}
2) if RSC_{i,j} then M_{i,j+1,1}
3) if RSC_{i,j-1} then M_{i,j-1,1}
4) if DSC_{i,j} then M_{i+1,j,1}
5) if DSC_{i-1,j} then M_{i-1,j,1}
```

If the above works for every case you can think of, I can go on and encode the winning condition, which will be quite hard. I hope you have a good idea for that, my idea would require N*R*C variables per turn, where N is the number of tiles which must become connected. And with 200 tiles on a 32*32 field, and a solution of 100 turns, this would need 20.480.000 variables and many clauses just for the winning condition. Improving that in some way might be necessary for a usable solver.
--------------------------
From the mathematical point of view, I guess it would be sufficient to only encode "movable to the right", because all other cases can be done in other ways:
move left: flip the playing field horizontal
move up/down: flip diagonal
Both ways of encoding work, I'm not sure which one works better