int player_init(struct player* pl,unsigned int deck_size,int hp)
{
if(!pl){
return PLAYER_ERROR;
}
//init deck
if( DECK_OK != deck_init(&pl->deck,deck_size)){
return PLAYER_ERROR;
}
//init manapool
manapool_init(&pl->mpool);
//set hp
pl->hp = hp;
//init hand of the player
if( NULL == (pl->hand = malloc(deck_size*sizeof(struct card)))){
deck_deinit(&pl->deck);
return PLAYER_ERROR;
}
memset(pl->hand,0,deck_size*sizeof(struct card));
pl->current_cards_in_hand = 0;
pl->hand_size = deck_size;
return PLAYER_OK;
}
int main(int argc, char** argv){
printf("**********************************************************\n");
printf("* Runbai Ma *\n");
printf("* Final Project *\n");
printf("* Five draw Card Game *\n");
printf("* *\n");
printf("* *\n");
printf("**********************************************************\n");
printf("1.start game \n");
printf("2.quit\n");
char input = getchar();
char play_again = '1';
if(input == '1'){
while(play_again == '1'){
putchar('\n');
srand((unsigned int)time(NULL));
Deck* deck = (Deck*) malloc(sizeof(Deck));
Card* card_arr = malloc (sizeof(Card)*52);
int* ret_value = malloc(sizeof(int));
card_arr = shuffle_card();
deck_init(deck,card_arr);
/* initial the four player*/
char* name2 = malloc(sizeof(char)*15);
name2 = "Computer 1";
Player* p2 = malloc(sizeof(Player));
player_init(p2,name2);
deal_card(p2->hand,deck,5);
printf("computer 1 hand: ");
hand_print(p2->hand);
char* name3 = malloc(sizeof(char)*15);
name3 = "Computer 2";
Player* p3 = malloc(sizeof(Player));
player_init(p3,name3);
deal_card(p3->hand,deck,5);
printf("computer 2 hand: ");
hand_print(p3->hand);
char* name4 = malloc(sizeof(char)*15);
name4 = "Computer 3";
Player* p4 = malloc(sizeof(Player));
player_init(p4,name4);
deal_card(p4->hand,deck,5);
printf("computer 3 hand: ");
hand_print(p4->hand);
char* name = malloc(sizeof(char)*15);
name = "Poker King";
Player* p1 = malloc(sizeof(Player));
player_init(p1,name);
deal_card(p1->hand,deck,5);
printf("your hand: ");
hand_print(p1->hand);
printf("----------------------------------------------------------\n");
putchar('\n');
ret_value = monte_carlo_advisor(p2->hand);
change_card_by_montecarlo(ret_value,p2->hand,deck);
compute_hand_afterchange(p2->hand);
ret_value = monte_carlo_advisor(p3->hand);
change_card_by_montecarlo(ret_value,p3->hand,deck);
compute_hand_afterchange(p3->hand);
ret_value = monte_carlo_advisor(p4->hand);
change_card_by_montecarlo(ret_value,p4->hand,deck);
compute_hand_afterchange(p4->hand);
printf("Monte Carlor suggestion for u: \n");
putchar('\n');
ret_value= monte_carlo_advisor(p1->hand);
print_montecarlo_result(ret_value);
printf("----------------------------------------------------------\n");
putchar('\n');
printf("Your hand: ");
hand_print(p1->hand);
putchar('\n');
char c;
c = getchar();
printf("Enter the card index you want to change: \n");
while((c = getchar()) != '\n'){
//int i = atoi(&c);
//printf("oh god: %d\n", i);
if(c == '1')
change_card(p1->hand, deck, 1);
else if(c == '2')
change_card(p1->hand, deck, 2);
else if(c == '3')
change_card(p1->hand, deck, 3);
else if(c == '4')
change_card(p1->hand, deck, 4);
else if(c == '5')
change_card(p1->hand, deck, 5);
}
compute_hand_afterchange(p1->hand);
printf("----------------------------------------------------------\n");
putchar('\n');
printf("computer 1 after change is: ");
hand_print(p2->hand);
printf("computer 2 after change is: ");
hand_print(p3->hand);
printf("computer 3 after change is: ");
hand_print(p4->hand);
printf("your hand after change is : ");
hand_print(p1->hand);
printf("----------------------------------------------------------\n");
putchar('\n');
printf("the game result is: \n");
Player* p[4] = {p1,p2,p3,p4};
int winner = get_winner(p);
if(winner == 0){
printf("You won the game!\n");
}
else{
printf("%s won the game!\n", p[winner]->name);
}
putchar('\n');
putchar('\n');
putchar('\n');
printf("1.play again\n");
printf("2.quit\n");
play_again = getchar();
}
}
}
coup_t *
coup_newgame(
int nplayers,
const struct coup_cb_set *cb)
{
if (nplayers < COUP_MIN_PLAYERS || nplayers > COUP_MAX_PLAYERS)
{
return NULL;
}
/* Allocate memory for game */
coup_t *coup = (coup_t*)malloc(sizeof(coup_t));
if (!coup)
{
return NULL;
}
memset(coup, 0x00, sizeof(coup_t));
/* Initialize properties */
coup->state = COUP_STATE_NEWGAME;
coup->turn = 0;
coup->cb = cb;
/* Initialize court deck */
deck_t *court = deck_alloc();
deck_init(court);
int i;
for(i=0; i<3; i++)
{
deck_add_card(court, card_make("Captain", "\"Steal\" 2 coins from a player. Blocks Stealing."));
deck_add_card(court, card_make("Ambassador", "\"Exchange\" 2 cards from the deck. Blocks Stealing."));
deck_add_card(court, card_make("Duke", "\"Tax\" 3 coins. Blocks foreign aid."));
deck_add_card(court, card_make("Contessa", "\"Block\" assassination."));
deck_add_card(court, card_make("Assassin", "\"Assassinate\" a player for 3 coins."));
}
deck_shuffle(court);
coup->court = court;
/* Initialize discard deck */
deck_t *discard = deck_alloc();
deck_init(discard);
coup->discard = discard;
/* Initialize player data */
coup->nplayers = nplayers;
coup->player = (struct coup_player*)calloc(nplayers, sizeof(struct coup_player));
if (!coup->player)
{
return NULL;
}
for(i=0; i<nplayers; i++)
{
struct coup_player *player = &coup->player[i];
player->ncoins = COUP_START_COINS;
player->hand = deck_alloc();
deck_init(player->hand);
card_t *card1 = deck_take_card(coup->court);
card_t *card2 = deck_take_card(coup->court);
deck_add_card(player->hand, card1);
deck_add_card(player->hand, card2);
}
return coup;
}
int main(int argc, char *argv[])
{
int rc = -1, n, priority;
const char *importer, *scanner, *geo;
char *endptr;
size_t nctl;
double speed;
struct timecode_def *timecode;
bool protect, use_mlock, phono;
struct controller ctl[2];
struct rt rt;
struct library library;
#if defined WITH_OSS || WITH_ALSA
int rate;
#endif
#ifdef WITH_OSS
int oss_buffers, oss_fragment;
#endif
#ifdef WITH_ALSA
int alsa_buffer;
#endif
fprintf(stderr, "%s\n\n" NOTICE "\n\n", banner);
if (thread_global_init() == -1)
return -1;
if (rig_init() == -1)
return -1;
rt_init(&rt);
library_init(&library);
ndeck = 0;
geo = "";
nctl = 0;
priority = DEFAULT_PRIORITY;
importer = DEFAULT_IMPORTER;
scanner = DEFAULT_SCANNER;
timecode = NULL;
speed = 1.0;
protect = false;
phono = false;
use_mlock = false;
#if defined WITH_OSS || WITH_ALSA
rate = DEFAULT_RATE;
#endif
#ifdef WITH_ALSA
alsa_buffer = DEFAULT_ALSA_BUFFER;
#endif
#ifdef WITH_OSS
oss_fragment = DEFAULT_OSS_FRAGMENT;
oss_buffers = DEFAULT_OSS_BUFFERS;
#endif
/* Skip over command name */
argv++;
argc--;
while (argc > 0) {
if (!strcmp(argv[0], "-h")) {
usage(stdout);
return 0;
#ifdef WITH_OSS
} else if (!strcmp(argv[0], "-f")) {
/* Set fragment size for subsequent devices */
if (argc < 2) {
fprintf(stderr, "-f requires an integer argument.\n");
return -1;
}
oss_fragment = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-f requires an integer argument.\n");
return -1;
}
/* Fragment sizes greater than the default aren't useful
* as they are dependent on DEVICE_FRAME */
if (oss_fragment < DEFAULT_OSS_FRAGMENT) {
fprintf(stderr, "Fragment size must be %d or more; aborting.\n",
DEFAULT_OSS_FRAGMENT);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-b")) {
/* Set number of buffers for subsequent devices */
if (argc < 2) {
fprintf(stderr, "-b requires an integer argument.\n");
return -1;
}
oss_buffers = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-b requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
#if defined WITH_OSS || WITH_ALSA
} else if (!strcmp(argv[0], "-r")) {
/* Set sample rate for subsequence devices */
if (argc < 2) {
fprintf(stderr, "-r requires an integer argument.\n");
return -1;
}
rate = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-r requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
#ifdef WITH_ALSA
} else if (!strcmp(argv[0], "-m")) {
/* Set size of ALSA buffer for subsequence devices */
if (argc < 2) {
fprintf(stderr, "-m requires an integer argument.\n");
return -1;
}
alsa_buffer = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-m requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
} else if (!strcmp(argv[0], "-d") || !strcmp(argv[0], "-a") ||
!strcmp(argv[0], "-j"))
{
int r;
unsigned int sample_rate;
struct deck *ld;
struct device *device;
struct timecoder *timecoder;
/* Create a deck */
if (argc < 2) {
fprintf(stderr, "-%c requires a device name as an argument.\n",
argv[0][1]);
return -1;
}
if (ndeck == ARRAY_SIZE(deck)) {
fprintf(stderr, "Too many decks; aborting.\n");
return -1;
}
fprintf(stderr, "Initialising deck %zd (%s)...\n", ndeck, argv[1]);
ld = &deck[ndeck];
device = &ld->device;
timecoder = &ld->timecoder;
ld->importer = importer;
ld->protect = protect;
/* Work out which device type we are using, and initialise
* an appropriate device. */
switch(argv[0][1]) {
#ifdef WITH_OSS
case 'd':
r = oss_init(device, argv[1], rate, oss_buffers, oss_fragment);
break;
#endif
#ifdef WITH_ALSA
case 'a':
r = alsa_init(device, argv[1], rate, alsa_buffer);
break;
#endif
#ifdef WITH_JACK
case 'j':
r = jack_init(device, argv[1]);
break;
#endif
default:
fprintf(stderr, "Device type is not supported by this "
"distribution of xwax.\n");
return -1;
}
if (r == -1)
return -1;
sample_rate = device_sample_rate(device);
/* Default timecode decoder where none is specified */
if (timecode == NULL) {
timecode = timecoder_find_definition(DEFAULT_TIMECODE);
assert(timecode != NULL);
}
timecoder_init(timecoder, timecode, speed, sample_rate, phono);
/* Connect up the elements to make an operational deck */
r = deck_init(ld, &rt, ndeck);
if (r == -1)
return -1;
/* Connect this deck to available controllers */
for (n = 0; n < nctl; n++)
controller_add_deck(&ctl[n], &deck[ndeck]);
/* Connect this deck to OSC server */
osc_add_deck();
ndeck++;
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-t")) {
/* Set the timecode definition to use */
if (argc < 2) {
fprintf(stderr, "-t requires a name as an argument.\n");
return -1;
}
timecode = timecoder_find_definition(argv[1]);
if (timecode == NULL) {
fprintf(stderr, "Timecode '%s' is not known.\n", argv[1]);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-33")) {
speed = 1.0;
argv++;
argc--;
} else if (!strcmp(argv[0], "-45")) {
speed = 1.35;
argv++;
argc--;
} else if (!strcmp(argv[0], "-c")) {
protect = true;
argv++;
argc--;
} else if (!strcmp(argv[0], "-u")) {
protect = false;
argv++;
argc--;
} else if (!strcmp(argv[0], "--line")) {
phono = false;
argv++;
argc--;
} else if (!strcmp(argv[0], "--phono")) {
phono = true;
argv++;
argc--;
} else if (!strcmp(argv[0], "-k")) {
use_mlock = true;
track_use_mlock();
argv++;
argc--;
} else if (!strcmp(argv[0], "-q")) {
if (argc < 2) {
fprintf(stderr, "-q requires an integer argument.\n");
return -1;
}
priority = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-q requires an integer argument.\n");
return -1;
}
if (priority < 0) {
fprintf(stderr, "Priority (%d) must be zero or positive.\n",
priority);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-g")) {
if (argc < 2) {
fprintf(stderr, "-g requires an argument.\n");
return -1;
}
geo = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-i")) {
/* Importer script for subsequent decks */
if (argc < 2) {
fprintf(stderr, "-i requires an executable path "
"as an argument.\n");
return -1;
}
importer = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-s")) {
/* Scan script for subsequent libraries */
if (argc < 2) {
fprintf(stderr, "-s requires an executable path "
"as an argument.\n");
return -1;
}
scanner = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-l")) {
/* Load in a music library */
if (argc < 2) {
fprintf(stderr, "-%c requires a pathname as an argument.\n",
argv[0][1]);
return -1;
}
if (library_import(&library, scanner, argv[1]) == -1)
return -1;
argv += 2;
argc -= 2;
#ifdef WITH_ALSA
} else if (!strcmp(argv[0], "--dicer")) {
struct controller *c;
if (nctl == sizeof ctl) {
fprintf(stderr, "Too many controllers; aborting.\n");
return -1;
}
c = &ctl[nctl];
if (argc < 2) {
fprintf(stderr, "Dicer requires an ALSA device name.\n");
return -1;
}
if (dicer_init(c, &rt, argv[1]) == -1)
return -1;
nctl++;
argv += 2;
argc -= 2;
#endif
} else {
fprintf(stderr, "'%s' argument is unknown; try -h.\n", argv[0]);
return -1;
}
}
#ifdef WITH_ALSA
alsa_clear_config_cache();
#endif
if (ndeck == 0) {
fprintf(stderr, "You need to give at least one audio device to use "
"as a deck; try -h.\n");
return -1;
}
rc = EXIT_FAILURE; /* until clean exit */
if (osc_start((struct deck *)&deck, &library) == -1)
return -1;
osc_start_updater_thread();
/* Order is important: launch realtime thread first, then mlock.
* Don't mlock the interface, use sparingly for audio threads */
if (rt_start(&rt, priority) == -1)
return -1;
if (use_mlock && mlockall(MCL_CURRENT) == -1) {
perror("mlockall");
goto out_rt;
}
if (interface_start(&library, geo) == -1)
goto out_rt;
if (rig_main() == -1)
goto out_interface;
rc = EXIT_SUCCESS;
fprintf(stderr, "Exiting cleanly...\n");
out_interface:
interface_stop();
out_rt:
rt_stop(&rt);
for (n = 0; n < ndeck; n++)
deck_clear(&deck[n]);
for (n = 0; n < nctl; n++)
controller_clear(&ctl[n]);
timecoder_free_lookup();
library_clear(&library);
rt_clear(&rt);
rig_clear();
osc_stop();
thread_global_clear();
if (rc == EXIT_SUCCESS)
fprintf(stderr, "Done.\n");
return rc;
}
int main()
{
struct deck my_deck;
struct card my_card,card_result;
int res,i;
#define CHECK_DECK_OP() \
if ( res != DECK_OK ) {\
deck_get_op_result(res);\
deck_print_cards_cnt(&my_deck);\
}
//10 cards at first
res = deck_init(&my_deck,10);
CHECK_DECK_OP();
//look in empty deck
printf("look in empty deck test\n");
res =deck_look(&my_deck,&my_card);
CHECK_DECK_OP();
card_print(&my_card);
printf("look in empty deck test end\n");
printf("draw from empty deck test\n");
res = deck_draw(&my_deck,&my_card);
CHECK_DECK_OP();
card_print(&my_card);
printf("draw from empty deck test end\n");
printf("push in deck test\n");
card_init(&my_card,"test",1,1,1);
res =deck_push(&my_deck,&my_card);
CHECK_DECK_OP();
res =deck_look(&my_deck,&card_result);
CHECK_DECK_OP();
card_print(&card_result);
printf("push in deck test end\n");
printf("push five cards and draw 5 cards test\n");
for( i =0; i < 5; i ++ ){
card_init(&my_card,"test",i,i,i);
res = deck_push(&my_deck,&my_card);
CHECK_DECK_OP();
}
printf("get last 10 cards from deck\n");
for ( i =0; i < 10; i++ ){
res = deck_draw(&my_deck,&card_result);
CHECK_DECK_OP();
card_print(&card_result);
}
printf("push five cards and draw 10 cards test end\n");
printf("reallocation test\n");
printf("old size [%d]\n",deck_get_size(&my_deck));
for ( i =0; i < 15; i++ ){
card_init(&my_card,"test",i,i,i);
res = deck_push(&my_deck,&my_card);
CHECK_DECK_OP();
}
printf("new size [%d]\n",deck_get_size(&my_deck));
printf("reallocation test end\n");
printf("Deck deinit\n");
deck_deinit(&my_deck);
return 0;
}
int mc_findbest(Hand *hand, bool player){
int i, j, k, n;
double score = 0.0;
int best=0;
double best_ev=0;
Hand *handcopy = (Hand *)malloc(sizeof(Hand));
Deck *deck = (Deck *)malloc(sizeof(Deck));
hand_init(handcopy);
deck_init(deck);
if(hand->numCards < NUM_CARDS){
printf("Error: Can only advise on a full hand.\n");
return 0;
}
hand_sort(hand);
for(i=0; i<=31; i++){/*0-31 corresponds to 00000-11111 in binary, 1 means discard that card*/
unsigned int seed = time(NULL);
score = 0;
for(j=0; j<NUM_TRIALS; j++){
for(k=0; k<NUM_CARDS; k++){
hand_add_card(handcopy, deck_remove_card(deck, hand->cards[k]));
}
if(handcopy->numCards < NUM_CARDS){
hand_print(hand);
hand_print(handcopy);
printf("Error: Could not find all cards in deck");
return 0;
}
seed = (seed+5);
deck_shuffle(deck, seed);
n=i;
for(k=NUM_CARDS-1; k>=0; k--){
if(n >= power(2, k)){
n -= power(2, k);
hand_discard(handcopy, k, deck);
}
}
hand_draw5(handcopy, deck);
score += imp_score_hand(handcopy);
for(k=0; k<NUM_CARDS; k++){
hand_discard(handcopy, k, deck);
}
}
if(score/NUM_TRIALS > best_ev){
best = i;
best_ev = score/NUM_TRIALS;
}
}
if(player){
printf("Current hand score: %.2f\n", imp_score_hand(hand));
printf("Best expected hand score: %.2f\n", best_ev);
printf("Advise discarding cards:\n");
for(k=NUM_CARDS-1; k>=0; k--){
if(best >= power(2, k)){
best -= power(2, k);
printf("\t");
printf("%d: ", k);
card_print(hand->cards[k]);
printf("\n");
}
}
printf("\n");
}
hand_destroy(handcopy, deck);
free(handcopy);
deck_destroy(deck);
free(deck);
return best;
}
