maride/tty-solitaire
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Array for maneuvre and foundation stacks.

Browse Source
This commit is contained in:
Murilo Pereira 2011-05-29 17:12:52 -03:00
parent b94ea8797a
commit 25ac37a219
7 changed files with 109 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
lib/cursor.c
View File

@ -48,25 +48,25 @@ void move_cursor(struct cursor *cursor, enum movement movement) {
erase_cursor(cursor); erase_cursor(cursor);
switch (cursor->x - 3) { switch (cursor->x - 3) {
case MANEUVRE_0_BEGIN_X: case MANEUVRE_0_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_0); cursor->y = cursor->y + 7 + length(deck->maneuvre[0]);
break; break;
case MANEUVRE_1_BEGIN_X: case MANEUVRE_1_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_1); cursor->y = cursor->y + 7 + length(deck->maneuvre[1]);
break; break;
case MANEUVRE_2_BEGIN_X: case MANEUVRE_2_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_2); cursor->y = cursor->y + 7 + length(deck->maneuvre[2]);
break; break;
case MANEUVRE_3_BEGIN_X: case MANEUVRE_3_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_3); cursor->y = cursor->y + 7 + length(deck->maneuvre[3]);
break; break;
case MANEUVRE_4_BEGIN_X: case MANEUVRE_4_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_4); cursor->y = cursor->y + 7 + length(deck->maneuvre[4]);
break; break;
case MANEUVRE_5_BEGIN_X: case MANEUVRE_5_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_5); cursor->y = cursor->y + 7 + length(deck->maneuvre[5]);
break; break;
case MANEUVRE_6_BEGIN_X: case MANEUVRE_6_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_6); cursor->y = cursor->y + 7 + length(deck->maneuvre[6]);
break; break;
} }
} }

58
lib/deck.c
View File

@ -14,55 +14,35 @@ void allocate_deck(struct deck **deck) {
allocate_stack(&((*deck)->stock)); allocate_stack(&((*deck)->stock));
allocate_stack(&((*deck)->waste_pile)); allocate_stack(&((*deck)->waste_pile));
for (int i = 0; i < 4; i++) {
allocate_stack(&((*deck)->foundation_0)); allocate_stack(&((*deck)->foundation[i]));
allocate_stack(&((*deck)->foundation_1)); }
allocate_stack(&((*deck)->foundation_2)); for (int i = 0; i < 7; i++) {
allocate_stack(&((*deck)->foundation_3)); allocate_stack(&((*deck)->maneuvre[i]));
}
allocate_stack(&((*deck)->maneuvre_0));
allocate_stack(&((*deck)->maneuvre_1));
allocate_stack(&((*deck)->maneuvre_2));
allocate_stack(&((*deck)->maneuvre_3));
allocate_stack(&((*deck)->maneuvre_4));
allocate_stack(&((*deck)->maneuvre_5));
allocate_stack(&((*deck)->maneuvre_6));
} }
void initialize_deck(struct deck *deck) { void initialize_deck(struct deck *deck) {
initialize_stack(deck->stock); initialize_stack(deck->stock);
initialize_stack(deck->waste_pile); initialize_stack(deck->waste_pile);
for (int i = 0; i < 4; i++) {
initialize_stack(deck->foundation_0); initialize_stack(deck->foundation[i]);
initialize_stack(deck->foundation_1); }
initialize_stack(deck->foundation_2); for (int i = 0; i < 7; i++) {
initialize_stack(deck->foundation_3); initialize_stack(deck->maneuvre[i]);
}
initialize_stack(deck->maneuvre_0);
initialize_stack(deck->maneuvre_1);
initialize_stack(deck->maneuvre_2);
initialize_stack(deck->maneuvre_3);
initialize_stack(deck->maneuvre_4);
initialize_stack(deck->maneuvre_5);
initialize_stack(deck->maneuvre_6);
} }
void free_deck(struct deck *deck) { void free_deck(struct deck *deck) {
if (deck) { if (deck) {
free_stack(deck->stock);
free_stack(deck->waste_pile); free_stack(deck->waste_pile);
for (int i = 0; i < 4; i++) {
free_stack(deck->foundation_0); free_stack(deck->foundation[i]);
free_stack(deck->foundation_1); }
free_stack(deck->foundation_2); for (int i = 0; i < 7; i++) {
free_stack(deck->foundation_3); free_stack(deck->maneuvre[i]);
}
free_stack(deck->maneuvre_0);
free_stack(deck->maneuvre_1);
free_stack(deck->maneuvre_2);
free_stack(deck->maneuvre_3);
free_stack(deck->maneuvre_4);
free_stack(deck->maneuvre_5);
free_stack(deck->maneuvre_6);
} }
free(deck); free(deck);
} }

15
lib/deck.h
View File

@ -6,19 +6,8 @@
struct deck { struct deck {
struct stack *stock; struct stack *stock;
struct stack *waste_pile; struct stack *waste_pile;
struct stack *foundation[4];
struct stack *foundation_0; struct stack *maneuvre[7];
struct stack *foundation_1;
struct stack *foundation_2;
struct stack *foundation_3;
struct stack *maneuvre_0;
struct stack *maneuvre_1;
struct stack *maneuvre_2;
struct stack *maneuvre_3;
struct stack *maneuvre_4;
struct stack *maneuvre_5;
struct stack *maneuvre_6;
}; };
void allocate_deck(struct deck **); void allocate_deck(struct deck **);

19
lib/display.c
View File

@ -135,19 +135,12 @@ void draw_stack(struct stack *stack) {
void draw_deck(struct deck *deck) { void draw_deck(struct deck *deck) {
draw_stack(deck->stock); draw_stack(deck->stock);
draw_stack(deck->waste_pile); draw_stack(deck->waste_pile);
for (int i = 0; i < 4; i++) {
draw_stack(deck->foundation_0); draw_stack(deck->foundation[i]);
draw_stack(deck->foundation_1); }
draw_stack(deck->foundation_2); for (int i = 0; i < 7; i++) {
draw_stack(deck->foundation_3); draw_stack(deck->maneuvre[i]);
}
draw_stack(deck->maneuvre_0);
draw_stack(deck->maneuvre_1);
draw_stack(deck->maneuvre_2);
draw_stack(deck->maneuvre_3);
draw_stack(deck->maneuvre_4);
draw_stack(deck->maneuvre_5);
draw_stack(deck->maneuvre_6);
} }
void draw_cursor(struct cursor *cursor) { void draw_cursor(struct cursor *cursor) {

189
lib/game.c
View File

@ -4,42 +4,67 @@
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <time.h> #include <time.h>
#include <assert.h>
#include "display.h" #include "display.h"
#include "curses.h" #include "curses.h"
#include "common.h" #include "common.h"
#include "game.h" #include "game.h"
int foundation_begin_x(int x) {
switch (x) {
case 0: return(FOUNDATION_0_BEGIN_X); break;
case 1: return(FOUNDATION_1_BEGIN_X); break;
case 2: return(FOUNDATION_2_BEGIN_X); break;
case 3: return(FOUNDATION_3_BEGIN_X); break;
default: assert(false && "foundation_begin_x called x < 0 || x > 3");
}
}
int maneuvre_begin_x(int x) {
switch (x) {
case 0: return(MANEUVRE_0_BEGIN_X); break;
case 1: return(MANEUVRE_1_BEGIN_X); break;
case 2: return(MANEUVRE_2_BEGIN_X); break;
case 3: return(MANEUVRE_3_BEGIN_X); break;
case 4: return(MANEUVRE_4_BEGIN_X); break;
case 5: return(MANEUVRE_5_BEGIN_X); break;
case 6: return(MANEUVRE_6_BEGIN_X); break;
default: assert(false && "maneuvre_begin_x called x < 0 || x > 6");
}
}
bool stock_stack(struct stack *stack) { bool stock_stack(struct stack *stack) {
return(stack && stack->card && stack->card->frame && return(stack && stack->card && stack->card->frame &&
(stack->card->frame->begin_y == STOCK_BEGIN_Y) && (stack->card->frame->begin_y == STOCK_BEGIN_Y) &&
(stack->card->frame->begin_x == STOCK_BEGIN_X)); (stack->card->frame->begin_x == STOCK_BEGIN_X));
} }
bool waste_pile_stack(struct stack *stack) { bool waste_pile_stack(struct stack *stack) {
return(stack && stack->card && stack->card->frame && return(stack && stack->card && stack->card->frame &&
(stack->card->frame->begin_y == WASTE_PILE_BEGIN_Y) && (stack->card->frame->begin_y == WASTE_PILE_BEGIN_Y) &&
(stack->card->frame->begin_x == WASTE_PILE_BEGIN_X)); (stack->card->frame->begin_x == WASTE_PILE_BEGIN_X));
} }
bool foundation_stack(struct stack *stack) { bool foundation_stack(struct stack *stack) {
return(stack && stack->card && stack->card->frame && return(stack && stack->card && stack->card->frame &&
stack->card->frame->begin_y == FOUNDATION_BEGIN_Y && stack->card->frame->begin_y == FOUNDATION_BEGIN_Y &&
(stack->card->frame->begin_x == FOUNDATION_0_BEGIN_X || (stack->card->frame->begin_x == FOUNDATION_0_BEGIN_X ||
stack->card->frame->begin_x == FOUNDATION_1_BEGIN_X || stack->card->frame->begin_x == FOUNDATION_1_BEGIN_X ||
stack->card->frame->begin_x == FOUNDATION_2_BEGIN_X || stack->card->frame->begin_x == FOUNDATION_2_BEGIN_X ||
stack->card->frame->begin_x == FOUNDATION_3_BEGIN_X)); stack->card->frame->begin_x == FOUNDATION_3_BEGIN_X));
} }
bool maneuvre_stack(struct stack *stack) { bool maneuvre_stack(struct stack *stack) {
return(stack && stack->card && stack->card->frame && return(stack && stack->card && stack->card->frame &&
stack->card->frame->begin_y >= MANEUVRE_BEGIN_Y && stack->card->frame->begin_y >= MANEUVRE_BEGIN_Y &&
(stack->card->frame->begin_x == MANEUVRE_0_BEGIN_X || (stack->card->frame->begin_x == MANEUVRE_0_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_1_BEGIN_X || stack->card->frame->begin_x == MANEUVRE_1_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_2_BEGIN_X || stack->card->frame->begin_x == MANEUVRE_2_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_3_BEGIN_X || stack->card->frame->begin_x == MANEUVRE_3_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_4_BEGIN_X || stack->card->frame->begin_x == MANEUVRE_4_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_5_BEGIN_X || stack->card->frame->begin_x == MANEUVRE_5_BEGIN_X ||
stack->card->frame->begin_x == MANEUVRE_6_BEGIN_X)); stack->card->frame->begin_x == MANEUVRE_6_BEGIN_X));
} }
bool valid_move(struct stack *origin, struct stack *destination) { bool valid_move(struct stack *origin, struct stack *destination) {
@ -88,80 +113,24 @@ void move_card(struct stack **origin, struct stack **destination) {
static void set_stacks_initial_coordinates(struct deck *deck) { static void set_stacks_initial_coordinates(struct deck *deck) {
set_frame(deck->stock->card->frame, STOCK_BEGIN_Y, STOCK_BEGIN_X); set_frame(deck->stock->card->frame, STOCK_BEGIN_Y, STOCK_BEGIN_X);
set_frame(deck->waste_pile->card->frame, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X); set_frame(deck->waste_pile->card->frame, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
set_frame(deck->foundation_0->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X); for (int i = 0; i < 4; i++) {
set_frame(deck->foundation_1->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X); set_frame(deck->foundation[i]->card->frame, FOUNDATION_BEGIN_Y, foundation_begin_x(i));
set_frame(deck->foundation_2->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X); }
set_frame(deck->foundation_3->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X); for (int i = 0; i < 7; i++) {
set_frame(deck->maneuvre_0->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X); set_frame(deck->maneuvre[i]->card->frame, MANEUVRE_BEGIN_Y, maneuvre_begin_x(i));
set_frame(deck->maneuvre_1->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X); }
set_frame(deck->maneuvre_2->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
set_frame(deck->maneuvre_3->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
set_frame(deck->maneuvre_4->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
set_frame(deck->maneuvre_5->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
set_frame(deck->maneuvre_6->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
} }
static void fill_deck(struct deck *deck) { static void fill_deck(struct deck *deck) {
struct card *card[NUMBER_OF_CARDS]; struct card *card[NUMBER_OF_CARDS];
for (int i = 0; i < NUMBER_OF_CARDS; i++) { for (int i = TWO; i <= ACE; i++) {
allocate_card(&(card[i])); for (int j = DIAMONDS; j <= CLUBS; j++) {
} int index = 4 * (i - TWO) + j;
set_card(card[0], TWO, DIAMONDS, COVERED, 1, 1); allocate_card(&(card[index]));
set_card(card[1], TWO, SPADES, COVERED, 1, 1); set_card(card[index], i, j, COVERED, 1, 1);
set_card(card[2], TWO, HEARTS, COVERED, 1, 1); push(&(deck->stock), card[index]);
set_card(card[3], TWO, CLUBS, COVERED, 1, 1); }
set_card(card[4], THREE, DIAMONDS, COVERED, 1, 1);
set_card(card[5], THREE, SPADES, COVERED, 1, 1);
set_card(card[6], THREE, HEARTS, COVERED, 1, 1);
set_card(card[7], THREE, CLUBS, COVERED, 1, 1);
set_card(card[8], FOUR, DIAMONDS, COVERED, 1, 1);
set_card(card[9], FOUR, SPADES, COVERED, 1, 1);
set_card(card[10], FOUR, HEARTS, COVERED, 1, 1);
set_card(card[11], FOUR, CLUBS, COVERED, 1, 1);
set_card(card[12], FIVE, DIAMONDS, COVERED, 1, 1);
set_card(card[13], FIVE, SPADES, COVERED, 1, 1);
set_card(card[14], FIVE, HEARTS, COVERED, 1, 1);
set_card(card[15], FIVE, CLUBS, COVERED, 1, 1);
set_card(card[16], SIX, DIAMONDS, COVERED, 1, 1);
set_card(card[17], SIX, SPADES, COVERED, 1, 1);
set_card(card[18], SIX, HEARTS, COVERED, 1, 1);
set_card(card[19], SIX, CLUBS, COVERED, 1, 1);
set_card(card[20], SEVEN, DIAMONDS, COVERED, 1, 1);
set_card(card[21], SEVEN, SPADES, COVERED, 1, 1);
set_card(card[22], SEVEN, HEARTS, COVERED, 1, 1);
set_card(card[23], SEVEN, CLUBS, COVERED, 1, 1);
set_card(card[24], EIGHT, DIAMONDS, COVERED, 1, 1);
set_card(card[25], EIGHT, SPADES, COVERED, 1, 1);
set_card(card[26], EIGHT, HEARTS, COVERED, 1, 1);
set_card(card[27], EIGHT, CLUBS, COVERED, 1, 1);
set_card(card[28], NINE, DIAMONDS, COVERED, 1, 1);
set_card(card[29], NINE, SPADES, COVERED, 1, 1);
set_card(card[30], NINE, HEARTS, COVERED, 1, 1);
set_card(card[31], NINE, CLUBS, COVERED, 1, 1);
set_card(card[32], TEN, DIAMONDS, COVERED, 1, 1);
set_card(card[33], TEN, SPADES, COVERED, 1, 1);
set_card(card[34], TEN, HEARTS, COVERED, 1, 1);
set_card(card[35], TEN, CLUBS, COVERED, 1, 1);
set_card(card[36], JACK, DIAMONDS, COVERED, 1, 1);
set_card(card[37], JACK, SPADES, COVERED, 1, 1);
set_card(card[38], JACK, HEARTS, COVERED, 1, 1);
set_card(card[39], JACK, CLUBS, COVERED, 1, 1);
set_card(card[40], QUEEN, DIAMONDS, COVERED, 1, 1);
set_card(card[41], QUEEN, SPADES, COVERED, 1, 1);
set_card(card[42], QUEEN, HEARTS, COVERED, 1, 1);
set_card(card[43], QUEEN, CLUBS, COVERED, 1, 1);
set_card(card[44], KING, DIAMONDS, COVERED, 1, 1);
set_card(card[45], KING, SPADES, COVERED, 1, 1);
set_card(card[46], KING, HEARTS, COVERED, 1, 1);
set_card(card[47], KING, CLUBS, COVERED, 1, 1);
set_card(card[48], ACE, DIAMONDS, COVERED, 1, 1);
set_card(card[49], ACE, SPADES, COVERED, 1, 1);
set_card(card[50], ACE, HEARTS, COVERED, 1, 1);
set_card(card[51], ACE, CLUBS, COVERED, 1, 1);
for (int i = 0; i < NUMBER_OF_CARDS; i++) {
push(&(deck->stock), card[i]);
} }
} }
@ -193,47 +162,13 @@ static void shuffle_deck(struct deck *deck) {
} }
static void deal_cards(struct deck *deck) { static void deal_cards(struct deck *deck) {
move_card(&(deck->stock), &(deck->maneuvre_0)); for (int i = 0; i < 7; i++) {
expose_card(deck->maneuvre_0->card); move_card(&(deck->stock), &(deck->maneuvre[i]));
move_card(&(deck->stock), &(deck->maneuvre_1)); expose_card(deck->maneuvre[i]->card);
move_card(&(deck->stock), &(deck->maneuvre_2)); for (int j = i + 1; j < 7; j++) {
move_card(&(deck->stock), &(deck->maneuvre_3)); move_card(&(deck->stock), &(deck->maneuvre[j]));
move_card(&(deck->stock), &(deck->maneuvre_4)); }
move_card(&(deck->stock), &(deck->maneuvre_5)); }
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_1));
expose_card(deck->maneuvre_1->card);
move_card(&(deck->stock), &(deck->maneuvre_2));
move_card(&(deck->stock), &(deck->maneuvre_3));
move_card(&(deck->stock), &(deck->maneuvre_4));
move_card(&(deck->stock), &(deck->maneuvre_5));
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_2));
expose_card(deck->maneuvre_2->card);
move_card(&(deck->stock), &(deck->maneuvre_3));
move_card(&(deck->stock), &(deck->maneuvre_4));
move_card(&(deck->stock), &(deck->maneuvre_5));
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_3));
expose_card(deck->maneuvre_3->card);
move_card(&(deck->stock), &(deck->maneuvre_4));
move_card(&(deck->stock), &(deck->maneuvre_5));
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_4));
expose_card(deck->maneuvre_4->card);
move_card(&(deck->stock), &(deck->maneuvre_5));
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_5));
expose_card(deck->maneuvre_5->card);
move_card(&(deck->stock), &(deck->maneuvre_6));
move_card(&(deck->stock), &(deck->maneuvre_6));
expose_card(deck->maneuvre_6->card);
} }
void greet_player() { void greet_player() {

2
lib/game.h
View File

@ -31,6 +31,8 @@
struct deck *deck; struct deck *deck;
struct cursor *cursor; struct cursor *cursor;
int foundation_begin_x(int);
int maneuvre_begin_x(int);
bool valid_move(struct stack *, struct stack *); bool valid_move(struct stack *, struct stack *);
bool maneuvre_stack(struct stack *); bool maneuvre_stack(struct stack *);
void move_card(struct stack **, struct stack **); void move_card(struct stack **, struct stack **);

22
lib/keyboard.c
View File

@ -16,20 +16,20 @@ static struct stack *cursor_stack(struct cursor *cursor) {
switch (cursor->x) { switch (cursor->x) {
case CURSOR_STOCK_X: cursor_stack = deck->stock; break; case CURSOR_STOCK_X: cursor_stack = deck->stock; break;
case CURSOR_WASTE_PILE_X: cursor_stack = deck->waste_pile; break; case CURSOR_WASTE_PILE_X: cursor_stack = deck->waste_pile; break;
case CURSOR_FOUNDATION_0_X: cursor_stack = deck->foundation_0; break; case CURSOR_FOUNDATION_0_X: cursor_stack = deck->foundation[0]; break;
case CURSOR_FOUNDATION_1_X: cursor_stack = deck->foundation_1; break; case CURSOR_FOUNDATION_1_X: cursor_stack = deck->foundation[1]; break;
case CURSOR_FOUNDATION_2_X: cursor_stack = deck->foundation_2; break; case CURSOR_FOUNDATION_2_X: cursor_stack = deck->foundation[2]; break;
case CURSOR_FOUNDATION_3_X: cursor_stack = deck->foundation_3; break; case CURSOR_FOUNDATION_3_X: cursor_stack = deck->foundation[3]; break;
} }
} else { } else {
switch (cursor->x) { switch (cursor->x) {
case CURSOR_MANEUVRE_0_X: cursor_stack = deck->maneuvre_0; break; case CURSOR_MANEUVRE_0_X: cursor_stack = deck->maneuvre[0]; break;
case CURSOR_MANEUVRE_1_X: cursor_stack = deck->maneuvre_1; break; case CURSOR_MANEUVRE_1_X: cursor_stack = deck->maneuvre[1]; break;
case CURSOR_MANEUVRE_2_X: cursor_stack = deck->maneuvre_2; break; case CURSOR_MANEUVRE_2_X: cursor_stack = deck->maneuvre[2]; break;
case CURSOR_MANEUVRE_3_X: cursor_stack = deck->maneuvre_3; break; case CURSOR_MANEUVRE_3_X: cursor_stack = deck->maneuvre[3]; break;
case CURSOR_MANEUVRE_4_X: cursor_stack = deck->maneuvre_4; break; case CURSOR_MANEUVRE_4_X: cursor_stack = deck->maneuvre[4]; break;
case CURSOR_MANEUVRE_5_X: cursor_stack = deck->maneuvre_5; break; case CURSOR_MANEUVRE_5_X: cursor_stack = deck->maneuvre[5]; break;
case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre_6; break; case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre[6]; break;
} }
} }