Pressing
Nonpressing

Write a better initial board/initial layout validation code for the online solver (at least initially]):

Exact number of playstacks. (requires introspection).

Number of Freecells not exceeded. (requires introspection).

missing/extra cards.

whitespace gaps.

invalid characters.

misformatting of the format.


Try to convert the fcs_is_parent() functions to a lookup bit vector based on 64*64 bits.

Currently
var_base*.h
use many type casting and other minor inefficiencies. Refactor/optimize to avoid that. 
Try different
fcs_hash.c
hash fill factors, and try to avoid unnecessary calculations to check if it should be rehashed. 
Try to convert to an open addressing hash instead of chaining (for better memory localisation).

Find how well the solver performs with different permutations of the order of columns/freecells.

See if it’s possible to combine several scans on such different permutations.


Write a "simulator" for new flarebased runs to see how they improve on the existing runs. It will process the scans' command line based on their end results and performance and will generate the new estimated performance.

Write the splitdbmsolver which stores the results on the disk for every nonreversiblemoves offset, and fullyconnectedcomponents.

Refer to
expandsolitairemulticardmoves
from the fcsolve process. 
Create a displayer for fcsolve’s solutions which will allow seeing where a card was moved from (using a colored →) and where it was placed.

Create a GUI version.


If
opt
is specified for the flare, then make sure that if the flares loop stop it when it’s doing the optimization scan, then the optimization scan goes on until it ends.
Not sure about it.


Investigate a way to have positions_by_rank also index according to the suit, and to traverse only the possible parents or children based on the suit.

In the states handling, there’s still some room for pointer arithmetics.

Implement more of Kevin Atkinson’s Common Lisp solver’s atomic move types, and try to construct good heuristics out of them.

Play with writing a memoryrecycling SoftDFS scan: if a subtree was marked as a deadend, then its states might be able to be placed on a linked list of states that can be reused.

PySolFC Deal No. 48007594292403677907 :
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve l cpb sam  grep ^Move  wc l
106
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve method astar to 01234675 asw 300,1500,0,2,50000 sam  grep ^Move  wc l
105
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve method astar to 01234675 asw 40,2,40,0,40 sam  grep ^Move  wc l
121
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve method astar to 0123467589 asw 300,1500,0,2,50000 sam  grep ^Move  wc l
100
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve method astar to 0123467589 asw 300,1500,0,2,40000 sam  grep ^Move  wc l
106
shlomif:~$ make_pysol_freecell_board.py t F 48007594292403677907  fcsolve method astar to 0123467589 asw 300,1500,0,2,60000 sam  grep ^Move  wc l
91
shlomif:~$ make_pysol_freecell_board.py F t 91151234961275807905  ~/apps/test/fcs/bin/fcsolve p t sam method astar to 0123467589 asw 300,1000,0,2,90000  grep ^Move  wc l
84
However this scan generates takes too much time for most boards (over 100K iterations).

PySolFC deal No. 03620802041832966472:
shlomif[fcs]:$trunk/fcsolve/source$ make_pysol_freecell_board.py t F 03620802041832966472  ./scripts/summarizefcsolve  method astar to 0123467589 asw 300,1500,99,2,65000
Verdict: Solved ; Iters: 156 ; Length: 87

I solved it at length 87.

PySolFC deal No. 54369539487824719321:

shlomif[fcs]:$trunk/fcsolve/source$ make_pysol_freecell_board.py F t 54369539487824719321  ./scripts/summarizefcsolve method astar to 0123456789 asw 3000,100,60,0,500
Verdict: Solved ; Iters: 1325 ; Length: 115

Shlomi Fish solved it in under 110 moves.

PySolFC deal 96166640969002647853:

shlomif[fcs]:$trunk/fcsolve/source$ make_pysol_freecell_board.py F t 96166640969002647853  ./scripts/summarizefcsolve method astar to 0123467589 asw 370,0,0,2,90000
Verdict: Solved ; Iters: 615 ; Length: 77

Shlomi Fish solved it in 77 moves.

PySolFC deal 26892246862786948900:

shlomif[fcs]:$trunk/fcsolve/source$ make_pysol_freecell_board.py F t 26892246862786948900  perl scripts/summarizefcsolve l qsi flareschoice fc_solve
Verdict: Solved ; Iters: 195331 ; Length: 98
shlomif[fcs]:$trunk/fcsolve/source$ make_pysol_freecell_board.py F t 26892246862786948900  perl scripts/summarizefcsolve method astar asw '1,0,4,0,4' flareschoice fc_solve
Verdict: Solved ; Iters: 111 ; Length: 92

Shlomi Fish solved it in 92 moves.

Add the new Freecell Solvercompatible game variants of PySolFC.

Convert magic rank constants such as 1 or 13 to FCS_MAX_RANK and FCS_RANK_ACE/etc.

Investigate:

$ make_pysol_freecell_board.py F t 00682189035907813607  perl ../scripts/summarizefcsolve l qsi
Verdict: Solved ; Iters: 157905 ; Length: 109
$ make_pysol_freecell_board.py F t 00682189035907813607  perl ../scripts/summarizefcsolve method astar to '01234567' asw 1 opt
Verdict: Solved ; Iters: 433 ; Length: 89

Consider adding the
restrict
keyword:
Longterm

Integrate the patsolve’s prioritization and mixed BFS/DFS scan.

Update the architecture document.

Make a superstrict parsableoutput without all the quirks of p t (see GamesSolitaireVerify for why).

Write a multithreaded version.

Port to Java (?)

Add a switch to ask the user if he wants to continue and enter a bigger iterations limit.

Check for unmalloced data and if so gracefully exit.

Experiment with a deltabased state storage.

see delta_states_debondt.c  port it to the main libfreecellsolver.

see: http://fcsolve.shlomifish.org/todo.html#orig_calc_states .


Make the dbm_fc_solver not dependent on http://gmplib.org/ by implementing our own big ints.

Adapt the scans based on the parameters of the initial board.

Try to find a correlation between various parameters of the initial board (such as those calculated in the A* scan or the number of steps required to sort the cards in each column by rank), and the performance of various scans and then:

Calculate the initial parameters on startup.

See what would be a good metascan based on them.

Use it.



Unittest
fc_solve_compare_lru_cache_keys
inscans.c
. 
Interactive mode? Continue a scan that reached its limit.

Get the tests to run and pass on MS Windows (32bit/64bit) and implement AppVeyor Continuous Integration.
To be considered

Make the code splintclean.

Write a multiprocess client/server program.

Add a limit to stacks number (in the case of Indirect Stack States), number of states that are stored anywhere, etc.