private static SolitaireState setupInitial()
{
var initialState = new SolitaireState();
initialState.Deck = NewDeck();
var deck = NewDeck();
for (byte a = 0; a < 7; a++)
{
for (int i = a; i < 7; i++)
{
var index = deck.Length - 1;
var c = deck[index];
if (i == a)
{
initialState.PileFaceDown[i] = a;
}
Utilities.Add(ref initialState.Piles[i], c);
Utilities.RemoveLast(ref deck);
}
}
for (int i = 0; i < 7; i++)
{
initialState.PilesLast[i] = initialState.Piles[i][initialState.Piles[i].Length - 1];
}
for (int i = 0; i < 4; i++)
{
initialState.TopLast[i] = Utilities.CardDefault;
}
initialState.Deck = deck.ToArray();
initialState.DeckDiscardLast = Utilities.CardDefault;
initialState.DeckLast = initialState.Deck[initialState.Deck.Length - 1];
return(initialState);
}
public SolitaireState(SolitaireState state)
{
Piles = new byte[7][];
PileFaceDown = new byte[7];
Top = new byte[4][];
TopLast = new byte[4];
PilesLast = new byte[7];
for (int i = 0; i < 4; i++)
{
Top[i] = state.Top[i];
TopLast[i] = state.TopLast[i];
}
Deck = state.Deck;
DeckLast = state.DeckLast;
DeckDiscard = state.DeckDiscard;
DeckDiscardLast = state.DeckDiscardLast;
for (int i = 0; i < 7; i++)
{
Piles[i] = state.Piles[i];
PilesLast[i] = state.PilesLast[i];
PileFaceDown[i] = state.PileFaceDown[i];
}
copyState = state;
ResetCount = state.ResetCount;
}
private static void tryPopDeck(SolitaireState SolitaireState, List <SolitaireState> cache)
{
if (SolitaireState.Deck.Length > 0)
{
var s = new SolitaireState(SolitaireState);
s.CopyDiscard();
s.CopyDeck();
var l = Utilities.RemoveLast(ref s.Deck);
if (s.Deck.Length == 0)
{
s.DeckLast = Utilities.CardDefault;
}
else
{
s.DeckLast = s.Deck[s.Deck.Length - 1];
}
Utilities.Add(ref s.DeckDiscard, l);
s.DeckDiscardLast = l;
cache.Add(s);
}
else
{
var s = new SolitaireState(SolitaireState);
s.CopyDiscard();
s.CopyDeck();
s.ResetCount++;
s.Deck = s.DeckDiscard;
Array.Resize(ref s.DeckDiscard, 0);
s.DeckLast = s.Deck[s.Deck.Length - 1];
s.DeckDiscardLast = Utilities.CardDefault;
cache.Add(s);
}
}
private static void tryMoveFromDiscard(SolitaireState SolitaireState, List <SolitaireState> cache)
{
if (SolitaireState.DeckDiscard.Length == 0)
{
return;
}
var topCard = SolitaireState.DeckDiscardLast;
for (int index = 0; index < 7; index++)
{
if (cardFits(SolitaireState.PilesLast[index], topCard))
{
var s = new SolitaireState(SolitaireState);
s.CopyDiscard();
s.CopyPile(index);
var top = Utilities.RemoveLast(ref s.DeckDiscard);
if (s.DeckDiscard.Length == 0)
{
s.DeckDiscardLast = Utilities.CardDefault;
}
else
{
s.DeckDiscardLast = s.DeckDiscard[s.DeckDiscard.Length - 1];
}
Utilities.Add(ref s.Piles[index], top);
s.PilesLast[index] = top;
cache.Add(s);
}
}
}
private static void oneTick(SolitaireState SolitaireState, List <SolitaireState> cache)
{
tryMoveFromDiscard(SolitaireState, cache);
tryMoveToTop(SolitaireState, cache);
tryPopDeck(SolitaireState, cache);
tryMovePiles(SolitaireState, cache);
}
private static void rebuild(SolitaireState SolitaireState)
{
List <SolitaireState> states = new List <SolitaireState>();
states.Add(SolitaireState);
while (SolitaireState.copyState != null)
{
states.Insert(0, SolitaireState.copyState);
SolitaireState = SolitaireState.copyState;
}
foreach (var state in states)
{
Console.WriteLine(state);
Console.ReadLine();
}
}
private static void tryMovePiles(SolitaireState SolitaireState, List <SolitaireState> cache)
{
for (int index = 0; index < 7; index++)
{
var pile = SolitaireState.Piles[index];
var faceDownIndex = SolitaireState.PileFaceDown[index];
if (faceDownIndex > 0)
{
var card = pile[faceDownIndex];
for (int pindex = 0; pindex < 7; pindex++)
{
if (pindex == index)
{
continue;
}
if (cardFits(SolitaireState.PilesLast[pindex], card))
{
var s = new SolitaireState(SolitaireState);
s.CopyPile(index);
s.CopyPile(pindex);
var cards = s.Piles[index];
var l = s.Piles[pindex].Length;
var newSize = cards.Length - faceDownIndex;
Array.Resize(ref s.Piles[pindex], l + newSize);
Array.ConstrainedCopy(cards, faceDownIndex, s.Piles[pindex], l, newSize);
Utilities.Resize(ref s.Piles[index], faceDownIndex);
if (s.Piles[pindex].Length == 0)
{
s.PilesLast[pindex] = Utilities.CardDefault;
}
else
{
s.PilesLast[pindex] = s.Piles[pindex][s.Piles[pindex].Length - 1];
}
if (s.Piles[index].Length == 0)
{
s.PilesLast[index] = Utilities.CardDefault;
}
else
{
s.PilesLast[index] = s.Piles[index][s.Piles[index].Length - 1];
}
cards = s.Piles[index];
if (cards.Length > 0)
{
s.PileFaceDown[index] = (byte)(cards.Length - 1);
}
cache.Add(s);
}
}
}
}
}
private static void tryMoveToTop(SolitaireState SolitaireState, List <SolitaireState> cache)
{
byte l;
for (int index = 0; index < 7; index++)
{
var pile = SolitaireState.Piles[index];
if (pile.Length == 0)
{
continue;
}
l = SolitaireState.PilesLast[index];
var type = l / 13;
if (cardFitsTop(SolitaireState.TopLast[type], type, l))
{
var s = new SolitaireState(SolitaireState);
s.CopyPile(index);
s.CopyTop(type);
var p = Utilities.RemoveLast(ref s.Piles[index]);
var items = s.Piles[index];
if (items.Length == 0)
{
s.PilesLast[index] = Utilities.CardDefault;
}
else
{
s.PilesLast[index] = items[items.Length - 1];
}
if (items.Length > 0)
{
s.PileFaceDown[index] = (byte)(items.Length - 1);
}
Utilities.Add(ref s.Top[type], p);
s.TopLast[type] = p;
cache.Add(s);
}
}
if (SolitaireState.DeckDiscard.Length > 0)
{
l = SolitaireState.DeckDiscardLast;
var type = l / 13;
if (cardFitsTop(SolitaireState.TopLast[type], type, l))
{
var s = new SolitaireState(SolitaireState);
s.CopyDiscard();
s.CopyTop(type);
var p = Utilities.RemoveLast(ref s.DeckDiscard);
if (s.DeckDiscard.Length == 0)
{
s.DeckDiscardLast = Utilities.CardDefault;
}
else
{
s.DeckDiscardLast = s.DeckDiscard[s.DeckDiscard.Length - 1];
}
Utilities.Add(ref s.Top[type], p);
s.TopLast[type] = p;
cache.Add(s);
}
}
}
