1FC-SOLVE(6) FC-SOLVE(6)
2
6 fc-solve - automated solver for Freecell and related Solitiare variants
7
9 This is Freecell Solver version 5.0.x, a program that automatically
10 solves most layouts of Freecell, and similar Solitaire variants as well
11 as those of Simple Simon.
12 Freecell Solver is distributed under the MIT/Expat License (
14 http://en.wikipedia.org/wiki/MIT_License ), a free, permissive,
15 open-source license.
16 Note that the Freecell Solver source and Win32 binary distributions do
18 not provide a graphical user-interface (GUI) and are primarily meant to
19 be used by Solitaire researchers and software developers. If you’re
20 looking for a suitable GUI based on Freecell Solver, see our links at:
21 http://fc-solve.shlomifish.org/links.html#front_ends
23 I hope you’ll enjoy using Freecell Solver, and make the best of it.
25 — Shlomi Fish ( http://www.shlomifish.org/ )
27
30 Read the file INSTALL.txt for information on how to do that.
31
34 The program is called "fc-solve". You invoke it like this:
35 fc-solve board_file
38 board_file is the filename with a valid Freecell startup board. The
40 file is built as follows:
41 It has the 8 Freecell stacks.
43 Each stack contains its cards separated by a whitespace and terminated
45 with a newline character( it’s important that the last stack will also
46 be terminated with a newline !). The cards in the line are ordered from
47 the topmost card (= the card right on the virtual table and the one
48 with the most cards placed on it) in the left, to the bottommost card
49 in the right (= the card with no other cards placed on it).
50 A card string contains the rank of the card followed by its suit. The
52 card number is one of: A,1,2,3,4,5,6,7,8,9,10,J,Q,K. Alternatively, T
53 can be used instead of 10. The card suit is one of: H,S,D,C (standing
54 for Hearts, Spades, Diamonds and Clubs respectively).
55 Here is an example board: (PySol/Microsoft board No. 24)
57 4C 2C 9C 8C QS 4S 2H
60 5H QH 3C AC 3H 4H QD
61 QC 9S 6H 9H 3S KS 3D
62 5D 2S JC 5C JH 6D AS
63 2D KD 10H 10C 10D 8D
64 7H JS KH 10S KC 7C
65 AH 5S 6S AD 8H JD
66 7S 6C 7D 4D 8S 9D
67 Visually, it appears as this:
69 [IMAGE] [1] [Freecell Deal No. 24]
71 As can be seen, the four of clubs (4C), five of hearts (5H), etc. are
73 at the bottom of the stacks and the start of the lines in the board
74 input.
75 And another one: (PySol board No. 198246790)
77 KD JH 5H 7D 9H KC 9D
80 3H JD 5D 8H QH 7H 2D
81 4D 3S QC 3C 6S QS KS
82 10C 9S 6D 9C QD 8S 10D
83 10S 8C 7S 10H 2C AS
84 8D AC AH 4H JC 4C
85 6H 7C 4S 5S 5C JS
86 AD KH 6C 2H 3D 2S
87 Starting from Freecell Solver 3.14.x, a stack can also start with a
89 leading colon (":"). This is to allow input from states as output by
90 Freecell Solver using the -p option.
91 You can specify the contents of the freecells by prefixing the line
93 with "FC:" or with "Freecells:". For example:
94 FC: 3H QC
97 will specify that the cards 3 of hearts and queen of clubs are present
99 in the freecells. To specify an empty freecell use a "-" as its
100 designator.
101 If there’s another "FC:" line, the previous line will be overridden.
103 You can specify the contents of the foundations by prefixing the line
105 with "Founds:" or with "Foundations:" and then using a format as
106 follows:
107 Founds: H-5 C-A S-0 D-K
110 Hence, the suit ID followed by a dash followed by the card number in
112 the foundation. A suit that is not present will be assumed to be 0.
113 Again, if there’s more than one line like that, then the previous lines
114 will be ignored and overridden.
115 The program will stop processing the input as soon as it read 8 lines
117 of standard stacks. Therefore, it is recommended that the foundations
118 and freecells lines will come at the beginning of the file.
119 The program will process the board and try to solve it. If it succeeds
121 it will output the states from the initial board to its final solution
122 to the standard output. If it fails, it will notify it.
123 For information about the various command-line switches that Freecell
125 Solver accepts, read the USAGE.txt file in this directory.
126 To solve Simple Simon boards append --game simple_simon right after the
128 "fc-solve" program name.
129
132 Several programs which can generate the initial boards of various
133 Freecell implementations can be found in the "board_gen/"
134 sub-directory. Read the README.txt file there for details on how they
135 can be compiled and used.
136 In any case, they can save you the time of inputting the board
138 yourself.
139
142 A layout in the middle of the MS Freecell deal No. 109 solution:
143 Foundations: H-6 C-9 D-2 S-0
146 Freecells: QS 3S 2S KD
147 : 8H 3D
148 : KS QD JC
149 : AS 8D TD 7D JH TS 9D
150 : 7S 6D
151 : 5S
152 : KH QC JD TC 9H 8S 7H 6S 5D 4S
153 : KC QH JS TH 9S
154 : 4D
155 Similar, but with an empty Freecell:
157 Foundations: H-6 C-9 D-2 S-0
160 Freecells: QS 3S - KD
161 : 8H 3D 2S
162 : KS QD JC
163 : AS 8D TD 7D JH TS 9D
164 : 7S 6D
165 : 5S
166 : KH QC JD TC 9H 8S 7H 6S 5D 4S
167 : KC QH JS TH 9S
168 : 4D
169 Likewise, only without leading colons where unnecessary:
171 Foundations: H-6 C-9 D-2 S-0
174 Freecells: QS 3S - KD
175 8H 3D 2S
176 KS QD JC
177 AS 8D TD 7D JH TS 9D
178 7S 6D
179 5S
180 KH QC JD TC 9H 8S 7H 6S 5D 4S
181 KC QH JS TH 9S
182 4D
183
187 The file USAGE.txt covers all of Freecell Solver’s command line
188 options, but it may be too exhaustive for casual users. As a result,
189 here is a shorter tutorial. First of all whenever invoking fc-solve one
190 should add the flags -p -t -sam -sel which will make the solution
191 easier to understand. Then, assuming the board could be successfully
192 solved, one will be given the layouts in the solution (in the format
193 given above) vis-a-vis with the moves as the string. Note that the
194 indexes of the resources given in the moves are 0-based rather than the
195 more natural 1-based notation.
196
199 Most command-line switches have two versions:
200 · A short POSIX one which is a dash followed by a letter or a few.
203 This option must come standalone and not clustered: -sam is not
204 equivalent to specifying -s, -a and -m.
205 · A long switch which is two dashes followed by the command string.
207 For example: --prelude, --st-name.
208 If command line arguments have parameters, they are followed in
210 separate parameters - Freecell Solver won’t recognise a parameter
211 preceded by an equal sign. --st-name=myname is invalid, while --st-name
212 myname is OK.
213 The Scope of the Options
215 The scope of the options is mentioned along with them. Options can be:
216 1. Global - affects all the soft-threads.
219 2. Instance-specific - affects an instance (separated by the
221 --next-instance option below). Each instance consists of several
222 flares.
223 3. Flare-specific - affects the current flare (separated by the
225 --next-flare option below. Each flare consists of several hard
226 threads.
227 4. Hard-thread-specific - affects the current hard thread (separated
229 by the --next-hard-thread option below. Each hard thread consists
230 of several soft threads.
231 5. Soft-thread-specific - affects only the current soft thread.
233
237 -h , --help
238 Global
239 This option displays a help text on the screen. This help gives a help
241 display summarizing some ways to use the program and get more help.
242 --version
245 Global
246 This option displays the version number of the components that make the
248 executable (and then exits).
249 --help-configs
252 Global
253 Some help on the various configurations of Freecell Solver.
255 --help-options
258 Global
259 A help screen giving an overview of all available options.
261 --help-real-help
264 Global
265 Explains how to change the default help screen to a different one.
267 --help-short-sol
270 Global
271 How to generate shorter solutions.
273 --help-summary
276 Global
277 The default help screen.
279
283 -p , --parseable-output
284 Global
285 This option will display the columns in a format that can be more
287 easily manipulated by text-processing programs such as grep or perl.
288 Namely, The freecells will be displayed in one line, and the
289 foundations in a separate line. Plus, Each column will be displayed
290 horizontally, in its own line, while beginning with a :.
291 -t , --display-10-as-t
294 Global
295 This option will display the 10 cards as a capital T +instead of a +10.
297 Thus, the cards will be more properly aligned.
298 For example, here is a command line using -p and -t:
300 $ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
303 -=-=-=-=-=-=-=-=-=-=-=-
304 Foundations: H-0 C-0 D-0 S-0
306 Freecells:
307 : 4C 2C 9C 8C QS 4S 2H
308 : 5H QH 3C AC 3H 4H QD
309 : QC 9S 6H 9H 3S KS 3D
310 : 5D 2S JC 5C JH 6D AS
311 : 2D KD TH TC TD 8D
312 : 7H JS KH TS KC 7C
313 : AH 5S 6S AD 8H JD
314 : 7S 6C 7D 4D 8S 9D
315 ====================
318 Foundations: H-0 C-0 D-0 S-A
320 Freecells:
321 : 4C 2C 9C 8C QS 4S 2H
322 : 5H QH 3C AC 3H 4H QD
323 : QC 9S 6H 9H 3S KS 3D
324 : 5D 2S JC 5C JH 6D
325 : 2D KD TH TC TD 8D
326 : 7H JS KH TS KC 7C
327 : AH 5S 6S AD 8H JD
328 : 7S 6C 7D 4D 8S 9D
329 -c , --canonized-order-output
333 Global
334 Freecell Solver re-arranges the stacks and freecells in a given state
336 according to their first card. It keeps their actual position in a
337 separate place, but internally it uses their canonized place. Use this
338 option, if you want Freecell Solver to display them in that order. One
339 should be warned that that way the place of a given stack in the board
340 will not be preserved throughout the solution.
341 -m , --display-moves
344 Global
345 This option will display the moves instead of the intermediate states.
347 Each move will be displayed in a separate line, in a format that is
348 human-readable, but that can also be parsed and analyzed by a computer
349 program with some effort on the programmer’s part.
350 For example:
352 $ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
355 -=-=-=-=-=-=-=-=-=-=-=-
356 Move a card from stack 3 to the foundations
358 ====================
360 Move a card from stack 6 to freecell 0
362 ====================
364 Move a card from stack 6 to freecell 1
366 -sn , --standard-notation
370 Global
371 This option will display the moves in standard notation in which every
373 move consists of two characters and there are ten moves in a line.
374 Naturally, this option will only become apparent if the display moves
375 is specified. (it does not implicitly specify it, though).
376 For more information regarding standard notation refer to the following
378 web-page:
379 http://home.earthlink.net/~fomalhaut/freecell.html
381 -snx , --standard-notation-extended
384 Global
385 This option is similar to the previous one, except that when a sequence
387 move is made to an empty stack with more than one card in the sequence,
388 the move will be followed with "v" and the number of cards moved in
389 hexadecimal.
390 -sam , --display-states-and-moves
393 Global
394 This option will display both the intermediate states and the moves
396 that are needed to move from one to another. The standard notation
397 option applies to it to.
398 $ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
401 -=-=-=-=-=-=-=-=-=-=-=-
402 Foundations: H-0 C-0 D-0 S-0
404 Freecells:
405 : 4C 2C 9C 8C QS 4S 2H
406 : 5H QH 3C AC 3H 4H QD
407 : QC 9S 6H 9H 3S KS 3D
408 : 5D 2S JC 5C JH 6D AS
409 : 2D KD TH TC TD 8D
410 : 7H JS KH TS KC 7C
411 : AH 5S 6S AD 8H JD
412 : 7S 6C 7D 4D 8S 9D
413 ====================
416 Move a card from stack 3 to the foundations
418 Foundations: H-0 C-0 D-0 S-A
420 Freecells:
421 : 4C 2C 9C 8C QS 4S 2H
422 : 5H QH 3C AC 3H 4H QD
423 : QC 9S 6H 9H 3S KS 3D
424 : 5D 2S JC 5C JH 6D
425 : 2D KD TH TC TD 8D
426 : 7H JS KH TS KC 7C
427 : AH 5S 6S AD 8H JD
428 : 7S 6C 7D 4D 8S 9D
429 ====================
432 Move a card from stack 6 to freecell 0
434 Foundations: H-0 C-0 D-0 S-A
436 Freecells: JD
437 : 4C 2C 9C 8C QS 4S 2H
438 : 5H QH 3C AC 3H 4H QD
439 : QC 9S 6H 9H 3S KS 3D
440 : 5D 2S JC 5C JH 6D
441 : 2D KD TH TC TD 8D
442 : 7H JS KH TS KC 7C
443 : AH 5S 6S AD 8H
444 : 7S 6C 7D 4D 8S 9D
445 ====================
448 Move a card from stack 6 to freecell 1
450 -pi , --display-parent-iter
454 Global
455 This option (assuming the -s and -i options are specified) will also
457 display the iteration index of the state from which the current state
458 was derived. This is especially useful for BeFS (so-called a-star) or
459 BFS scans.
460 -o [filename] , --output [filename]
463 Global
464 Outputs to a file instead of standard output. So for example:
466 $ fc-solve -o 2405.solution.txt 2405.board
469 Will put the solution to the file in 2405.board in the file
471 2405.solution.txt . This will also be done using:
472 $ fc-solve --output 2405.solution.txt 2405.board
475 -sel , --show-exceeded-limits
479 Global
480 This option will display a different status message ("Iterations count
482 exceeded.") instead of "I could not solve this game." in case the
483 iterations count was exceeded. This is recommended because the "I could
484 not solve this game." message can also mean that the entire game graph
485 was fully traversed (within the limitations of the specified moves'
486 types) and so no solution is possible.
487 This option is not the default, to retain compatibility with previous
489 versions of Freecell Solver, and was added in version 3.12.0 of
490 fc-solve.
491 -hoi , --hint-on-intractable
494 Global
495 Presents the moves to the intermediate reached state, if the maximal
497 number of iterations was reached without a conclusion (=
498 "intractable").
499 This option is not the default, to retain compatibility with previous
501 versions of Freecell Solver, and was added in version 4.20.0 of
502 fc-solve.
503
507 --freecells-num [Number of Freecells]
508 Global
509 This option specifies the number of freecells which are available to
511 the program. Freecell Solver can use any number of freecells as long as
512 it does not exceed its maximal number.
513 This maximum is hard-coded into the program, and can be specified at
515 compile-time by modifying the file config.h. See the file INSTALL (or
516 alternatively INSTALL.html) for details.
517 --stacks-num [Number of Stacks]
520 Global
521 This option specifies the number of stacks present in the board. Again,
523 this number cannot exceed the maximal number of stacks, which can be
524 specified in the file config.h during compile-time of Freecell Solver.
525 --decks-num [Number of Decks]
528 Global
529 This options specifies how many decks are found in the board. This
531 number cannot exceed the maximal number of decks, which can be
532 specified by the Freecell Solver build system.
533 --sequences-are-built-by {suit|alternate_color|rank}
536 Global
537 This option specifies whether a card sequence is built by suit or by
539 alternate colour or by rank regardless of suit.
540 --sequence-move {limited|unlimited}
543 Global
544 This option specifies whether the sequence move is limited by the
546 number of freecells or vacant stacks or not.
547 --empty-stacks-filled-by {kings|none|all}
550 Global
551 Specifies which cards can fill an empty stack.
553 --game [game] , --preset [game] , -g [game]
556 Global
557 Specifies the type of game. Each preset implies several of the settings
559 options above and sometimes even the moves’ order below. The default
560 configuration is for Freecell.
561 Available presets:
563 ┌───────────────────┬──────────────────────────┐
565 │ │ │
566 │bakers_dozen │ Baker’s Dozen │
567 ├───────────────────┼──────────────────────────┤
568 │ │ │
569 │bakers_game │ Baker’s Game │
570 ├───────────────────┼──────────────────────────┤
571 │ │ │
572 │beleaguered_castle │ Beleaguered Castle │
573 ├───────────────────┼──────────────────────────┤
574 │ │ │
575 │citadel │ Citadel │
576 ├───────────────────┼──────────────────────────┤
577 │ │ │
578 │cruel │ Cruel │
579 ├───────────────────┼──────────────────────────┤
580 │ │ │
581 │der_katz │ Der Katzenschwanz │
582 ├───────────────────┼──────────────────────────┤
583 │ │ │
584 │die_schlange │ Die Schlange │
585 ├───────────────────┼──────────────────────────┤
586 │ │ │
587 │eight_off │ Eight Off │
588 ├───────────────────┼──────────────────────────┤
589 │ │ │
590 │fan │ Fan │
591 ├───────────────────┼──────────────────────────┤
592 │ │ │
593 │forecell │ Forecell │
594 ├───────────────────┼──────────────────────────┤
595 │ │ │
596 │freecell │ Freecell (default) │
597 ├───────────────────┼──────────────────────────┤
598 │ │ │
599 │good_measure │ Good Measure │
600 ├───────────────────┼──────────────────────────┤
601 │ │ │
602 │ko_bakers_game │ Kings' Only Baker’s Game │
603 ├───────────────────┼──────────────────────────┤
604 │ │ │
605 │relaxed_freecell │ Relaxed Freecell │
606 ├───────────────────┼──────────────────────────┤
607 │ │ │
608 │relaxed_sehaven │ Relaxed Seahaven Towers │
609 ├───────────────────┼──────────────────────────┤
610 │ │ │
611 │seahaven │ Seahaven Towers │
612 ├───────────────────┼──────────────────────────┤
613 │ │ │
614 │simple_simon │ Simple Simon │
615 ├───────────────────┼──────────────────────────┤
616 │ │ │
617 │streets_and_alleys │ Streets and Alleys │
618 └───────────────────┴──────────────────────────┘
619 Note: in order to solve Der Katzenschwanz and Die Schlange I recommend
621 you compile Freecell Solver with the INDIRECT_STACK_STATES option, or
622 else it will consume much more memory. For details consult the file
623 INSTALL.
624 Examples
627 To solve PySol Eight Off game No. 1,000 type:
628 $ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off
631 To solve PySol Baker’s Game No. 50, type:
633 $ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game
636 If you want to solve a game similar to Freecell only with sequences
638 built by rank, and unlimited sequence move, do:
639 $ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited
642
647 -mi [Iterations num] , --max-iters [Iterations num]
648 Global
649 This parameter limits the maximal number of states to check. This will
651 give a rough limit on the time spent to solve a given board.
652 -md [Maximal depth] , --max-depth [Maximal depth]
655 Not currently implemented
656 Freecell Solver recurses into the solution. This parameter specifies a
658 maximal recursion depth. Generally speaking, it’s not a good idea to
659 set it, because that way several important intermediate states may
660 become inaccessible.
661 -mss [num] , --max-stored-states [num]
664 Global
665 Limits the number of the states stored by the program in the computer’s
667 memory. This differs from the maximal number of iterations in the
668 sense, that it is possible that a stored state was not checked yet.
669 -tmss [num] , --trim-max-stored-states [num]
672 Instance-wide
673 This also limits the number of trimmed stored states, but this time
675 will try to trim them once the limit has been reached (which is time
676 consuming and may cause states to be traversed again in the future).
677 -to [Moves’ Order] , --tests-order [Moves Order]
680 Soft-thread-specific
681 This option specifies the order in which Freecell Solver will try the
683 different types of moves (formerly termed "tests") that it can perform.
684 Each move is specified by one character, and they are performed in the
685 order in which they appear in the parameter string. You can omit moves
686 by not including their corresponding characters in the string.
687 The moves along with their characters are:
689 ┌───────────────────────────────┐
691 │ │
692 │Freecell Moves: │
693 ├──┬────────────────────────────┤
694 │ │ │
695 │0 │ put top stack cards in the │
696 │ │ foundations. │
697 ├──┼────────────────────────────┤
698 │ │ │
699 │1 │ put freecell cards in the │
700 │ │ foundations. │
701 ├──┼────────────────────────────┤
702 │ │ │
703 │2 │ put freecell cards on top │
704 │ │ of stacks. │
705 ├──┼────────────────────────────┤
706 │ │ │
707 │3 │ put non-top stack cards in │
708 │ │ the foundations. │
709 ├──┼────────────────────────────┤
710 │ │ │
711 │4 │ move stack cards to │
712 │ │ different stacks. │
713 ├──┼────────────────────────────┤
714 │ │ │
715 │5 │ move stack cards to a │
716 │ │ parent card on the same │
717 │ │ stack. │
718 ├──┼────────────────────────────┤
719 │ │ │
720 │6 │ move sequences of cards │
721 │ │ onto free stacks. │
722 ├──┼────────────────────────────┤
723 │ │ │
724 │7 │ put freecell cards on │
725 │ │ empty stacks. │
726 ├──┼────────────────────────────┤
727 │ │ │
728 │8 │ move cards to a different │
729 │ │ parent. │
730 ├──┼────────────────────────────┤
731 │ │ │
732 │9 │ empty an entire stack into │
733 │ │ the freecells. │
734 ├──┼────────────────────────────┤
735 │ │ │
736 │j │ put freecell cards on │
737 │ │ empty stacks and right │
738 │ │ away put cards on top. │
739 ├──┴────────────────────────────┤
740 │ │
741 │Atomic Freecell Moves: │
742 ├──┬────────────────────────────┤
743 │ │ │
744 │A │ move a stack card to an │
745 │ │ empty stack. │
746 ├──┼────────────────────────────┤
747 │ │ │
748 │B │ move a stack card to a │
749 │ │ parent on a different │
750 │ │ stack. │
751 ├──┼────────────────────────────┤
752 │ │ │
753 │C │ move a stack card to a │
754 │ │ freecell. │
755 ├──┼────────────────────────────┤
756 │ │ │
757 │D │ move a freecell card to a │
758 │ │ parent. │
759 ├──┼────────────────────────────┤
760 │ │ │
761 │E │ move a freecell card to an │
762 │ │ empty stack. │
763 ├──┴────────────────────────────┤
764 │ │
765 │Simple Simon Moves: │
766 ├──┬────────────────────────────┤
767 │ │ │
768 │a │ move a full sequence to │
769 │ │ the foundations. │
770 ├──┼────────────────────────────┤
771 │ │ │
772 │b │ move a sequence to a true │
773 │ │ parent of his. │
774 ├──┼────────────────────────────┤
775 │ │ │
776 │c │ move a whole stack │
777 │ │ sequence to a false parent │
778 │ │ (in order to clear the │
779 │ │ stack) │
780 ├──┼────────────────────────────┤
781 │ │ │
782 │d │ move a sequence to a true │
783 │ │ parent that has some cards │
784 │ │ above it. │
785 ├──┼────────────────────────────┤
786 │ │ │
787 │e │ move a sequence with some │
788 │ │ cards above it to a true │
789 │ │ parent. │
790 ├──┼────────────────────────────┤
791 │ │ │
792 │f │ move a sequence with a │
793 │ │ junk sequence above it to │
794 │ │ a true parent that has │
795 │ │ some cards above it. │
796 ├──┼────────────────────────────┤
797 │ │ │
798 │g │ move a whole stack │
799 │ │ sequence to a false parent │
800 │ │ which has some cards above │
801 │ │ it. │
802 ├──┼────────────────────────────┤
803 │ │ │
804 │h │ move a sequence to a │
805 │ │ parent on the same stack. │
806 ├──┼────────────────────────────┤
807 │ │ │
808 │i │ move any sequence to a │
809 │ │ false parent (using it may │
810 │ │ make the solution much │
811 │ │ slower). │
812 └──┴────────────────────────────┘
813 Manipulating the moves order can be very helpful to the quick solution
815 of a given board. If you found that a certain board cannot be solved in
816 after a long time or in a certain maximal number of iterations, you
817 should try different moves' orders. Usually, one can find a moves order
818 that solves a board very quickly.
819 Note that this moves order usually makes sense only for the Soft-DFS
821 and Random DFS scans (see the --method option below).
822 Also note that Freecell moves are not suitable for solving Simple Simon
824 games and Simple Simon moves are not suitable for solving anything
825 except Simple Simon.
826 Moves can be grouped together into groups using parenthesis (e.g:
828 "(0123)") or square brackets ("[012][3456789]"). Such grouping is only
829 relevant to the Random DFS scan (see below). A group may optionally be
830 followed by the equal sign "=" and by an ordering specifier. If one
831 specifies "=rand()", then the derived states will be randomised based
832 on the seed (which is what happens if no equal sign is specified). On
833 the other hand, if one specifies something like "=asw(5,0,5,0,0,5)",
834 then the numbers inside the parentheses will be treated as weights for
835 the same ordering function used by the -asw flag (see below).
836 -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves'
839 Order]
840 Soft-thread-specific
841 Sets the Moves' order starting from the minimal depth onwards. This
843 way, if a Soft-DFS scan recurses deeply into the game, it will use a
844 different moves' order.
845 Note that if you set the moves' order of a minimal depth of say 50,
847 then it will override all the moves' order of 50 and above. As a
848 result, it is recommended that you set the minimal depth moves order in
849 an increasing depth.
850 It should be noted that the -to or --tests-order option above is
852 equivalent to using this option with a minimal depth of 0.
853 Here are some examples:
855 -to 0123456789 -dto2 30,0138924567
858 This sets the moves' order to 0123456789 for all depths below 30 and to
860 0138924567 for all depths above it.
861 -to 0123457 -dto2 10,750123 -dto2 25,710235
864 This sets the moves' order to 0123457 for depths -9 (those below 10),
866 to 750123 for depths 10-24, and to 710235 for the depths 25 onwards.
867 -to 0123457 -dto2 "10,[012357]=asw(1)"
870 This sorts the moves starting from 10 onward based on the asw()
872 function.
873 -to 0123457 -dto2 "10,[012357]=rand()"
876 This randomises the moves from 10 onward.
878 -to 0123457 -dto2 "10,[012357]"
881 This does the same thing as the previous example.
883 Note : This option should be used instead of the older -dto option
885 given below which mutilates the moves order parameter and is still
886 provided for backward compatibility.
887 -dto [Min Depth],[Moves' Order] , --depth-tests-order [Min Depth],[Moves'
890 Order]
891 This is equivalent to specifying -dto2 [Min Depth],[Min Depth],[Moves'
892 Order] - i.e: the "[Min Depth]," string is prefixed to the given moves
893 order.
894 This option is provided for backward compatibility with older versions
896 of Freecell Solver.
897 -me [Solving Method] , --method [Solving Method]
900 Soft-thread-specific
901 This option specifies the solving method that will be used to solve the
903 board. Currently, the following methods are available:
904 · a-star - A Best-First-Search scan (not "A*" as it was once thought
907 to be)
908 · bfs - A Breadth-First Search (or BFS) scan
910 · dfs - A Depth-First Search (or DFS) scan
912 · random-dfs - A randomized DFS scan
914 · patsolve - uses the scan of patsolve.
916 · soft-dfs - A "soft" DFS scan
918 Starting from recent Freecell Solver versions there is no difference
920 between dfs and soft-dfs. In earlier versions, use of soft-dfs is
921 recommended. random-dfs is similar to soft-dfs only it determines to
922 which states to recurse into randomly. Its behaviour will differ
923 depending on the seed you supply to it. (see the "-seed" option below.)
924 BFS does not yield good results, and a-star has a mixed behaviour, so
926 for the time being I recommend using Soft-DFS or Random-DFS.
927 The Random-DFS scan processes every moves' random group, randomizes the
929 states that it found and recurses into them one by one. Standalone
930 moves that do not belong to any group, are processed in a non-random
931 manner.
932 -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
935 Soft-thread-specific
936 Specify weights for the a-star (= "Best-First Search") scan, assuming
938 it is used. The parameter should be a comma-separated list of numbers,
939 each one is proportional to the weight of its corresponding test.
940 The numbers are, in order:
942 1. The number of cards out.
945 2. The maximal sequence move.
947 3. The number of cards under sequences.
949 4. The length of the sequences which are found over renegade cards.
951 5. The depth of the board in the solution.
953 6. The negative of the number of cards that are not placed above
955 their parents. To get the irreversibility depth, give equal weight
956 to this weight and to the number of cards out.
957 The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}
959 -seed [Seed Number]
962 Soft-thread-specific
963 Specifies a seed to be used by Freecell Solver’s internal random number
965 generator. This seed may alter the behaviour and speed of the
966 random-dfs scan.
967 --set-pruning [Pruning] , -sp [Pruning]
970 Soft-thread-specific
971 This option sets the pruning algorithm for the soft thread. Current
973 valid values are only the empty string ("") for no pruning and r:tf
974 (short for "Run: to foundations") for Horne’s rule. See:
975 https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214
977 -opt , --optimize-solution
980 Flare-wide
981 This option instructs Freecell Solver to try and optimize the solution
983 path so it will have a smaller number of moves.
984 -opt-to [moves order] , --optimization-tests-order [moves order]
987 Flare-wide
988 This argument specifies the moves order for the optimization scan, in
990 case it should be different than an order that contains all the moves
991 that were used in all the normal scans.
992 --reparent-states
995 Flare-wide
996 This option specifies that states that were encountered whose depth in
998 the states graph can be improved should be reparented to the new
999 parent. This option can possibly make solutions shorter.
1000 --calc-real-depth
1003 Flare-wide
1004 This option becomes effective only if --reparent-states is specified.
1006 What it does, is explicitly calculate the depth of the state by tracing
1007 its path to the initial state. This may make depth consideration more
1008 accurate.
1009 --patsolve-x-param [pos],[value]
1012 Soft-thread-specific
1013 Sets the patsolve’s scan X param (an integer) in position "pos" into
1015 "value".
1016 Examples:
1018 --patsolve-x-param 0,5
1021 --patsolve-x-param 2,100
1022 --patsolve-y-param [pos],[value]
1026 Soft-thread-specific
1027 Sets the patsolve Y param (a floating point number) in position "pos"
1029 into "value".
1030 Examples:
1032 --patsolve-y-param 0,0.5
1035 --patsolve-y-param 1,103.2
1036
1041 Starting from Version 2.4.0, Freecell Solver can run several scans in
1042 parallel on the same state collection. Each scan resides in its own
1043 "Soft Thread". By specifying several soft threads on the command line
1044 one can create use several parallel scans. Once one of the scans
1045 reaches a solution, the solution will be displayed.
1046 -nst , --next-soft-thread
1048 Hard-thread-specific
1049 This option creates a new soft-thread and makes the following
1051 scan-specific options initialize it. For example:
1052 $ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
1055 will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467
1057 on myboard.txt.
1058 -step [Step] , --soft-thread-step [Step]
1061 Soft-thread-specific
1062 This option will set the number of iterations with which to run the
1064 soft thread before switching to the next one. By specifying a larger
1065 step, one can give a certain scan a longer run-time and a higher
1066 priority.
1067 Note: after some experimentation, we have concluded that the --prelude
1069 option normally yields better results, but -step can be used as a
1070 fallback.
1071 -nht , --next-hard-thread
1074 Flare-wide
1075 This argument lets one initialize the next hard thread. If Freecell
1077 Solver was compiled with such support, then it is possible to run each
1078 hard thread in its own system thread. Each hard-thread contains one or
1079 more soft threads.
1080 --st-name [soft thread name]
1083 Soft-thread-specific
1084 This argument sets the name used to identify the current soft thread.
1086 This name can later be used to construct the prelude (see below).
1087 --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
1090 Hard-thread-specific
1091 Sets the prelude for the hard thread. At the beginning of the search,
1093 the hard thread plays a static sequence of iterations at each of the
1094 soft threads specified in the prelude, for the number of iterations
1095 specified.
1096 For example, if you had three soft threads named "foo", "bar" and
1098 "rin", then the following prelude:
1099 --prelude 500@foo,1590@bar,100@foo,200@rin
1102 Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo"
1104 again, and then 200 in "rin". After the prelude finishes, the hard
1105 thread would run the scans one after the other in the sequence they
1106 were defined for their step number.
1107 --scans-synergy {none|dead-end-marks}
1110 Flare-wide
1111 Specifies the synergy between the various scans, or how much they
1113 cooperate between themselves. none means they do not cooperate and only
1114 share the same memory resources. dead-end-marks means they try to mark
1115 states that they have withdrawn from, and states whose all their
1116 derived states are such, as "dead ends". This may or may not improve
1117 the speed of the solution.
1118 -ni , --next-instance
1121 Global
1122 This option allows one to run two or more separate solvers one after
1124 the other. If the first one returned an unsolvable verdict, then the
1125 second one would run and so on. One use of it is to run an atomic moves
1126 scan after a meta-moves scan, so we will always get an accurate verdict
1127 and still enjoy some of the speed benefits of the meta-moves scan.
1128 -nf , --next-flare
1131 Instance-wide
1132 Each instance contains several flares. Flares are various alternative
1134 scans, that are ran one after another, as specified in the
1135 --flares-plan below or defaulting to running only the first flare
1136 (which isn’t very useful). Out of all the flares that are successful in
1137 solving a board, Freecell Solver picks the one with the shortest
1138 solution.
1139 --flare-name [flare name]
1142 Flare-wide
1143 This is a name that identifies the flare for use in the flares' plan.
1145 --flares-plan [flare plan]
1148 Instance-wide
1149 This instance-wide parameter gives a plan for the flares as a big
1151 string. Here are some examples:
1152 --flares-plan "RunIndef:FlareyFlare"
1155 This plan will run the flare with the name FlareyFlare indefinitely,
1157 until it terminates. Once a RunIndef action is encountered, the rest of
1158 the plan is ignored.
1159 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
1162 Runs MyFlare for 500 iterations and FooFlare for 2,000 iterations. Note
1164 that both flares will be run and won’t share any resources between
1165 them, and then the minimal solution out of both flares (or only those
1166 that finished ). If no flares finished, then Freecell Solver will run
1167 them both again for the same number of iterations each, until at least
1168 one finishes (or it ran out of the iterations' limit).
1169 --flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
1172 This runs the flares identified by dfs and befs and then see if a
1174 solution was reached ("CP:" stands for "checkpoint"), and if so yield
1175 it. If both flares did not reach a solution yet, or failed to solve the
1176 board, it will run the flare funky for 10,000 iterations and yield its
1177 solution. And like the previous case, this solution will loop after it
1178 ended for as long as the no flare solved the board or the program did
1179 not run out of iterations.
1180 Using checkpoints one can yield a possibly sub-optimal (as far as
1182 solution length is concerned) solution that will still solve faster
1183 than letting all the flares run.
1184 --flares-choice [choice]
1187 Global
1188 This dictates how to choose the winning flare based on if more than one
1190 yielded a solution. Possible options are:
1191 1. --flares-choice fc_solve - the default, which picks up the
1194 solutions based on the length of the solution in Freecell Solver’s
1195 moves.
1196 2. --flares-choice fcpro - picks up the shortest solution based on
1198 the number of Freecell Pro moves, while not considering implicit
1199 moves to the foundations using Horne’s Prune / Raymond Prune.
1200 -fif [factor] , --flares-iters-factor [factor]
1203 Global
1204 Sets a global, floating-point number, factor to multiply all the
1206 iterations counts in the flares plans. The higher it is, the longer the
1207 scans will take, but there is a greater chance more of them will
1208 succeed, and, as a result, the solution may be shorter.
1209 As an example, the following:
1211 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
1214 Is equivalent to:
1216 --flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
1219 while:
1221 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
1224 Is equivalent to:
1226 --flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
1229 --cache-limit [cache limit]
1233 Global
1234 This is a numeric limit to the LRU cache which only matters if Freecell
1236 Solver was compiled with FCS_RCS_STATES enabled. This value should be a
1237 positive integer and the higher it is, the more quickly it is likely
1238 that Freecell Solver will run, but it will also consume more memory.
1239 (The entire point of FCS_RCS_STATES is to conserve memory).
1240
1244 --reset
1245 Global
1246 This option resets the program to its initial state, losing all the
1248 configuration logic that was input to it up to that state. Afterwards,
1249 it can be set to a different configuration, again.
1250 --read-from-file [num_skip,]filename
1253 Global (but context-specific).
1254 This option will read the configuration options from a file. The format
1256 of the file is similar to that used by the UNIX Bourne Shell. (i.e:
1257 spaces denote separate arguments, double-quotes encompass arguments,
1258 backslash escapes characters).
1259 The filename can be preceded by an optional number of the arguments to
1261 skip followed by a comma. (the default is 0)
1262 -l [preset] , --load-config [preset]
1265 Global (but context-specific).
1266 Reads the configuration specified by [preset] and configures the solver
1268 accordingly. A preset is a set of command line arguments to be analyzed
1269 in the place of this option. They are read from a set of presetrc files
1270 : one installed system-wide, the other at
1271 $HOME/.freecell-solver/presetrc and the third at the path specified by
1272 the FREECELL_SOLVER_PRESETRC environment variable. You can add more
1273 presets at any of these places. (refer to
1274 http://groups.yahoo.com/group/fc-solve-discuss/message/403 for
1275 information about their format)
1276 Presets that are shipped with Freecell Solver:
1278 ┌────────────────────────────┬────────────────────────────┐
1280 │ │ │
1281 │abra-kadabra │ a meta-moves preset │
1282 ├────────────────────────────┼────────────────────────────┤
1283 │ │ │
1284 │amateur-star │ a meta-moves preset that │
1285 │ │ yields solutions faster on │
1286 │ │ average than three-eighty. │
1287 ├────────────────────────────┼────────────────────────────┤
1288 │ │ │
1289 │blue-yonder │ a meta-moves preset │
1290 │ │ generated by a quota │
1291 │ │ optimization algorithm. │
1292 ├────────────────────────────┼────────────────────────────┤
1293 │ │ │
1294 │children-playing-ball │ a meta-moves and │
1295 │ │ flare-based preset that │
1296 │ │ tends to yield very short │
1297 │ │ solution, but is very slow │
1298 │ │ (solves only 3 boards per │
1299 │ │ second on a Pentium 4 │
1300 │ │ 2.4GHz). │
1301 ├────────────────────────────┼────────────────────────────┤
1302 │ │ │
1303 │conspiracy-theory │ a meta-moves preset that │
1304 │ │ yields solutions faster on │
1305 │ │ average than amateur-star. │
1306 ├────────────────────────────┼────────────────────────────┤
1307 │ │ │
1308 │cookie-monster │ a meta-moves preset that │
1309 │ │ yields solutions faster on │
1310 │ │ average than │
1311 │ │ one-big-family. │
1312 ├────────────────────────────┼────────────────────────────┤
1313 │ │ │
1314 │cool-jives │ a meta-moves preset │
1315 ├────────────────────────────┼────────────────────────────┤
1316 │ │ │
1317 │crooked-nose │ an atomic-moves preset │
1318 │ │ (guarantees an accurate │
1319 │ │ verdict) │
1320 ├────────────────────────────┼────────────────────────────┤
1321 │ │ │
1322 │enlightened-ostrich │ a meta-moves preset (that │
1323 │ │ depends on Freecell Solver │
1324 │ │ 3.4.0 and above) that │
1325 │ │ yields solutions faster on │
1326 │ │ average than foss-nessy. │
1327 ├────────────────────────────┼────────────────────────────┤
1328 │ │ │
1329 │fools-gold │ an atomic-moves preset │
1330 ├────────────────────────────┼────────────────────────────┤
1331 │ │ │
1332 │foss-nessy │ a meta-moves preset (that │
1333 │ │ depends on Freecell Solver │
1334 │ │ 3.2.0 and above) that │
1335 │ │ yields solutions faster on │
1336 │ │ average than │
1337 │ │ the-iglu-cabal. │
1338 ├────────────────────────────┼────────────────────────────┤
1339 │ │ │
1340 │good-intentions │ runs "cool-jives" and then │
1341 │ │ "fools-gold" │
1342 ├────────────────────────────┼────────────────────────────┤
1343 │ │ │
1344 │gooey-unknown-thing │ a meta-moves preset that │
1345 │ │ aims to minimise the │
1346 │ │ outcome solution’s length. │
1347 ├────────────────────────────┼────────────────────────────┤
1348 │ │ │
1349 │hello-world │ a meta-moves preset │
1350 ├────────────────────────────┼────────────────────────────┤
1351 │ │ │
1352 │john-galt-line │ a meta-moves preset │
1353 ├────────────────────────────┼────────────────────────────┤
1354 │ │ │
1355 │looking-glass │ a meta-moves preset that │
1356 │ │ yields solutions faster on │
1357 │ │ average than │
1358 │ │ cookie-monster. │
1359 ├────────────────────────────┼────────────────────────────┤
1360 │ │ │
1361 │maliciously-obscure │ a meta-moves and │
1362 │ │ flare-based preset that │
1363 │ │ tends to yield very short │
1364 │ │ solutions (even in │
1365 │ │ comparison to │
1366 │ │ children-playing-ball ) │
1367 │ │ but is slow. │
1368 ├────────────────────────────┼────────────────────────────┤
1369 │ │ │
1370 │micro-finance │ a meta-moves and │
1371 │ │ flare-based preset that │
1372 │ │ tends to yield very short │
1373 │ │ solutions (even in │
1374 │ │ comparison to │
1375 │ │ maliciously-obscure ) but │
1376 │ │ is even slower. │
1377 ├────────────────────────────┼────────────────────────────┤
1378 │ │ │
1379 │micro-finance-improved │ a meta-moves and │
1380 │ │ flare-based preset, based │
1381 │ │ on micro-finance that │
1382 │ │ yields somewhat shorter │
1383 │ │ solutions on average, and │
1384 │ │ should not be slower. │
1385 ├────────────────────────────┼────────────────────────────┤
1386 │ │ │
1387 │one-big-family │ a meta-moves preset that │
1388 │ │ yields solutions faster on │
1389 │ │ average than │
1390 │ │ conspiracy-theory. │
1391 ├────────────────────────────┼────────────────────────────┤
1392 │ │ │
1393 │qualified-seed │ a meta-moves and │
1394 │ │ flare-based preset, based │
1395 │ │ on micro-finance-improved │
1396 │ │ that yields somewhat │
1397 │ │ shorter solutions on │
1398 │ │ average, and should not be │
1399 │ │ slower. │
1400 ├────────────────────────────┼────────────────────────────┤
1401 │ │ │
1402 │qualified-seed-improved │ qualified-seed with -fif 5 │
1403 │ │ and --flares-choice fcpro │
1404 ├────────────────────────────┼────────────────────────────┤
1405 │ │ │
1406 │rin-tin-tin │ a meta-moves preset │
1407 ├────────────────────────────┼────────────────────────────┤
1408 │ │ │
1409 │sand-stone │ an atomic-moves preset │
1410 │ │ that aims to minimise the │
1411 │ │ outcome solution’s length. │
1412 ├────────────────────────────┼────────────────────────────┤
1413 │ │ │
1414 │slick-rock │ run "gooey-unknown-thing" │
1415 │ │ and then "sand-stone" │
1416 ├────────────────────────────┼────────────────────────────┤
1417 │ │ │
1418 │sentient-pearls │ a meta-moves and flares │
1419 │ │ based preset with short │
1420 │ │ solutions. Much faster │
1421 │ │ than children-playing-ball │
1422 │ │ but yields less optimal │
1423 │ │ solutions. │
1424 ├────────────────────────────┼────────────────────────────┤
1425 │ │ │
1426 │tea-for-two │ a meta-moves preset │
1427 │ │ optimized for │
1428 │ │ two-freecells' Freecell │
1429 │ │ games (although it can │
1430 │ │ work on other │
1431 │ │ Freecell-like games as │
1432 │ │ well). │
1433 ├────────────────────────────┼────────────────────────────┤
1434 │ │ │
1435 │the-iglu-cabal │ a meta-moves preset that │
1436 │ │ yields faster solutions on │
1437 │ │ average than blue-yonder. │
1438 ├────────────────────────────┼────────────────────────────┤
1439 │ │ │
1440 │the-last-mohican │ a preset for solving │
1441 │ │ Simple Simon. Yields less │
1442 │ │ false negatives than the │
1443 │ │ default one, but might be │
1444 │ │ slower. │
1445 ├────────────────────────────┼────────────────────────────┤
1446 │ │ │
1447 │three-eighty │ a meta-moves preset (that │
1448 │ │ depends on Freecell Solver │
1449 │ │ 3.4.0 and above) that │
1450 │ │ yields solutions faster on │
1451 │ │ average than │
1452 │ │ enlightened-ostrich. │
1453 ├────────────────────────────┼────────────────────────────┤
1454 │ │ │
1455 │toons-for-twenty-somethings │ an atomic-moves preset │
1456 │ │ that solves more boards │
1457 │ │ efficiently than │
1458 │ │ "fools-gold". │
1459 ├────────────────────────────┼────────────────────────────┤
1460 │ │ │
1461 │video-editing │ a meta-moves and │
1462 │ │ flare-based preset, based │
1463 │ │ on qualified-seed that │
1464 │ │ yields shorter solutions │
1465 │ │ on average, but may be │
1466 │ │ somewhat slower. Named to │
1467 │ │ commemorate the earlier │
1468 │ │ work of Adrian Ettlinger │
1469 │ │ (1925-2013) who later │
1470 │ │ contributed to Freecell │
1471 │ │ Solver and to Freecell │
1472 │ │ research. │
1473 ├────────────────────────────┼────────────────────────────┤
1474 │ │ │
1475 │yellow-brick-road │ a meta-moves preset │
1476 └────────────────────────────┴────────────────────────────┘
1477 They can be abbreviated into their lowercase acronym (i.e: "ak" or
1479 "rtt").
1480
1484 -i , --iter-output
1485 Global
1486 This option tells fc-solve to print the iteration number and the
1488 recursion depth of every state which is checked, to the standard
1489 output. It’s a good way to keep track of how it’s doing, but the output
1490 slows it down a bit.
1491 --iter-output-step [step]
1494 Global
1495 Prints the current iteration if -i is specified, only every [step]
1497 steps, where [step] is a positive integer. For example, if you do
1498 fc-solve -i --iter-output-step 100, you will see this:
1499 Iteration: 0
1502 Iteration: 100
1503 Iteration: 200
1504 Iteration: 300
1505 This option has been added in Freecell Solver 4.20.0 and is useful for
1507 speeding up the runtime process, by avoiding excessive output.
1508 -s , --state-output
1511 Global
1512 This option implies -i. If specified, this option outputs the cards and
1514 formation of the board itself, for every state that is checked.
1515 "fc-solve -s" yields a nice real-time display of the progress of
1516 Freecell Solver, but you usually cannot make what is going on because
1517 it is so fast.
1518
1522 If you are working on a UNIX or a similar system, then you can set some
1523 run-time options in "fc-solve" by sending it some signal combinations.
1524 If you send the fc-solve a single ABRT signal, then fc-solve will
1526 terminate the scan prematurely, and report that the iterations’s limit
1527 has been exceeded.
1528 If you send the signal USR1, without sending any other signals before
1530 that, then fc-solve will output the present number of iterations. This
1531 method is a good way to monitor an instance that takes a long time to
1532 solve.
1533 If you send it the signal USR2 and then USR1, then fc-solve will print
1535 the iteration number and depth on every state that it checks. It is the
1536 equivalent of specifying (or unspecifying) the option -i/--iter-output.
1537 If you send it two USR2 signals and then USR1, then fc-solve will also
1539 print the board of every state. Again, this will only be done assuming
1540 the iteration output is turned on.
1541
1544 Shlomi Fish <shlomif@cpan.org>
1545 Author.
1546 2018-10-27 FC-SOLVE(6)