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);
switch (cursor->x - 3) {
case MANEUVRE_0_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_0);
cursor->y = cursor->y + 7 + length(deck->maneuvre[0]);
break;
case MANEUVRE_1_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_1);
cursor->y = cursor->y + 7 + length(deck->maneuvre[1]);
break;
case MANEUVRE_2_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_2);
cursor->y = cursor->y + 7 + length(deck->maneuvre[2]);
break;
case MANEUVRE_3_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_3);
cursor->y = cursor->y + 7 + length(deck->maneuvre[3]);
break;
case MANEUVRE_4_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_4);
cursor->y = cursor->y + 7 + length(deck->maneuvre[4]);
break;
case MANEUVRE_5_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_5);
cursor->y = cursor->y + 7 + length(deck->maneuvre[5]);
break;
case MANEUVRE_6_BEGIN_X:
cursor->y = cursor->y + 7 + length(deck->maneuvre_6);
cursor->y = cursor->y + 7 + length(deck->maneuvre[6]);
break;
}
}

58
lib/deck.c
View File

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

15
lib/deck.h
View File

@ -6,19 +6,8 @@
struct deck {
struct stack *stock;
struct stack *waste_pile;
struct stack *foundation_0;
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;
struct stack *foundation[4];
struct stack *maneuvre[7];
};
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) {
draw_stack(deck->stock);
draw_stack(deck->waste_pile);
draw_stack(deck->foundation_0);
draw_stack(deck->foundation_1);
draw_stack(deck->foundation_2);
draw_stack(deck->foundation_3);
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);
for (int i = 0; i < 4; i++) {
draw_stack(deck->foundation[i]);
}
for (int i = 0; i < 7; i++) {
draw_stack(deck->maneuvre[i]);
}
}
void draw_cursor(struct cursor *cursor) {

153
lib/game.c
View File

@ -4,11 +4,36 @@
#include <string.h>
#include <errno.h>
#include <time.h>
#include <assert.h>
#include "display.h"
#include "curses.h"
#include "common.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) {
return(stack && stack->card && stack->card->frame &&
(stack->card->frame->begin_y == STOCK_BEGIN_Y) &&
@ -88,80 +113,24 @@ void move_card(struct stack **origin, struct stack **destination) {
static void set_stacks_initial_coordinates(struct deck *deck) {
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->foundation_0->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
set_frame(deck->foundation_1->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
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);
set_frame(deck->maneuvre_0->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
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);
for (int i = 0; i < 4; i++) {
set_frame(deck->foundation[i]->card->frame, FOUNDATION_BEGIN_Y, foundation_begin_x(i));
}
for (int i = 0; i < 7; i++) {
set_frame(deck->maneuvre[i]->card->frame, MANEUVRE_BEGIN_Y, maneuvre_begin_x(i));
}
}
static void fill_deck(struct deck *deck) {
struct card *card[NUMBER_OF_CARDS];
for (int i = 0; i < NUMBER_OF_CARDS; i++) {
allocate_card(&(card[i]));
for (int i = TWO; i <= ACE; i++) {
for (int j = DIAMONDS; j <= CLUBS; j++) {
int index = 4 * (i - TWO) + j;
allocate_card(&(card[index]));
set_card(card[index], i, j, COVERED, 1, 1);
push(&(deck->stock), card[index]);
}
set_card(card[0], TWO, DIAMONDS, COVERED, 1, 1);
set_card(card[1], TWO, SPADES, COVERED, 1, 1);
set_card(card[2], TWO, HEARTS, COVERED, 1, 1);
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) {
move_card(&(deck->stock), &(deck->maneuvre_0));
expose_card(deck->maneuvre_0->card);
move_card(&(deck->stock), &(deck->maneuvre_1));
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_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);
for (int i = 0; i < 7; i++) {
move_card(&(deck->stock), &(deck->maneuvre[i]));
expose_card(deck->maneuvre[i]->card);
for (int j = i + 1; j < 7; j++) {
move_card(&(deck->stock), &(deck->maneuvre[j]));
}
}
}
void greet_player() {

2
lib/game.h
View File

@ -31,6 +31,8 @@
struct deck *deck;
struct cursor *cursor;
int foundation_begin_x(int);
int maneuvre_begin_x(int);
bool valid_move(struct stack *, struct stack *);
bool maneuvre_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) {
case CURSOR_STOCK_X: cursor_stack = deck->stock; 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_1_X: cursor_stack = deck->foundation_1; 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_0_X: cursor_stack = deck->foundation[0]; 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_3_X: cursor_stack = deck->foundation[3]; break;
}
} else {
switch (cursor->x) {
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_2_X: cursor_stack = deck->maneuvre_2; 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_5_X: cursor_stack = deck->maneuvre_5; break;
case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre_6; 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_2_X: cursor_stack = deck->maneuvre[2]; 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_5_X: cursor_stack = deck->maneuvre[5]; break;
case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre[6]; break;
}
}