bool BingoGame::imprimir_cartones(const char* template_name)
{
std::string str;
std::ofstream index_file;
std::string temp_name(template_name);
name = temp_name.substr(0, temp_name.length() - 4);
index_file.open((name + ".idx").c_str());
if ( ! index_file )
{
std::cerr << "toc: could not create index document" << std::endl;
return false;
}
index_file << numero_cartones << std::endl;
std::vector < std::string > temp(25);
for (size_t i = 0; i < numero_cartones ; ++i)
{
card_shuffle();
str = "";
str = name + "-" + std::to_string(i) + ".svg";
Carton nuevo(words);
if ( ! nuevo.imprimir_carta(template_name, str.c_str(), i) )
{
std::cerr << "toc: could not print document(clase bingo)" << std::endl;
return false;
}
nuevo.copiar_vector(temp);
index_file << std::to_string(i) << std::endl;
for (int j = 0; j < 25; ++j)
index_file << temp[j] << std::endl;
index_file << std::endl;
}
index_file.close();
//std::cerr << "se imprimio carton" << std::endl;
return true;
}
static void action_deal_execute(visual_pile_action *action) {
action_deal_data *data = action->data;
internal *i = data->i;
solitaire *sol = data->sol;
if(card_count(i->deck) == 52) {
card_move_count(i->build[0], i->deck, 7);
card_reveal_count(i->build[0], 4, 3);
card_move_count(i->build[1], i->deck, 7);
card_reveal_count(i->build[1], 4, 3);
card_move_count(i->build[2], i->deck, 7);
card_reveal_count(i->build[2], 4, 3);
card_move_count(i->build[3], i->deck, 7);
card_reveal_count(i->build[3], 4, 3);
card_move_count(i->build[4], i->deck, 6);
card_reveal_all(i->build[4]);
card_move_count(i->build[5], i->deck, 6);
card_reveal_all(i->build[5]);
card_move_count(i->build[6], i->deck, 6);
card_reveal_all(i->build[6]);
card_move_count(i->build[7], i->deck, 6);
card_reveal_all(i->build[7]);
}
else {
card_move_all_array(
i->deck, 12,
i->build[0], i->build[1], i->build[2], i->build[3],
i->build[4], i->build[5], i->build[6], i->build[7],
i->ace[0], i->ace[1], i->ace[2], i->ace[3]);
card_hide_all(i->deck);
card_shuffle(i->deck);
}
visual_sync(sol->visual);
}
solitaire* solitaire_theidiot(mem_context *context, visual_settings *settings) {
visual_pile *deck, *pile1, *pile2, *pile3, *pile4, *done;
rule *rule1, *rule2;
condition *pile1_4_cond;
/* The one solitaire instance we have.*/
solitaire* s = mem_alloc(context, sizeof(solitaire));
/* This is the internal data representation of this
* solitaire. This is a local struct hidden from other
* members. */
internal* i = mem_alloc(context, sizeof(internal));
s->data = i;
s->visual = visual_create(context, settings);
i->deck = pile_create(context, 52);
deck = visual_pile_create(context, i->deck);
deck->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2 + settings->card_width / 2);
deck->origin[1] = 40.0f;
deck->rotation = 45.0f;
deck->action = action_deal(context, s, i);
visual_add_pile(context, s->visual, deck);
i->pile1 = pile_create(context, 13);
pile1 = visual_pile_create(context, i->pile1);
pile1->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width + settings->card_spacing);
pile1->origin[1] = 70.0f;
pile1->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile1);
i->pile2 = pile_create(context, 13);
pile2 = visual_pile_create(context, i->pile2);
pile2->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2);
pile2->origin[1] = 70.0f;
pile2->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile2);
i->pile3 = pile_create(context, 13);
pile3 = visual_pile_create(context, i->pile3);
pile3->origin[0] = settings->card_width / 2 + settings->card_spacing / 2;
pile3->origin[1] = 70.0f;
pile3->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile3);
i->pile4 = pile_create(context, 13);
pile4 = visual_pile_create(context, i->pile4);
pile4->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width + settings->card_spacing;
pile4->origin[1] = 70.0f;
pile4->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile4);
i->done = pile_create(context, 48);
done = visual_pile_create(context, i->done);
done->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2 + settings->card_width / 2;
done->origin[1] = 40.0f;
done->rotation = -45.0f;
visual_add_pile(context, s->visual, done);
card_create_deck(context, i->deck, 14);
card_shuffle(i->deck);
visual_sync(s->visual);
s->ruleset = ruleset_create(context);
/* Shared condition between several rules. */
pile1_4_cond = condition_source_array(
context, 4, i->pile1, i->pile2, i->pile3, i->pile4);
/* Move card to done pile if source is pile1-pile4 and there is
a higher card in same suit in those piles. */
rule1 = rule_create(context);
rule_add_condition(context, rule1, pile1_4_cond);
rule_add_condition(context, rule1, condition_destination(context, i->done));
rule_add_condition(
context,
rule1,
condition_or_array(
context, 4,
condition_top_card_compare(context, i->pile1,
e_dest_higher_value | e_follow_suit),
condition_top_card_compare(context, i->pile2,
e_dest_higher_value | e_follow_suit),
condition_top_card_compare(context, i->pile3,
e_dest_higher_value | e_follow_suit),
condition_top_card_compare(context, i->pile4,
e_dest_higher_value | e_follow_suit)));
rule_add_condition(context, rule1, condition_top_card(context));
ruleset_add_rule(context, s->ruleset, rule1);
/* Allow move to a top card to an empty pile. */
rule2 = rule_create(context);
rule_add_condition(context, rule2, pile1_4_cond);
rule_add_condition(context, rule2, condition_top_card(context));
rule_add_condition(context, rule2, condition_destination_empty(context));
rule_add_condition(
context, rule2,
condition_destination_array(
context, 4, i->pile1, i->pile2, i->pile3, i->pile4));
ruleset_add_rule(context, s->ruleset, rule2);
/* Solved rule */
s->ruleset->solved = rule_create(context);
rule_add_condition(
context, s->ruleset->solved,
condition_source_card_equal(
context, e_suit_none, 14, e_equal_value, i->pile1));
rule_add_condition(
context, s->ruleset->solved,
condition_source_card_equal(
context, e_suit_none, 14, e_equal_value, i->pile2));
rule_add_condition(
context, s->ruleset->solved,
condition_source_card_equal(
context, e_suit_none, 14, e_equal_value, i->pile3));
rule_add_condition(
context, s->ruleset->solved,
condition_source_card_equal(
context, e_suit_none, 14, e_equal_value, i->pile4));
rule_add_condition(
context, s->ruleset->solved,
condition_card_count_array(
context, 1, 4, i->pile1, i->pile2, i->pile3, i->pile4));
return s;
}
int main(int argc, char* argv[])
{
struct deck thisDeck;
struct player thisPlayer;
struct game thisGame;
int inputValidity;
int menu;
int game;
int load = 0;
//Not Working!!! card_init_deck(&thisDeck);
//This is the exact same algorithm used in card.c and it works great here!!! Why!!!
for (int k = 0; k < 4; k++)
{
for (int i = 0; i < 13; i++)
{
for (int j = 0; j < 4; j++)
{
strcpy(thisDeck.oneCard[k*52+i*4+j].rank, ranks[i]);
strcpy(thisDeck.oneCard[k*52+i*4+j].suit, suits[j]);
thisDeck.oneCard[k*52+i*4+j].value = value[i];
}
}
}
card_shuffle(&thisDeck);
thisPlayer.chip = 0;
system("clear");
while (1)
{
printf("\n\n**********BlackJack**********\n\n");
printf(" 1. Play\n");
printf(" 2. Load\n");
printf(" 3. Player status\n");
printf(" 4. Exit\n\n");
printf("*****************************\n\n");
while(1)
{
printf("Please enter menu number: ");
inputValidity = scanf("%d", &menu);
while(getchar()!='\n'){}
if (inputValidity)
{
if (menu < 1 || menu > 4)
{
printf("Please select from menu!\n");
}
else
{
break;
}
}
else
{
printf("Please enter a NUMBER!\n");
}
}
if (menu == 4)
{
player_save(&thisPlayer);
printf("Thanks for playing! Bye!\n");
break;
}
else if (menu == 3)
{
if (thisPlayer.name == NULL)
{
printf("No player record.\n");
continue;
}
player_status(&thisPlayer);
continue;
}
else if (menu == 2)
{
player_load(&thisPlayer);
continue;
}
else
{
if (thisPlayer.chip == 0)
{
player_name(&thisPlayer);
player_chip(&thisPlayer);
}
printf("Welcome %s!\nHave fun!\n\n", thisPlayer.name);
while(1)
{
//Deal initial cards
game_init(&thisGame);
if (thisDeck.cardNow > 180)
{
printf("\n\nShuffling...\n\n");
card_shuffle(&thisDeck);
}
if (thisPlayer.chip <= 0)
{
printf("You are penniless!\n");
thisPlayer.win = 0;
thisPlayer.lose = 0;
thisPlayer.push = 0;
break;
}
game_bet(1, &thisPlayer, &thisGame);
printf("\nDealer is dealing the cards...\n\n");
game_deal_card(2, &thisGame, &thisDeck);
game_deal_card(1, &thisGame, &thisDeck);
game_deal_card(2, &thisGame, &thisDeck);
game_deal_card(1, &thisGame, &thisDeck);
printf("Dealer shows %s of %s\n", thisDeck.oneCard[thisGame.dealer_inhand[0]].rank, thisDeck.oneCard[thisGame.dealer_inhand[0]].suit);
printf("Dealer\'s point is %d\n", thisDeck.oneCard[thisGame.dealer_inhand[0]].value);
printf("Your cards: ");
game_print_card(2, &thisGame, &thisDeck);
printf("\n");
printf("Your point is %d\n", game_totalvalue(2, &thisGame, &thisDeck));
//Check if dealer shows an Ace
if (thisDeck.oneCard[thisGame.dealer_inhand[0]].value == 11)
{
game_bet(2, &thisPlayer, &thisGame);
if (game_totalvalue(1, &thisGame, &thisDeck) == 21 && game_judge(&thisGame, &thisDeck) != 4)
{
if (thisGame.is_insured)
{
thisPlayer.chip += thisGame.bet;
}
thisPlayer.lose++;
printf("Dealer\'s cards: ");
game_print_card(1, &thisGame, &thisDeck);
printf("\n");
printf("Dealer\'s point is %d\n", game_totalvalue(1, &thisGame, &thisDeck));
printf("Dealer is BlackJack!\n");
if (game_end())
{
break;
}
else
{
continue;
}
}
else if (game_totalvalue(2, &thisGame, &thisDeck) == 21 && game_judge(&thisGame, &thisDeck) == 4)
{
thisPlayer.chip += thisGame.bet;
thisPlayer.push++;
printf("Push!\n");
}
}
game_play(&thisPlayer, &thisDeck, &thisGame);
if (game_end())
{
break;
}
continue;
}
continue;
}
}
return 0;
}
solitaire* solitaire_noname1(mem_context *context, visual_settings *settings) {
visual_pile *deck, *ace1, *ace2, *ace3, *ace4;
visual_pile *pile1, *pile2, *pile3, *pile4, *pile5, *pile6, *pile7, *pile8;
/* The one solitaire instance we have.*/
solitaire* s = mem_alloc(context, sizeof(solitaire));
/* This is the internal data representation of this
* solitaire. This is a local struct hidden from other
* members. */
internal* i = mem_alloc(context, sizeof(internal));
s->data = i;
s->visual = visual_create(context, settings);
i->deck = pile_create(context, 52);
deck = visual_pile_create(context, i->deck);
deck->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2 + settings->card_width / 2);
deck->origin[1] = 70.0f;
deck->rotation = 45.0f;
deck->action = action_deal(context, s, i);
visual_add_pile(context, s->visual, deck);
i->ace[0] = pile_create(context, 13);
ace1 = visual_pile_create(context, i->ace[0]);
ace1->origin[0] = settings->card_width / 2 + settings->card_spacing / 2;
ace1->origin[1] = 70.0f;
visual_add_pile(context, s->visual, ace1);
i->ace[1] = pile_create(context, 13);
ace2 = visual_pile_create(context, i->ace[1]);
ace2->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width + settings->card_spacing;
ace2->origin[1] = 70.0f;
visual_add_pile(context, s->visual, ace2);
i->ace[2] = pile_create(context, 13);
ace3 = visual_pile_create(context, i->ace[2]);
ace3->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2;
ace3->origin[1] = 70.0f;
visual_add_pile(context, s->visual, ace3);
i->ace[3] = pile_create(context, 13);
ace4 = visual_pile_create(context, i->ace[3]);
ace4->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 3 + settings->card_spacing * 3;
ace4->origin[1] = 70.0f;
visual_add_pile(context, s->visual, ace4);
i->build[0] = pile_create(context, 52);
pile1 = visual_pile_create(context, i->build[0]);
pile1->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 3 + settings->card_spacing * 3);
pile1->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile1);
i->build[1] = pile_create(context, 52);
pile2 = visual_pile_create(context, i->build[1]);
pile2->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2);
pile2->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile2);
i->build[2] = pile_create(context, 52);
pile3 = visual_pile_create(context, i->build[2]);
pile3->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width + settings->card_spacing);
pile3->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile3);
i->build[3] = pile_create(context, 52);
pile4 = visual_pile_create(context, i->build[3]);
pile4->origin[0] = 0 - (settings->card_width / 2 + settings->card_spacing / 2);
pile4->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile4);
i->build[4] = pile_create(context, 52);
pile5 = visual_pile_create(context, i->build[4]);
pile5->origin[0] = settings->card_width / 2 + settings->card_spacing / 2;
pile5->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile5);
i->build[5] = pile_create(context, 52);
pile6 = visual_pile_create(context, i->build[5]);
pile6->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width + settings->card_spacing;
pile6->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile6);
i->build[6] = pile_create(context, 52);
pile7 = visual_pile_create(context, i->build[6]);
pile7->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 2 + settings->card_spacing * 2;
pile7->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile7);
i->build[7] = pile_create(context, 52);
pile8 = visual_pile_create(context, i->build[7]);
pile8->origin[0] = settings->card_width / 2 + settings->card_spacing / 2 + settings->card_width * 3 + settings->card_spacing * 3;
pile8->translateY = 0 - settings->card_height / 5;
visual_add_pile(context, s->visual, pile8);
card_create_deck(context, i->deck, 1);
card_shuffle(i->deck);
visual_sync(s->visual);
setup_rules(context, s, i);
return s;
}
