bassguitarbill/hanafuda
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Rework states to be player-agnostic

Browse Source
This commit is contained in:
Bill Rossi 2025-02-19 06:04:10 -05:00
parent b318591451
commit 96a3b38e34
2 changed files with 162 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

249
game.c
View File

@ -22,9 +22,13 @@ void initialize_game(Game *g) {
g->player.teyaku.calculated = false;
g->left.teyaku.calculated = false;
g->right.teyaku.calculated = false;
g->player.dekiyaku_score = 0;
g->left.dekiyaku_score = 0;
g->right.dekiyaku_score = 0;
g->kan_value = 12;
g->current_play_from_hand = NULL;
g->current_play_target = NULL;
g->turn_number = 0;
for (int i = 0; i < 48; i++) {
CardType t = CHAFF;
@ -66,6 +70,7 @@ void initialize_game(Game *g) {
g->cards[i].move.position = &g->cards[i].position;
g->cards[i].move.destination = (Vector2) { 800, 400 };
g->cards[i].order = i;
g->cards[i].selected = false;
g->deck.cards[i] = &g->cards[i];
g->deck.count++;
}
@ -109,10 +114,27 @@ void initialize_game(Game *g) {
g->state = GAME_STATE_DEALING;
}
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;
}
}
bool is_player_turn(Game *g) {
return current_player(g) == &g->player;
}
bool stale_calculation = true;
void handle_input(Game *g) {
if (!is_player_turn(g)) return;
switch (g->state) {
case GAME_STATE_PLAYER_CHOOSING_FROM_HAND:
case GAME_STATE_CHOOSING_FROM_HAND:
if (IsMouseButtonPressed(0)) {
mouse_pos = GetMousePosition();
for (int i = 0; i < g->player.hand.count; i++) {
@ -126,7 +148,7 @@ void handle_input(Game *g) {
}
}
break;
case GAME_STATE_PLAYER_CHOOSING_TARGET:
case GAME_STATE_CHOOSING_TARGET:
if (IsMouseButtonPressed(0)) {
mouse_pos = GetMousePosition();
for (int i = 0; i < g->player.hand.count; i++) {
@ -178,31 +200,10 @@ void handle_input(Game *g) {
}
}
bool run_frame_from_deck(Game *g, Hand *to_hand) {
Card *top_card = g->deck.cards[g->deck.count - 1];
if (top_card->visible) {
Card *target = valid_target(top_card, &g->field);
if (target) {
remove_from_hand(&g->field, target);
add_to_hand(to_hand, target);
remove_from_hand(&g->deck, top_card);
add_to_hand(to_hand, top_card);
} else {
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->field, top_card);
}
return true;
} else {
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->deck, top_card);
top_card->visible = true;
top_card->move.end_time = 0.3;
top_card->move.destination.x = top_card->move.destination.x + 100;
return false;
}
}
void run_frame_ai_playing(Game *g) {
Hand *hand = &current_player(g)->hand;
Hand *scored = &current_player(g)->scored;
void run_frame_ai_playing(Game *g, Hand *hand, Hand *scored) {
Play play = ai_play(hand, &g->field);
play.played->visible = true;
@ -251,22 +252,64 @@ void run_frame_calculating_field_multiplier(Game *g) {
void run_frame_calculating_teyaku(Game *g) {
calculate_teyaku(g->player.hand, &g->player.teyaku);
for (int i = 0; i < 48; i++) {
g->cards[i].selected = false;
calculate_teyaku(g->right.hand, &g->right.teyaku);
calculate_teyaku(g->left.hand, &g->left.teyaku);
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) {
g->state = GAME_STATE_CALCULATING_SCORES;
} 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)) {
// check for player canceling
// if they do:
// g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
// else
g->state = GAME_STATE_CHOOSING_FROM_HAND;
} else {
// AI decides whether to cancel or not
// if they do:
// g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
// else
g->state = GAME_STATE_CHOOSING_FROM_HAND;
}
} else {
g->state = GAME_STATE_CHOOSING_FROM_HAND;
}
g->state = GAME_STATE_PLAYER_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_PLAYER_CHOOSING_TARGET;
g->state = GAME_STATE_CHOOSING_TARGET;
return;
}
}
}
void run_frame_player_choosing_target(Game *g) {
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_PLAYING_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;
}
bool no_cards_selected = true;
for (int i = 0; i < g->player.hand.count; i++) {
if (g->player.hand.cards[i]->selected) {
@ -276,7 +319,7 @@ void run_frame_player_choosing_target(Game *g) {
}
if (no_cards_selected) {
g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND;
g->state = GAME_STATE_CHOOSING_FROM_HAND;
return;
}
@ -295,57 +338,63 @@ void run_frame_player_choosing_target(Game *g) {
add_to_hand(&g->field, g->current_play_from_hand);
g->current_play_from_hand = NULL;
}
g->state = GAME_STATE_PLAYER_FROM_DECK;
g->state = GAME_STATE_PLAYING_FROM_DECK;
}
}
void run_frame_player_from_deck(Game *g) {
if (run_frame_from_deck(g, &g->player.scored)) {
calculate_dekiyaku(&g->player.scored, &g->player.dekiyaku);
if (dekiyaku_score(&g->player.dekiyaku) != g->player.dekiyaku_score) {
g->player.dekiyaku_score = dekiyaku_score(&g->player.dekiyaku);
g->state = GAME_STATE_PLAYER_HAS_DEKIYAKU;
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];
if (top_card->visible) {
Card *target = valid_target(top_card, &g->field);
if (target) {
remove_from_hand(&g->field, target);
add_to_hand(to_hand, target);
remove_from_hand(&g->deck, top_card);
add_to_hand(to_hand, top_card);
} else {
g->state = GAME_STATE_RIGHT_PLAYING;
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->field, top_card);
}
g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU;
} else {
remove_from_hand(&g->deck, top_card);
add_to_hand(&g->deck, top_card);
top_card->visible = true;
top_card->move.end_time = 0.3;
top_card->move.destination.x = top_card->move.destination.x + 100;
}
}
void run_frame_player_has_dekiyaku(Game *g) {
if (g->player.dekiyaku_action == DEKIYAKU_ACTION_SAGE) {
g->state = GAME_STATE_RIGHT_PLAYING;
} else if (g->player.dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) {
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;
cp->dekiyaku_action = DEKIYAKU_ACTION_NONE;
g->state = GAME_STATE_SELECTING_DEKIYAKU_ACTION;
} 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 {
printf("Hey you can't choose a dekiyaku action yet, sorry\n");
g->player.dekiyaku_action = DEKIYAKU_ACTION_SAGE;
}
} else {
// TODO: better AI
current_player(g)->dekiyaku_action = DEKIYAKU_ACTION_SHOUBU;
g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE;
}
}
void run_frame_right_playing(Game *g) {
run_frame_ai_playing(g, &g->right.hand, &g->right.scored);
g->state = GAME_STATE_RIGHT_FROM_DECK;
}
void run_frame_right_from_deck(Game *g) {
if (run_frame_from_deck(g, &g->right.scored)) {
calculate_dekiyaku(&g->right.scored, &g->right.dekiyaku);
g->state = GAME_STATE_LEFT_PLAYING;
}
}
void run_frame_left_playing(Game *g) {
run_frame_ai_playing(g, &g->left.hand, &g->left.scored);
g->state = GAME_STATE_LEFT_FROM_DECK;
}
void run_frame_left_from_deck(Game *g) {
if (run_frame_from_deck(g, &g->left.scored)) {
if (g->player.hand.count) {
g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND;
} else {
g->state = GAME_STATE_CALCULATING_SCORES;
}
}
}
void run_frame_calculating_scores(Game *g) {
printf("Hand scores: %d %d %d\n", hand_points(&g->player.scored), hand_points(&g->right.scored), hand_points(&g->left.scored));
@ -381,6 +430,11 @@ void run_frame_calculating_scores(Game *g) {
g->state = GAME_STATE_INITIALIZING;
}
void run_frame_calculating_dekiyaku_score(Game *g) {
printf("Somebody won with dekiyaku. Cool.\n");
g->state = GAME_STATE_INITIALIZING;
}
void run_frame(Game *g) {
handle_input(g);
@ -404,30 +458,33 @@ void run_frame(Game *g) {
case GAME_STATE_CALCULATING_TEYAKU:
run_frame_calculating_teyaku(g);
break;
case GAME_STATE_PLAYER_CHOOSING_FROM_HAND:
run_frame_player_choosing_from_hand(g);
case GAME_STATE_START_OF_TURN:
run_frame_start_of_turn(g);
break;
case GAME_STATE_PLAYER_CHOOSING_TARGET:
run_frame_player_choosing_target(g);
case GAME_STATE_CHECKING_FOR_CANCEL:
run_frame_checking_for_cancel(g);
break;
case GAME_STATE_PLAYER_FROM_DECK:
run_frame_player_from_deck(g);
case GAME_STATE_CHOOSING_FROM_HAND:
run_frame_choosing_from_hand(g);
break;
case GAME_STATE_RIGHT_PLAYING:
run_frame_right_playing(g);
case GAME_STATE_CHOOSING_TARGET:
run_frame_choosing_target(g);
break;
case GAME_STATE_RIGHT_FROM_DECK:
run_frame_right_from_deck(g);
case GAME_STATE_PLAYING_FROM_DECK:
run_frame_playing_from_deck(g);
break;
case GAME_STATE_LEFT_PLAYING:
run_frame_left_playing(g);
case GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU:
run_frame_checking_for_new_dekiyaku(g);
break;
case GAME_STATE_LEFT_FROM_DECK:
run_frame_left_from_deck(g);
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;
}
}
@ -449,16 +506,18 @@ void draw_frame(Game *g) {
DrawText(g->right.points_string, 40, 750, 20, BLACK);
DrawText(g->left.points_string, 40, 800, 20, BLACK);
switch (g->state) {
case GAME_STATE_PLAYER_CHOOSING_FROM_HAND:
DrawText("Choose a card to play", 60, 485, 20, BLACK);
break;
case GAME_STATE_PLAYER_CHOOSING_TARGET:
DrawText("Choose a target on the field", 60, 485, 20, BLACK);
DrawRectangleRec(next_card_position(&g->field), BLUE);
break;
default:
break;
if (is_player_turn(g)) {
switch (g->state) {
case GAME_STATE_CHOOSING_FROM_HAND:
DrawText("Choose a card to play", 60, 485, 20, BLACK);
break;
case GAME_STATE_CHOOSING_TARGET:
DrawText("Choose a target on the field", 60, 485, 20, BLACK);
DrawRectangleRec(next_card_position(&g->field), BLUE);
break;
default:
break;
}
}
EndDrawing();

16
game.h
View File

@ -17,14 +17,13 @@ typedef enum GameState {
GAME_STATE_DEALING,
GAME_STATE_CALCULATING_FIELD_MULTIPLIER,
GAME_STATE_CALCULATING_TEYAKU,
GAME_STATE_PLAYER_CHOOSING_FROM_HAND,
GAME_STATE_PLAYER_CHOOSING_TARGET,
GAME_STATE_PLAYER_FROM_DECK,
GAME_STATE_PLAYER_HAS_DEKIYAKU,
GAME_STATE_RIGHT_PLAYING,
GAME_STATE_RIGHT_FROM_DECK,
GAME_STATE_LEFT_PLAYING,
GAME_STATE_LEFT_FROM_DECK,
GAME_STATE_START_OF_TURN,
GAME_STATE_CHECKING_FOR_CANCEL,
GAME_STATE_CHOOSING_FROM_HAND,
GAME_STATE_CHOOSING_TARGET,
GAME_STATE_PLAYING_FROM_DECK,
GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU,
GAME_STATE_SELECTING_DEKIYAKU_ACTION,
GAME_STATE_CALCULATING_SCORES,
GAME_STATE_CALCULATING_DEKIYAKU_SCORE,
} GameState;
@ -40,6 +39,7 @@ struct Game {
int kan_value;
Player player, right, left;
int temp_points;
int turn_number;
};
void initialize_game(Game *g);