/*
* simpsim.c - a module that contains Simple Simon Moves.
*
* Written by Shlomi Fish (shlomif@vipe.technion.ac.il), 2001
*
* This file is in the public domain (it's uncopyrighted).
*/
#include <stdio.h>
#include "fcs.h"
#include "tests.h"
#include "ms_ca.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif
#define fcs_is_ss_false_parent(parent, child) \
(fcs_card_card_num(parent) == fcs_card_card_num(child)+1)
#define fcs_suit_is_ss_true_parent(parent_suit, child_suit) \
((parent_suit) == (child_suit))
#define fcs_is_ss_true_parent(parent, child) \
( \
fcs_is_ss_false_parent(parent,child) && \
(fcs_suit_is_ss_true_parent(fcs_card_suit(parent),fcs_card_suit(child))) \
)
/*
* Those are some macros to make it easier for the programmer.
* */
#define state_with_locations (*ptr_state_with_locations)
#define state (ptr_state_with_locations->s)
#define new_state_with_locations (*ptr_new_state_with_locations)
#define new_state (ptr_new_state_with_locations->s)
int freecell_solver_sfs_simple_simon_move_sequence_to_founds(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
fcs_card_t temp_card;
/*
* stack - the stack index from which to move cards to the founds.
* cards_num - the number of cards in "stack"
* suit - the suit of the complete sequence
* a - the height of the card
* */
int stack, cards_num, suit, a;
/*
* card - the current card (at height a)
* above_card - the card above it.
* */
fcs_card_t card, above_card;
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num >= 13)
{
card = fcs_stack_card(state,stack,cards_num-1);
/* Check if the top 13 cards are a sequence */
for(a=2;a<=13;a++)
{
above_card = fcs_stack_card(state,stack,cards_num-a);
if (fcs_is_ss_true_parent(above_card, card))
{
/* Do nothing - the card is OK for a propert sequence*/
}
else
{
break;
}
card = above_card;
}
if (a == 14)
{
/* We can move this sequence up there */
sfs_check_state_begin();
my_copy_stack(stack);
suit = fcs_card_suit(card);
for(a=0;a<13;a++)
{
fcs_pop_stack_card(new_state, stack, temp_card);
fcs_increment_foundation(new_state, suit);
}
fcs_move_init(temp_move);
fcs_move_set_type(temp_move, FCS_MOVE_TYPE_SEQ_TO_FOUNDATION);
fcs_move_set_src_stack(temp_move, stack);
fcs_move_set_foundation(temp_move,suit);
fcs_move_stack_push(moves,temp_move);
sfs_check_state_end();
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_sequence_to_true_parent(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
/*
* stack - the source stack index on which the sequence currently resides.
* cards_num - the number of cards in "stack".
* suit - the suit of the current card
* a - a temporary variable that designates a card height
* */
int stack, cards_num, suit, a;
/*
* h - the current height in stack
* */
int h;
/*
* card - the current card (at height h)
* above_card - the card above it.
* dest_card - the destination card on which to put the sequence
* */
fcs_card_t card, temp_card, dest_card;
/*
* card_num - the card number (i.e: A, 2 ,3 ... K) of the card, or
* its previous one.
* num_true_seqs - the number of true sequences (i.e: sequences of a
* unified suit) in the source sequence.
* ds - the destination stack index.
* dest_cards_num - the number of cards in "ds".
* */
int card_num, num_true_seqs, ds, dest_cards_num ;
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
/* Loop on the cards in the stack and try to look for a true
* parent on top one of the stacks */
card = fcs_stack_card(state,stack,cards_num-1);
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
num_true_seqs = 1;
for(h=cards_num-2;h>=-1;h--)
{
for(ds=0;ds<state_stacks_num;ds++)
{
if (ds == stack)
{
continue;
}
dest_cards_num = fcs_stack_len(state,ds);
if (dest_cards_num > 0)
{
dest_card = fcs_stack_card(state, ds, dest_cards_num-1);
if ((fcs_card_suit(dest_card) == suit) &&
(fcs_card_card_num(dest_card) == (card_num+1))
)
{
/* This is a suitable parent - let's check if we
* have enough empty stacks to make the move feasible */
if (calc_max_sequence_move(0, num_freestacks) >= num_true_seqs)
{
/* We can do it - so let's move */
sfs_check_state_begin();
my_copy_stack(stack);
my_copy_stack(ds);
fcs_move_sequence(ds, stack, h+1, cards_num-1, a);
sfs_check_state_end();
}
}
}
}
/* Stop if we reached the bottom of the stack */
if (h == -1)
{
break;
}
card = fcs_stack_card(state,stack,h);
/* If this is no longer a sequence - move to the next stack */
if (fcs_card_card_num(card) != card_num+1)
{
break;
}
if (! fcs_suit_is_ss_true_parent(suit, fcs_card_suit(card)))
{
num_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_whole_stack_sequence_to_false_parent(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
/*
* stack - the source stack index
* cards_num - number of cards in "stack"
* ds - the dest stack index
* dest_cards_num - number of cards in "ds".
* card - the current card
* card_num - its card number
* suit - its suit
* dest_card - the card at the top of "ds".
* h - the height of the current card on "stack"
* num_true_seqs - the number of true sequences on the current
* false sequence
* */
int stack, cards_num, suit, a;
fcs_card_t card, temp_card, dest_card;
int card_num, num_true_seqs, h, ds, dest_cards_num ;
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
card = fcs_stack_card(state,stack,cards_num-1);
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
num_true_seqs = 1;
/* Stop if we reached the bottom of the stack */
for(h=cards_num-2;h>-1;h--)
{
card = fcs_stack_card(state,stack,h);
/* If this is no longer a sequence - move to the next stack */
if (fcs_card_card_num(card) != card_num+1)
{
break;
}
if (fcs_card_suit(card) != suit)
{
num_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
/* This means that the loop exited prematurely and the stack does
* not contain a sequence. */
if (h != -1)
{
continue;
}
for(ds=0;ds<state_stacks_num;ds++)
{
dest_cards_num = fcs_stack_len(state,ds);
if (dest_cards_num > 0)
{
dest_card = fcs_stack_card(state, ds, dest_cards_num-1);
if (
(fcs_is_ss_false_parent(dest_card, card))
)
{
/* This is a suitable parent - let's check if we
* have enough empty stacks to make the move feasible */
if (calc_max_sequence_move(0, num_freestacks) >= num_true_seqs)
{
/* We can do it - so let's move */
sfs_check_state_begin();
my_copy_stack(stack);
my_copy_stack(ds);
fcs_move_sequence(ds, stack, h+1, cards_num-1, a);
sfs_check_state_end();
}
}
}
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_sequence_to_true_parent_with_some_cards_above(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
/*
* stack - the source stack index
* cards_num - the number of cards in "stack"
* h - the height of the current card in "stack"
* card - the card in height "h"
* suit - its suit
* card_num - its card number
* ds - the destionation stack index
* dest_cards_num - the number of cards in "ds"
* dc - the index of the current card in "ds".
* num_separate_false_seqs - this variable tells how many distinct false
* sequences exist above the true parent
* above_num_true_seqs[] - the number of true sequences in each false
* sequence
* seq_points[] - the separation points of the false sequences (i.e: where
* they begin and end)
* stacks_map[] - a boolean map that indicates if one can place a card
* on this stack or is it already taken.
* junk_move_to_stacks[] - the stacks to move each false sequence of the
* junk to.
* false_seq_index - an iterator to hold the index of the current false
* sequence.
* after_junk_num_freestacks - this variable holds the number of stacks
* that remained unoccupied during and after the process of moving
* the junk sequences to different stacks.
*
* */
int stack, cards_num, suit, a;
fcs_card_t card, temp_card, dest_card;
int card_num, above_num_true_seqs[MAX_NUM_CARDS_IN_A_STACK], h, ds, dest_cards_num ;
int dc;
int seq_points[MAX_NUM_CARDS_IN_A_STACK];
int num_separate_false_seqs;
int false_seq_index;
int num_true_seqs;
int stacks_map[MAX_NUM_STACKS];
int after_junk_num_freestacks;
int junk_move_to_stacks[MAX_NUM_STACKS];
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
card = fcs_stack_card(state,stack,cards_num-1);
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
num_true_seqs = 1;
for(h=cards_num-2;h>=-1;h--)
{
for(ds=0;ds<state_stacks_num;ds++)
{
if (ds == stack)
{
continue;
}
dest_cards_num = fcs_stack_len(state,ds);
if (dest_cards_num > 0)
{
for(dc=dest_cards_num-1;dc>=0;dc--)
{
dest_card = fcs_stack_card(state, ds, dc);
if ((fcs_card_suit(dest_card) == suit) &&
(fcs_card_card_num(dest_card) == (card_num+1))
)
{
/* This is a suitable parent - let's check if there's a sequence above it. */
/*
* above_c - the height of the card that is to be checked.
* above_card - the card at height above_c+1
* up_above_card - the card at height above_c
*
* */
int above_c;
fcs_card_t above_card, up_above_card;
num_separate_false_seqs = 0;
above_card = fcs_stack_card(state, ds, dest_cards_num-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = dest_cards_num-2 ;
above_c > dc ;
above_c--
)
{
up_above_card = fcs_stack_card(state, ds, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (dc < dest_cards_num - 1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
for(a=0;a<state_stacks_num;a++)
{
stacks_map[a] = 0;
}
stacks_map[stack] = 1;
stacks_map[ds] = 1;
after_junk_num_freestacks = num_freestacks;
for(false_seq_index=0;false_seq_index<num_separate_false_seqs;false_seq_index++)
{
/* Find a suitable place to put it */
/*
* clear_junk_dest_stack is the stack to move this particular junk sequence to.
* */
int clear_junk_dest_stack = -1;
/* Let's try to find a suitable parent on top one of the stacks */
for(clear_junk_dest_stack=0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
int clear_junk_stack_len;
clear_junk_stack_len = fcs_stack_len(state, clear_junk_dest_stack);
if ((clear_junk_stack_len > 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
fcs_card_t clear_junk_dest_card;
clear_junk_dest_card = fcs_stack_card(state, clear_junk_dest_stack, clear_junk_stack_len-1);
if (fcs_is_ss_false_parent(clear_junk_dest_card, fcs_stack_card(state, ds, seq_points[false_seq_index])))
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= above_num_true_seqs[false_seq_index])
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
}
if (clear_junk_dest_stack == state_stacks_num)
{
clear_junk_dest_stack = -1;
}
if (clear_junk_dest_stack == -1)
{
/* Check if there is a vacant stack */
if (num_freestacks > 0)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks-1) >= above_num_true_seqs[false_seq_index])
{
/* Find an empty stack and designate it as the destination for the junk */
for(
clear_junk_dest_stack = 0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
if ((fcs_stack_len(state, clear_junk_dest_stack) == 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
after_junk_num_freestacks--;
}
}
if ((clear_junk_dest_stack == -1))
{
break;
}
junk_move_to_stacks[false_seq_index] = clear_junk_dest_stack;
}
if (false_seq_index == num_separate_false_seqs)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= num_true_seqs)
{
/*
* We can do it - so let's move everything.
* Notice that we only put the child in a different stack
* then the parent and let it move to the parent in the
* next iteration of the program
* */
sfs_check_state_begin();
my_copy_stack(ds);
my_copy_stack(stack);
/* Move the junk cards to their place */
for(false_seq_index=0;
false_seq_index<num_separate_false_seqs;
false_seq_index++
)
{
/*
* start and end are the start and end heights of the sequence that is to be moved.
* */
int start = seq_points[false_seq_index];
int end = ((false_seq_index == 0) ? (dest_cards_num-1) : (seq_points[false_seq_index-1]-1));
my_copy_stack(junk_move_to_stacks[false_seq_index]);
fcs_move_sequence(junk_move_to_stacks[false_seq_index], ds, start, end, a);
}
/* Move the source seq on top of the dest seq */
fcs_move_sequence(ds, stack, h+1, cards_num-1, a);
sfs_check_state_end();
}
}
}
}
}
}
/* Stop if we reached the bottom of the stack */
if (h == -1)
{
break;
}
/* If this is no longer a sequence - move to the next stack */
if (fcs_stack_card_num(state,stack, h) != card_num+1)
{
break;
}
card = fcs_stack_card(state,stack,h);
if (! fcs_suit_is_ss_true_parent(suit, fcs_card_suit(card)))
{
num_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_sequence_with_some_cards_above_to_true_parent(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int stack, cards_num, suit, a;
fcs_card_t card, temp_card, dest_card;
int card_num, num_true_seqs, ds, dest_cards_num ;
int check;
int sc, num_separate_false_seqs, above_num_true_seqs[MAX_NUM_CARDS_IN_A_STACK];
int seq_points[MAX_NUM_CARDS_IN_A_STACK];
int stacks_map[MAX_NUM_STACKS];
int after_junk_num_freestacks;
int false_seq_index;
int junk_move_to_stacks[MAX_NUM_CARDS_IN_A_STACK];
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
for( sc = cards_num-1 ; sc >= 0 ; sc-- )
{
int above_c;
fcs_card_t above_card, up_above_card;
int end_of_src_seq;
card = fcs_stack_card(state, stack, sc);
suit = fcs_card_suit(card);
card_num = fcs_card_card_num(card);
num_true_seqs = 1;
for (end_of_src_seq = sc+1; end_of_src_seq < cards_num ; end_of_src_seq++)
{
above_card = fcs_stack_card(state, stack, end_of_src_seq);
if (!fcs_is_ss_false_parent(card, above_card))
{
break;
}
if (fcs_card_suit(above_card) != fcs_card_suit(card))
{
num_true_seqs++;
}
card = above_card;
}
if (end_of_src_seq == cards_num)
{
continue;
}
/* Split the cards above it into false sequences */
num_separate_false_seqs = 0;
above_card = fcs_stack_card(state, stack, cards_num-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = cards_num-2 ;
above_c > end_of_src_seq-1 ;
above_c--
)
{
up_above_card = fcs_stack_card(state, stack, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (end_of_src_seq-1 < cards_num-1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
for(ds=0;ds<state_stacks_num;ds++)
{
if (ds == stack)
{
continue;
}
dest_cards_num = fcs_stack_len(state,ds);
if (dest_cards_num > 0)
{
dest_card = fcs_stack_card(state, ds, dest_cards_num-1);
if ((fcs_card_suit(dest_card) == suit) &&
(fcs_card_card_num(dest_card) == (card_num+1))
)
{
/* This is a suitable parent - let's check if we
* have enough empty stacks to make the move feasible */
for(a=0;a<state_stacks_num;a++)
{
stacks_map[a] = 0;
}
stacks_map[stack] = 1;
stacks_map[ds] = 1;
after_junk_num_freestacks = num_freestacks;
for(false_seq_index=0;false_seq_index<num_separate_false_seqs;false_seq_index++)
{
/* Find a suitable place to put it */
int clear_junk_dest_stack = -1;
/* Let's try to find a suitable parent on top one of the stacks */
for(clear_junk_dest_stack=0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
int clear_junk_stack_len;
clear_junk_stack_len = fcs_stack_len(state, clear_junk_dest_stack);
if ((clear_junk_stack_len > 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
fcs_card_t clear_junk_dest_card;
clear_junk_dest_card = fcs_stack_card(state, clear_junk_dest_stack, clear_junk_stack_len-1);
if (fcs_is_ss_false_parent(clear_junk_dest_card, fcs_stack_card(state, stack, seq_points[false_seq_index])))
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= above_num_true_seqs[false_seq_index])
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
}
if (clear_junk_dest_stack == state_stacks_num)
{
clear_junk_dest_stack = -1;
}
if (clear_junk_dest_stack == -1)
{
/* Check if there is a vacant stack */
if (num_freestacks > 0)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks-1) >= above_num_true_seqs[false_seq_index])
{
/* Find an empty stack and designate it as the destination for the junk */
for(
clear_junk_dest_stack = 0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
if ((fcs_stack_len(state, clear_junk_dest_stack) == 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
after_junk_num_freestacks--;
}
}
if ((clear_junk_dest_stack == -1))
{
break;
}
junk_move_to_stacks[false_seq_index] = clear_junk_dest_stack;
}
if (false_seq_index == num_separate_false_seqs)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) > num_true_seqs)
{
sfs_check_state_begin();
my_copy_stack(stack);
my_copy_stack(ds);
/* Let's boogie - we can move everything */
/* Move the junk cards to their place */
for(false_seq_index=0;
false_seq_index<num_separate_false_seqs;
false_seq_index++
)
{
int start;
int end;
int src_stack;
{
start = seq_points[false_seq_index];
end = ((false_seq_index == 0) ? (cards_num-1) : (seq_points[false_seq_index-1]-1));
src_stack = stack;
}
my_copy_stack(junk_move_to_stacks[false_seq_index]);
fcs_move_sequence(junk_move_to_stacks[false_seq_index], src_stack, start, end, a);
}
fcs_move_sequence(ds, stack, sc, end_of_src_seq-1, a);
sfs_check_state_end();
}
}
}
}
}
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_sequence_with_junk_seq_above_to_true_parent_with_some_cards_above(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
/*
* stack - the source stack index
* cards_num - the number of cards in "stack"
* h - the height of the current card in "stack".
* card - the current card in "stack"
* suit - its suit
* card_num - its card number
* ds - the index of the destination stack
* dest_cards_num - the number of cards in "ds".
* dc - the height of the current card in "ds".
* num_separate_false_seqs - the number of false sequences
* seq_points[] - the places in which the false sequences of the junk begin
* and end
* false_seq_index - an iterator that marks the index of the current
* false sequence
* stacks_map[] - a map of booleans that indicates if one can place a card
* on this stack or is already taken.
* above_num_true_seqs[] - the number of true sequences in each false
* sequence
* num_src_junk_true_seqs - the number of true seqs in the false seq above
* the source card.
* end_of_junk - the height marking the end of the source junk.
* num_true_seqs - the number of true sequences in the false seq which we
* wish to move.
* */
int stack, cards_num, suit, a;
fcs_card_t card, temp_card, dest_card;
int card_num, above_num_true_seqs[MAX_NUM_CARDS_IN_A_STACK], h, ds, dest_cards_num ;
int dc;
int seq_points[MAX_NUM_CARDS_IN_A_STACK];
int num_separate_false_seqs;
int false_seq_index;
int stacks_map[MAX_NUM_STACKS];
int after_junk_num_freestacks;
int junk_move_to_stacks[MAX_NUM_STACKS];
int num_src_junk_true_seqs;
int end_of_junk;
int num_true_seqs;
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
card = fcs_stack_card(state,stack,cards_num-1);
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
num_src_junk_true_seqs = 1;
for(h=cards_num-2;h>=-1;h--)
{
if (h == -1)
{
break;
}
card = fcs_stack_card(state, stack, h);
if (fcs_card_card_num(card) != card_num+1)
{
break;
}
if (fcs_card_suit(card) != suit)
{
num_src_junk_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
if (h != -1)
{
end_of_junk = h;
num_true_seqs = 1;
for(;h>=-1;h--)
{
if (h == -1)
{
break;
}
card = fcs_stack_card(state,stack,h);
if (fcs_card_card_num(card) != card_num+1)
{
break;
}
if (fcs_card_suit(card) != suit)
{
num_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
for(ds=0;ds<state_stacks_num;ds++)
{
if (ds == stack)
{
continue;
}
dest_cards_num = fcs_stack_len(state,ds);
/* At least a card with another card above it */
if (dest_cards_num > 1)
{
/* Start at the card below the top one, so we will
* make sure there's at least some junk above it
* */
for(dc=dest_cards_num-2;dc>=0;dc--)
{
dest_card = fcs_stack_card(state, ds, dc);
if ((fcs_card_suit(dest_card) == suit) &&
(fcs_card_card_num(dest_card) == (card_num+1))
)
{
/* This is a suitable parent - let's check if there's a sequence above it. */
int above_c;
fcs_card_t above_card, up_above_card;
num_separate_false_seqs = 0;
above_card = fcs_stack_card(state, ds, dest_cards_num-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = dest_cards_num-2 ;
above_c > dc ;
above_c--
)
{
up_above_card = fcs_stack_card(state, ds, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (dc < dest_cards_num - 1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
for(a=0;a<state_stacks_num;a++)
{
stacks_map[a] = 0;
}
stacks_map[stack] = 1;
stacks_map[ds] = 1;
after_junk_num_freestacks = num_freestacks;
for(false_seq_index=0;false_seq_index<num_separate_false_seqs+1;false_seq_index++)
{
/* Find a suitable place to put it */
int clear_junk_dest_stack = -1;
fcs_card_t the_card =
(
(false_seq_index == num_separate_false_seqs) ?
(fcs_stack_card(state, stack, end_of_junk+1)) :
(fcs_stack_card(state, ds, seq_points[false_seq_index]))
);
int the_num_true_seqs =
(
(false_seq_index == num_separate_false_seqs) ?
num_src_junk_true_seqs :
above_num_true_seqs[false_seq_index]
);
/* Let's try to find a suitable parent on top one of the stacks */
for(clear_junk_dest_stack=0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
int clear_junk_stack_len;
clear_junk_stack_len = fcs_stack_len(state, clear_junk_dest_stack);
if ((clear_junk_stack_len > 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
fcs_card_t clear_junk_dest_card;
clear_junk_dest_card = fcs_stack_card(state, clear_junk_dest_stack, clear_junk_stack_len-1);
if (fcs_is_ss_false_parent(clear_junk_dest_card, the_card))
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= the_num_true_seqs)
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
}
if (clear_junk_dest_stack == state_stacks_num)
{
clear_junk_dest_stack = -1;
}
if (clear_junk_dest_stack == -1)
{
/* Check if there is a vacant stack */
if (num_freestacks > 0)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks-1) >= the_num_true_seqs)
{
/* Find an empty stack and designate it as the destination for the junk */
for(
clear_junk_dest_stack = 0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
if ((fcs_stack_len(state, clear_junk_dest_stack) == 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
after_junk_num_freestacks--;
}
}
if ((clear_junk_dest_stack == -1))
{
break;
}
junk_move_to_stacks[false_seq_index] = clear_junk_dest_stack;
}
if (false_seq_index == num_separate_false_seqs+1)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= num_true_seqs)
{
/* We can do it - so let's move everything */
sfs_check_state_begin();
my_copy_stack(stack);
my_copy_stack(ds);
/* Move the junk cards to their place */
for(false_seq_index=0;
false_seq_index<num_separate_false_seqs+1;
false_seq_index++
)
{
int start;
int end;
int src_stack;
if (false_seq_index == num_separate_false_seqs)
{
start = end_of_junk+1;
end = cards_num-1;
src_stack = stack;
}
else
{
start = seq_points[false_seq_index];
end = ((false_seq_index == 0) ? (dest_cards_num-1) : (seq_points[false_seq_index-1]-1));
src_stack = ds;
}
my_copy_stack(src_stack);
my_copy_stack(junk_move_to_stacks[false_seq_index]);
fcs_move_sequence(junk_move_to_stacks[false_seq_index], src_stack, start, end, a);
}
/* Move the source seq on top of the dest seq */
fcs_move_sequence(ds, stack, h, end_of_junk, a);
sfs_check_state_end();
}
}
}
}
}
}
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_whole_stack_sequence_to_false_parent_with_some_cards_above(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
/*
* stack - the source stack index
* cards_num - the number of cards in "stack"
* h - the height of the current card in stack
* card - the current card
* suit - its suit
* card_num - its card number
* ds - the destination stack index.
* dest_cards_num - the number of cards in it.
* dc - the height of the card in "ds".
* num_separate_false_seqs - this variable tells how many distinct false
* sequences exist above the false parent
* above_num_true_seqs[] - the number of true sequences in each false
* sequence
* seq_points[] - the separation points of the false sequences (i.e: where
* they begin and end)
* stacks_map[] - a boolean map that indicates if one can place a card
* on this stack or is it already taken.
* junk_move_to_stacks[] - the stacks to move each false sequence of the
* junk to.
* false_seq_index - an iterator to hold the index of the current false
* sequence.
* after_junk_num_freestacks - a variable that holds the number of stacks
* that are left unoccupied as part of the junk disposal process.
*
* */
int stack, cards_num, suit, a;
fcs_card_t card, temp_card, dest_card;
int card_num, num_true_seqs, h, ds, dest_cards_num ;
int dc, num_separate_false_seqs, above_num_true_seqs[MAX_NUM_CARDS_IN_A_STACK];
int seq_points[MAX_NUM_CARDS_IN_A_STACK];
int stacks_map[MAX_NUM_STACKS];
int after_junk_num_freestacks;
int false_seq_index;
int junk_move_to_stacks[MAX_NUM_STACKS];
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0;stack<state_stacks_num;stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 0)
{
card = fcs_stack_card(state,stack,cards_num-1);
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
num_true_seqs = 1;
for(h=cards_num-2;h>=-1;h--)
{
if (h == -1)
{
break;
}
card = fcs_stack_card(state,stack,h);
if (fcs_card_card_num(card) != card_num+1)
{
break;
}
if (fcs_card_suit(card) != suit)
{
num_true_seqs++;
}
card_num = fcs_card_card_num(card);
suit = fcs_card_suit(card);
}
if (h == -1)
{
for(ds=0;ds<state_stacks_num;ds++)
{
dest_cards_num = fcs_stack_len(state,ds);
if (dest_cards_num > 0)
{
for(dc=dest_cards_num-1;dc>=0;dc--)
{
dest_card = fcs_stack_card(state, ds, dc);
if (
(fcs_card_card_num(dest_card) == (card_num+1))
)
{
/* This is a suitable parent - let's check if there's a sequence above it. */
int above_c;
fcs_card_t above_card, up_above_card;
num_separate_false_seqs = 0;
above_card = fcs_stack_card(state, ds, dest_cards_num-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = dest_cards_num-2 ;
above_c > dc ;
above_c--
)
{
up_above_card = fcs_stack_card(state, ds, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (dc < dest_cards_num - 1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
for(a=0;a<state_stacks_num;a++)
{
stacks_map[a] = 0;
}
stacks_map[stack] = 1;
stacks_map[ds] = 1;
after_junk_num_freestacks = num_freestacks;
for(false_seq_index=0;false_seq_index<num_separate_false_seqs;false_seq_index++)
{
/* Find a suitable place to put it */
int clear_junk_dest_stack = -1;
fcs_card_t the_card =
(fcs_stack_card(state, ds, seq_points[false_seq_index]))
;
int the_num_true_seqs =
above_num_true_seqs[false_seq_index];
/* Let's try to find a suitable parent on top one of the stacks */
for(clear_junk_dest_stack=0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
int clear_junk_stack_len;
clear_junk_stack_len = fcs_stack_len(state, clear_junk_dest_stack);
if ((clear_junk_stack_len > 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
fcs_card_t clear_junk_dest_card;
clear_junk_dest_card = fcs_stack_card(state, clear_junk_dest_stack, clear_junk_stack_len-1);
if (fcs_is_ss_false_parent(clear_junk_dest_card, the_card))
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= the_num_true_seqs)
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
}
if (clear_junk_dest_stack == state_stacks_num)
{
clear_junk_dest_stack = -1;
}
if ((clear_junk_dest_stack == -1))
{
break;
}
junk_move_to_stacks[false_seq_index] = clear_junk_dest_stack;
}
if (false_seq_index == num_separate_false_seqs)
{
/* This is a suitable parent - let's check if we
* have enough empty stacks to make the move feasible */
if (calc_max_sequence_move(0, num_freestacks) >= num_true_seqs)
{
/* We can do it - so let's move */
sfs_check_state_begin();
my_copy_stack(stack);
my_copy_stack(ds);
/* Move the junk cards to their place */
for(false_seq_index=0;
false_seq_index<num_separate_false_seqs;
false_seq_index++
)
{
int start;
int end;
int src_stack;
{
start = seq_points[false_seq_index];
end = ((false_seq_index == 0) ? (dest_cards_num-1) : (seq_points[false_seq_index-1]-1));
src_stack = ds;
}
my_copy_stack(src_stack);
my_copy_stack(junk_move_to_stacks[false_seq_index]);
fcs_move_sequence( junk_move_to_stacks[false_seq_index], src_stack, start, end, a);
}
fcs_move_sequence( ds, stack, h+1, cards_num-1, a);
sfs_check_state_end();
}
}
}
}
}
}
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
int freecell_solver_sfs_simple_simon_move_sequence_to_parent_on_the_same_stack(
freecell_solver_soft_thread_t * soft_thread,
fcs_state_with_locations_t * ptr_state_with_locations,
int num_freestacks,
int num_freecells,
fcs_derived_states_list_t * derived_states_list,
int reparent
)
{
tests_declare_accessors();
fcs_move_t temp_move;
int check;
int stack, cards_num, pc, cc;
fcs_card_t parent_card, child_card;
int a;
int after_junk_num_freestacks;
int false_seq_index;
int child_seq_index;
fcs_card_t temp_card;
int state_stacks_num;
tests_define_accessors();
state_stacks_num = instance->stacks_num;
for(stack=0 ; stack < state_stacks_num ; stack++)
{
cards_num = fcs_stack_len(state, stack);
if (cards_num > 2)
{
/* Search for a parent card */
for(pc=0; pc < cards_num-1 ; pc++)
{
parent_card = fcs_stack_card(state, stack, pc);
if (
fcs_is_ss_true_parent(
parent_card,
fcs_stack_card(state, stack, pc+1)
)
)
{
continue;
}
for(cc = pc + 2 ; cc < cards_num ; cc++)
{
child_card = fcs_stack_card(state, stack, cc);
if (fcs_is_ss_true_parent(
parent_card,
child_card
)
)
{
/* We have a matching parent and child cards */
#if 0
printf("Stack %i, Parent %i, Child %i\n", stack, pc, cc);
fflush(stdout);
#endif
/*
* Now let's try to find stacks to place the cards above
* the child card.
* */
int above_num_true_seqs[MAX_NUM_CARDS_IN_A_STACK];
int seq_points[MAX_NUM_CARDS_IN_A_STACK];
int stacks_map[MAX_NUM_STACKS];
int junk_move_to_stacks[MAX_NUM_STACKS];
int num_separate_false_seqs;
fcs_card_t above_card, up_above_card;
int above_c;
int end_of_child_seq;
int child_num_true_seqs;
end_of_child_seq = cc;
child_num_true_seqs = 1;
while ((end_of_child_seq+1 < cards_num) &&
fcs_is_ss_false_parent(
fcs_stack_card(state, stack, end_of_child_seq),
fcs_stack_card(state, stack, end_of_child_seq+1)
)
)
{
child_num_true_seqs += (!fcs_is_ss_true_parent(
fcs_stack_card(state, stack, end_of_child_seq),
fcs_stack_card(state, stack, end_of_child_seq+1)
));
end_of_child_seq++;
}
num_separate_false_seqs = 0;
above_card = fcs_stack_card(state, stack, cards_num-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = cards_num-2;
above_c > end_of_child_seq ;
above_c--
)
{
up_above_card = fcs_stack_card(state, stack, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (end_of_child_seq < cards_num - 1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
/* Add the child to the seq_points */
child_seq_index = num_separate_false_seqs;
above_num_true_seqs[num_separate_false_seqs] = child_num_true_seqs;
seq_points[num_separate_false_seqs++] = cc;
/* Add the cards between the parent and the child to the seq_points */
above_card = fcs_stack_card(state, stack, cc-1);
above_num_true_seqs[num_separate_false_seqs] = 1;
for(above_c = cc-2;
above_c > pc ;
above_c--
)
{
up_above_card = fcs_stack_card(state, stack, above_c);
if (! fcs_is_ss_false_parent(up_above_card, above_card))
{
seq_points[num_separate_false_seqs++] = above_c+1;
above_num_true_seqs[num_separate_false_seqs] = 1;
}
above_num_true_seqs[num_separate_false_seqs] += ! (fcs_card_suit(up_above_card) == fcs_card_suit(above_card));
above_card = up_above_card;
}
if (pc < cc - 1)
{
seq_points[num_separate_false_seqs++] = above_c+1;
}
for(a = 0 ; a < state_stacks_num ; a++)
{
stacks_map[a] = 0;
}
stacks_map[stack] = 1;
after_junk_num_freestacks = num_freestacks;
for(false_seq_index=0;false_seq_index<num_separate_false_seqs;false_seq_index++)
{
/* Find a suitable place to put it */
int clear_junk_dest_stack = -1;
/* Let's try to find a suitable parent on top one of the stacks */
for(clear_junk_dest_stack=0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
int clear_junk_stack_len;
clear_junk_stack_len = fcs_stack_len(state, clear_junk_dest_stack);
if ((clear_junk_stack_len > 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
fcs_card_t clear_junk_dest_card;
clear_junk_dest_card = fcs_stack_card(state, clear_junk_dest_stack, clear_junk_stack_len-1);
if (fcs_is_ss_false_parent(clear_junk_dest_card, fcs_stack_card(state, stack, seq_points[false_seq_index])))
{
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= above_num_true_seqs[false_seq_index])
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
}
if (clear_junk_dest_stack == state_stacks_num)
{
clear_junk_dest_stack = -1;
}
if (clear_junk_dest_stack == -1)
{
/* Check if there is a vacant stack */
if (num_freestacks > 0)
{
if (calc_max_sequence_move(0, after_junk_num_freestacks-1) >= above_num_true_seqs[false_seq_index])
{
/* Find an empty stack and designate it as the destination for the junk */
for(
clear_junk_dest_stack = 0;
clear_junk_dest_stack < state_stacks_num;
clear_junk_dest_stack++
)
{
if ((fcs_stack_len(state, clear_junk_dest_stack) == 0) && (stacks_map[clear_junk_dest_stack] == 0))
{
stacks_map[clear_junk_dest_stack] = 1;
break;
}
}
}
after_junk_num_freestacks--;
}
}
if ((clear_junk_dest_stack == -1))
{
break;
}
junk_move_to_stacks[false_seq_index] = clear_junk_dest_stack;
}
if (false_seq_index == num_separate_false_seqs)
{
/* Let's check if we can move the child after we are done moving all the junk cards */
if (calc_max_sequence_move(0, after_junk_num_freestacks) >= child_num_true_seqs)
{
/* We can do it - so let's move everything */
sfs_check_state_begin();
/* Move the junk cards to their place */
my_copy_stack(stack);
for(false_seq_index=0;
false_seq_index<num_separate_false_seqs;
false_seq_index++
)
{
int start = seq_points[false_seq_index];
int end = ((false_seq_index == 0) ? (cards_num-1) : (seq_points[false_seq_index-1]-1));
my_copy_stack(junk_move_to_stacks[false_seq_index]);
fcs_move_sequence ( junk_move_to_stacks[false_seq_index], stack, start, end, a);
}
{
int end = fcs_stack_len(new_state, junk_move_to_stacks[child_seq_index])-1;
int start = end-(end_of_child_seq-cc);
my_copy_stack(junk_move_to_stacks[child_seq_index]);
fcs_move_sequence( stack, junk_move_to_stacks[child_seq_index], start, end, a);
}
sfs_check_state_end();
}
}
}
}
}
}
}
return FCS_STATE_IS_NOT_SOLVEABLE;
}
#undef state_with_locations
#undef state
#undef new_state_with_locations
#undef new_state