Stepwise moves

[Leanny]

After using Shuffle Moves I asked myself a lot "How the hell can this be a 7 combo?!" and could only see a 5 combo. It would be really useful if you can make a "Step" function that allows to see how the whole move is executed. A step would be defined by at least these points:

• (1) If one tile is midair, it will fall one tile below
• (2) If you have a match, they disapear and trigger the effect if possible
• If neither (1) nor (2) can be executed then the move is completed.

I hope this is possible to realise without much to do. If you need ideas how to implement this:

• Use a stack to track every step and just empty the stack for each click on "Step"
• Use a finite state machine and do the computation of each step after clicking on "Step". This way you can modify the board on the fly while the steps are executed (e.g. you know what tiles are falling down)

[avengah]

I second this, as well as an undo function so you can see the final state of the board and go back. This would be useful for potentially setting up the next turn.

[Loreinator]

@Leanny There is a way for me to hook this into the existing framework, but my only concern is how much memory this will take. The SimulationResult will obviously have to change slightly to include this new component of data. The boards that result could be listed there with their likelihood and allow you to select them to switch between which you want to 'step' through.

@avengah what do you mean by undo? There already is an undo function in the program.

[avengah]

Oh, sorry, my mistake - I must have missed it.

[Leanny]

@Loreinator It looks like you are storing the whole result board for each possible move. Wouldn't it be possible to store the reference to the original board and a diff set where only the changed ones are stored? (E.g. [[1,1],Air] for in 1,1 is now Air.) That way you would not need to store the whole board and will save memory most of the times. The calculation of the new board would be easy by replacing the tiles. Undo would be possible by creating an inverse array. (E.g. [[1,1], Bulbasaur] for Bulbasaur in 1,1.) Steps could be done easily with this and would not need that much memory, since the whole board would rarely change at once.

[Loreinator]

Good idea, I hadn't thought of that - since the boards are fairly efficiently stored anyway I never considered compression of them.

It will take some doing though to get it perfect - and I'm definitely going to write some rigorous tests for it, i.e. randomized boards and small random changes to see that the before and after (and reverse) are all consistent.

[tcm1998]

IMHO it's not necessary to store all in-between boards for all moves. When step by step inspection comes around, the user has already chosen ONE move. Why not run the simulation for THAT particular move again, but now storing the in-between results? After that the UI can deal with displaying the in-between steps.

[Loreinator]

Yup, definitely possible to adapt the simulation to do that.