You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
661 lines
18 KiB
661 lines
18 KiB
/*
|
|
* state.h - header file for state functions and macros for Freecell Solver
|
|
*
|
|
* Written by Shlomi Fish (shlomif@vipe.technion.ac.il), 2000
|
|
*
|
|
* This file is in the public domain (it's uncopyrighted).
|
|
*/
|
|
#include "fcs_config.h"
|
|
|
|
#include "fcs_move.h"
|
|
|
|
#ifndef FC_SOLVE__STATE_H
|
|
#define FC_SOLVE__STATE_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if MAX_NUM_INITIAL_CARDS_IN_A_STACK+12>(MAX_NUM_DECKS*52)
|
|
#define MAX_NUM_CARDS_IN_A_STACK (MAX_NUM_DECKS*52)
|
|
#else
|
|
#define MAX_NUM_CARDS_IN_A_STACK (MAX_NUM_INITIAL_CARDS_IN_A_STACK+12)
|
|
#endif
|
|
|
|
#define MAX_NUM_SCANS_BUCKETS 1
|
|
#define MAX_NUM_SCANS (MAX_NUM_SCANS_BUCKETS * (sizeof(int)*8))
|
|
|
|
/**********
|
|
* TODO: Change 5 to the log2 of sizeof(int)*8
|
|
*
|
|
************/
|
|
|
|
#define is_scan_visited(ptr_state, scan_id) (ptr_state->scan_visited[(scan_id)>>5] & (1 << ((scan_id)&((1<<(5))-1))))
|
|
#define set_scan_visited(ptr_state, scan_id) { ptr_state->scan_visited[(scan_id)>>5] |= (1 << ((scan_id)&((1<<(5))-1))); }
|
|
|
|
|
|
#ifdef DEBUG_STATES
|
|
|
|
struct fcs_struct_card_t
|
|
{
|
|
short card_num;
|
|
char suit;
|
|
char flags;
|
|
};
|
|
|
|
typedef struct fcs_struct_card_t fcs_card_t;
|
|
|
|
struct fcs_struct_stack_t
|
|
{
|
|
unsigned int num_cards;
|
|
fcs_card_t cards[MAX_NUM_CARDS_IN_A_STACK];
|
|
};
|
|
|
|
typedef struct fcs_struct_stack_t fc_stack_t;
|
|
|
|
struct fcs_struct_state_t
|
|
{
|
|
fc_stack_t stacks[MAX_NUM_STACKS];
|
|
fcs_card_t freecells[MAX_NUM_FREECELLS];
|
|
int foundations[MAX_NUM_DECKS*4];
|
|
#ifdef FCS_WITH_TALONS
|
|
fcs_card_t * talon;
|
|
char talon_params[4];
|
|
#endif
|
|
};
|
|
|
|
typedef struct fcs_struct_state_t fcs_state_t;
|
|
|
|
#if 0
|
|
struct fcs_struct_state_with_locations_t
|
|
{
|
|
fcs_state_t s;
|
|
int stack_locs[MAX_NUM_STACKS];
|
|
int fc_locs[MAX_NUM_FREECELLS];
|
|
struct fcs_struct_state_with_locations_t * parent;
|
|
fcs_move_stack_t * moves_to_parent;
|
|
int depth;
|
|
int visited;
|
|
int visited_iter;
|
|
int num_active_children;
|
|
int scan_visited[MAX_NUM_SCANS_BUCKETS];
|
|
};
|
|
|
|
typedef struct fcs_struct_state_with_locations_t fcs_state_with_locations_t;
|
|
#endif
|
|
typedef int fcs_locs_t;
|
|
|
|
#define fcs_stack_len(state, s) \
|
|
( (state).stacks[(s)].num_cards )
|
|
|
|
#define fcs_stack_card(state, s, c) \
|
|
( (state).stacks[(s)].cards[(c)] )
|
|
|
|
#define fcs_stack_card_suit(state, s, c) \
|
|
( fcs_card_suit(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define fcs_stack_card_num(state, s, c) \
|
|
( fcs_card_card_num(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define fcs_card_card_num(card) \
|
|
( (card).card_num )
|
|
|
|
#define fcs_card_suit(card) \
|
|
((int)( (card).suit ))
|
|
|
|
#define fcs_card_get_flipped(card) \
|
|
( (card).flags )
|
|
|
|
#define fcs_freecell_card(state, f) \
|
|
( (state).freecells[(f)] )
|
|
|
|
#define fcs_freecell_card_num(state, f) \
|
|
( fcs_card_card_num(fcs_freecell_card((state),(f))) )
|
|
|
|
#define fcs_freecell_card_suit(state, f) \
|
|
( fcs_card_suit(fcs_freecell_card((state),(f))) )
|
|
|
|
#define fcs_foundation_value(state, found) \
|
|
( (state).foundations[(found)] )
|
|
|
|
#define fcs_increment_foundation(state, found) \
|
|
( (state).foundations[(found)]++ )
|
|
|
|
#define fcs_set_foundation(state, found, value) \
|
|
( (state).foundations[(found)] = (value) )
|
|
|
|
#define fcs_pop_stack_card(state, s, into) \
|
|
{ \
|
|
into = (state).stacks[(s)].cards[(state).stacks[(s)].num_cards-1]; \
|
|
(state).stacks[(s)].cards[(state).stacks[(s)].num_cards-1] = fcs_empty_card; \
|
|
(state).stacks[(s)].num_cards--; \
|
|
}
|
|
|
|
#define fcs_push_stack_card_into_stack(state, ds, ss, sc) \
|
|
{ \
|
|
(state).stacks[(ds)].cards[(state).stacks[(ds)].num_cards] = (state).stacks[(ss)].cards[(sc)]; \
|
|
(state).stacks[(ds)].num_cards++; \
|
|
}
|
|
|
|
#define fcs_push_card_into_stack(state, ds, from) \
|
|
{ \
|
|
(state).stacks[(ds)].cards[(state).stacks[(ds)].num_cards] = (from); \
|
|
(state).stacks[(ds)].num_cards++; \
|
|
}
|
|
|
|
#define fcs_duplicate_state(dest, src) \
|
|
(dest) = (src)
|
|
|
|
#define fcs_put_card_in_freecell(state, f, card) \
|
|
(state).freecells[(f)] = (card)
|
|
|
|
#define fcs_empty_freecell(state, f) \
|
|
(state).freecells[(f)] = fcs_empty_card
|
|
|
|
#define fcs_card_set_suit(card, d) \
|
|
(card).suit = (d)
|
|
|
|
#define fcs_card_set_num(card, num) \
|
|
(card).card_num = (num)
|
|
|
|
#define fcs_card_set_flipped(card, flipped) \
|
|
(card).flags = (flipped)
|
|
|
|
#define fcs_flip_stack_card(state, s, c) \
|
|
fcs_card_set_flipped(fcs_stack_card((state),(s),(c)), 0)
|
|
|
|
#ifdef FCS_WITH_TALONS
|
|
#define fcs_talon_len(state) \
|
|
((state).talon_params[0])
|
|
|
|
#define fcs_talon_pos(state) \
|
|
((state).talon_params[1])
|
|
|
|
#define fcs_get_talon_card(state, pos) \
|
|
((state).talon[pos])
|
|
|
|
#define fcs_put_card_in_talon(state, pos, card) \
|
|
((state).talon[pos] = (card))
|
|
#endif
|
|
|
|
#define fcs_copy_stack(state, idx, buffer) {}
|
|
|
|
#elif defined(COMPACT_STATES) /* #ifdef DEBUG_STATES */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef char fcs_card_t;
|
|
/*
|
|
* Card:
|
|
* Bits 0-3 - Card Number
|
|
* Bits 4-5 - Deck
|
|
*
|
|
*/
|
|
|
|
struct fcs_struct_state_t
|
|
{
|
|
char data[MAX_NUM_STACKS*(MAX_NUM_CARDS_IN_A_STACK+1)+MAX_NUM_FREECELLS+4*MAX_NUM_DECKS];
|
|
#ifdef FCS_WITH_TALON
|
|
fcs_card_t * talon;
|
|
char talon_params[4];
|
|
#endif
|
|
};
|
|
/*
|
|
* Stack: 0 - Number of cards
|
|
* 1-19 - Cards
|
|
* Stacks: stack_num*20 where stack_num >= 0 and
|
|
* stack_num <= (MAX_NUM_STACKS-1)
|
|
* Bytes: (MAX_NUM_STACKS*20) to
|
|
* (MAX_NUM_STACKS*20+MAX_NUM_FREECELLS-1)
|
|
* are Freecells.
|
|
* Bytes: (MAX_NUM_STACKS*20+MAX_NUM_FREECELLS) to
|
|
* MAX_NUM_STACKS*20+MAX_NUM_FREECELLS+3
|
|
* are Foundations.
|
|
* */
|
|
|
|
/* ===== Depracated Information =====
|
|
* Stack: 0 - Number of cards 1-19 - Cards
|
|
* Stacks: stack_num*20 where stack_num >= 0 and stack_num <= 7
|
|
* Bytes 160-163 - Freecells
|
|
* Bytes 164-167 - Decks
|
|
*/
|
|
|
|
typedef struct fcs_struct_state_t fcs_state_t;
|
|
|
|
#if 0
|
|
struct fcs_struct_state_with_locations_t
|
|
{
|
|
fcs_state_t s;
|
|
char stack_locs[MAX_NUM_STACKS];
|
|
char fc_locs[MAX_NUM_FREECELLS];
|
|
struct fcs_struct_state_with_locations_t * parent;
|
|
fcs_move_stack_t * moves_to_parent;
|
|
int depth;
|
|
int visited;
|
|
int visited_iter;
|
|
int num_active_children;
|
|
int scan_visited[MAX_NUM_SCANS_BUCKETS];
|
|
};
|
|
|
|
typedef struct fcs_struct_state_with_locations_t fcs_state_with_locations_t;
|
|
#endif
|
|
typedef char fcs_locs_t;
|
|
|
|
#define fcs_card_card_num(card) \
|
|
( (card) & 0x0F )
|
|
|
|
#define fcs_card_suit(card) \
|
|
( ((card) >> 4) & 0x03 )
|
|
|
|
#define fcs_stack_len(state, s) \
|
|
( (size_t)(state).data[s*(MAX_NUM_CARDS_IN_A_STACK+1)] )
|
|
|
|
#define fcs_stack_card(state, s, c) \
|
|
( (state).data[(s)*(MAX_NUM_CARDS_IN_A_STACK+1)+(c)+1] )
|
|
|
|
#define fcs_stack_card_num(state, s, c) \
|
|
( fcs_card_card_num(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define fcs_stack_card_suit(state, s, c) \
|
|
( fcs_card_suit(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define FCS_FREECELLS_OFFSET ((MAX_NUM_STACKS)*(MAX_NUM_CARDS_IN_A_STACK+1))
|
|
|
|
#define fcs_freecell_card(state, f) \
|
|
( (state).data[FCS_FREECELLS_OFFSET+(f)] )
|
|
|
|
#define fcs_freecell_card_num(state, f) \
|
|
( fcs_card_card_num(fcs_freecell_card((state),(f))) )
|
|
|
|
#define fcs_freecell_card_suit(state, f) \
|
|
( fcs_card_suit(fcs_freecell_card((state),(f))) )
|
|
|
|
#define FCS_FOUNDATIONS_OFFSET (((MAX_NUM_STACKS)*(MAX_NUM_CARDS_IN_A_STACK+1))+(MAX_NUM_FREECELLS))
|
|
|
|
#define fcs_foundation_value(state, d) \
|
|
( (state).data[FCS_FOUNDATIONS_OFFSET+(d)])
|
|
|
|
#define fcs_increment_foundation(state, d) \
|
|
( (state).data[FCS_FOUNDATIONS_OFFSET+(d)]++ )
|
|
|
|
#define fcs_set_foundation(state, d, value) \
|
|
( (state).data[FCS_FOUNDATIONS_OFFSET+(d)] = (value) )
|
|
|
|
#define fcs_pop_stack_card(state, s, into) \
|
|
{ \
|
|
into = fcs_stack_card((state), (s), (fcs_stack_len((state), (s))-1)); \
|
|
(state).data[((s)*(MAX_NUM_CARDS_IN_A_STACK+1))+1+(fcs_stack_len((state), (s))-1)] = fcs_empty_card; \
|
|
(state).data[(s)*(MAX_NUM_CARDS_IN_A_STACK+1)]--; \
|
|
}
|
|
|
|
#define fcs_push_card_into_stack(state, ds, from) \
|
|
{ \
|
|
(state).data[(ds)*(MAX_NUM_CARDS_IN_A_STACK+1)+1+fcs_stack_len((state), (ds))] = (from); \
|
|
(state).data[(ds)*(MAX_NUM_CARDS_IN_A_STACK+1)]++; \
|
|
}
|
|
|
|
#define fcs_push_stack_card_into_stack(state, ds, ss, sc) \
|
|
fcs_push_card_into_stack((state), (ds), fcs_stack_card((state), (ss), (sc)))
|
|
|
|
#define fcs_duplicate_state(dest, src) \
|
|
(dest) = (src)
|
|
|
|
#define fcs_put_card_in_freecell(state, f, card) \
|
|
(state).data[FCS_FREECELLS_OFFSET+(f)] = (card);
|
|
|
|
#define fcs_empty_freecell(state, f) \
|
|
fcs_put_card_in_freecell((state), (f), fcs_empty_card)
|
|
|
|
#define fcs_card_set_num(card, num) \
|
|
(card) = (((card)&0xF0)|(num));
|
|
|
|
#define fcs_card_set_suit(card, suit) \
|
|
(card) = (((card)&0x4F)|((suit)<<4));
|
|
|
|
#define fcs_card_set_flipped(card, flipped) \
|
|
(card) = (((card)&((fcs_card_t)0x3F))|((fcs_card_t)((flipped)<<6)))
|
|
|
|
#define fcs_card_get_flipped(card) \
|
|
( (card) >> 6 )
|
|
|
|
|
|
#ifdef FCS_WITH_TALONS
|
|
#define fcs_talon_len(state) \
|
|
((state).talon_params[0])
|
|
|
|
#define fcs_talon_pos(state) \
|
|
((state).talon_params[1])
|
|
|
|
#define fcs_put_card_in_talon(state, pos, card) \
|
|
((state).talon[pos] = (card))
|
|
|
|
#define fcs_get_talon_card(state, pos) \
|
|
((state).talon[pos])
|
|
#endif
|
|
|
|
#define fcs_flip_stack_card(state, s, c) \
|
|
(fcs_card_set_flipped(fcs_stack_card((state),(s),(c)), ((fcs_card_t)0) ))
|
|
|
|
#define fcs_copy_stack(state, idx, buffer) {}
|
|
|
|
#elif defined(INDIRECT_STACK_STATES) /* #ifdef DEBUG_STATES
|
|
#elif defined(COMPACT_STATES)
|
|
*/
|
|
|
|
typedef char fcs_card_t;
|
|
|
|
struct fcs_struct_state_t
|
|
{
|
|
fcs_card_t * stacks[MAX_NUM_STACKS];
|
|
fcs_card_t freecells[MAX_NUM_FREECELLS];
|
|
char foundations[MAX_NUM_DECKS*4];
|
|
#ifdef FCS_WITH_TALONS
|
|
fcs_card_t * talon;
|
|
char talon_params[4];
|
|
#endif
|
|
};
|
|
|
|
typedef struct fcs_struct_state_t fcs_state_t;
|
|
|
|
#define fcs_card_card_num(card) \
|
|
( (card) & 0x0F )
|
|
|
|
#define fcs_card_suit(card) \
|
|
( ((card) >> 4) & 0x03 )
|
|
|
|
#define fcs_card_get_flipped(card) \
|
|
( (card) >> 6 )
|
|
|
|
#define fcs_standalone_stack_len(stack) \
|
|
( (size_t)(stack[0]) )
|
|
|
|
#define fcs_stack_len(state, s) \
|
|
( (unsigned int)(state).stacks[(s)][0] )
|
|
|
|
#define fcs_stack_card(state, s, c) \
|
|
( (state).stacks[(s)][c+1] )
|
|
|
|
#define fcs_stack_card_num(state, s, c) \
|
|
( fcs_card_card_num(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define fcs_stack_card_suit(state, s, c) \
|
|
( fcs_card_suit(fcs_stack_card((state),(s),(c))) )
|
|
|
|
#define fcs_freecell_card(state, f) \
|
|
( (state).freecells[(f)] )
|
|
|
|
#define fcs_freecell_card_num(state, f) \
|
|
( fcs_card_card_num(fcs_freecell_card((state),(f))) )
|
|
|
|
#define fcs_freecell_card_suit(state, f) \
|
|
( fcs_card_suit(fcs_freecell_card((state),(f))) )
|
|
|
|
#define fcs_foundation_value(state, d) \
|
|
( (state).foundations[(d)] )
|
|
|
|
#define fcs_increment_foundation(state, d) \
|
|
( (state).foundations[(d)]++ )
|
|
|
|
#define fcs_set_foundation(state, d, value) \
|
|
( (state).foundations[(d)] = (value) )
|
|
|
|
#define fcs_pop_stack_card(state, s, into) \
|
|
{ \
|
|
into = fcs_stack_card((state), (s), (fcs_stack_len((state), (s))-1)); \
|
|
(state).stacks[s][fcs_stack_len((state), (s))] = fcs_empty_card; \
|
|
(state).stacks[s][0]--; \
|
|
}
|
|
|
|
|
|
#define fcs_push_card_into_stack(state, ds, from) \
|
|
{ \
|
|
(state).stacks[(ds)][fcs_stack_len((state), (ds))+1] = (from); \
|
|
(state).stacks[(ds)][0]++; \
|
|
}
|
|
|
|
#define fcs_push_stack_card_into_stack(state, ds, ss, sc) \
|
|
fcs_push_card_into_stack((state), (ds), fcs_stack_card((state), (ss), (sc)))
|
|
|
|
#define fcs_put_card_in_freecell(state, f, card) \
|
|
(state).freecells[(f)] = (card)
|
|
|
|
#define fcs_empty_freecell(state, f) \
|
|
fcs_put_card_in_freecell((state), (f), fcs_empty_card)
|
|
|
|
#define fcs_card_set_num(card, num) \
|
|
(card) = (((card)&0xF0)|(num))
|
|
|
|
#define fcs_card_set_suit(card, suit) \
|
|
(card) = (((card)&0x4F)|((suit)<<4))
|
|
|
|
#define fcs_card_set_flipped(card, flipped) \
|
|
(card) = (fcs_card_t)(((card)&0x3F)|((fcs_card_t)(flipped<<6)))
|
|
|
|
#ifdef FCS_WITH_TALONS
|
|
#define fcs_talon_len(state) \
|
|
((state).talon_params[0])
|
|
|
|
#define fcs_talon_pos(state) \
|
|
((state).talon_params[1])
|
|
|
|
#define fcs_put_card_in_talon(state, pos, card) \
|
|
((state).talon[pos] = (card))
|
|
|
|
#define fcs_get_talon_card(state, pos) \
|
|
((state).talon[pos])
|
|
#endif
|
|
|
|
#define fcs_flip_stack_card(state, s, c) \
|
|
(fcs_card_set_flipped(fcs_stack_card(state,s,c), ((fcs_card_t)0) ))
|
|
|
|
|
|
#define fcs_duplicate_state(dest,src) \
|
|
{ \
|
|
(dest) = (src); \
|
|
(dest).stacks_copy_on_write_flags = 0; \
|
|
}
|
|
|
|
#define fcs_copy_stack(state, idx, buffer) \
|
|
{ \
|
|
if (! ((state).stacks_copy_on_write_flags & (1 << idx))) \
|
|
{ \
|
|
size_t stack_len; \
|
|
(state).stacks_copy_on_write_flags |= (1 << idx); \
|
|
stack_len = fcs_stack_len((state).s,idx); \
|
|
memcpy(&buffer[idx << 7], (state).s.stacks[idx], stack_len+1); \
|
|
(state).s.stacks[idx] = &buffer[idx << 7]; \
|
|
} \
|
|
}
|
|
|
|
|
|
typedef char fcs_locs_t;
|
|
|
|
#endif /* #ifdef DEBUG_STATES -
|
|
#elif defined COMPACT_STATES -
|
|
#elif defined INDIRECT_STACK_STATES
|
|
*/
|
|
|
|
struct fcs_struct_state_with_locations_t
|
|
{
|
|
fcs_state_t s;
|
|
fcs_locs_t stack_locs[MAX_NUM_STACKS];
|
|
fcs_locs_t fc_locs[MAX_NUM_FREECELLS];
|
|
struct fcs_struct_state_with_locations_t * parent;
|
|
fcs_move_stack_t * moves_to_parent;
|
|
int depth;
|
|
/*
|
|
* This field contains global, scan-independant flags, which are used
|
|
* from the FCS_VISITED_T enum below.
|
|
*
|
|
* FCS_VISITED_VISITED - deprecated
|
|
*
|
|
* FCS_VISITED_IN_SOLUTION_PATH - indicates that the state is in the
|
|
* solution path found by the scan. (used by the optimization scan)
|
|
*
|
|
* FCS_VISITED_IN_OPTIMIZED_PATH - indicates that the state is in the
|
|
* optimized solution path which is computed by the optimization scan.
|
|
*
|
|
* FCS_VISITED_DEAD_END - indicates that the state does not lead to
|
|
* anywhere useful, and scans should not examine it in the first place.
|
|
* */
|
|
int visited;
|
|
/*
|
|
* The iteration in which this state was marked as visited
|
|
* */
|
|
int visited_iter;
|
|
/*
|
|
* This is the number of direct children of this state which were not
|
|
* yet declared as dead ends. Once this counter reaches zero, this
|
|
* state too is declared as a dead end.
|
|
* */
|
|
int num_active_children;
|
|
/*
|
|
* This is a vector of flags - one for each scan. Each indicates whether
|
|
* its scan has already visited this state
|
|
* */
|
|
int scan_visited[MAX_NUM_SCANS_BUCKETS];
|
|
#ifdef INDIRECT_STACK_STATES
|
|
/*
|
|
* A vector of flags that indicates which stacks were already copied.
|
|
* */
|
|
int stacks_copy_on_write_flags;
|
|
#endif
|
|
};
|
|
|
|
typedef struct fcs_struct_state_with_locations_t fcs_state_with_locations_t;
|
|
|
|
|
|
extern fcs_card_t freecell_solver_empty_card;
|
|
#define fcs_empty_card freecell_solver_empty_card
|
|
|
|
|
|
#ifdef FCS_WITH_TALONS
|
|
#define fcs_klondike_talon_len(state) \
|
|
((state).talon[0])
|
|
|
|
#define fcs_klondike_talon_stack_pos(state) \
|
|
((state).talon_params[0])
|
|
|
|
#define fcs_klondike_talon_queue_pos(state) \
|
|
((state).talon_params[1])
|
|
|
|
#define fcs_klondike_talon_num_redeals_left(state) \
|
|
((state).talon_params[2])
|
|
|
|
#define fcs_klondike_talon_get_top_card(state) \
|
|
((state).talon[(int)fcs_klondike_talon_stack_pos(state)])
|
|
|
|
#define fcs_klondike_talon_queue_to_stack(state) \
|
|
( ((state).talon[(int)((++fcs_klondike_talon_stack_pos(state))+1)]) = \
|
|
((state).talon[(int)((fcs_klondike_talon_queue_pos(state)++)+1)]) )
|
|
|
|
#define fcs_klondike_talon_redeal_bare(state) \
|
|
{ \
|
|
fcs_klondike_talon_stack_pos(state) = -1; \
|
|
fcs_klondike_talon_queue_pos(state) = 0; \
|
|
}
|
|
|
|
#define fcs_klondike_talon_decrement_stack(state) \
|
|
((state).talon[(int)((fcs_klondike_talon_stack_pos(state)--)+1)] = fcs_empty_card)
|
|
#endif
|
|
|
|
|
|
extern void freecell_solver_canonize_state(
|
|
fcs_state_with_locations_t * state,
|
|
int freecells_num,
|
|
int stacks_num
|
|
);
|
|
|
|
#define fcs_canonize_state(state,freecells_num,stacks_num) freecell_solver_canonize_state((state),(freecells_num),(stacks_num))
|
|
|
|
#if (FCS_STATE_STORAGE != FCS_STATE_STORAGE_INDIRECT)
|
|
|
|
#if (FCS_STATE_STORAGE != FCS_STATE_STORAGE_LIBREDBLACK_TREE)
|
|
typedef void * fcs_compare_context_t;
|
|
#else
|
|
typedef const void * fcs_compare_context_t;
|
|
#endif
|
|
|
|
extern int freecell_solver_state_compare(const void * s1, const void * s2);
|
|
extern int freecell_solver_state_compare_equal(const void * s1, const void * s2);
|
|
extern int freecell_solver_state_compare_with_context(const void * s1, const void * s2, fcs_compare_context_t context);
|
|
#else
|
|
extern int freecell_solver_state_compare_indirect(const void * s1, const void * s2);
|
|
extern int freecell_solver_state_compare_indirect_with_context(const void * s1, const void * s2, void * context);
|
|
#endif
|
|
|
|
#ifdef FCS_WITH_TALONS
|
|
extern int fcs_talon_compare_with_context(const void * s1, const void * s2, fcs_compare_context_t context);
|
|
#endif
|
|
|
|
enum FCS_USER_STATE_TO_C_RETURN_CODES
|
|
{
|
|
FCS_USER_STATE_TO_C__SUCCESS = 0,
|
|
FCS_USER_STATE_TO_C__PREMATURE_END_OF_INPUT
|
|
};
|
|
|
|
int freecell_solver_initial_user_state_to_c(
|
|
const char * string,
|
|
fcs_state_with_locations_t * out_state,
|
|
int freecells_num,
|
|
int stacks_num,
|
|
int decks_num
|
|
#ifdef FCS_WITH_TALONS
|
|
,int talon_type
|
|
#endif
|
|
#ifdef INDIRECT_STACK_STATES
|
|
, fcs_card_t * indirect_stacks_buffer
|
|
#endif
|
|
);
|
|
|
|
|
|
extern char * freecell_solver_state_as_string(
|
|
fcs_state_with_locations_t * state,
|
|
int freecells_num,
|
|
int stacks_num,
|
|
int decks_num,
|
|
int parseable_output,
|
|
int canonized_order_output,
|
|
int display_10_as_t
|
|
);
|
|
|
|
enum FCS_STATE_VALIDITY_CODES
|
|
{
|
|
FCS_STATE_VALIDITY__OK = 0,
|
|
FCS_STATE_VALIDITY__EMPTY_SLOT = 3,
|
|
FCS_STATE_VALIDITY__EXTRA_CARD = 2,
|
|
FCS_STATE_VALIDITY__MISSING_CARD = 1,
|
|
FCS_STATE_VALIDITY__PREMATURE_END_OF_INPUT = 4
|
|
};
|
|
|
|
extern int freecell_solver_check_state_validity(
|
|
fcs_state_with_locations_t * state,
|
|
int freecells_num,
|
|
int stacks_num,
|
|
int decks_num,
|
|
#ifdef FCS_WITH_TALONS
|
|
int talon_type,
|
|
#endif
|
|
fcs_card_t * misplaced_card
|
|
);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
enum FCS_VISITED_T
|
|
{
|
|
FCS_VISITED_VISITED = 0x1,
|
|
FCS_VISITED_IN_SOLUTION_PATH = 0x2,
|
|
FCS_VISITED_IN_OPTIMIZED_PATH = 0x4,
|
|
FCS_VISITED_DEAD_END = 0x8,
|
|
FCS_VISITED_ALL_TESTS_DONE = 0x10
|
|
};
|
|
|
|
|
|
#endif /* FC_SOLVE__STATE_H */
|