某同学的期末大作业 UNO的简单实现

这破玩意儿写了好久，代码又长又丑。

实在是拿不出手的东西。。。。而且估计还是有很多bug，从老哥结婚准备那天开始零零散散地写到现在，果然写代码战线拖太长不行啊。。。。

姑且写了很长， 在这里放出来

首先这是他们老师放出来的.h，代码之所以很乱也有原因是要实现他们老师要求的function！！！（其实是自己菜吧）

一个是对game的限制：

// The game of Final Card-Down. v1.1.2
//
// !!! DO NOT CHANGE THIS FILE !!!

#include "Card.h"

#ifndef GAME_H
#define GAME_H

#define NUM_PLAYERS 4

#define NOT_FINISHED -1
#define NO_WINNER 4

#define FALSE 0
#define TRUE (!FALSE)

typedef struct _game *Game;

typedef enum {
// Clockwise is 0 -> 1 -> 2 -> 3 -> 0 ...
CLOCKWISE,
// Anticlockwise is 0 -> 3 -> 2 -> 1 -> 0 ...
ANTICLOCKWISE
} direction;

typedef enum {
// Draw a single card from the deck.
DRAW_CARD,
// Play a single card onto the discard pile.
PLAY_CARD,
// Say the word "UNO".
SAY_UNO,
// Say the word "DUO".
SAY_DUO,
// Say the word "TRIO".
SAY_TRIO,
// End the player's turn.
END_TURN
} action;

typedef struct _playerMove {
// Which action to play.
action action;
// Declare which color must be played on the next turn.
// This is only used when playing a DECLARE.
color nextColor;
// Which card to play (only valid for PLAY_CARD).
Card card;
} playerMove;

// Create a new game engine.
//
// This creates a game with a deck of the given size
// and the value, color, and suit of each card to be taken from
// each of the arrays in order.
//
// Your game will always have 4 players. Each player starts with a hand
// of 7 cards. The first card from the deck is given to player 0, the
// second to player 1, the third to player 2, the fourth to player 3,
// the fifth to player 0, and so on until each player has 7 cards.
Game newGame(int deckSize, value values[], color colors[], suit suits[]);

// Destroy an existing game.
//
// This should free all existing memory used in the game including
// allocations for players and cards.
void destroyGame(Game game);

// The following functions can be used by players to discover
// information about the state of the game.

// Get the number of cards that were in the initial deck.
int numCards(Game game);

// Get the number of cards in the initial deck of a particular
// suit.
int numOfSuit(Game game, suit suit);

// Get the number of cards in the initial deck of a particular color.
int numOfColor(Game game, color color);

// Get the number of cards in the initial deck of a particular value.
int numOfValue(Game game, value value);

// Get the number of the player whose turn it is.
int currentPlayer(Game game);

// Get the current turn number.
//
// The turn number increases after a player ends their turn.
// The turn number should start at 0 once the game has started.
int currentTurn(Game game);

// Get the number of points for a given player.
// Player should be between 0 and 3.
//
// This should _not_ be called by a player.
int playerPoints(Game game, int player);

// Get the current direction of play.
direction playDirection(Game game);

// This function returns the number of turns that have occurred in the
// game so far including the current turn.
// When using either the turnMoves or pastMove function,
// the turn number should be less than the number of moves that this
// function returns.
// (i.e. on turn 0 of the game, this should return 1, as there has been
// 1 turn so far including the current turn; if you called pastMove you
// would need to call it on turn 0, as this is the only possible value
// less than 1.)
int numTurns(Game game);

// Get the number of moves that happened on a turn.
//
// A turn may consist of multiple moves such as drawing cards,
// playing cards, and ending the turn.
int turnMoves(Game game, int turn);

// Look at a previous move from a specified turn.
playerMove pastMove(Game game, int turn, int move);

// Get the number of cards in a given player's hand.
int playerCardCount(Game game, int player);

// Get the number of cards in the current player's hand.
int handCardCount(Game game);

// View a card from the current player's own hand.
//
// The player should not need to free() this card,
// so you should not allocate or clone an existing card
// but give a reference to an existing card.
Card handCard(Game game, int card);

// Check if a given move is valid.
//
// If the last player played a 2 (DRAW_TWO),
// the next player must either play a 2
// or draw 2 cards.
// Otherwise, the player must play a card that is either a ZERO
// or that has the same color, value, or suit as the card on the top
// of the discard pile.
//
// If the player plays an ADVANCE, the next player's turn is skipped.
// If the player plays a BACKWARDS, the direction of play is reversed.
// If the player plays a CONTINUE, they may play another card.
// If the player plays a DECLARE, they must also state which color
// the next player's discarded card should be.
//
// A player can only play cards from their hand.
// A player may choose to draw a card instead of discarding a card.
// A player must draw a card if they are unable to discard a card.
//
// This check should verify that:
// * The card being played is in the player's hand
// * The player has played at least one card before finishing their turn,
//   unless a draw-two was played, in which case the player may not
//   play a card, and instead must draw the appropriate number of cards.
int isValidMove(Game game, playerMove move);

// Play the given action for the current player
//
// If the player makes the END_TURN move, their turn ends,
// and it becomes the turn of the next player.
//
// This should _not_ be called by the player AI.
void playMove(Game game, playerMove move);

// Check the game winner.
//
// Returns NOT_FINISHED if the game has not yet finished,
// 0-3, representing which player has won the game, or
// NO_WINNER if the game has ended but there was no winner.
int gameWinner(Game game);

#endif // GAME_H

一个是对card的一些限制：

// The playing card interface. v1.1.0
//
// !!! DO NOT CHANGE THIS FILE !!!
//
// This interface represents a single playing card
// in the game of Final Card-Down.

#ifndef CARD_H
#define CARD_H

typedef struct _card *Card;

// The various colors that a card can have.
typedef enum {
RED,
BLUE,
GREEN,
YELLOW,
PURPLE
} color;

// The various suits that a card can have.
typedef enum {
HEARTS,
DIAMONDS,
CLUBS,
SPADES,
QUESTIONS
} suit;

// The various values that a card can have.
typedef enum {
ZERO,
ONE,
DRAW_TWO,
THREE,
FOUR,
FIVE,
SIX,
SEVEN,
EIGHT,
NINE,
ADVANCE,
BACKWARDS,
CONTINUE,
DECLARE,
E,
F
} value;

// Create a new card.
// These values can only be set at creation time.
// The number should be between 0x0 and 0xF.
Card newCard(value value, color color, suit suit);

// Destroy an existing card.
void destroyCard(Card card);

// Get the card's suit (HEARTS, DIAMONDS, etc).
suit cardSuit(Card card);

// Get the card's number (0x0 through 0xF).
value cardValue(Card card);

// Get the card's color (RED, BLUE, etc).
color cardColor(Card card);

#endif // CARD_H

然后是我的破代码。。。。本来还需要写测试的，不过我就不写了哈哈哈！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include "Game.h"
#include "Card.h"
using namespace std;
#define MAX_DECK_SIZE 100
#define MAX_TURNS 100
#define MAX_MOVE 15
struct cardPile{
int card[MAX_DECK_SIZE];
int num;
};

struct _game{
int deckSize;
int numPlayers;
int moveInTurn[MAX_TURNS];
int nowPlayer;
int lastPlayer;
int isFirstTurn;
int twoValue;
int haveDraw;
int havePlay;
int haveSayUno;
int haveSayDuo;
int haveSayTrio;
int lastForgetO;
int noWinner;
int points;
int playerPoints[NUM_PLAYERS];
int turns;
playerMove *lastMove;
playerMove *pastMoveRec[MAX_TURNS][MAX_MOVE];
cardPile player[NUM_PLAYERS];
cardPile disPile;
direction nowDirection;
color *colors;
suit *suits;
value *values;
};

struct _card{
value value;
color color;
suit suit;
};

Card newCard(value value, color color, suit suit){
Card card = (_card*)calloc(1, sizeof(_card));
card->value = value;
card->color = color;
card->suit = suit;
return card;
}

playerMove *newPlayerMove(){
playerMove *p = (playerMove*)calloc(1, sizeof(playerMove));
p->card = newCard(ZERO, RED, HEARTS);
return p;
}

void destroyPlayerMove(playerMove *p){
destroyCard(p->card);
free(p);
}

Game newGame(int deckSize, value values[], color colors[], suit suits[]){
Game nowGame = (_game*)calloc(1, sizeof(_game));
nowGame->deckSize = deckSize;
nowGame->disPile.num = 0;
for(int i=0;i<NUM_PLAYERS;i++){
nowGame->player[i].num = 0;
}
nowGame->turns = 0;
nowGame->nowDirection = CLOCKWISE;
nowGame->twoValue = 0;
nowGame->nowPlayer = 0;
nowGame->haveDraw = FALSE;
nowGame->havePlay = FALSE;
nowGame->haveSayUno = FALSE;
nowGame->haveSayDuo = FALSE;
nowGame->haveSayTrio = FALSE;
nowGame->noWinner = FALSE;
nowGame->points = 0;
nowGame->lastMove = newPlayerMove();
for(int i = 0; i<MAX_TURNS; i++){
for(int j = 0; j<MAX_MOVE; j++){
nowGame->pastMoveRec[i][j] = newPlayerMove();
}
}
nowGame->values = values;
nowGame->colors = colors;
nowGame->suits = suits;
return nowGame;
};

int isOver(Game game){
if(game->noWinner == TRUE) return TRUE;
int sum = 0;
for(int i=0;i<NUM_PLAYERS;i++){
sum += game->player[i].num;
}
if(sum==0) return TRUE;
else return FALSE;
}
void dealCard(Game game){
int i,j,k;
k = 0, j = 0;
int p = game->deckSize;
for(i=0;i<28;i++){
j = i%NUM_PLAYERS;
game->player[j].card[k] = --p;
++game->player[j].num;
if(j==3){
++k;
}
}
game->deckSize -= 28;

}
void systemVoice(Game game){
printf("Player %d's turn\n",game->nowPlayer);
printf("you have %d cards,there are:\n",game->player[game->nowPlayer].num);
printf("index: ");
for(int i = 0;i<game->player[game->nowPlayer].num;i++){
printf("%d ",game->player[game->nowPlayer].card[i]);
}
printf("\n");
printf("value: ");
for(int i = 0;i<game->player[game->nowPlayer].num;i++){
printf("%d ",game->values[game->player[game->nowPlayer].card[i]]);
}
printf("\n");
printf("color: ");
for(int i = 0;i<game->player[game->nowPlayer].num;i++){
printf("%d ",game->colors[game->player[game->nowPlayer].card[i]]);
}
printf("\n");
printf("suit:  ");
for(int i = 0;i<game->player[game->nowPlayer].num;i++){
printf("%d ",game->suits[game->player[game->nowPlayer].card[i]]);
}
printf("\n");
printf("Please select your action: \n");
printf("0: DRAW_CARD\n1:PLAY_CARD\n2:SAY_UNO\n3:SAY_DUO\n4:SAY_TRIO\n5:END_TURN\n");
}

int drawACard(Game game, int playerIndex){
int numOfMyCards = game->player[playerIndex].num;
if(game->deckSize > 0){
game->player[playerIndex].card[numOfMyCards++] = game->deckSize - 1;
game->deckSize -= 1;
game->player[playerIndex].num = numOfMyCards;
return TRUE;
}else if(game->disPile.num > 0){
game->player[playerIndex].card[numOfMyCards++] = game->disPile.card[game->disPile.num - 1];
game->disPile.num -= 1;
game->player[playerIndex].num = numOfMyCards;
return TRUE;
}else{
return FALSE;
}
}

void discard(Game game, int playerIndex, int cardIndex){
int numOfDispile = game->disPile.num;
int numOfCardsOnHand = game->player[playerIndex].num;
game->disPile.card[numOfDispile++] = cardIndex;
for(int i = 0; i<numOfCardsOnHand; i++){
if(game->player[playerIndex].card[i] == cardIndex){
for(int j = i+1; j < numOfCardsOnHand; j++){
game->player[playerIndex].card[j-1] = game->player[playerIndex].card[j];
}
}
}
game->disPile.num = numOfDispile;
game->player[playerIndex].num = numOfCardsOnHand - 1;
}

void copyLastMove(Game game, playerMove &move){
game->lastMove->action = PLAY_CARD;
game->lastMove->card->value = move.card->value;
game->lastMove->card->color = move.card->color;
game->lastMove->card->suit = move.card->suit;
}

int isValidMove(Game game, playerMove move){
if(game->lastMove->card->value == ADVANCE){
if(move.action == END_TURN){
game->isFirstTurn = TRUE;
return TRUE;
}
printf("This turn you are been skipped ...invalid action!\n");
return FALSE;
}
if(move.action == PLAY_CARD){
if(game->havePlay != FALSE){
printf("You have no change to play.... invalid action\n");
return FALSE;
}
if(game->haveDraw == TRUE){
printf("You can't played now.... invalid action\n");
return FALSE;
}

if(game->lastMove->card->value == DRAW_TWO){
if(move.card->value != DRAW_TWO){
printf("You can only play card whose value is 2, or draw %d cards\n", game->twoValue);
return FALSE;
}else{
game->twoValue += 2;
game->havePlay = TRUE;
copyLastMove(game, move);
return TRUE;
}
}else if(game->lastMove->card->value == DECLARE){
if(move.card->color != game->lastMove->nextColor){
printf("You can't play this color\n");
return FALSE;
}else{
copyLastMove(game, move);
game->havePlay = TRUE;
return TRUE;
}
}

if(game->lastMove->card->value == move.card->value || game->lastMove->card->color == move.card->suit || game->lastMove->card->suit == move.card->suit || game->isFirstTurn || move.card->value == ZERO){
copyLastMove(game, move);
if(game->isFirstTurn == TRUE){
game->isFirstTurn = FALSE;
}
if(move.card->value == DRAW_TWO){
game->havePlay = TRUE;
game->twoValue += 2;
return TRUE;
}else if(move.card->value == ADVANCE){
game->havePlay = TRUE;
return TRUE;
}else if(move.card->value == BACKWARDS){
game->nowDirection = (direction)(!game->nowDirection);
game->havePlay = TRUE;
return TRUE;
}else if(move.card->value == CONTINUE){
game->haveDraw = -1; //fuck up... For the Draw action
game->isFirstTurn = TRUE;
return TRUE;
}else if(move.card->value == DECLARE){
copyLastMove(game, move);
game->havePlay = TRUE;
return TRUE;
}else{
game->havePlay = TRUE;
return TRUE;
}
}else{
printf("What are you thinking? Invalid card\n");
return FALSE;
}
}else if(move.action == DRAW_CARD){
if(game->haveDraw == TRUE && game->twoValue == 0){
printf("You have drawed... invalid action\n");
return FALSE;
}
if(game->haveDraw == -1 || game->havePlay == TRUE){
printf("You have chosen to play card... invalid action\n");
return FALSE;
}
game->haveDraw = TRUE;
if(drawACard(game, game->nowPlayer)){
if(game->twoValue>0){
-- game->twoValue;
}
return TRUE;
}else{
printf("No cards left....No winner\n");
return -1; //No winner;
}

}else if(move.action == SAY_UNO){
game->haveSayUno = TRUE;
if(game->lastForgetO == 1){
for(int i = 1; i<=2;i++){
drawACard(game, game->lastPlayer);
}
}
printf("UNO!!\n");
return TRUE;
}else if(move.action == SAY_DUO){
game->haveSayDuo = TRUE;
if(game->lastForgetO == 2){
for(int i=1; i<=2; i++){
drawACard(game, game->lastPlayer);
}
}
printf("DUO!!\n");
return TRUE;
}else if(move.action == SAY_TRIO){
game->haveSayTrio = TRUE;
if(game->lastForgetO == 3){
for(int i=1; i<=2; i++){
drawACard(game, game->lastPlayer);
}
}
}else{
if(game->havePlay==FALSE && game->haveDraw == FALSE){
printf("Nothong has been done\n");
return FALSE;
}
return 2;
}

printf("wtf?!\n");
return FALSE;
}

void initBeforeMove(Game game){
game->haveDraw = FALSE;
game->havePlay = FALSE;
game->haveSayUno = FALSE;
game->haveSayDuo = FALSE;
game->haveSayTrio = FALSE;
}

void playMove(Game game, playerMove move){
//emmmmmmmmmmmmm
}

void copyMove(playerMove *a, playerMove *b){
a->action = b->action;
a->nextColor = b->nextColor;
a->card = b->card;
}

void makeMove(Game game){
int isOver = FALSE;
playerMove *nowMove = newPlayerMove();
int num, flag, cardIndex;
initBeforeMove(game);
while (isOver == FALSE) {
if(game->player[game->nowPlayer].num == 0){
printf("No cards! Congarduations\n");
game->playerPoints[game->nowPlayer] = game->points++;
break;
}
systemVoice(game);
scanf("%d",&nowMove->action);
if(nowMove->action==PLAY_CARD){
printf("pelase input the index of the card\n");
scanf("%d",&num);
cardIndex = num;
nowMove->card->color = game->colors[num];
nowMove->card->suit = game->suits[num];
nowMove->card->value = game->values[num];
nowMove->action = PLAY_CARD;
if(game->values[num] == DECLARE){
printf("Please select the color which the next player need to play\n");
printf("0:RED, 1:BLUE, 2:GREEN, 3:YELLOW, 4:PURPLE\n");
while(scanf("%d", &num)&&(num<0||num>4)){
printf("invalid color!\n");
}
nowMove->nextColor = (color)num;
}
flag = isValidMove(game, *nowMove);
if(flag == TRUE){
discard(game, game->nowPlayer, cardIndex);
}
}else{
flag = isValidMove(game, *nowMove);
if(flag == -1){
game->noWinner = TRUE;
}else if(flag == 2){
isOver = TRUE;
}
}
copyMove(game->pastMoveRec[game->turns][game->moveInTurn[game->turns]], nowMove);
++(game->moveInTurn[game->turns]);
}
if(game->player[game->nowPlayer].num == 1 && game->haveSayUno == FALSE){
game->lastForgetO = 1;
}else if(game->player[game->nowPlayer].num == 2 && game->haveSayDuo == FALSE){
game->lastForgetO = 2;
}else if(game->player[game->nowPlayer].num == 3 && game->haveSayTrio == FALSE){
game->lastForgetO = 3;
}
destroyPlayerMove(nowMove);
}
void playGame(Game game){
dealCard(game);
printf("Welcome to Uno World, the loser will go die\n");
game->isFirstTurn = TRUE;
game->lastMove->card->value = ZERO, game->lastMove->card->color = RED, game->lastMove->card->suit = HEARTS;
game->twoValue = 0;
while(!isOver(game)){
makeMove(game);
int add;
if(game->nowDirection == CLOCKWISE) add = 1;
else add = -1;
game->nowPlayer = (game->nowPlayer + add + NUM_PLAYERS)%NUM_PLAYERS;
game->turns++;
}
printf("The game is over\n");
}

void destroyCard(Card card){
free(card);
}

suit cardSuit(Card card){
return card->suit;
}

value cardValue(Card card){
return card->value;
}

color cardColor(Card card){
return card->color;
}

void destroyGame(Game game){
destroyPlayerMove(game->lastMove);
for(int i = 0; i<MAX_TURNS; i++){
for(int j = 0; j<MAX_MOVE; j++){
destroyPlayerMove(game->pastMoveRec[i][j]);
}
}
free(game);
}

int numCards(Game game){
return game->deckSize;
}

int numOfSuit(Game game, suit suit){
int sum = 0;
for(int i = 0; i<game->deckSize; i++){
if(game->suits[i] == suit){
++sum;
}
}
return sum;
}

int numOfColor(Game game, color color){
int sum = 0;
for(int i = 0; i<game->deckSize; i++){
if(game->colors[i] == color){
++sum;
}
}
return sum;
}

int numOfValue(Game game, value value){
int sum = 0;
for(int i = 0; i<game->deckSize; i++){
if(game->values[i] == value){
++sum;
}
}
return sum;
}

int currentPlayer(Game game){
return game->nowPlayer;
}
int currentTurn(Game game){
return game->turns;
}
int playerPoints(Game game, int player){
return game->playerPoints[player];
}

direction playDirection(Game game){
return game->nowDirection;
}

int numTurns(Game game){
return game->turns + 1;
}

int turnMoves(Game game, int turn){
return game->moveInTurn[turn];
}

playerMove pastMove(Game game, int turn, int move){
return *game->pastMoveRec[turn][move];
}

int playerCardCount(Game game, int player){
return game->player[player].num;
}

int handCardCount(Game game){
return game->player[game->nowPlayer].num;
}

Card handCard(Game game, int card){
int index;
for(int i = 0; i<game->player[game->nowPlayer].num; i++){
if(i==card){
index =  game->player[game->nowPlayer].card[i];
}
}
Card ca = newCard(game->values[index], game->colors[index], game->suits[index]);
return ca;
}

int gameWinner(Game game){
for(int i = 0; i<NUM_PLAYERS; i++){
if(game->playerPoints[i] == 0){
return i;
}
}
return NO_WINNER;
}

int main(){
value a[50];
color b[50];
suit c[50];
for(int i = 0; i<30; i++){
scanf("%d",a+i);
}
for(int i = 0; i<30; i++){
scanf("%d",b+i);
}
for(int i = 0; i<30; i++){
scanf("%d",c+i);
}
Game killme = newGame(30, a, b, c);
playGame(killme);
destroyGame(killme);

return 0;
}