bassguitarbill/hanafuda
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
f33844834b
hanafuda/game.c
Bill Rossi f33844834b GPL bay beeeeeee
2025-02-26 20:05:31 -05:00

1052 lines
32 KiB
C
Raw Blame History

// Copyright 2025 Bill Rossi
//
// This file is part of Hanafuda Hachi-Hachi.
//
// Hanafuda Hachi-Hachi is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
//
// Hanafuda Hachi-Hachi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with Hanafuda Hachi-Hachi. If not, see <https://www.gnu.org/licenses/>.
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "game.h"
#include "card.h"
#include "teyaku.h"
#include "dekiyaku.h"
#include "field_multiplier.h"
#include "special_cases.h"
#include "play.h"
#include "dialog.h"
Vector2 mouse_pos;
char teyaku_calculation[400];
void initialize_game(Game *g) {
Image cards_image_red = LoadImage("img/cards_red.png");
g->cards_texture_red = LoadTextureFromImage(cards_image_red);
UnloadImage(cards_image_red);
Image cards_image_black = LoadImage("img/cards_black.png");
g->cards_texture_black = LoadTextureFromImage(cards_image_black);
UnloadImage(cards_image_black);
g->deck.count = 0;
g->deck.position = (Vector2) { 500, 300 };
g->deck.display_type = HAND_DISPLAY_DECK;
g->should_close = false;
g->state = GAME_STATE_INITIALIZING;
g->field_multiplier = NULL;
g->dialog = NULL;
g->kan_value = 12;
g->number_of_rounds = 1;
g->black_card_backs = true;
g->deal_speed = 0.2;
g->options = malloc(sizeof(Options));
initialize_title(g);
load_options_from_game(g);
init_dialogs(g);
for (int i = 0; i < 48; i++) {
CardType t = CHAFF;
RibbonType rt = RIBBON_NONE;
Month month = i / 4;
switch (i) {
case 0:
case 8:
case 28:
case 40:
case 44:
t = BRIGHT; break;
case 1:
case 5:
case 9:
t = RIBBON; rt = RIBBON_POETRY; break;
case 21:
case 33:
case 37:
t = RIBBON; rt = RIBBON_BLUE; break;
case 13:
case 17:
case 25:
case 42:
t = RIBBON; rt = RIBBON_PLAIN; break;
case 4:
case 12:
case 16:
case 20:
case 24:
case 29:
case 32:
case 36:
case 41:
t = ANIMAL; break;
}
g->cards[i] = (Card) { i, t, rt, month, { -500, -300 }, false };
g->cards[i].move.end_time = 0.;
g->cards[i].move.position = &g->cards[i].position;
g->cards[i].move.destination = (Vector2) { -500, -300 };
g->cards[i].order = i;
g->cards[i].selected = false;
g->cards[i].visible = false;
g->deck.cards[g->deck.count++] = &g->cards[i];
}
g->player.points = 100 * g->kan_value;
g->right.points = 100 * g->kan_value;
g->left.points = 100 * g->kan_value;
g->player.last_round_points = 100 * g->kan_value;
g->right.last_round_points = 100 * g->kan_value;
g->left.last_round_points = 100 * g->kan_value;
g->player.points_string[0] = '\0';
g->right.points_string[0] = '\0';
g->left.points_string[0] = '\0';
g->player.teyaku_string[0] = '\0';
g->right.teyaku_string[0] = '\0';
g->left.teyaku_string[0] = '\0';
g->player.name = "Player";
g->right.name = "Right";
g->left.name = "Left";
g->player.hand.count = 0;
g->right.hand.count = 0;
g->left.hand.count = 0;
g->field.count = 0;
g->player.scored.count = 0;
g->right.scored.count = 0;
g->left.scored.count = 0;
g->player.dekiyaku_score = 0;
g->left.dekiyaku_score = 0;
g->right.dekiyaku_score = 0;
g->player.teyaku.calculated = false;
g->right.teyaku.calculated = false;
g->left.teyaku.calculated = false;
g->player.seat = PLAYER;
g->right.seat = RIGHT;
g->left.seat = LEFT;
g->player.hand.position = (Vector2) { 300, 600 };
g->player.hand.display_type = HAND_DISPLAY_ROW;
g->right.hand.position = (Vector2) { 750, 125 };
g->right.hand.display_type = HAND_DISPLAY_ROW;
g->left.hand.position = (Vector2) { 50, 125 };
g->left.hand.display_type = HAND_DISPLAY_ROW;
g->player.scored.position = (Vector2) { 300, 750 };
g->player.scored.display_type = HAND_DISPLAY_SCORED;
g->right.scored.position = (Vector2) { 750, 25 };
g->right.scored.display_type = HAND_DISPLAY_SCORED;
g->left.scored.position = (Vector2) { 50, 25 };
g->left.scored.display_type = HAND_DISPLAY_SCORED;
g->field.position = (Vector2) { 600, 300 };
g->field.display_type = HAND_DISPLAY_FIELD;
strcpy(teyaku_calculation, "");
int dealer = rand() % 3;
switch (dealer) {
case PLAYER:
g->dealer = &g->player;
break;
case RIGHT:
g->dealer = &g->right;
break;
case LEFT:
g->dealer = &g->left;
break;
}
g->current_round = 0;
g->state = GAME_STATE_TITLE_SCREEN;
}
Player *current_player(Game *g) {
switch (g->turn_number % 3) {
case 0:
return &g->player;
case 1:
return &g->right;
case 2:
return &g->left;
}
return NULL;
}
bool is_player_turn(Game *g) {
return current_player(g) == &g->player;
}
void handle_input(Game *g) {
if (g->state == GAME_STATE_OPTIONS) {
return options_handle_input(g);
}
if (g->state == GAME_STATE_TITLE_SCREEN) {
return title_handle_input(g);
}
if (g->dialog) {
return dialog_handle_input(g->dialog);
}
if (IsKeyPressed(KEY_R)) {
g->state = GAME_STATE_INITIALIZING;
return;
}
if (!is_player_turn(g)) return;
switch (g->state) {
case GAME_STATE_CHOOSING_FROM_HAND:
if (IsMouseButtonPressed(0)) {
mouse_pos = GetMousePosition();
for (int i = 0; i < g->player.hand.count; i++) {
if (point_within_card(g->player.hand.cards[i], mouse_pos)) {
for (int j = 0; j < 48; j++) {
g->cards[j].selected = false;
}
g->player.hand.cards[i]->selected = true;
break;
}
}
}
break;
case GAME_STATE_CHOOSING_TARGET:
if (IsMouseButtonPressed(0)) {
mouse_pos = GetMousePosition();
for (int i = 0; i < g->player.hand.count; i++) {
if (point_within_card(g->player.hand.cards[i], mouse_pos)) {
if (g->player.hand.cards[i]->selected) {
g->player.hand.cards[i]->selected = false;
} else {
for (int j = 0; j < g->player.hand.count; j++) {
g->player.hand.cards[j]->selected = false;
}
g->player.hand.cards[i]->selected = true;
}
}
}
Card *selected_card = NULL;
for (int i = 0; i < g->player.hand.count; i++) {
if (g->player.hand.cards[i]->selected) {
selected_card = g->player.hand.cards[i];
break;
}
}
for (int i = 0; i < g->field.count; i++) {
if (point_within_card(g->field.cards[i], mouse_pos)) {
if (selected_card == NULL) printf("No card selected, whoops");
if (valid_play(&g->field, selected_card, g->field.cards[i])) {
g->current_play_from_hand = selected_card;
g->current_play_target = g->field.cards[i];
} else {
printf("Invalid\n");
}
break;
}
}
if (CheckCollisionPointRec(mouse_pos, next_card_position(&g->field))) {
if (valid_play(&g->field, selected_card, NULL)) {
g->current_play_from_hand = selected_card;
g->current_play_target = NULL;
} else {
printf("Invalid\n");
}
}
}
break;
case GAME_STATE_CHOOSING_TARGET_FROM_DECK:
if (IsMouseButtonPressed(0)) {
mouse_pos = GetMousePosition();
for (int i = 0; i < g->field.count; i++) {
if (point_within_card(g->field.cards[i], mouse_pos)) {
Card *selected_card = g->deck.cards[g->deck.count - 1];
if (valid_play(&g->field, selected_card, g->field.cards[i])) {
g->current_play_from_hand = selected_card;
g->current_play_target = g->field.cards[i];
} else {
printf("Invalid\n");
}
break;
}
}
}
break;
default:
break;
}
}
void capture_card_from_field(Game *g, Card *played, Card *target, Hand *hand, Hand *scored) {
// capture all three cards if they play the fourth
Card *same_month_card[3];
int same_month_card_count = 0;
for (int i = 0; i < g->field.count; i++) {
Card *c = g->field.cards[i];
if (c->month == played->month) {
same_month_card[same_month_card_count++] = c;
}
}
remove_from_hand(hand, played);
add_to_hand(scored, played, g->deal_speed);
if (same_month_card_count == 3) {
for (int i = 0; i < 3; i++) {
remove_from_hand(&g->field, same_month_card[i]);
add_to_hand(scored, same_month_card[i], g->deal_speed);
}
} else {
remove_from_hand(&g->field, target);
add_to_hand(scored, target, g->deal_speed);
}
}
void run_frame_ai_playing(Game *g) {
Hand *hand = &current_player(g)->hand;
Hand *scored = &current_player(g)->scored;
Play play = ai_play(hand, &g->field);
play.played->visible = true;
if (play.target) {
capture_card_from_field(g, play.played, play.target, hand, scored);
} else {
remove_from_hand(hand, play.played);
add_to_hand(&g->field, play.played, g->deal_speed);
}
}
void run_frame_initializing(Game *g) {
g->turn_number = g->dealer->seat;
g->player.hand.count = 0;
g->right.hand.count = 0;
g->left.hand.count = 0;
g->field.count = 0;
g->player.scored.count = 0;
g->right.scored.count = 0;
g->left.scored.count = 0;
g->player.dekiyaku_score = 0;
g->left.dekiyaku_score = 0;
g->right.dekiyaku_score = 0;
g->player.dekiyaku_action = DEKIYAKU_ACTION_NONE;
g->right.dekiyaku_action = DEKIYAKU_ACTION_NONE;
g->left.dekiyaku_action = DEKIYAKU_ACTION_NONE;
strcpy(g->player.teyaku_string, "");
strcpy(g->right.teyaku_string, "");
strcpy(g->left.teyaku_string, "");
g->current_play_from_hand = NULL;
g->current_play_target = NULL;
g->first_sage = NULL;
g->deck.count = 0;
for (int i = 0; i < 48; i++) {
Card *c = &g->cards[i];
c->visible = false;
c->selected = false;
add_to_hand(&g->deck, c, g->deal_speed);
}
shuffle_hand(&g->deck);
// order_deck(&g->deck);
kan_points_string(g, g->player.points, g->player.points_string);
kan_points_string(g, g->right.points, g->right.points_string);
kan_points_string(g, g->left.points, g->left.points_string);
g->state = GAME_STATE_DEALING;
}
bool misdeal(Game *g) {
int month_count[12] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
for (int i = 0; i < g->field.count; i++) {
Card *c = g->field.cards[i];
month_count[c->month]++;
}
for (int i = 0; i < 12; i++)
if (month_count[i] >= 4) return true;
return false;
}
void run_frame_dealing(Game *g) {
if (current_player(g)->hand.count < 4) {
deal(&g->deck, &current_player(g)->hand, 4, is_player_turn(g), g->deal_speed);
g->turn_number++;
} else if (g->field.count < 3) {
deal(&g->deck, &g->field, 3, true, g->deal_speed);
} else if (current_player(g)->hand.count < 7) {
deal(&g->deck, &current_player(g)->hand, 3, is_player_turn(g), g->deal_speed);
g->turn_number++;
} else if (g->field.count < 6) {
deal(&g->deck, &g->field, 3, true, g->deal_speed);
} else {
if (misdeal(g)) {
printf("misdeal\n");
g->state = GAME_STATE_INITIALIZING;
} else {
g->turn_number++;
g->state = GAME_STATE_CALCULATING_FIELD_MULTIPLIER;
}
}
}
void run_frame_calculating_field_multiplier(Game *g) {
g->field_multiplier = calculate_field_multiplier(&g->field);
g->state = GAME_STATE_CALCULATING_TEYAKU;
}
void run_frame_calculating_teyaku(Game *g) {
calculate_teyaku(g->player.hand, &g->player.teyaku);
teyaku_to_string(&g->player.teyaku, g->player.teyaku_string);
calculate_teyaku(g->right.hand, &g->right.teyaku);
teyaku_to_string(&g->right.teyaku, g->right.teyaku_string);
calculate_teyaku(g->left.hand, &g->left.teyaku);
teyaku_to_string(&g->left.teyaku, g->left.teyaku_string);
if (teyaku_points(&g->player.teyaku) > 0) {
teyaku_dialog(g);
set_teyaku_to_string(&g->player.teyaku, g->dialog->text[1]);
chaff_teyaku_to_string(&g->player.teyaku, g->dialog->text[2]);
} else {
g->state = GAME_STATE_START_OF_TURN;
}
}
void run_frame_start_of_turn(Game *g) {
g->turn_number++;
if(g->player.hand.count == 0 && g->right.hand.count == 0 && g->left.hand.count == 0) {
if (
g->player.dekiyaku_action == DEKIYAKU_ACTION_NONE &&
g->left.dekiyaku_action == DEKIYAKU_ACTION_NONE &&
g->right.dekiyaku_action == DEKIYAKU_ACTION_NONE) {
g->state = GAME_STATE_CALCULATING_SCORES;
} else {
g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
}
} else {
g->state = GAME_STATE_CHECKING_FOR_CANCEL;
}
}
void run_frame_checking_for_cancel(Game *g) {
if (current_player(g)->dekiyaku_action == DEKIYAKU_ACTION_SAGE) {
if (is_player_turn(g)) {
cancel_dialog(g);
} else {
// TODO: the AI might want to cancel at some point
g->state = GAME_STATE_CHOOSING_FROM_HAND;
}
} else {
g->state = GAME_STATE_CHOOSING_FROM_HAND;
}
}
void run_frame_player_choosing_from_hand(Game *g) {
for (int i = 0; i < g->player.hand.count; i++) {
if (g->player.hand.cards[i]->selected) {
g->state = GAME_STATE_CHOOSING_TARGET;
return;
}
}
}
void run_frame_choosing_from_hand(Game *g) {
if (is_player_turn(g)) {
run_frame_player_choosing_from_hand(g);
} else {
run_frame_ai_playing(g);
g->state = GAME_STATE_SHOWING_CARD_FROM_DECK;
}
}
void run_frame_choosing_target(Game *g) {
if (!is_player_turn(g)) {
printf("An AI player is choosing a target. That ain't right\n");
return;
}
Card *selected_card = NULL;
bool no_cards_selected = true;
for (int i = 0; i < g->player.hand.count; i++) {
if (g->player.hand.cards[i]->selected) {
selected_card = g->player.hand.cards[i];
break;
}
}
if (!selected_card) {
g->state = GAME_STATE_CHOOSING_FROM_HAND;
return;
}
for (int i = 0; i < g->field.count; i++) {
g->field.cards[i]->selected = g->field.cards[i]->month == selected_card->month;
}
if (g->current_play_from_hand) {
if (g->current_play_target) {
g->current_play_from_hand->selected = false;
capture_card_from_field(
g,
g->current_play_from_hand,
g->current_play_target,
&g->player.hand,
&g->player.scored
);
g->current_play_from_hand = NULL;
g->current_play_target = NULL;
} else {
g->current_play_from_hand->selected = false;
remove_from_hand(&g->player.hand, g->current_play_from_hand);
add_to_hand(&g->field, g->current_play_from_hand, g->deal_speed);
g->current_play_from_hand = NULL;
}
for (int i = 0; i < g->player.scored.count; i++) {
g->player.scored.cards[i]->selected = false;
}
g->state = GAME_STATE_SHOWING_CARD_FROM_DECK;
}
}
void run_frame_showing_card_from_deck(Game *g) {
Card *top_card = g->deck.cards[g->deck.count - 1];
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->deck, top_card, g->deal_speed);
top_card->visible = true;
top_card->move.end_time = 0.3;
top_card->move.destination.y = top_card->move.destination.y + 150;
g->state = GAME_STATE_PLAYING_FROM_DECK;
}
void run_frame_playing_from_deck(Game *g) {
Hand *to_hand = &current_player(g)->scored;
Card *top_card = g->deck.cards[g->deck.count - 1];
Card *targets[4];
int target_count = 0;
valid_targets(top_card, &g->field, &targets[0], &target_count);
if (target_count == 1) {
capture_card_from_field(g, top_card, targets[0], &g->deck, to_hand);
g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU;
} else if(target_count == 0) {
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->field, top_card, g->deal_speed);
g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU;
} else {
g->state = GAME_STATE_CHOOSING_TARGET_FROM_DECK;
return;
}
}
void run_frame_choosing_target_from_deck(Game *g) {
Hand *to_hand = &current_player(g)->scored;
Card *top_card = g->deck.cards[g->deck.count - 1];
Card *targets[4];
int target_count = 0;
valid_targets(top_card, &g->field, &targets[0], &target_count);
if (is_player_turn(g)) {
for (int i = 0; i < target_count; i++) {
targets[i]->selected = true;
}
if (g->current_play_target) {
for (int i = 0; i < target_count; i++) {
targets[i]->selected = false;
}
capture_card_from_field(g, top_card, g->current_play_target, &g->deck, to_hand);
g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU;
g->current_play_from_hand = NULL;
g->current_play_target = NULL;
}
} else {
// TODO: better AI
capture_card_from_field(g, top_card, targets[0], &g->deck, to_hand);
g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU;
}
}
void run_frame_checking_for_new_dekiyaku(Game *g) {
Player *cp = current_player(g);
calculate_dekiyaku(&cp->scored, &cp->dekiyaku);
int new_score = dekiyaku_score(&cp->dekiyaku);
if (new_score != cp->dekiyaku_score) {
cp->dekiyaku_score = new_score;
if (is_player_turn(g)) {
shoubu_dialog(g);
} else {
// TODO: better AI
// TODO: if it can sage, set "first sage" if possible
cp->dekiyaku_action = DEKIYAKU_ACTION_SHOUBU;
g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
}
} else {
g->state = GAME_STATE_START_OF_TURN;
}
}
void run_frame_selecting_dekiyaku_action(Game *g) {
if (is_player_turn(g)) {
if (g->player.dekiyaku_action != DEKIYAKU_ACTION_NONE) {
g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
} else {
shoubu_dialog(g);
}
} else {
// TODO: better AI
current_player(g)->dekiyaku_action = DEKIYAKU_ACTION_SHOUBU;
g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
}
}
void pay_teyaku_to_player(Game *g, Player *p) {
int points = teyaku_points(&p->teyaku);
transfer_kan(g, &p->points, &g->player.points, points);
transfer_kan(g, &p->points, &g->right.points, points);
transfer_kan(g, &p->points, &g->left.points, points);
}
void pay_teyaku(Game *g) {
pay_teyaku_to_player(g, &g->player);
pay_teyaku_to_player(g, &g->right);
pay_teyaku_to_player(g, &g->left);
}
void run_frame_calculating_scores(Game *g) {
no_dekiyaku_end_of_round_dialog(g);
int hp[3];
hp[0] = hand_points(&g->player.scored);
hp[1] = hand_points(&g->right.scored);
hp[2] = hand_points(&g->left.scored);
SpecialCase special_case = calculate_special_case(g);
switch(special_case.type) {
case SPECIAL_CASE_ALL_EIGHTS:
sprintf(g->dialog->text[0], "All eights!");
sprintf(g->dialog->text[0], "Dealer gets %d kan", special_case.score);
transfer_kan(g, &g->dealer->points, &g->player.points, special_case.score);
transfer_kan(g, &g->dealer->points, &g->right.points, special_case.score);
transfer_kan(g, &g->dealer->points, &g->left.points, special_case.score);
break;
case SPECIAL_CASE_DOUBLE_EIGHTS:
case SPECIAL_CASE_SIXTEEN_CHAFF:
if (special_case.type == SPECIAL_CASE_DOUBLE_EIGHTS) sprintf(g->dialog->text[0], "Double eights!");
else sprintf(g->dialog->text[0], "Sixteen chaff!");
sprintf(g->dialog->text[1], "Player %d gets %d kan\n", special_case.target, special_case.score);
switch (special_case.target) {
case SPECIAL_CASE_TARGET_PLAYER:
transfer_kan(g, &g->player.points, &g->right.points, special_case.score);
transfer_kan(g, &g->player.points, &g->left.points, special_case.score);
g->dealer = &g->player;
break;
case SPECIAL_CASE_TARGET_RIGHT:
transfer_kan(g, &g->right.points, &g->player.points, special_case.score);
transfer_kan(g, &g->right.points, &g->left.points, special_case.score);
g->dealer = &g->right;
break;
case SPECIAL_CASE_TARGET_LEFT:
transfer_kan(g, &g->left.points, &g->right.points, special_case.score);
transfer_kan(g, &g->left.points, &g->player.points, special_case.score);
g->dealer = &g->left;
break;
}
break;
default:
sprintf(g->dialog->text[0], "Player score: %d", hp[0]);
sprintf(g->dialog->text[1], "Right score: %d", hp[1]);
sprintf(g->dialog->text[2], "Left score: %d", hp[2]);
transfer_points(g, &g->player.points, &g->temp_points, hp[0]);
transfer_points(g, &g->right.points, &g->temp_points, hp[1]);
transfer_points(g, &g->left.points, &g->temp_points, hp[2]);
if (hp[0] > hp[1]) {
if (hp[0] > hp[2]) g->dealer = &g->player;
else
if (hp[2] > hp[1]) g->dealer = &g->left;
else g->dealer = &g->right;
} else {
if (hp[1] > hp[2]) g->dealer = &g->right;
else g->dealer = &g->left;
}
pay_teyaku(g);
break;
}
}
int calculate_dekiyaku_score(Game *g, Player *p) {
Dekiyaku d;
calculate_dekiyaku(&p->scored, &d);
if (p->dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) {
sprintf(g->dialog->text[0], "%s wins with dekiyaku!", p->name);
dekiyaku_to_string(&d, g->dialog->text[1]);
sprintf(g->dialog->text[2], "%s wins %d kan", p->name, dekiyaku_score(&d));
transfer_kan(g, &p->points, &g->player.points, dekiyaku_score(&d));
transfer_kan(g, &p->points, &g->right.points, dekiyaku_score(&d));
transfer_kan(g, &p->points, &g->left.points, dekiyaku_score(&d));
return dekiyaku_score(&d) * g->kan_value;
} else {
sprintf(g->dialog->text[0], "%s cancels with dekiyaku!", p->name);
dekiyaku_to_string(&d, g->dialog->text[1]);
if (dekiyaku_score(&d) % 2) {
sprintf(g->dialog->text[2], "%s wins %d.5 kan", p->name, dekiyaku_score(&d) / 2);
transfer_points(g, &p->points, &g->player.points, (dekiyaku_score(&d) * g->kan_value) / 2);
transfer_points(g, &p->points, &g->right.points, (dekiyaku_score(&d) * g->kan_value) / 2);
transfer_points(g, &p->points, &g->left.points, (dekiyaku_score(&d) * g->kan_value) / 2);
} else {
sprintf(g->dialog->text[2], "%s wins %d kan", p->name, dekiyaku_score(&d) / 2);
transfer_kan(g, &p->points, &g->player.points, dekiyaku_score(&d) / 2);
transfer_kan(g, &p->points, &g->right.points, dekiyaku_score(&d) / 2);
transfer_kan(g, &p->points, &g->left.points, dekiyaku_score(&d) / 2);
}
return (dekiyaku_score(&d) * g->kan_value) / 2;
}
}
void calculate_exhausted_dekiyaku_score(Game *g) {
g->player.dekiyaku_action = DEKIYAKU_ACTION_CANCEL;
int p_score = calculate_dekiyaku_score(g, &g->player);
g->right.dekiyaku_action = DEKIYAKU_ACTION_CANCEL;
int r_score = calculate_dekiyaku_score(g, &g->right);
g->left.dekiyaku_action = DEKIYAKU_ACTION_CANCEL;
int l_score = calculate_dekiyaku_score(g, &g->left);
printf("%d %d %d\n", p_score, r_score, l_score);
sprintf(g->dialog->text[0], "Hands are exhausted (half dekiyaku scores)");
sprintf(g->dialog->text[1], "Player scores %d points", p_score);
sprintf(g->dialog->text[2], "Right scores %d points", r_score);
sprintf(g->dialog->text[3], "Left scores %d points", l_score);
}
void run_frame_calculating_dekiyaku_score(Game *g) {
dekiyaku_end_of_round_dialog(g);
if (g->player.dekiyaku_action == DEKIYAKU_ACTION_CANCEL || g->player.dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) {
calculate_dekiyaku_score(g, &g->player);
} else if (g->right.dekiyaku_action == DEKIYAKU_ACTION_CANCEL || g->right.dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) {
calculate_dekiyaku_score(g, &g->right);
} else if (g->left.dekiyaku_action == DEKIYAKU_ACTION_CANCEL || g->left.dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) {
calculate_dekiyaku_score(g, &g->left);
} else {
g->dealer = g->first_sage;
calculate_exhausted_dekiyaku_score(g);
}
pay_teyaku(g);
}
void run_frame_end_of_round(Game *g) {
end_of_round_dialog(g);
int player_diff = g->player.points - g->player.last_round_points;
if (player_diff > 0) {
sprintf(g->dialog->text[0], "Player gains %d points, has %d", player_diff, g->player.points);
} else if (player_diff < 0) {
sprintf(g->dialog->text[0], "Player loses %d points, has %d", -player_diff, g->player.points);
} else {
sprintf(g->dialog->text[0], "Player gains no points, has %d", g->player.points);
}
int right_diff = g->right.points - g->right.last_round_points;
if (right_diff > 0) {
sprintf(g->dialog->text[1], "Right gains %d points, has %d", right_diff, g->right.points);
} else if (right_diff < 0) {
sprintf(g->dialog->text[1], "Right loses %d points, has %d", -right_diff, g->right.points);
} else {
sprintf(g->dialog->text[1], "Right gains no points, has %d", g->right.points);
}
int left_diff = g->left.points - g->left.last_round_points;
if (left_diff > 0) {
sprintf(g->dialog->text[2], "Left gains %d points, has %d", left_diff, g->left.points);
} else if (left_diff < 0) {
sprintf(g->dialog->text[2], "Left loses %d points, has %d", -left_diff, g->left.points);
} else {
sprintf(g->dialog->text[2], "Left gains no points, has %d", g->left.points);
}
kan_points_string(g, g->player.points, g->player.points_string);
kan_points_string(g, g->right.points, g->right.points_string);
kan_points_string(g, g->left.points, g->left.points_string);
g->current_round++;
if (g->current_round >= g->number_of_rounds) {
g->state = GAME_STATE_END_OF_GAME;
} else {
g->state = GAME_STATE_INITIALIZING;
}
}
void *winning_player_string(Game *g, char *string) {
int p = g->player.points;
int r = g->right.points;
int l = g->left.points;
if (p == r && p == l) sprintf(string, "It's a three-way tie!");
else if (p > r && p == l) sprintf(string, "%s and %s tie for the win!", g->player.name, g->left.name);
else if (p > l && p == r) sprintf(string, "%s and %s tie for the win!", g->player.name, g->right.name);
else if (p < l && l == r) sprintf(string, "%s and %s tie for the win!", g->right.name, g->left.name);
else if (p > l && p > r) sprintf(string, "%s wins!", g->player.name);
else if (l > r && l > p) sprintf(string, "%s wins!", g->left.name);
else if (r > l && r > p) sprintf(string, "%s wins!", g->right.name);
else sprintf(string, "I have no idea who wins (%d %d %d) wins!", p, r, l);
}
void run_frame_end_of_game(Game *g) {
end_of_game_dialog(g);
char line[200];
kan_points_string(g, g->player.points, &line[0]);
sprintf(g->dialog->text[0], "Player: %s", line);
kan_points_string(g, g->right.points, &line[0]);
sprintf(g->dialog->text[1], "Right: %s", line);
kan_points_string(g, g->left.points, &line[0]);
sprintf(g->dialog->text[2], "Left: %s", line);
winning_player_string(g, g->dialog->text[3]);
}
void run_frame_new_game(Game *g) {
g->field_multiplier = NULL;
g->dialog = NULL;
g->player.points = 100 * g->kan_value;
g->right.points = 100 * g->kan_value;
g->left.points = 100 * g->kan_value;
g->player.points_string[0] = '\0';
g->right.points_string[0] = '\0';
g->left.points_string[0] = '\0';
strcpy(teyaku_calculation, "");
int dealer = rand() % 3;
switch (dealer) {
case PLAYER:
g->dealer = &g->player;
break;
case RIGHT:
g->dealer = &g->right;
break;
case LEFT:
g->dealer = &g->left;
break;
}
g->current_round = 0;
g->state = GAME_STATE_INITIALIZING;
}
void move_cards(Game *g) {
float delta = GetFrameTime();
for (int i = 0; i < 48; i++) {
move_position(&g->cards[i].move, delta);
}
}
bool done_moving(Game *g) {
for (int i = 0; i < 48; i++) {
if (!card_done_moving(&g->cards[i])) return false;
}
return true;
}
void run_frame(Game *g) {
handle_input(g);
if (g->dialog) return;
move_cards(g);
if (g->state == GAME_STATE_TITLE_SCREEN) run_frame_title(g);
if (!done_moving(g)) return;
switch (g->state) {
case GAME_STATE_INITIALIZING:
run_frame_initializing(g);
return;
case GAME_STATE_DEALING:
run_frame_dealing(g);
break;
case GAME_STATE_CALCULATING_FIELD_MULTIPLIER:
run_frame_calculating_field_multiplier(g);
break;
case GAME_STATE_CALCULATING_TEYAKU:
run_frame_calculating_teyaku(g);
break;
case GAME_STATE_START_OF_TURN:
run_frame_start_of_turn(g);
break;
case GAME_STATE_CHECKING_FOR_CANCEL:
run_frame_checking_for_cancel(g);
break;
case GAME_STATE_CHOOSING_FROM_HAND:
run_frame_choosing_from_hand(g);
break;
case GAME_STATE_CHOOSING_TARGET:
run_frame_choosing_target(g);
break;
case GAME_STATE_SHOWING_CARD_FROM_DECK:
run_frame_showing_card_from_deck(g);
break;
case GAME_STATE_PLAYING_FROM_DECK:
run_frame_playing_from_deck(g);
break;
case GAME_STATE_CHOOSING_TARGET_FROM_DECK:
run_frame_choosing_target_from_deck(g);
break;
case GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU:
run_frame_checking_for_new_dekiyaku(g);
break;
case GAME_STATE_SELECTING_DEKIYAKU_ACTION:
run_frame_selecting_dekiyaku_action(g);
break;
case GAME_STATE_CALCULATING_SCORES:
run_frame_calculating_scores(g);
break;
case GAME_STATE_CALCULATING_DEKIYAKU_SCORE:
run_frame_calculating_dekiyaku_score(g);
break;
case GAME_STATE_END_OF_ROUND:
run_frame_end_of_round(g);
break;
case GAME_STATE_END_OF_GAME:
run_frame_end_of_game(g);
break;
case GAME_STATE_NEW_GAME:
run_frame_new_game(g);
break;
case GAME_STATE_TITLE_SCREEN:
break;
case GAME_STATE_OPTIONS:
break;
}
}
Texture *cards_texture_fun(Game *g) {
return g->black_card_backs ? &g->cards_texture_black : &g->cards_texture_red;
}
void draw_player_cards(Game *g, Player *p) {
for (int i = 0; i < p->hand.count; i++) {
draw_card(p->hand.cards[i], cards_texture_fun(g), g->black_card_backs);
}
for (int i = 0; i < p->scored.count; i++) {
draw_card(p->scored.cards[i], cards_texture_fun(g), g->black_card_backs);
}
}
void draw_cards(Game *g) {
draw_player_cards(g, &g->player);
draw_player_cards(g, &g->right);
draw_player_cards(g, &g->left);
for (int i = 0; i < g->field.count; i++) {
draw_card(g->field.cards[i], cards_texture_fun(g), g->black_card_backs);
}
for (int i = 0; i < g->deck.count; i++) {
draw_card(g->deck.cards[i], cards_texture_fun(g), g->black_card_backs);
}
}
void draw_frame(Game *g) {
BeginDrawing();
ClearBackground(RAYWHITE);
if (g->state == GAME_STATE_TITLE_SCREEN) {
title_draw(g);
EndDrawing();
return;
}
if (g->state == GAME_STATE_OPTIONS) {
options_draw(g);
EndDrawing();
return;
}
draw_cards(g);
if (g->state == GAME_STATE_DEALING) {
DrawText("Dealing....", 60, 385, 40, BLACK);
} else if (g->field_multiplier) {
DrawText(g->field_multiplier->name, 60, 385, 30, BLACK);
DrawText(g->field_multiplier->explanation, 60, 445, 20, BLACK);
}
DrawText(g->player.points_string, 1000, 650, 20, BLACK);
DrawText(g->player.teyaku_string, 1000, 680, 20, BLACK);
DrawText(g->right.points_string, 1000, 260, 20, BLACK);
DrawText(g->right.teyaku_string, 1100, 260, 20, BLACK);
DrawText(g->left.points_string, 200, 260, 20, BLACK);
DrawText(g->left.teyaku_string, 300, 260, 20, BLACK);
char round_text[40];
if (g->current_round < g->number_of_rounds)
sprintf(round_text, "Round %d / %d", g->current_round+1, g->number_of_rounds);
else
sprintf(round_text, "Game Over");
DrawText(round_text, 20, 875, 20, BLACK);
if (is_player_turn(g)) {
switch (g->state) {
case GAME_STATE_CHOOSING_FROM_HAND:
DrawText("Choose a card to play from your hand", 60, 485, 20, BLACK);
break;
case GAME_STATE_CHOOSING_TARGET:
DrawText("Choose a target on the field", 60, 485, 20, BLACK);
Card *selected_card = NULL;
for (int i = 0; i < g->player.hand.count; i++) {
if (g->player.hand.cards[i]->selected) {
selected_card = g->player.hand.cards[i];
break;
}
}
if (!selected_card) break;
bool draw_next_rec = true;
for (int i = 0; i < g->field.count; i++) {
if (g->field.cards[i]->month == selected_card->month) draw_next_rec = false;
}
if (draw_next_rec) DrawRectangleRec(next_card_position(&g->field), BLUE);
break;
default:
break;
}
}
if (g->dialog) {
dialog_draw(g->dialog);
}
EndDrawing();
}
void run_until_closing(Game *g) {
while (!WindowShouldClose() && !g->should_close) {
run_frame(g);
draw_frame(g);
}
}
void transfer_points(Game *g, int *to, int *from, int amount) {
amount *= g->field_multiplier->value;
*to += amount;
*from -= amount;
}
void transfer_kan(Game *g, int *to, int *from, int amount) {
amount *= g->kan_value;
transfer_points(g, to, from, amount);
}
Reference in New Issue View Git Blame Copy Permalink