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.


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.


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.

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 .


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.

Adapt
dto2
to other parameters aside from depth, such as totalnumberofcardsinthefoundations or maximal foundation value. 
Set up a
dto2
like scheme formethod astar
where we change the tests order based on the depth/etc. 
Set up a move func which moves a card from a freecell to an empty stack and immediately puts a child card on top.

Work on HYBRID_STACKS_STATES where if the stacks are shorter than 8 cards, then one can store them in the normally pointer bytes, by specifying whether the stack is a pointer or a direct stack using the low bit. (An improvement to INDIRECT_STACK_STATES).
To be considered

Make the code splintclean.

Write a multiprocess client/server program.