Solitaire/Stack.cpp at main · ThatOtherOtherBob/Solitaire · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include "Stack.hpp"

void Stack::Setup(StackTypeEnum stackType, int x, int y)
{
	this->stackType = stackType;
	this->x = x;
	this->y = y;

	setAppropriateStackEnd();
}

void Stack::Render(ArtTools* artTools)
{
	if (cards.size() == 1 || stackType != StackTypeEnum::BottomStack)
		renderOnlyTopCard(artTools);
	else
		renderSpreadStack(artTools);
}

void Stack::renderOnlyTopCard(ArtTools* artTools)
{
	cards[cards.size() - 1]->Render(x, y, artTools);
}

void Stack::renderSpreadStack(ArtTools* artTools)
{
	size_t indexOfLastCard = cards.size() - 1;
	int offset = 0;

	if (indexOfLastCard > 1 && !cards[1]->FaceUp)
		cards[1]->Render(x, y - MINI_STEP, artTools);

	for (int c = 1; c < indexOfLastCard; c++)
		if (cards[c]->FaceUp)
			cards[c]->Render(x, y + offset++ * STEP_SIZE, artTools);

	cards[indexOfLastCard]->Render(x, y + offset * STEP_SIZE, artTools);
}

void Stack::AddCard(Card *card)
{
	cards.push_back(card);
}

void Stack::FlipTopCard()
{
	size_t indexOfLastCard = cards.size() - 1;

	cards[indexOfLastCard]->FaceUp = !cards[indexOfLastCard]->FaceUp;
}

void Stack::GetFreshDeck()
{
	for (int suitNumber = (int)CardSuit::Lowest; suitNumber <= (int)CardSuit::Highest; suitNumber++)
		for (int rankNumber = (int)CardRank::Lowest; rankNumber <= (int)CardRank::Highest; rankNumber++)
			cards.push_back(new Card((CardRank)rankNumber, (CardSuit)suitNumber));
}

void Stack::setAppropriateStackEnd()
{
	if (stackType == StackTypeEnum::TopStack)
		cards.push_back(Card::CreateAceAcceptingSlot());
	else if (stackType == StackTypeEnum::BottomStack)
		cards.push_back(Card::CreateKingAcceptingSlot());
	else
		cards.push_back(Card::CreateDeckBlankSlot());
}

bool Stack::IsEmpty()
{
	return cards.size() == 1;
}

void Stack::Shuffle()
{
	for (int c = SIZE_OF_DECK; c > 0; c--) // ignore the placeholder on the bottom, do grab the last card before to force face-down
	{
		int cardToSwap = blit::random() % c + 1;
		Card* card = cards[cardToSwap];
		cards[cardToSwap] = cards[c];
		card->FaceUp = false;
		cards[c] = card;
	}
}

Card* Stack::DrawCard()
{
	Card* card = cards[cards.size() - 1];

	cards.pop_back();

	return card;
}

int Stack::CountOfSelectableCards()
{
	int count = 0;

	for (int c = cards.size() - 1; c > 0; c--)
		if (cards[c]->FaceUp)
			count++;

	return count;
}

void Stack::RefillFromOtherStack(Stack* otherStack)
{
	while (!otherStack->IsEmpty())
		cards.push_back(otherStack->DrawCard()->Flip());
}

Card* Stack::GetCardForMove(int y, bool source)
{
	int count = cards.size(), faceUp = 0;

	if (HasTopCardNeedingFlipping())
		return NULL;

	if (y == TOP_ROW || (y == 1 && count == 1) || source == DESTINATION)
		return cards[count - 1];

	for (int c = 1; c < count; c++)
		if (cards[c]->FaceUp && ++faceUp == y)
			return cards[c];

	return NULL;
}

bool Stack::HasTopCardNeedingFlipping()
{
	if (IsEmpty())
		return false;

	return !cards[cards.size() - 1]->FaceUp;
}

bool Stack::IsTopCard(Card* card)
{
	return card == cards[cards.size() - 1];
}

Card* Stack::PeekTopCard()
{
	return cards[cards.size() - 1];
}