Purchase Solution

developing a game program in c

Not what you're looking for?

Ask Custom Question

//Game specification is to write a program that plays a variant of the solitaire
//game known as Klondike. The goal is to construct four sequences of cards. The
//foundation piles, each sequence is formed by putting cards of the same suit
//into the same pile ascending order beginning with the ace. The setup of the game
//begins by shuffling a deck of cards .Seven piles of cards are dealt out to form the
//tableau, The first pile has one card. The second has 2 etc. The top card on each pile
// is turned up. The others remain hidden. A card can be added to the foundation pile
//pile if its value is one greater than that of the topmost visible card and the color
//is opposite. All of the cards of the pile can be moved to another pile if the bottommost
//visible card can legally be added to the pile. When all of the visible cards are moved,
//the top hidden card is turned over. If there are no more hidden cards the empty spot
//can be occupied by the visible cards from the other pile. A card can be added to the
//foundation pile if its value is one greater than the topmost card and the suite is the
//same. The first card in the pile must be an ace of that suit. Cards can be moved to a
//fondation pile. Cards can be moved to a foundation pile from either the top visible
//card in the tableau pile or the waste pile. In the beginning of play the waste pile is
//empty .After adjustments are made to the initial tableau a card is taken form the
//remainder of the deck and placed as the first card in the waste pile. This card can be
//moved to either a foundation pile or a tableau pile if it fits. If it doesn't fit it remains in
// the waste pile. Another card from the remaining deck is drawn and placed on the waste
//pile. if a drawn card can be placed on a pile this may open up the possibility of moving
//cards around in the tableau. It may also enable the top card in the waste pile to be placed
//.The adjustments are made until nothing can be moved. Play continues until all of the
//original cards in the deck are in play and all adjustments are made. It is then permitted
//to move all of the cards in the waste pile back into the deck .Another round of play
//resumes until the deck is emptied.

//The program should have the capability to play the game. A combination of structures
//stacke and queues to represent the various groups of cards. You can represent a card
//using a structure with one component that is an integer value to hold a the face value
// and another that in an enumerated value to hold the suit. You can use a queue to
//represent the main deck of cards you will be taking cards from the top and occasionally
//putting others back on the bottom. A foundation pile can be most easily represented by a
//queue since it is required that the contents be displayed. The hidden portion of the
//tableau should be represented by a stack to facilitate adding and removing from the top
//of the pile.The waste pile is also best represented with a stack.
//A suggested order of development is as follows
//*Generate the initial deck of cards. Store 52 cards in an array. Then randomly
//select cards from the set and insert them into a queue for the starting hand of the cards.
//* Initialize the foundation piles and the waste pile to be empty deal out the cards to the
//the seven tableau stacks then take the top cared and place it in the corresponding visible
//*Develop a printing routine to display the contents of the foundation piles and the
//visible parts of the tableau pile and the waste pile. A textual printout is all that is needed
//(graphical output is not necessary.
// *Develop the strategy to move around cards as the result of taking one card from the
//remaining deck on the top of the waste pile. Examine first whether this card can be
//placed on the foundation pile. If not can it br played onto one of the tableau piles? Next
//determine if the visible cards on the tableau piles can be moved to another to free up a
//hidden cards. If this happens the new card should be examined for moving to another
//pile. If no visible cards can be moved to another tableau pile then determine if the
//topmost visible cards can be moved to a foundation pile.
//* all of the stepts above should be repeated in a loop until there is no further card
//movement possible.
// organize the play for an entire round. Continue to take cards out of the remaining deck
//hand and deal them until the entire hand is used. check the contents of four foundation
//piles and determine if the game is over.
//* if the game is not over move the cards from the waste pile to the deck .
//continue playing until either the game is won or an entire round goes by without any
//movement of the cards on the table.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct{ //typedef selected to eliminate the need for structure tag
char *face;
char *suit;

void populate_deck(Card *, char *[], char *[]);
void print_deck(Card*);
void shuffle (Card *);



Card deck [52]; //declares an array of 52 cards

char*face[] = {"Ace","2","3","4","5","6","7","8","9","10",
char *suit[] = {"Hearts","Diamonds","Clubs", "Spades"};

puts("t Shuffled Deckn");
shuffle (deck);


void populate_deck(Card * wDeck, char *wFace[], char *wSuit[])
int i;
for(i=0; i<52; i++)
wDeck[i].face = wFace[i%13];
wDeck[i].suit = wSuit[i/13];

void print_deck(Card*wDeck)
int i;
for (i = 0; i<52;i++)
printf("%5s of %-8s%c",wDeck[i].face, wDeck[i].suit,
(i+1) % 2 ?'t':'n');

void shuffle(Card *wDeck)
int i,j;
Card temp;
for (i = 0;i<52;i++)
j = rand() %52;
temp = wDeck[i];
wDeck[j] = temp;

Purchase this Solution

Solution Summary

The expert develops a game program in c is given.

Solution Preview

Dear Student,

I wrote and debugged all the necessary structures (bi-directional lists) and functions/routines. Now all you need to do is to implement the game ...

Purchase this Solution

Free BrainMass Quizzes
Inserting and deleting in a linked list

This quiz tests your understanding of how to insert and delete elements in a linked list. Understanding of the use of linked lists, and the related performance aspects, is an important fundamental skill of computer science data structures.

Java loops

This quiz checks your knowledge of for and while loops in Java. For and while loops are essential building blocks for all Java programs. Having a solid understanding of these constructs is critical for success in programming Java.

Javscript Basics

Quiz on basics of javascript programming language.

Basic UNIX commands

Use this quiz to check your knowledge of a few common UNIX commands. The quiz covers some of the most essential UNIX commands and their basic usage. If you can pass this quiz then you are clearly on your way to becoming an effective UNIX command line user.

C++ Operators

This quiz tests a student's knowledge about C++ operators.