From f17bd76b837443936ba093ddd8c55a30df872470 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 2 Feb 2025 18:13:19 -0500 Subject: [PATCH 01/51] Get a game going --- card.h | 2 +- dekiyaku.c | 10 ++--- game.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++ game.h | 20 +++++++++ main.c | 119 +++-------------------------------------------------- teyaku.c | 4 +- 6 files changed, 147 insertions(+), 122 deletions(-) create mode 100644 game.c create mode 100644 game.h diff --git a/card.h b/card.h index e00e9b4..5cd7bd9 100644 --- a/card.h +++ b/card.h @@ -49,7 +49,7 @@ struct Card { }; struct Hand { - Card cards[48]; + Card *cards[48]; int count; }; diff --git a/dekiyaku.c b/dekiyaku.c index 6475888..fbe6cf3 100644 --- a/dekiyaku.c +++ b/dekiyaku.c @@ -6,20 +6,20 @@ void calculate_dekiyaku(const Hand h, Dekiyaku *d) { int brights = 0, ribbons = 0, ribbons_except_november = 0, blue_ribbons = 0, poetry_ribbons = 0, boar = 0, deer = 0, butterflies = 0; for (int i = 0; i < h.count; i++) { - const Card card = h.cards[i]; - switch (card.type) { + Card *card = h.cards[i]; + switch (card->type) { case BRIGHT: brights++; break; case RIBBON: ribbons++; - if (card.month != NOVEMBER) ribbons_except_november++; - switch (card.ribbon_type) { + if (card->month != NOVEMBER) ribbons_except_november++; + switch (card->ribbon_type) { case RIBBON_BLUE: blue_ribbons++; break; case RIBBON_POETRY: poetry_ribbons++; break; default: break; } break; case ANIMAL: - switch (card.month) { + switch (card->month) { case JUNE: butterflies++; break; case JULY: boar++; break; case OCTOBER: deer++; break; diff --git a/game.c b/game.c new file mode 100644 index 0000000..ce17783 --- /dev/null +++ b/game.c @@ -0,0 +1,114 @@ +#include + +#include "game.h" +#include "card.h" +#include "teyaku.h" +#include "dekiyaku.h" + +Vector2 mouse_pos; +char teyaku_calculation[400]; +char dekiyaku_calculation[400]; + +void initialize_game(Game *g) { + g->should_close = false; + 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, (Vector2) { month * 75, (i % 4) * 123 }, false }; + } + + strcpy(teyaku_calculation, ""); + strcpy(dekiyaku_calculation, ""); + + Image cards_image = LoadImage("img/cards.png"); + g->cards_texture = LoadTextureFromImage(cards_image); + UnloadImage(cards_image); +} + +bool stale_calculation = true; +void run_frame(Game *g) { + if (IsMouseButtonPressed(0)) { + mouse_pos = GetMousePosition(); + for (int i = 0; i < 48; i++) { + if (point_within_card(&g->cards[i], mouse_pos)) { + g->cards[i].selected = !g->cards[i].selected; + stale_calculation = true; + break; + } + } + } + + int num_selected = 0; + if (stale_calculation) { + Hand h; + h.count = 0; + for (int i = 0; i < 48; i++) { + num_selected += g->cards[i].selected; + if (g->cards[i].selected) h.cards[h.count++] = &g->cards[i]; + } + + if (num_selected == 7) { + Teyaku t; + calculate_teyaku(h, &t); + teyaku_to_string(&t, teyaku_calculation); + } else { + strcpy(teyaku_calculation, ""); + } + + Dekiyaku d; + calculate_dekiyaku(h, &d); + dekiyaku_to_string(&d, dekiyaku_calculation); + stale_calculation = false; + } +} + +void draw_frame(Game *g) { + BeginDrawing(); + ClearBackground(RAYWHITE); + for (int i = 0; i < 48; i++) { + draw_card(&g->cards[i], &g->cards_texture); + } + + DrawText(teyaku_calculation, 10, 550, 25, BLACK); + DrawText(dekiyaku_calculation, 10, 500, 25, BLACK); + EndDrawing(); +} + +void run_until_closing(Game *g) { + while (!WindowShouldClose() && !g->should_close) { + run_frame(g); + draw_frame(g); + } +} diff --git a/game.h b/game.h new file mode 100644 index 0000000..d38e5f2 --- /dev/null +++ b/game.h @@ -0,0 +1,20 @@ +#ifndef _HF_GAME_ +#define _HF_GAME_ + +#include + +typedef struct Game Game; + +#include "card.h" + +struct Game { + bool should_close; + Card cards[48]; + Texture2D cards_texture; + Hand player_hand, left_hand, right_hand; +}; + +void initialize_game(Game *g); +void run_until_closing(Game *g); + +#endif diff --git a/main.c b/main.c index a5d6ab1..02f13a9 100644 --- a/main.c +++ b/main.c @@ -5,129 +5,20 @@ #include -#include "card.h" -#include "move.h" -#include "teyaku.h" -#include "dekiyaku.h" +#include "game.h" char *text = "こんにちわ、 世界！"; +Texture2D cards_texture; int main(int argc, char** argv) { InitWindow(900, 600, "Hanafuda Hachi-Hachi"); SetTargetFPS(60); - Image cards_image = LoadImage("img/cards.png"); - Texture2D cards_texture = LoadTextureFromImage(cards_image); - UnloadImage(cards_image); + Game g; + initialize_game(&g); - /* - Hand h; - h.cards[0] = (Card) { 1, BRIGHT, RIBBON_NONE, NOVEMBER, (Vector2) { 0, 0 } }; - h.cards[1] = (Card) { 1, ANIMAL, RIBBON_NONE, NOVEMBER, (Vector2) { 0, 0 } }; - h.cards[2] = (Card) { 1, RIBBON, RIBBON_PLAIN, NOVEMBER, (Vector2) { 0, 0 } }; - h.cards[3] = (Card) { 1, CHAFF, RIBBON_NONE, NOVEMBER, (Vector2) { 0, 0 } }; - h.cards[4] = (Card) { 1, CHAFF, RIBBON_NONE, DECEMBER, (Vector2) { 0, 0 } }; - h.cards[5] = (Card) { 1, CHAFF, RIBBON_NONE, DECEMBER, (Vector2) { 0, 0 } }; - h.cards[6] = (Card) { 1, CHAFF, RIBBON_NONE, DECEMBER, (Vector2) { 0, 0 } }; - h.count = 7; - - printf("Teyaku: %d\n", calculate_teyaku(h)); - */ - - Card cards[48]; - 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; - } - cards[i] = (Card) { i, t, rt, month, (Vector2) { month * 75, (i % 4) * 123 }, false }; - } - - // float delta; - Vector2 mouse_pos; - char teyaku_calculation[400]; - strcpy(teyaku_calculation, ""); - char dekiyaku_calculation[400]; - strcpy(dekiyaku_calculation, ""); - - while (!WindowShouldClose()) { - // delta = GetFrameTime(); - - if (IsMouseButtonPressed(0)) { - mouse_pos = GetMousePosition(); - for (int i = 0; i < 48; i++) { - if (point_within_card(&cards[i], mouse_pos)) { - cards[i].selected = !cards[i].selected; - strcpy(teyaku_calculation, ""); - break; - } - } - } - - BeginDrawing(); - ClearBackground(RAYWHITE); - int num_selected = 0; - for (int i = 0; i < 48; i++) { - num_selected += cards[i].selected; - draw_card(&cards[i], &cards_texture); - } - - if (strlen(teyaku_calculation) == 0) { - Hand h; - h.count = 0; - for (int i = 0; i < 48; i++) { - if (cards[i].selected) memcpy(&h.cards[h.count++], &cards[i], sizeof(Card)); - } - - if (num_selected == 7) { - Teyaku t; - calculate_teyaku(h, &t); - teyaku_to_string(&t, teyaku_calculation); - } else { - strcpy(teyaku_calculation, ""); - } - - Dekiyaku d; - calculate_dekiyaku(h, &d); - dekiyaku_to_string(&d, dekiyaku_calculation); - } - - DrawText(teyaku_calculation, 10, 550, 25, BLACK); - DrawText(dekiyaku_calculation, 10, 500, 25, BLACK); - EndDrawing(); - } + run_until_closing(&g); CloseWindow(); - return 0; } diff --git a/teyaku.c b/teyaku.c index 8066304..8984b66 100644 --- a/teyaku.c +++ b/teyaku.c @@ -7,7 +7,7 @@ SetTeyaku calculate_set_teyaku(const Hand h) { int month_counts[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int month_stands[12] = { 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1 }; for (int i = 0; i < h.count; i++) { - Card c = h.cards[i]; + Card c = *h.cards[i]; month_counts[c.month]++; } @@ -45,7 +45,7 @@ ChaffTeyaku calculate_chaff_teyaku(const Hand h) { int chaff = 0; for (int i = 0; i < h.count; i++) { - Card c = h.cards[i]; + Card c = *h.cards[i]; if (c.month == NOVEMBER) chaff++; // November cards are all counted as chaff here else if (c.type == BRIGHT) brights++; else if (c.type == RIBBON) ribbons++; From f852af7cd71e6601d92285ac2e50593325da1e2d Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 2 Feb 2025 18:30:45 -0500 Subject: [PATCH 02/51] Shuffle cards --- card.c | 14 ++++++++++++++ card.h | 1 + game.c | 5 +++++ game.h | 2 +- 4 files changed, 21 insertions(+), 1 deletion(-) diff --git a/card.c b/card.c index 37be84b..f5e08b2 100644 --- a/card.c +++ b/card.c @@ -1,3 +1,6 @@ +#include +#include +#include #include "card.h" static Vector2 card_size = (Vector2) { CARD_WIDTH, CARD_HEIGHT }; @@ -26,3 +29,14 @@ bool point_within_card(Card *c, Vector2 point) { return point.x > c->position.x && point.x < c->position.x + card_size.x && point.y > c->position.y && point.y < c->position.y + card_size.y; } + +void shuffle_hand(Hand *h) { + srand(time(NULL)); + Card *swap; + for (int i = h->count - 1; i >= 0; i--) { + int index = rand() % (i + 1); + swap = h->cards[i]; + h->cards[i] = h->cards[index]; + h->cards[index] = swap; + } +} diff --git a/card.h b/card.h index 5cd7bd9..c36702a 100644 --- a/card.h +++ b/card.h @@ -55,5 +55,6 @@ struct Hand { void draw_card(Card *c, Texture2D *cards_texture); bool point_within_card(Card *c, Vector2 v); +void shuffle_hand(Hand *h); #endif diff --git a/game.c b/game.c index ce17783..2bcfe04 100644 --- a/game.c +++ b/game.c @@ -1,4 +1,5 @@ #include +#include #include "game.h" #include "card.h" @@ -47,8 +48,12 @@ void initialize_game(Game *g) { t = ANIMAL; break; } g->cards[i] = (Card) { i, t, rt, month, (Vector2) { month * 75, (i % 4) * 123 }, false }; + g->deck.cards[i] = &g->cards[i]; + g->deck.count++; } + shuffle_hand(&g->deck); + strcpy(teyaku_calculation, ""); strcpy(dekiyaku_calculation, ""); diff --git a/game.h b/game.h index d38e5f2..2ca6dc6 100644 --- a/game.h +++ b/game.h @@ -11,7 +11,7 @@ struct Game { bool should_close; Card cards[48]; Texture2D cards_texture; - Hand player_hand, left_hand, right_hand; + Hand player_hand, left_hand, right_hand, deck; }; void initialize_game(Game *g); From de975d524d53432fab1f268d2359fcede5be0058 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 2 Feb 2025 19:07:49 -0500 Subject: [PATCH 03/51] Let me deal you a hand --- card.c | 36 ++++++++++++++++++++++++++---------- card.h | 3 +++ game.c | 27 +++++++++++++++++++++++++-- main.c | 16 +++++++++------- 4 files changed, 63 insertions(+), 19 deletions(-) diff --git a/card.c b/card.c index f5e08b2..1748867 100644 --- a/card.c +++ b/card.c @@ -1,6 +1,5 @@ #include #include -#include #include "card.h" static Vector2 card_size = (Vector2) { CARD_WIDTH, CARD_HEIGHT }; @@ -12,14 +11,19 @@ void draw_card(Card *c, Texture2D *cards_texture) { int pos_vert = i_vert * CARD_HEIGHT; int pos_horiz = i_horiz * CARD_WIDTH; - DrawTexturePro( - *cards_texture, - (Rectangle) { pos_horiz, pos_vert, CARD_WIDTH, CARD_HEIGHT }, - (Rectangle) { c->position.x, c->position.y, card_size.x, card_size.y }, - (Vector2) { 0, 0 }, - 0., - RAYWHITE - ); + if (c->visible) { + DrawTexturePro( + *cards_texture, + (Rectangle) { pos_horiz, pos_vert, CARD_WIDTH, CARD_HEIGHT }, + (Rectangle) { c->position.x, c->position.y, card_size.x, card_size.y }, + (Vector2) { 0, 0 }, + 0., + RAYWHITE + ); + } else { + DrawRectangleRec((Rectangle) { c->position.x, c->position.y, card_size.x, card_size.y }, BLACK); + } + if (c->selected) { DrawCircle(c->position.x + 10, c->position.y + 10, 10, BLUE); } @@ -31,7 +35,6 @@ bool point_within_card(Card *c, Vector2 point) { } void shuffle_hand(Hand *h) { - srand(time(NULL)); Card *swap; for (int i = h->count - 1; i >= 0; i--) { int index = rand() % (i + 1); @@ -40,3 +43,16 @@ void shuffle_hand(Hand *h) { h->cards[index] = swap; } } + +void add_to_hand(Hand *h, Card *c) { + h->cards[h->count++] = c; + c->position = (Vector2) { h->position.x + (h->count * (CARD_WIDTH + 10)), h->position.y }; +} + +void deal(Hand *from, Hand *to, int count) { + for (int i = 0; i < count; i++) { + Card *t = from->cards[from->count - 1]; + add_to_hand(to, t); + from->count--; + } +} diff --git a/card.h b/card.h index c36702a..92d9110 100644 --- a/card.h +++ b/card.h @@ -46,15 +46,18 @@ struct Card { Month month; Vector2 position; bool selected; + bool visible; }; struct Hand { Card *cards[48]; int count; + Vector2 position; }; void draw_card(Card *c, Texture2D *cards_texture); bool point_within_card(Card *c, Vector2 v); void shuffle_hand(Hand *h); +void deal(Hand *from, Hand *to, int count); #endif diff --git a/game.c b/game.c index 2bcfe04..a2ea379 100644 --- a/game.c +++ b/game.c @@ -11,6 +11,7 @@ char teyaku_calculation[400]; char dekiyaku_calculation[400]; void initialize_game(Game *g) { + g->deck.count = 0; g->should_close = false; for (int i = 0; i < 48; i++) { CardType t = CHAFF; @@ -47,13 +48,31 @@ void initialize_game(Game *g) { case 41: t = ANIMAL; break; } - g->cards[i] = (Card) { i, t, rt, month, (Vector2) { month * 75, (i % 4) * 123 }, false }; + g->cards[i] = (Card) { i, t, rt, month, (Vector2) { 800, 100 }, false, false }; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } shuffle_hand(&g->deck); + g->player_hand.count = 0; + g->player_hand.position = (Vector2) { 20, 450 }; + g->right_hand.count = 0; + g->right_hand.position = (Vector2) { 20, 100 }; + g->left_hand.count = 0; + g->left_hand.position = (Vector2) { 20, 300 }; + + deal(&g->deck, &g->player_hand, 4); + deal(&g->deck, &g->right_hand, 4); + deal(&g->deck, &g->left_hand, 4); + deal(&g->deck, &g->player_hand, 3); + deal(&g->deck, &g->right_hand, 3); + deal(&g->deck, &g->left_hand, 3); + + for (int i = 0; i < g->player_hand.count; i++) { + g->player_hand.cards[i]->visible = true; + } + strcpy(teyaku_calculation, ""); strcpy(dekiyaku_calculation, ""); @@ -63,7 +82,8 @@ void initialize_game(Game *g) { } bool stale_calculation = true; -void run_frame(Game *g) { + +void handle_input(Game *g) { if (IsMouseButtonPressed(0)) { mouse_pos = GetMousePosition(); for (int i = 0; i < 48; i++) { @@ -74,7 +94,10 @@ void run_frame(Game *g) { } } } +} +void run_frame(Game *g) { + handle_input(g); int num_selected = 0; if (stale_calculation) { Hand h; diff --git a/main.c b/main.c index 02f13a9..af7acf6 100644 --- a/main.c +++ b/main.c @@ -2,6 +2,7 @@ #include #include #include +#include #include @@ -11,14 +12,15 @@ char *text = "こんにちわ、 世界！"; Texture2D cards_texture; int main(int argc, char** argv) { - InitWindow(900, 600, "Hanafuda Hachi-Hachi"); - SetTargetFPS(60); + srand(time(NULL)); + InitWindow(900, 600, "Hanafuda Hachi-Hachi"); + SetTargetFPS(60); - Game g; - initialize_game(&g); + Game g; + initialize_game(&g); - run_until_closing(&g); + run_until_closing(&g); - CloseWindow(); - return 0; + CloseWindow(); + return 0; } From c3094a9a5d7afb4e668bebca07fe2e4b15c6fee4 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Mon, 3 Feb 2025 20:07:22 -0500 Subject: [PATCH 04/51] Deal properly --- card.c | 21 +++++++++++++++++---- card.h | 6 +++++- game.c | 58 ++++++++++++++++++++++++++++++++++++++++++++-------------- game.h | 6 ++++++ move.c | 15 +++++++++++---- move.h | 3 ++- 6 files changed, 85 insertions(+), 24 deletions(-) diff --git a/card.c b/card.c index 1748867..79d38ad 100644 --- a/card.c +++ b/card.c @@ -46,13 +46,26 @@ void shuffle_hand(Hand *h) { void add_to_hand(Hand *h, Card *c) { h->cards[h->count++] = c; - c->position = (Vector2) { h->position.x + (h->count * (CARD_WIDTH + 10)), h->position.y }; + + c->move.position = &c->position; + c->move.origin.x = c->position.x; + c->move.origin.y = c->position.y; + c->move.destination.x = h->position.x + (h->count * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y; + c->move.curve = CURVE_EASE_IN_OUT; + c->move.current_time = 0.; + c->move.end_time = 0.5; } -void deal(Hand *from, Hand *to, int count) { +bool card_done_moving(Card *c) { + return c->move.current_time > c->move.end_time; +} + +void deal(Hand *from, Hand *to, int count, bool up) { for (int i = 0; i < count; i++) { - Card *t = from->cards[from->count - 1]; - add_to_hand(to, t); + Card *c = from->cards[from->count - 1]; + c->visible = up; + add_to_hand(to, c); from->count--; } } diff --git a/card.h b/card.h index 92d9110..3c8beb0 100644 --- a/card.h +++ b/card.h @@ -4,6 +4,8 @@ #include #include +#include "move.h" + typedef struct Card Card; typedef struct Hand Hand; #define CARD_WIDTH 73 @@ -47,6 +49,7 @@ struct Card { Vector2 position; bool selected; bool visible; + Move move; }; struct Hand { @@ -58,6 +61,7 @@ struct Hand { void draw_card(Card *c, Texture2D *cards_texture); bool point_within_card(Card *c, Vector2 v); void shuffle_hand(Hand *h); -void deal(Hand *from, Hand *to, int count); +void deal(Hand *from, Hand *to, int count, bool up); +bool card_done_moving(Card *c); #endif diff --git a/game.c b/game.c index a2ea379..6f72e0f 100644 --- a/game.c +++ b/game.c @@ -13,6 +13,7 @@ char dekiyaku_calculation[400]; void initialize_game(Game *g) { g->deck.count = 0; g->should_close = false; + g->state = GAME_STATE_INITIALIZING; for (int i = 0; i < 48; i++) { CardType t = CHAFF; RibbonType rt = RIBBON_NONE; @@ -49,6 +50,8 @@ void initialize_game(Game *g) { t = ANIMAL; break; } g->cards[i] = (Card) { i, t, rt, month, (Vector2) { 800, 100 }, false, false }; + g->cards[i].move.end_time = 0.; + g->cards[i].move.position = &g->cards[i].position; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } @@ -62,27 +65,16 @@ void initialize_game(Game *g) { g->left_hand.count = 0; g->left_hand.position = (Vector2) { 20, 300 }; - deal(&g->deck, &g->player_hand, 4); - deal(&g->deck, &g->right_hand, 4); - deal(&g->deck, &g->left_hand, 4); - deal(&g->deck, &g->player_hand, 3); - deal(&g->deck, &g->right_hand, 3); - deal(&g->deck, &g->left_hand, 3); - - for (int i = 0; i < g->player_hand.count; i++) { - g->player_hand.cards[i]->visible = true; - } - strcpy(teyaku_calculation, ""); strcpy(dekiyaku_calculation, ""); Image cards_image = LoadImage("img/cards.png"); g->cards_texture = LoadTextureFromImage(cards_image); UnloadImage(cards_image); + g->state = GAME_STATE_DEALING; } bool stale_calculation = true; - void handle_input(Game *g) { if (IsMouseButtonPressed(0)) { mouse_pos = GetMousePosition(); @@ -96,8 +88,7 @@ void handle_input(Game *g) { } } -void run_frame(Game *g) { - handle_input(g); +void run_calculation(Game *g) { int num_selected = 0; if (stale_calculation) { Hand h; @@ -122,6 +113,45 @@ void run_frame(Game *g) { } } +void run_frame_dealing(Game *g) { + if (g->player_hand.count < 4) { + deal(&g->deck, &g->player_hand, 4, true); + } else if (g->right_hand.count < 4) { + deal(&g->deck, &g->right_hand, 4, false); + } else if (g->left_hand.count < 4) { + deal(&g->deck, &g->left_hand, 4, false); + } else if (g->player_hand.count < 7) { + deal(&g->deck, &g->player_hand, 3, true); + } else if (g->right_hand.count < 7) { + deal(&g->deck, &g->right_hand, 3, false); + } else if (g->left_hand.count < 7) { + deal(&g->deck, &g->left_hand, 3, false); + } else { + g->state = GAME_STATE_INITIALIZING; + } +} + +void run_frame(Game *g) { + float delta = GetFrameTime(); + bool done_moving = true; + for (int i = 0; i < 48; i++) { + move_position(&g->cards[i].move, delta); + if (!card_done_moving(&g->cards[i])) done_moving = false; + } + if (!done_moving) return; + + handle_input(g); + + switch (g->state) { + case GAME_STATE_INITIALIZING: + return; + case GAME_STATE_DEALING: + run_frame_dealing(g); + break; + } + run_calculation(g); +} + void draw_frame(Game *g) { BeginDrawing(); ClearBackground(RAYWHITE); diff --git a/game.h b/game.h index 2ca6dc6..c04ceb3 100644 --- a/game.h +++ b/game.h @@ -7,7 +7,13 @@ typedef struct Game Game; #include "card.h" +typedef enum GameState { + GAME_STATE_INITIALIZING, + GAME_STATE_DEALING +} GameState; + struct Game { + GameState state; bool should_close; Card cards[48]; Texture2D cards_texture; diff --git a/move.c b/move.c index 7eed111..6aefbec 100644 --- a/move.c +++ b/move.c @@ -1,25 +1,32 @@ #include #include "move.h" -Vector2 move_position(Move *m, float delta) { +void move_position(Move *m, float delta) { m->current_time += delta; float percentage = m->current_time / m->end_time; if (percentage < 0.0) percentage = 0.0; else if (percentage > 1.0) percentage = 1.0; + Vector2 v; switch (m->curve) { case CURVE_LINEAR: - return (Vector2) { + v = (Vector2) { ((m->destination.x - m->origin.x) * percentage) + m->origin.x, ((m->destination.y - m->origin.y) * percentage) + m->origin.y }; + break; case CURVE_EASE_IN_OUT: percentage = -(cos(PI * percentage) - 1) / 2; - return (Vector2) { + v = (Vector2) { ((m->destination.x - m->origin.x) * percentage) + m->origin.x, ((m->destination.y - m->origin.y) * percentage) + m->origin.y }; + break; default: - return m->destination; + v = m->destination; + break; } + + m->position->x = v.x; + m->position->y = v.y; } diff --git a/move.h b/move.h index 298efd8..a791342 100644 --- a/move.h +++ b/move.h @@ -11,6 +11,7 @@ typedef enum Curve { typedef struct Move Move; struct Move { + Vector2 *position; Vector2 origin; Vector2 destination; Curve curve; @@ -18,6 +19,6 @@ struct Move { float end_time; }; -Vector2 move_position(Move *m, float delta); +void move_position(Move *m, float delta); #endif From 371feff5fe2601e8e676c5a1a240e50cb860ac5f Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Mon, 3 Feb 2025 20:12:38 -0500 Subject: [PATCH 05/51] Initialize cards w correct position --- game.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/game.c b/game.c index 6f72e0f..f0be7a3 100644 --- a/game.c +++ b/game.c @@ -49,9 +49,10 @@ void initialize_game(Game *g) { case 41: t = ANIMAL; break; } - g->cards[i] = (Card) { i, t, rt, month, (Vector2) { 800, 100 }, false, false }; + g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false, false }; g->cards[i].move.end_time = 0.; g->cards[i].move.position = &g->cards[i].position; + g->cards[i].move.destination = (Vector2) { 800, 200 }; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } @@ -63,7 +64,7 @@ void initialize_game(Game *g) { g->right_hand.count = 0; g->right_hand.position = (Vector2) { 20, 100 }; g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 20, 300 }; + g->left_hand.position = (Vector2) { 20, 250 }; strcpy(teyaku_calculation, ""); strcpy(dekiyaku_calculation, ""); From 417544321ce4f40426244a37f9e8c7ac00f260ac Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Tue, 4 Feb 2025 18:47:56 -0500 Subject: [PATCH 06/51] Calculate field multipler and teyaku --- card.h | 6 ++++++ field_multiplier.c | 17 +++++++++++++++++ field_multiplier.h | 19 +++++++++++++++++++ game.c | 46 ++++++++++++++++++++++++++++++++++++---------- game.h | 10 ++++++++-- teyaku.c | 1 + teyaku.h | 3 +++ 7 files changed, 90 insertions(+), 12 deletions(-) create mode 100644 field_multiplier.c create mode 100644 field_multiplier.h diff --git a/card.h b/card.h index 3c8beb0..d5198b9 100644 --- a/card.h +++ b/card.h @@ -12,6 +12,12 @@ typedef struct Hand Hand; #define CARD_HEIGHT 120 #define CARD_BORDER 5 +#define CRANE_INDEX 0 +#define CURTAIN_INDEX 8 +#define MOON_INDEX 28 +#define RAINY_MAN_INDEX 40 +#define PHOENIX_INDEX 44 + typedef enum CardType { CHAFF, RIBBON, diff --git a/field_multiplier.c b/field_multiplier.c new file mode 100644 index 0000000..fca83f8 --- /dev/null +++ b/field_multiplier.c @@ -0,0 +1,17 @@ +#include + +#include "field_multiplier.h" +#include "card.h" + +const FieldMultiplier *calculate_field_multiplier(Hand *h) { + bool large = false; + for (int i = 0; i < h->count; i++) { + Card *c = h->cards[i]; + if (c->index == CRANE_INDEX || c->index == CURTAIN_INDEX || c->index == MOON_INDEX) + large = true; + else if (c->index == RAINY_MAN_INDEX || c->index == PHOENIX_INDEX) + return &grand_field; + } + + return large ? &large_field : &small_field; +} diff --git a/field_multiplier.h b/field_multiplier.h new file mode 100644 index 0000000..8b3e1f3 --- /dev/null +++ b/field_multiplier.h @@ -0,0 +1,19 @@ +#ifndef _HF_FIELD_MULTIPLIER_ +#define _HF_FIELD_MULTIPLIER_ + +typedef struct FieldMultiplier FieldMultiplier; + +#include "card.h" + +struct FieldMultiplier { + char *name; + int value; +}; + +static const FieldMultiplier small_field = { "Small Field", 1 }; +static const FieldMultiplier large_field = { "Large Field", 2 }; +static const FieldMultiplier grand_field = { "Grand Field", 4 }; + +const FieldMultiplier *calculate_field_multiplier(Hand *h); + +#endif diff --git a/game.c b/game.c index f0be7a3..02418ac 100644 --- a/game.c +++ b/game.c @@ -5,15 +5,19 @@ #include "card.h" #include "teyaku.h" #include "dekiyaku.h" +#include "field_multiplier.h" Vector2 mouse_pos; char teyaku_calculation[400]; -char dekiyaku_calculation[400]; void initialize_game(Game *g) { g->deck.count = 0; g->should_close = false; g->state = GAME_STATE_INITIALIZING; + g->field_multiplier = NULL; + g->player_teyaku.calculated = false; + g->left_teyaku.calculated = false; + g->right_teyaku.calculated = false; for (int i = 0; i < 48; i++) { CardType t = CHAFF; RibbonType rt = RIBBON_NONE; @@ -60,14 +64,15 @@ void initialize_game(Game *g) { shuffle_hand(&g->deck); g->player_hand.count = 0; - g->player_hand.position = (Vector2) { 20, 450 }; + g->player_hand.position = (Vector2) { 20, 475 }; g->right_hand.count = 0; g->right_hand.position = (Vector2) { 20, 100 }; g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 20, 250 }; + g->left_hand.position = (Vector2) { 20, 225 }; + g->field.count = 0; + g->field.position = (Vector2) { 20, 350 }; strcpy(teyaku_calculation, ""); - strcpy(dekiyaku_calculation, ""); Image cards_image = LoadImage("img/cards.png"); g->cards_texture = LoadTextureFromImage(cards_image); @@ -107,9 +112,6 @@ void run_calculation(Game *g) { strcpy(teyaku_calculation, ""); } - Dekiyaku d; - calculate_dekiyaku(h, &d); - dekiyaku_to_string(&d, dekiyaku_calculation); stale_calculation = false; } } @@ -121,17 +123,31 @@ void run_frame_dealing(Game *g) { deal(&g->deck, &g->right_hand, 4, false); } else if (g->left_hand.count < 4) { deal(&g->deck, &g->left_hand, 4, false); + } else if (g->field.count < 3) { + deal(&g->deck, &g->field, 3, true); } else if (g->player_hand.count < 7) { deal(&g->deck, &g->player_hand, 3, true); } else if (g->right_hand.count < 7) { deal(&g->deck, &g->right_hand, 3, false); } else if (g->left_hand.count < 7) { deal(&g->deck, &g->left_hand, 3, false); + } else if (g->field.count < 6) { + deal(&g->deck, &g->field, 3, true); } else { - g->state = GAME_STATE_INITIALIZING; + 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); + g->state = GAME_STATE_INITIALIZING; +} + void run_frame(Game *g) { float delta = GetFrameTime(); bool done_moving = true; @@ -149,6 +165,12 @@ void run_frame(Game *g) { 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; } run_calculation(g); } @@ -160,8 +182,12 @@ void draw_frame(Game *g) { draw_card(&g->cards[i], &g->cards_texture); } - DrawText(teyaku_calculation, 10, 550, 25, BLACK); - DrawText(dekiyaku_calculation, 10, 500, 25, BLACK); + if (g->field_multiplier) DrawText(g->field_multiplier->name, 600, 385, 40, BLACK); + if (g->player_teyaku.calculated) { + char s[200]; + teyaku_to_string(&g->player_teyaku, s); + DrawText(s, 5, 25, 30, BLACK); + } EndDrawing(); } diff --git a/game.h b/game.h index c04ceb3..c406708 100644 --- a/game.h +++ b/game.h @@ -6,10 +6,14 @@ typedef struct Game Game; #include "card.h" +#include "field_multiplier.h" +#include "teyaku.h" typedef enum GameState { GAME_STATE_INITIALIZING, - GAME_STATE_DEALING + GAME_STATE_DEALING, + GAME_STATE_CALCULATING_FIELD_MULTIPLIER, + GAME_STATE_CALCULATING_TEYAKU, } GameState; struct Game { @@ -17,7 +21,9 @@ struct Game { bool should_close; Card cards[48]; Texture2D cards_texture; - Hand player_hand, left_hand, right_hand, deck; + Hand player_hand, left_hand, right_hand, deck, field; + FieldMultiplier *field_multiplier; + Teyaku player_teyaku, left_teyaku, right_teyaku; }; void initialize_game(Game *g); diff --git a/teyaku.c b/teyaku.c index 8984b66..6a3373a 100644 --- a/teyaku.c +++ b/teyaku.c @@ -86,6 +86,7 @@ char *chaff_teyaku_english(ChaffTeyaku ct) { void calculate_teyaku(const Hand h, Teyaku *t) { t->chaff = calculate_chaff_teyaku(h); t->set = calculate_set_teyaku(h); + t->calculated = true; } void teyaku_to_string(Teyaku *t, char *str) { diff --git a/teyaku.h b/teyaku.h index 6e99abc..51d210e 100644 --- a/teyaku.h +++ b/teyaku.h @@ -1,6 +1,8 @@ #ifndef _HF_TEYAKU_ #define _HF_TEYAKU_ +#include + #include "card.h" typedef enum SetTeyaku { @@ -29,6 +31,7 @@ typedef enum ChaffTeyaku { typedef struct Teyaku { ChaffTeyaku chaff; SetTeyaku set; + bool calculated; } Teyaku; void calculate_teyaku(const Hand h, Teyaku *t); From 9701cc9e61cfc60b77518d5ed28f519c1551d4ef Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Wed, 5 Feb 2025 21:19:05 -0500 Subject: [PATCH 07/51] Fix some spacing and some layout --- card.c | 16 +++++++++++++--- card.h | 6 ++++++ game.c | 22 +++++++++++++--------- main.c | 2 +- 4 files changed, 33 insertions(+), 13 deletions(-) diff --git a/card.c b/card.c index 79d38ad..fc8f936 100644 --- a/card.c +++ b/card.c @@ -45,16 +45,26 @@ void shuffle_hand(Hand *h) { } void add_to_hand(Hand *h, Card *c) { - h->cards[h->count++] = c; + h->cards[h->count] = c; c->move.position = &c->position; c->move.origin.x = c->position.x; c->move.origin.y = c->position.y; - c->move.destination.x = h->position.x + (h->count * (CARD_WIDTH + 10)); - c->move.destination.y = h->position.y; + switch (h->display_type) { + case HAND_DISPLAY_ROW: + c->move.destination.x = h->position.x + (h->count * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y; + break; + case HAND_DISPLAY_FIELD: + c->move.destination.x = h->position.x + ((h->count / 2) * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y + (h->count % 2 * (CARD_HEIGHT + 10)); + break; + } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; c->move.end_time = 0.5; + + h->count++; } bool card_done_moving(Card *c) { diff --git a/card.h b/card.h index d5198b9..eb9575a 100644 --- a/card.h +++ b/card.h @@ -58,10 +58,16 @@ struct Card { Move move; }; +typedef enum HandDisplayType { + HAND_DISPLAY_ROW, + HAND_DISPLAY_FIELD, +} HandDisplayType; + struct Hand { Card *cards[48]; int count; Vector2 position; + HandDisplayType display_type; }; void draw_card(Card *c, Texture2D *cards_texture); diff --git a/game.c b/game.c index 02418ac..4d35886 100644 --- a/game.c +++ b/game.c @@ -56,7 +56,7 @@ void initialize_game(Game *g) { g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false, false }; g->cards[i].move.end_time = 0.; g->cards[i].move.position = &g->cards[i].position; - g->cards[i].move.destination = (Vector2) { 800, 200 }; + g->cards[i].move.destination = (Vector2) { 800, 300 }; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } @@ -64,13 +64,17 @@ void initialize_game(Game *g) { shuffle_hand(&g->deck); g->player_hand.count = 0; - g->player_hand.position = (Vector2) { 20, 475 }; + g->player_hand.position = (Vector2) { 300, 550 }; + g->player_hand.display_type = HAND_DISPLAY_ROW; g->right_hand.count = 0; g->right_hand.position = (Vector2) { 20, 100 }; + g->right_hand.display_type = HAND_DISPLAY_ROW; g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 20, 225 }; + g->left_hand.position = (Vector2) { 600, 100 }; + g->left_hand.display_type = HAND_DISPLAY_ROW; g->field.count = 0; - g->field.position = (Vector2) { 20, 350 }; + g->field.position = (Vector2) { 400, 250 }; + g->field.display_type = HAND_DISPLAY_FIELD; strcpy(teyaku_calculation, ""); @@ -119,18 +123,18 @@ void run_calculation(Game *g) { void run_frame_dealing(Game *g) { if (g->player_hand.count < 4) { deal(&g->deck, &g->player_hand, 4, true); - } else if (g->right_hand.count < 4) { - deal(&g->deck, &g->right_hand, 4, false); } else if (g->left_hand.count < 4) { deal(&g->deck, &g->left_hand, 4, false); + } else if (g->right_hand.count < 4) { + deal(&g->deck, &g->right_hand, 4, false); } else if (g->field.count < 3) { deal(&g->deck, &g->field, 3, true); } else if (g->player_hand.count < 7) { deal(&g->deck, &g->player_hand, 3, true); - } else if (g->right_hand.count < 7) { - deal(&g->deck, &g->right_hand, 3, false); } else if (g->left_hand.count < 7) { deal(&g->deck, &g->left_hand, 3, false); + } else if (g->right_hand.count < 7) { + deal(&g->deck, &g->right_hand, 3, false); } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); } else { @@ -182,7 +186,7 @@ void draw_frame(Game *g) { draw_card(&g->cards[i], &g->cards_texture); } - if (g->field_multiplier) DrawText(g->field_multiplier->name, 600, 385, 40, BLACK); + if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); if (g->player_teyaku.calculated) { char s[200]; teyaku_to_string(&g->player_teyaku, s); diff --git a/main.c b/main.c index af7acf6..0cf89e0 100644 --- a/main.c +++ b/main.c @@ -13,7 +13,7 @@ Texture2D cards_texture; int main(int argc, char** argv) { srand(time(NULL)); - InitWindow(900, 600, "Hanafuda Hachi-Hachi"); + InitWindow(1200, 700, "Hanafuda Hachi-Hachi"); SetTargetFPS(60); Game g; From b13bc3a7bbfa1e6b27a16b6d7af4ba0b391a434f Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Thu, 6 Feb 2025 18:20:16 -0500 Subject: [PATCH 08/51] More positioning --- game.c | 10 +++++----- main.c | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/game.c b/game.c index 4d35886..3f5f408 100644 --- a/game.c +++ b/game.c @@ -56,7 +56,7 @@ void initialize_game(Game *g) { g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false, false }; g->cards[i].move.end_time = 0.; g->cards[i].move.position = &g->cards[i].position; - g->cards[i].move.destination = (Vector2) { 800, 300 }; + g->cards[i].move.destination = (Vector2) { 800, 400 }; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } @@ -64,16 +64,16 @@ void initialize_game(Game *g) { shuffle_hand(&g->deck); g->player_hand.count = 0; - g->player_hand.position = (Vector2) { 300, 550 }; + g->player_hand.position = (Vector2) { 300, 600 }; g->player_hand.display_type = HAND_DISPLAY_ROW; g->right_hand.count = 0; - g->right_hand.position = (Vector2) { 20, 100 }; + g->right_hand.position = (Vector2) { 50, 125 }; g->right_hand.display_type = HAND_DISPLAY_ROW; g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 600, 100 }; + g->left_hand.position = (Vector2) { 750, 125 }; g->left_hand.display_type = HAND_DISPLAY_ROW; g->field.count = 0; - g->field.position = (Vector2) { 400, 250 }; + g->field.position = (Vector2) { 400, 300 }; g->field.display_type = HAND_DISPLAY_FIELD; strcpy(teyaku_calculation, ""); diff --git a/main.c b/main.c index 0cf89e0..69404e0 100644 --- a/main.c +++ b/main.c @@ -13,7 +13,7 @@ Texture2D cards_texture; int main(int argc, char** argv) { srand(time(NULL)); - InitWindow(1200, 700, "Hanafuda Hachi-Hachi"); + InitWindow(1400, 900, "Hanafuda Hachi-Hachi"); SetTargetFPS(60); Game g; From 08c5c086690e2cc5ebe4eb1ab2193314c82c370b Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Thu, 6 Feb 2025 19:44:48 -0500 Subject: [PATCH 09/51] What the heck --- game.c | 76 ++++++++++++++++++++++++++++++++-------------------------- game.h | 2 ++ play.c | 26 ++++++++++++++++++++ play.h | 10 ++++++++ 4 files changed, 80 insertions(+), 34 deletions(-) create mode 100644 play.c create mode 100644 play.h diff --git a/game.c b/game.c index 3f5f408..f59f320 100644 --- a/game.c +++ b/game.c @@ -53,7 +53,7 @@ void initialize_game(Game *g) { case 41: t = ANIMAL; break; } - g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false, false }; + g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false }; g->cards[i].move.end_time = 0.; g->cards[i].move.position = &g->cards[i].position; g->cards[i].move.destination = (Vector2) { 800, 400 }; @@ -86,37 +86,22 @@ void initialize_game(Game *g) { bool stale_calculation = true; void handle_input(Game *g) { - if (IsMouseButtonPressed(0)) { - mouse_pos = GetMousePosition(); - for (int i = 0; i < 48; i++) { - if (point_within_card(&g->cards[i], mouse_pos)) { - g->cards[i].selected = !g->cards[i].selected; - stale_calculation = true; - break; + switch (g->state) { + case GAME_STATE_PLAYER_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)) { + // g->selected_card = g->player_hand.cards[i]; + break; + } } } - } -} - -void run_calculation(Game *g) { - int num_selected = 0; - if (stale_calculation) { - Hand h; - h.count = 0; - for (int i = 0; i < 48; i++) { - num_selected += g->cards[i].selected; - if (g->cards[i].selected) h.cards[h.count++] = &g->cards[i]; - } - - if (num_selected == 7) { - Teyaku t; - calculate_teyaku(h, &t); - teyaku_to_string(&t, teyaku_calculation); - } else { - strcpy(teyaku_calculation, ""); - } - - stale_calculation = false; + break; + case GAME_STATE_PLAYER_CHOOSING_TARGET: + break; + default: + break; } } @@ -149,10 +134,18 @@ void run_frame_calculating_field_multiplier(Game *g) { void run_frame_calculating_teyaku(Game *g) { calculate_teyaku(g->player_hand, &g->player_teyaku); - g->state = GAME_STATE_INITIALIZING; + // g->selected_card = NULL; + g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; +} + +void run_frame_player_choosing_from_hand(Game *g) { +} +void run_frame_player_choosing_target(Game *g) { } void run_frame(Game *g) { + handle_input(g); + float delta = GetFrameTime(); bool done_moving = true; for (int i = 0; i < 48; i++) { @@ -161,8 +154,6 @@ void run_frame(Game *g) { } if (!done_moving) return; - handle_input(g); - switch (g->state) { case GAME_STATE_INITIALIZING: return; @@ -175,8 +166,13 @@ 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); + break; + case GAME_STATE_PLAYER_CHOOSING_TARGET: + run_frame_player_choosing_target(g); + break; } - run_calculation(g); } void draw_frame(Game *g) { @@ -192,6 +188,18 @@ void draw_frame(Game *g) { teyaku_to_string(&g->player_teyaku, s); DrawText(s, 5, 25, 30, BLACK); } + + switch (g->state) { + case GAME_STATE_PLAYER_CHOOSING_FROM_HAND: + DrawText("Choose a card to play", 60, 485, 40, BLACK); + break; + case GAME_STATE_PLAYER_CHOOSING_TARGET: + DrawText("Choose a target on the field", 60, 485, 40, BLACK); + break; + default: + break; + } + EndDrawing(); } diff --git a/game.h b/game.h index c406708..bbaf9e5 100644 --- a/game.h +++ b/game.h @@ -14,6 +14,8 @@ 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, } GameState; struct Game { diff --git a/play.c b/play.c new file mode 100644 index 0000000..4d777eb --- /dev/null +++ b/play.c @@ -0,0 +1,26 @@ +#include +#include +#include "play.h" + +bool valid_play(Hand *field, Card *played, Card *target) { + if (target == NULL) { + bool matching_month_in_field = false; + for (int i = 0; i < field->count; i++) { + if (field->cards[i]->month == target->month) { + matching_month_in_field = true; + break; + } + } + return !matching_month_in_field; + } else { + bool target_in_field = false; + for (int i = 0; i < field->count; i++) { + if (field->cards[i]->index == target->index) { + target_in_field = true; + break; + } + } + if (!target_in_field) return false; + return played->month == target->month; + } +} diff --git a/play.h b/play.h new file mode 100644 index 0000000..81cfdf1 --- /dev/null +++ b/play.h @@ -0,0 +1,10 @@ +#ifndef _HF_PLAY_ +#define _HF_PLAY_ + +#include + +#include "card.h" + +bool valid_play(Hand *field, Card *played, Card *target); + +#endif From 028da65317b7df9710836cf11e19fecbd19d2414 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Fri, 7 Feb 2025 19:07:17 -0500 Subject: [PATCH 10/51] Allow player to choose their cards --- game.c | 44 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/game.c b/game.c index f59f320..6c110f3 100644 --- a/game.c +++ b/game.c @@ -92,13 +92,33 @@ void handle_input(Game *g) { mouse_pos = GetMousePosition(); for (int i = 0; i < g->player_hand.count; i++) { if (point_within_card(g->player_hand.cards[i], mouse_pos)) { - // g->selected_card = g->player_hand.cards[i]; + for (int j = 0; j < 48; j++) { + g->cards[j].selected = false; + } + g->player_hand.cards[i]->selected = true; break; } } } break; case GAME_STATE_PLAYER_CHOOSING_TARGET: + if (IsMouseButtonPressed(0)) { + mouse_pos = GetMousePosition(); + bool clicked_hand_card = false; + for (int i = 0; i < g->player_hand.count; i++) { + if (point_within_card(g->player_hand.cards[i], mouse_pos)) { + clicked_hand_card = true; + 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; + } + } + } + } break; default: break; @@ -134,13 +154,33 @@ void run_frame_calculating_field_multiplier(Game *g) { void run_frame_calculating_teyaku(Game *g) { calculate_teyaku(g->player_hand, &g->player_teyaku); - // g->selected_card = NULL; + for (int i = 0; i < 48; i++) { + g->cards[i].selected = false; + } 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; + break; + } + } } + void run_frame_player_choosing_target(Game *g) { + bool no_cards_selected = true; + for (int i = 0; i < g->player_hand.count; i++) { + if (g->player_hand.cards[i]->selected) { + no_cards_selected = false; + break; + } + } + + if (no_cards_selected) { + g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; + } } void run_frame(Game *g) { From 3bac02c752ca2e4739f0cce13aae63c46801e27f Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 8 Feb 2025 07:33:23 -0500 Subject: [PATCH 11/51] Draw a target for playing a nonmatching card --- card.c | 11 ++++++++++- card.h | 1 + game.c | 5 +++-- 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/card.c b/card.c index fc8f936..5a7fbf2 100644 --- a/card.c +++ b/card.c @@ -62,7 +62,7 @@ void add_to_hand(Hand *h, Card *c) { } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; - c->move.end_time = 0.5; + c->move.end_time = 0.1; h->count++; } @@ -79,3 +79,12 @@ void deal(Hand *from, Hand *to, int count, bool up) { from->count--; } } + +Rectangle next_card_position(Hand *h) { + return (Rectangle) { + h->position.x + ((h->count / 2) * (CARD_WIDTH + 10)), + h->position.y + (h->count % 2 * (CARD_HEIGHT + 10)), + CARD_WIDTH, + CARD_HEIGHT + }; +} diff --git a/card.h b/card.h index eb9575a..b949f60 100644 --- a/card.h +++ b/card.h @@ -75,5 +75,6 @@ bool point_within_card(Card *c, Vector2 v); void shuffle_hand(Hand *h); void deal(Hand *from, Hand *to, int count, bool up); bool card_done_moving(Card *c); +Rectangle next_card_position(Hand *h); #endif diff --git a/game.c b/game.c index 6c110f3..65060c7 100644 --- a/game.c +++ b/game.c @@ -231,10 +231,11 @@ void draw_frame(Game *g) { switch (g->state) { case GAME_STATE_PLAYER_CHOOSING_FROM_HAND: - DrawText("Choose a card to play", 60, 485, 40, BLACK); + 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, 40, BLACK); + DrawText("Choose a target on the field", 60, 485, 20, BLACK); + DrawRectangleRec(next_card_position(&g->field), BLUE); break; default: break; From 19fcbb48874bf01b1f33c88586f48b8c1655516b Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 8 Feb 2025 07:55:28 -0500 Subject: [PATCH 12/51] Judge attempted playes from the player --- game.c | 28 ++++++++++++++++++++++++++++ play.c | 2 +- 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/game.c b/game.c index 65060c7..1737c17 100644 --- a/game.c +++ b/game.c @@ -6,6 +6,7 @@ #include "teyaku.h" #include "dekiyaku.h" #include "field_multiplier.h" +#include "play.h" Vector2 mouse_pos; char teyaku_calculation[400]; @@ -118,6 +119,33 @@ void handle_input(Game *g) { } } } + + 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])) { + printf("Valid\n"); + } else { + printf("Invalid\n"); + } + } + } + + if (CheckCollisionPointRec(mouse_pos, next_card_position(&g->field))) { + if (valid_play(&g->field, selected_card, NULL)) { + printf("Valid\n"); + } else { + printf("Invalid\n"); + } + } } break; default: diff --git a/play.c b/play.c index 4d777eb..d12c362 100644 --- a/play.c +++ b/play.c @@ -6,7 +6,7 @@ bool valid_play(Hand *field, Card *played, Card *target) { if (target == NULL) { bool matching_month_in_field = false; for (int i = 0; i < field->count; i++) { - if (field->cards[i]->month == target->month) { + if (field->cards[i]->month == played->month) { matching_month_in_field = true; break; } From ec9d0e500719d694a9d67d991bfad6ad9a52316b Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 8 Feb 2025 08:15:43 -0500 Subject: [PATCH 13/51] Make plays!! --- card.c | 9 +++++++++ game.c | 36 +++++++++++++++++++++++++++++++++++- game.h | 5 ++++- 3 files changed, 48 insertions(+), 2 deletions(-) diff --git a/card.c b/card.c index 5a7fbf2..1dc2e02 100644 --- a/card.c +++ b/card.c @@ -44,6 +44,15 @@ void shuffle_hand(Hand *h) { } } +void remove_from_hand(Hand *h, Card *c) { + bool card_found = false; + for (int i = 0; i < h->count - 1; i++) { + if (h->cards[i] == c) card_found = true; + h->cards[i] = h->cards[i + 1]; + } + h->count--; +} + void add_to_hand(Hand *h, Card *c) { h->cards[h->count] = c; diff --git a/game.c b/game.c index 1737c17..517c218 100644 --- a/game.c +++ b/game.c @@ -76,6 +76,15 @@ void initialize_game(Game *g) { g->field.count = 0; g->field.position = (Vector2) { 400, 300 }; g->field.display_type = HAND_DISPLAY_FIELD; + g->player_scored.count = 0; + g->player_scored.position = (Vector2) { 300, 750 }; + g->player_scored.display_type = HAND_DISPLAY_ROW; + g->right_scored.count = 0; + g->right_scored.position = (Vector2) { 50, 25 }; + g->right_scored.display_type = HAND_DISPLAY_ROW; + g->left_scored.count = 0; + g->left_scored.position = (Vector2) { 750, 25 }; + g->left_scored.display_type = HAND_DISPLAY_ROW; strcpy(teyaku_calculation, ""); @@ -132,7 +141,10 @@ void handle_input(Game *g) { 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]; printf("Valid\n"); + break; } else { printf("Invalid\n"); } @@ -141,6 +153,8 @@ void handle_input(Game *g) { 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; printf("Valid\n"); } else { printf("Invalid\n"); @@ -192,9 +206,10 @@ 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; - break; + return; } } + } void run_frame_player_choosing_target(Game *g) { @@ -208,6 +223,25 @@ void run_frame_player_choosing_target(Game *g) { if (no_cards_selected) { g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; + return; + } + + if (g->current_play_from_hand) { + if (g->current_play_target) { + g->current_play_from_hand->selected = false; + remove_from_hand(&g->player_hand, g->current_play_from_hand); + add_to_hand(&g->player_scored, g->current_play_from_hand); + remove_from_hand(&g->field, g->current_play_target); + add_to_hand(&g->player_scored, g->current_play_target); + 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->current_play_from_hand = NULL; + } + g->state = GAME_STATE_INITIALIZING; } } diff --git a/game.h b/game.h index bbaf9e5..bc309cd 100644 --- a/game.h +++ b/game.h @@ -23,9 +23,12 @@ struct Game { bool should_close; Card cards[48]; Texture2D cards_texture; - Hand player_hand, left_hand, right_hand, deck, field; + Hand player_hand, left_hand, right_hand; + Hand deck, field; + Hand player_scored, left_scored, right_scored; FieldMultiplier *field_multiplier; Teyaku player_teyaku, left_teyaku, right_teyaku; + Card *current_play_from_hand, *current_play_target; }; void initialize_game(Game *g); From 892fc32efaf4eda3e401ef98952f4d7d857e81ec Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Mon, 10 Feb 2025 17:27:02 -0500 Subject: [PATCH 14/51] The deck now knows where it is --- card.c | 19 ++++++++++++++----- card.h | 1 + game.c | 36 ++++++++++++++++++++++++++++++++++-- game.h | 1 + play.c | 10 ++++++++++ play.h | 1 + 6 files changed, 61 insertions(+), 7 deletions(-) diff --git a/card.c b/card.c index 1dc2e02..82fad22 100644 --- a/card.c +++ b/card.c @@ -48,25 +48,34 @@ void remove_from_hand(Hand *h, Card *c) { bool card_found = false; for (int i = 0; i < h->count - 1; i++) { if (h->cards[i] == c) card_found = true; - h->cards[i] = h->cards[i + 1]; + if (card_found) h->cards[i] = h->cards[i + 1]; } h->count--; } void add_to_hand(Hand *h, Card *c) { - h->cards[h->count] = c; + int i = 0; + for (; i < h->count; i++) { + if (h->cards[i] == NULL) break; + } + + h->cards[i] = c; c->move.position = &c->position; c->move.origin.x = c->position.x; c->move.origin.y = c->position.y; switch (h->display_type) { case HAND_DISPLAY_ROW: - c->move.destination.x = h->position.x + (h->count * (CARD_WIDTH + 10)); + c->move.destination.x = h->position.x + (i * (CARD_WIDTH + 10)); c->move.destination.y = h->position.y; break; case HAND_DISPLAY_FIELD: - c->move.destination.x = h->position.x + ((h->count / 2) * (CARD_WIDTH + 10)); - c->move.destination.y = h->position.y + (h->count % 2 * (CARD_HEIGHT + 10)); + c->move.destination.x = h->position.x + ((i / 2) * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y + (i % 2 * (CARD_HEIGHT + 10)); + break; + case HAND_DISPLAY_DECK: + c->move.destination.x = h->position.x; + c->move.destination.y = h->position.y; break; } c->move.curve = CURVE_EASE_IN_OUT; diff --git a/card.h b/card.h index b949f60..ea0b755 100644 --- a/card.h +++ b/card.h @@ -61,6 +61,7 @@ struct Card { typedef enum HandDisplayType { HAND_DISPLAY_ROW, HAND_DISPLAY_FIELD, + HAND_DISPLAY_DECK, } HandDisplayType; struct Hand { diff --git a/game.c b/game.c index 517c218..39e78f0 100644 --- a/game.c +++ b/game.c @@ -13,6 +13,8 @@ char teyaku_calculation[400]; void initialize_game(Game *g) { g->deck.count = 0; + g->deck.position = (Vector2) { 800, 400 }; + g->deck.display_type = HAND_DISPLAY_DECK; g->should_close = false; g->state = GAME_STATE_INITIALIZING; g->field_multiplier = NULL; @@ -144,10 +146,10 @@ void handle_input(Game *g) { g->current_play_from_hand = selected_card; g->current_play_target = g->field.cards[i]; printf("Valid\n"); - break; } else { printf("Invalid\n"); } + break; } } @@ -209,7 +211,6 @@ void run_frame_player_choosing_from_hand(Game *g) { return; } } - } void run_frame_player_choosing_target(Game *g) { @@ -241,7 +242,35 @@ 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; + } +} + +void run_frame_player_from_deck(Game *g) { + Card *top_card = g->deck.cards[g->deck.count - 1]; + if (top_card->visible) { + printf("flipped\n"); + // if the card's already been flipped up + Card *target = valid_target(top_card, &g->field); + if (target) { + remove_from_hand(&g->field, target); + add_to_hand(&g->player_scored, target); + remove_from_hand(&g->deck, top_card); + add_to_hand(&g->player_scored, top_card); + } else { + remove_from_hand(&g->deck, top_card); + add_to_hand(&g->field, top_card); + } g->state = GAME_STATE_INITIALIZING; + } else { + printf("flip top\n"); + // flip up the top card + 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; + printf("moving to %f %f\n", top_card->move.destination.x, top_card->move.destination.y); } } @@ -274,6 +303,9 @@ void run_frame(Game *g) { case GAME_STATE_PLAYER_CHOOSING_TARGET: run_frame_player_choosing_target(g); break; + case GAME_STATE_PLAYER_FROM_DECK: + run_frame_player_from_deck(g); + break; } } diff --git a/game.h b/game.h index bc309cd..bc219db 100644 --- a/game.h +++ b/game.h @@ -16,6 +16,7 @@ typedef enum GameState { GAME_STATE_CALCULATING_TEYAKU, GAME_STATE_PLAYER_CHOOSING_FROM_HAND, GAME_STATE_PLAYER_CHOOSING_TARGET, + GAME_STATE_PLAYER_FROM_DECK, } GameState; struct Game { diff --git a/play.c b/play.c index d12c362..f4c66f1 100644 --- a/play.c +++ b/play.c @@ -24,3 +24,13 @@ bool valid_play(Hand *field, Card *played, Card *target) { return played->month == target->month; } } + +Card *valid_target(Card *active, Hand *field) { + for (int i = 0; i < field->count; i++) { + if (field->cards[i]->month == active->month) { + return field->cards[i]; + } + } + + return NULL; +} diff --git a/play.h b/play.h index 81cfdf1..b67c40b 100644 --- a/play.h +++ b/play.h @@ -6,5 +6,6 @@ #include "card.h" bool valid_play(Hand *field, Card *played, Card *target); +Card *valid_target(Card *active, Hand *field); #endif From 98ba7fb67062360f24d57884e595dbd28887b147 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Wed, 12 Feb 2025 16:45:31 -0500 Subject: [PATCH 15/51] Cards no longer try to lay on top of each other --- card.c | 30 +++++++++++++++++++++++------- card.h | 3 +++ game.c | 10 +--------- 3 files changed, 27 insertions(+), 16 deletions(-) diff --git a/card.c b/card.c index 82fad22..c378d1a 100644 --- a/card.c +++ b/card.c @@ -54,24 +54,40 @@ void remove_from_hand(Hand *h, Card *c) { } void add_to_hand(Hand *h, Card *c) { - int i = 0; - for (; i < h->count; i++) { - if (h->cards[i] == NULL) break; + int order_guy[48]; + int order_guy_count = 0; + + for (int i = 0; i < 48; i++) { + order_guy[i] = 0; } - h->cards[i] = c; + for (int i = 0; i < h->count; i++) { + if (h->cards[i] == NULL) continue; + order_guy[h->cards[i]->order] = 1; + order_guy_count++; + } + + int first_open_spot = h->count; + for (int i = 0; i < order_guy_count; i++) { + if (order_guy[i]) continue; + first_open_spot = i; + break; + } + + c->order = first_open_spot; + h->cards[h->count] = c; c->move.position = &c->position; c->move.origin.x = c->position.x; c->move.origin.y = c->position.y; switch (h->display_type) { case HAND_DISPLAY_ROW: - c->move.destination.x = h->position.x + (i * (CARD_WIDTH + 10)); + c->move.destination.x = h->position.x + (first_open_spot * (CARD_WIDTH + 10)); c->move.destination.y = h->position.y; break; case HAND_DISPLAY_FIELD: - c->move.destination.x = h->position.x + ((i / 2) * (CARD_WIDTH + 10)); - c->move.destination.y = h->position.y + (i % 2 * (CARD_HEIGHT + 10)); + c->move.destination.x = h->position.x + ((first_open_spot / 2) * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y + (first_open_spot % 2 * (CARD_HEIGHT + 10)); break; case HAND_DISPLAY_DECK: c->move.destination.x = h->position.x; diff --git a/card.h b/card.h index ea0b755..85570e6 100644 --- a/card.h +++ b/card.h @@ -56,6 +56,7 @@ struct Card { bool selected; bool visible; Move move; + int order; }; typedef enum HandDisplayType { @@ -75,6 +76,8 @@ void draw_card(Card *c, Texture2D *cards_texture); bool point_within_card(Card *c, Vector2 v); void shuffle_hand(Hand *h); void deal(Hand *from, Hand *to, int count, bool up); +void remove_from_hand(Hand *h, Card *c); +void add_to_hand(Hand *h, Card *c); bool card_done_moving(Card *c); Rectangle next_card_position(Hand *h); diff --git a/game.c b/game.c index 39e78f0..d46b1a6 100644 --- a/game.c +++ b/game.c @@ -60,6 +60,7 @@ void initialize_game(Game *g) { g->cards[i].move.end_time = 0.; g->cards[i].move.position = &g->cards[i].position; g->cards[i].move.destination = (Vector2) { 800, 400 }; + g->cards[i].order = i; g->deck.cards[i] = &g->cards[i]; g->deck.count++; } @@ -116,10 +117,8 @@ void handle_input(Game *g) { case GAME_STATE_PLAYER_CHOOSING_TARGET: if (IsMouseButtonPressed(0)) { mouse_pos = GetMousePosition(); - bool clicked_hand_card = false; for (int i = 0; i < g->player_hand.count; i++) { if (point_within_card(g->player_hand.cards[i], mouse_pos)) { - clicked_hand_card = true; if (g->player_hand.cards[i]->selected) { g->player_hand.cards[i]->selected = false; } else { @@ -145,7 +144,6 @@ void handle_input(Game *g) { 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]; - printf("Valid\n"); } else { printf("Invalid\n"); } @@ -157,7 +155,6 @@ void handle_input(Game *g) { if (valid_play(&g->field, selected_card, NULL)) { g->current_play_from_hand = selected_card; g->current_play_target = NULL; - printf("Valid\n"); } else { printf("Invalid\n"); } @@ -249,8 +246,6 @@ void run_frame_player_choosing_target(Game *g) { void run_frame_player_from_deck(Game *g) { Card *top_card = g->deck.cards[g->deck.count - 1]; if (top_card->visible) { - printf("flipped\n"); - // if the card's already been flipped up Card *target = valid_target(top_card, &g->field); if (target) { remove_from_hand(&g->field, target); @@ -263,14 +258,11 @@ void run_frame_player_from_deck(Game *g) { } g->state = GAME_STATE_INITIALIZING; } else { - printf("flip top\n"); - // flip up the top card 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; - printf("moving to %f %f\n", top_card->move.destination.x, top_card->move.destination.y); } } From 49af79f93295f2d4e347604a7cdd3b79b0ccb580 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 15 Feb 2025 15:10:26 -0500 Subject: [PATCH 16/51] Play through en entire game!! --- card.c | 2 +- game.c | 107 ++++++++++++++++++++++++++++++++++++++++++++------------- game.h | 4 +++ play.c | 10 ++++++ play.h | 8 +++++ 5 files changed, 106 insertions(+), 25 deletions(-) diff --git a/card.c b/card.c index c378d1a..b4753a6 100644 --- a/card.c +++ b/card.c @@ -96,7 +96,7 @@ void add_to_hand(Hand *h, Card *c) { } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; - c->move.end_time = 0.1; + c->move.end_time = 0.5; h->count++; } diff --git a/game.c b/game.c index d46b1a6..fd8973a 100644 --- a/game.c +++ b/game.c @@ -71,10 +71,10 @@ void initialize_game(Game *g) { g->player_hand.position = (Vector2) { 300, 600 }; g->player_hand.display_type = HAND_DISPLAY_ROW; g->right_hand.count = 0; - g->right_hand.position = (Vector2) { 50, 125 }; + g->right_hand.position = (Vector2) { 750, 125 }; g->right_hand.display_type = HAND_DISPLAY_ROW; g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 750, 125 }; + g->left_hand.position = (Vector2) { 50, 125 }; g->left_hand.display_type = HAND_DISPLAY_ROW; g->field.count = 0; g->field.position = (Vector2) { 400, 300 }; @@ -83,10 +83,10 @@ void initialize_game(Game *g) { g->player_scored.position = (Vector2) { 300, 750 }; g->player_scored.display_type = HAND_DISPLAY_ROW; g->right_scored.count = 0; - g->right_scored.position = (Vector2) { 50, 25 }; + g->right_scored.position = (Vector2) { 750, 25 }; g->right_scored.display_type = HAND_DISPLAY_ROW; g->left_scored.count = 0; - g->left_scored.position = (Vector2) { 750, 25 }; + g->left_scored.position = (Vector2) { 50, 25 }; g->left_scored.display_type = HAND_DISPLAY_ROW; strcpy(teyaku_calculation, ""); @@ -166,6 +166,47 @@ 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, Hand *scored) { + Play play = ai_play(hand, &g->field); + if (play.target) printf("Playing %d on %d\n", play.played->index, play.target->index); + else printf("Playing %d on field\n", play.played->index); + play.played->visible = true; + + if (play.target) { + remove_from_hand(hand, play.played); + add_to_hand(scored, play.played); + remove_from_hand(&g->field, play.target); + add_to_hand(scored, play.target); + } else { + remove_from_hand(hand, play.played); + add_to_hand(&g->field, play.played); + } +} + void run_frame_dealing(Game *g) { if (g->player_hand.count < 4) { deal(&g->deck, &g->player_hand, 4, true); @@ -244,26 +285,32 @@ void run_frame_player_choosing_target(Game *g) { } void run_frame_player_from_deck(Game *g) { - 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(&g->player_scored, target); - remove_from_hand(&g->deck, top_card); - add_to_hand(&g->player_scored, top_card); - } else { - remove_from_hand(&g->deck, top_card); - add_to_hand(&g->field, top_card); - } - g->state = GAME_STATE_INITIALIZING; - } 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; - } + if (run_frame_from_deck(g, &g->right_hand)) + g->state = GAME_STATE_RIGHT_PLAYING; +} + +void run_frame_right_playing(Game *g) { + printf("right play\n"); + 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) { + printf("right deck\n"); + if (run_frame_from_deck(g, &g->right_scored)) + g->state = GAME_STATE_LEFT_PLAYING; +} + +void run_frame_left_playing(Game *g) { + printf("left play\n"); + 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) { + printf("left deck\n"); + if (run_frame_from_deck(g, &g->left_scored)) + g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; } void run_frame(Game *g) { @@ -298,6 +345,18 @@ void run_frame(Game *g) { case GAME_STATE_PLAYER_FROM_DECK: run_frame_player_from_deck(g); break; + case GAME_STATE_RIGHT_PLAYING: + run_frame_right_playing(g); + break; + case GAME_STATE_RIGHT_FROM_DECK: + run_frame_right_from_deck(g); + break; + case GAME_STATE_LEFT_PLAYING: + run_frame_left_playing(g); + break; + case GAME_STATE_LEFT_FROM_DECK: + run_frame_left_from_deck(g); + break; } } diff --git a/game.h b/game.h index bc219db..907aa70 100644 --- a/game.h +++ b/game.h @@ -17,6 +17,10 @@ typedef enum GameState { GAME_STATE_PLAYER_CHOOSING_FROM_HAND, GAME_STATE_PLAYER_CHOOSING_TARGET, GAME_STATE_PLAYER_FROM_DECK, + GAME_STATE_RIGHT_PLAYING, + GAME_STATE_RIGHT_FROM_DECK, + GAME_STATE_LEFT_PLAYING, + GAME_STATE_LEFT_FROM_DECK, } GameState; struct Game { diff --git a/play.c b/play.c index f4c66f1..49f8181 100644 --- a/play.c +++ b/play.c @@ -34,3 +34,13 @@ Card *valid_target(Card *active, Hand *field) { return NULL; } + +Play ai_play(Hand *hand, Hand *field) { + // very naive play initially + Card *played = hand->cards[0]; + for (int i = 0; i < field->count; i++) { + Card *target = field->cards[i]; + if (valid_play(field, played, target)) return (Play) { played, target }; + } + return (Play) { played, NULL }; +} diff --git a/play.h b/play.h index b67c40b..c580c45 100644 --- a/play.h +++ b/play.h @@ -3,9 +3,17 @@ #include +typedef struct Play Play; + #include "card.h" +struct Play { + Card *played; + Card *target; +}; + bool valid_play(Hand *field, Card *played, Card *target); Card *valid_target(Card *active, Hand *field); +Play ai_play(Hand *hand, Hand *field); #endif From 05e34e2fbb770184dd9224cff89de40b5e03eeab Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 15 Feb 2025 15:48:34 -0500 Subject: [PATCH 17/51] Put cards in the right place ha haaaaa --- card.c | 4 ++++ card.h | 1 + game.c | 14 ++++---------- 3 files changed, 9 insertions(+), 10 deletions(-) diff --git a/card.c b/card.c index b4753a6..0f3bac4 100644 --- a/card.c +++ b/card.c @@ -93,6 +93,10 @@ void add_to_hand(Hand *h, Card *c) { c->move.destination.x = h->position.x; c->move.destination.y = h->position.y; break; + case HAND_DISPLAY_SCORED: + c->move.destination.x = h->position.x + (first_open_spot * (CARD_WIDTH - 10)); + c->move.destination.y = h->position.y; + break; } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; diff --git a/card.h b/card.h index 85570e6..69d79d9 100644 --- a/card.h +++ b/card.h @@ -63,6 +63,7 @@ typedef enum HandDisplayType { HAND_DISPLAY_ROW, HAND_DISPLAY_FIELD, HAND_DISPLAY_DECK, + HAND_DISPLAY_SCORED, } HandDisplayType; struct Hand { diff --git a/game.c b/game.c index fd8973a..14f93fa 100644 --- a/game.c +++ b/game.c @@ -81,13 +81,13 @@ void initialize_game(Game *g) { g->field.display_type = HAND_DISPLAY_FIELD; g->player_scored.count = 0; g->player_scored.position = (Vector2) { 300, 750 }; - g->player_scored.display_type = HAND_DISPLAY_ROW; + g->player_scored.display_type = HAND_DISPLAY_SCORED; g->right_scored.count = 0; g->right_scored.position = (Vector2) { 750, 25 }; - g->right_scored.display_type = HAND_DISPLAY_ROW; + g->right_scored.display_type = HAND_DISPLAY_SCORED; g->left_scored.count = 0; g->left_scored.position = (Vector2) { 50, 25 }; - g->left_scored.display_type = HAND_DISPLAY_ROW; + g->left_scored.display_type = HAND_DISPLAY_SCORED; strcpy(teyaku_calculation, ""); @@ -192,8 +192,6 @@ bool run_frame_from_deck(Game *g, Hand *to_hand) { void run_frame_ai_playing(Game *g, Hand *hand, Hand *scored) { Play play = ai_play(hand, &g->field); - if (play.target) printf("Playing %d on %d\n", play.played->index, play.target->index); - else printf("Playing %d on field\n", play.played->index); play.played->visible = true; if (play.target) { @@ -285,30 +283,26 @@ void run_frame_player_choosing_target(Game *g) { } void run_frame_player_from_deck(Game *g) { - if (run_frame_from_deck(g, &g->right_hand)) + if (run_frame_from_deck(g, &g->player_scored)) g->state = GAME_STATE_RIGHT_PLAYING; } void run_frame_right_playing(Game *g) { - printf("right play\n"); 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) { - printf("right deck\n"); if (run_frame_from_deck(g, &g->right_scored)) g->state = GAME_STATE_LEFT_PLAYING; } void run_frame_left_playing(Game *g) { - printf("left play\n"); 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) { - printf("left deck\n"); if (run_frame_from_deck(g, &g->left_scored)) g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; } From fbddc6018857734884d05a1e3c2b59cbdcd2ed5c Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 15 Feb 2025 15:51:53 -0500 Subject: [PATCH 18/51] Remove warnings --- field_multiplier.c | 6 +++++- field_multiplier.h | 6 +----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/field_multiplier.c b/field_multiplier.c index fca83f8..6d0a38e 100644 --- a/field_multiplier.c +++ b/field_multiplier.c @@ -3,7 +3,11 @@ #include "field_multiplier.h" #include "card.h" -const FieldMultiplier *calculate_field_multiplier(Hand *h) { +static FieldMultiplier small_field = { "Small Field", 1 }; +static FieldMultiplier large_field = { "Large Field", 2 }; +static FieldMultiplier grand_field = { "Grand Field", 4 }; + +FieldMultiplier *calculate_field_multiplier(Hand *h) { bool large = false; for (int i = 0; i < h->count; i++) { Card *c = h->cards[i]; diff --git a/field_multiplier.h b/field_multiplier.h index 8b3e1f3..c9ea8a2 100644 --- a/field_multiplier.h +++ b/field_multiplier.h @@ -10,10 +10,6 @@ struct FieldMultiplier { int value; }; -static const FieldMultiplier small_field = { "Small Field", 1 }; -static const FieldMultiplier large_field = { "Large Field", 2 }; -static const FieldMultiplier grand_field = { "Grand Field", 4 }; - -const FieldMultiplier *calculate_field_multiplier(Hand *h); +FieldMultiplier *calculate_field_multiplier(Hand *h); #endif From 41afbf956fead9aa0dde78439ee6292ec050e33d Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 16 Feb 2025 09:11:50 -0500 Subject: [PATCH 19/51] Calculate points when the game is over --- game.c | 17 +++++++++++++++-- game.h | 2 ++ points.c | 23 +++++++++++++++++++++++ points.h | 8 ++++++++ special_cases.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ special_cases.h | 30 ++++++++++++++++++++++++++++++ 6 files changed, 126 insertions(+), 2 deletions(-) create mode 100644 points.c create mode 100644 points.h create mode 100644 special_cases.c create mode 100644 special_cases.h diff --git a/game.c b/game.c index 14f93fa..2f40e64 100644 --- a/game.c +++ b/game.c @@ -303,8 +303,18 @@ void run_frame_left_playing(Game *g) { } void run_frame_left_from_deck(Game *g) { - if (run_frame_from_deck(g, &g->left_scored)) - g->state = GAME_STATE_PLAYER_CHOOSING_FROM_HAND; + 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)); + g->state = GAME_STATE_INITIALIZING; } void run_frame(Game *g) { @@ -351,6 +361,9 @@ void run_frame(Game *g) { case GAME_STATE_LEFT_FROM_DECK: run_frame_left_from_deck(g); break; + case GAME_STATE_CALCULATING_SCORES: + run_frame_calculating_scores(g); + break; } } diff --git a/game.h b/game.h index 907aa70..c07b4b0 100644 --- a/game.h +++ b/game.h @@ -8,6 +8,7 @@ typedef struct Game Game; #include "card.h" #include "field_multiplier.h" #include "teyaku.h" +#include "points.h" typedef enum GameState { GAME_STATE_INITIALIZING, @@ -21,6 +22,7 @@ typedef enum GameState { GAME_STATE_RIGHT_FROM_DECK, GAME_STATE_LEFT_PLAYING, GAME_STATE_LEFT_FROM_DECK, + GAME_STATE_CALCULATING_SCORES, } GameState; struct Game { diff --git a/points.c b/points.c new file mode 100644 index 0000000..7483b04 --- /dev/null +++ b/points.c @@ -0,0 +1,23 @@ +#include "points.h" +int hand_points(Hand *hand) { + int points = 0; + for (int i = 0; i < hand->count; i++) { + Card *c = hand->cards[i]; + switch (c->type) { + case CHAFF: + points += 1; + break; + case RIBBON: + points += 5; + break; + case ANIMAL: + points += 10; + break; + case BRIGHT: + points += 20; + break; + } + } + + return points - 88; +} diff --git a/points.h b/points.h new file mode 100644 index 0000000..cd77d8e --- /dev/null +++ b/points.h @@ -0,0 +1,8 @@ +#ifndef _HF_POINTS_ +#define _HF_POINTS_ + +#include "card.h" + +int hand_points(Hand *hand); + +#endif diff --git a/special_cases.c b/special_cases.c new file mode 100644 index 0000000..6ca47e9 --- /dev/null +++ b/special_cases.c @@ -0,0 +1,48 @@ +#include "game.h" +#include "card.h" +#include "points.h" +#include "special_cases.h" + +int hand_count_chaff(Hand *hand) { + int chaff = 0; + for (int i = 0; i < hand->count; i++) { + Card *c = hand->cards[i]; + if (c->type == CHAFF || c->month == NOVEMBER) chaff++; + } + return chaff; +} + +SpecialCase calculate_special_case(Game *g) { + int player_points = hand_points(&g->player_scored); + int right_points = hand_points(&g->right_scored); + int left_points = hand_points(&g->left_scored); + + if (player_points == 0 && + right_points == 0 && + left_points == 0) { + return (SpecialCase) { SPECIAL_CASE_ALL_EIGHTS, SPECIAL_CASE_TARGET_DEALER, 10 }; + } + + if (player_points >= 80) + return (SpecialCase) { SPECIAL_CASE_DOUBLE_EIGHTS, SPECIAL_CASE_TARGET_PLAYER, player_points - 70 }; + if (right_points >= 80) + return (SpecialCase) { SPECIAL_CASE_DOUBLE_EIGHTS, SPECIAL_CASE_TARGET_RIGHT, right_points - 70 }; + if (left_points >= 80) + + return (SpecialCase) { SPECIAL_CASE_DOUBLE_EIGHTS, SPECIAL_CASE_TARGET_LEFT, left_points - 70 }; + + int player_chaff = hand_count_chaff(&g->player_scored); + if (player_chaff >= 16) + return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_PLAYER, (2 * player_chaff) - 20 }; + + int right_chaff = hand_count_chaff(&g->right_scored); + if (right_chaff >= 16) + return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_RIGHT, (2 * right_chaff) - 20 }; + + int left_chaff = hand_count_chaff(&g->left_scored); + if (left_chaff >= 16) + return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_LEFT, (2 * left_chaff) - 20 }; + + return (SpecialCase) { SPECIAL_CASE_NONE, SPECIAL_CASE_TARGET_NONE, 0 }; +} + diff --git a/special_cases.h b/special_cases.h new file mode 100644 index 0000000..ed89dfe --- /dev/null +++ b/special_cases.h @@ -0,0 +1,30 @@ +#ifndef _HF_SPECIAL_CASES_ +#define _HF_SPECIAL_CASES_ + +typedef struct SpecialCase SpecialCase; +typedef enum SpecialCaseType { + SPECIAL_CASE_NONE, + SPECIAL_CASE_ALL_EIGHTS, + SPECIAL_CASE_DOUBLE_EIGHTS, + SPECIAL_CASE_SIXTEEN_CHAFF, +} SpecialCaseType; + +typedef enum SpecialCaseTarget { + SPECIAL_CASE_TARGET_NONE, + SPECIAL_CASE_TARGET_DEALER, + SPECIAL_CASE_TARGET_PLAYER, + SPECIAL_CASE_TARGET_RIGHT, + SPECIAL_CASE_TARGET_LEFT, +} SpecialCaseTarget; + +#include "game.h" + +struct SpecialCase { + SpecialCaseType type; + SpecialCaseTarget target; + int score; +}; + +SpecialCase calculate_special_case(Game *g); + +#endif From e4e917ac481309535467174346bb42339e8d87c0 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 16 Feb 2025 09:21:34 -0500 Subject: [PATCH 20/51] Show message for special cases --- game.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/game.c b/game.c index 2f40e64..6a283c1 100644 --- a/game.c +++ b/game.c @@ -6,6 +6,7 @@ #include "teyaku.h" #include "dekiyaku.h" #include "field_multiplier.h" +#include "special_cases.h" #include "play.h" Vector2 mouse_pos; @@ -314,6 +315,19 @@ void run_frame_left_from_deck(Game *g) { 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)); + + SpecialCase special_case = calculate_special_case(g); + switch(special_case.type) { + case SPECIAL_CASE_ALL_EIGHTS: + printf("All eights! Dealer gets %d kan\n", special_case.score); + break; + case SPECIAL_CASE_DOUBLE_EIGHTS: + printf("Double eights! Player %d gets %d kan\n", special_case.target, special_case.score); + break; + case SPECIAL_CASE_SIXTEEN_CHAFF: + printf("Sixteen chaff! Player %d gets %d kan\n", special_case.target, special_case.score); + break; + } g->state = GAME_STATE_INITIALIZING; } From dd9c9fc2d3d7ccac3285812ef6a7663bbe9b4333 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 16 Feb 2025 09:37:53 -0500 Subject: [PATCH 21/51] Make it possible to score points ha haaaaa --- game.c | 38 +++++++++++++++++++++++++++++++++++--- game.h | 4 ++++ 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/game.c b/game.c index 6a283c1..4a297ae 100644 --- a/game.c +++ b/game.c @@ -22,6 +22,10 @@ void initialize_game(Game *g) { g->player_teyaku.calculated = false; g->left_teyaku.calculated = false; g->right_teyaku.calculated = false; + g->player_points = 0; + g->right_points = 0; + g->left_points = 0; + g->kan_value = 12; for (int i = 0; i < 48; i++) { CardType t = CHAFF; RibbonType rt = RIBBON_NONE; @@ -322,10 +326,27 @@ void run_frame_calculating_scores(Game *g) { printf("All eights! Dealer gets %d kan\n", special_case.score); break; case SPECIAL_CASE_DOUBLE_EIGHTS: - printf("Double eights! Player %d gets %d kan\n", special_case.target, special_case.score); - break; case SPECIAL_CASE_SIXTEEN_CHAFF: - printf("Sixteen chaff! Player %d gets %d kan\n", special_case.target, special_case.score); + printf("Double eights or 16 chaff! 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); + 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); + 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); + break; + } + break; + default: + transfer_points(g, &g->player_points, &g->temp_points, hand_points(&g->player_scored)); + transfer_points(g, &g->right_points, &g->temp_points, hand_points(&g->right_scored)); + transfer_points(g, &g->left_points, &g->temp_points, hand_points(&g->left_scored)); break; } g->state = GAME_STATE_INITIALIZING; @@ -416,3 +437,14 @@ void run_until_closing(Game *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); +} diff --git a/game.h b/game.h index c07b4b0..615486f 100644 --- a/game.h +++ b/game.h @@ -36,9 +36,13 @@ struct Game { FieldMultiplier *field_multiplier; Teyaku player_teyaku, left_teyaku, right_teyaku; Card *current_play_from_hand, *current_play_target; + int player_points, right_points, left_points, temp_points; + int kan_value; }; void initialize_game(Game *g); void run_until_closing(Game *g); +void transfer_points(Game *g, int *to, int *from, int amount); +void transfer_kan(Game *g, int *to, int *from, int amount); #endif From 296fa141a3f480c304b45b71d8ce5ac8f1d25a7f Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 16 Feb 2025 20:50:13 -0500 Subject: [PATCH 22/51] A bit of dekiyaku work --- dekiyaku.c | 14 +++++++++++--- dekiyaku.h | 9 ++++++++- game.c | 40 +++++++++++++++++++++++++++++++++++----- game.h | 7 +++++++ points.c | 7 +++++++ points.h | 2 ++ 6 files changed, 70 insertions(+), 9 deletions(-) diff --git a/dekiyaku.c b/dekiyaku.c index fbe6cf3..911b479 100644 --- a/dekiyaku.c +++ b/dekiyaku.c @@ -3,10 +3,10 @@ #include "dekiyaku.h" -void calculate_dekiyaku(const Hand h, Dekiyaku *d) { +void calculate_dekiyaku(Hand *h, Dekiyaku *d) { int brights = 0, ribbons = 0, ribbons_except_november = 0, blue_ribbons = 0, poetry_ribbons = 0, boar = 0, deer = 0, butterflies = 0; - for (int i = 0; i < h.count; i++) { - Card *card = h.cards[i]; + for (int i = 0; i < h->count; i++) { + Card *card = h->cards[i]; switch (card->type) { case BRIGHT: brights++; break; case RIBBON: @@ -113,3 +113,11 @@ void dekiyaku_to_string(Dekiyaku *d, char *str) { strcat(str, meld_str); } } + +int dekiyaku_score(Dekiyaku *d) { + int score = 0; + for (int i = 0; i < d->count; i++) { + score += d->meld[i].value; + } + return score; +} diff --git a/dekiyaku.h b/dekiyaku.h index bfd0fa7..48bb7f6 100644 --- a/dekiyaku.h +++ b/dekiyaku.h @@ -3,6 +3,12 @@ #include "card.h" +typedef enum DekiyakuAction { + DEKIYAKU_ACTION_NONE, + DEKIYAKU_ACTION_SAGE, + DEKIYAKU_ACTION_SHOUBU, +} DekiyakuAction; + typedef enum DekiyakuMeldType { NONE, FIVE_BRIGHTS, @@ -23,8 +29,9 @@ typedef struct Dekiyaku { int count; } Dekiyaku; -void calculate_dekiyaku(const Hand h, Dekiyaku *d); +void calculate_dekiyaku(Hand *h, Dekiyaku *d); char *meld_name(DekiyakuMeldType d); void dekiyaku_to_string(Dekiyaku *d, char *str); +int dekiyaku_score(Dekiyaku *d); #endif diff --git a/game.c b/game.c index 4a297ae..6cceeaa 100644 --- a/game.c +++ b/game.c @@ -22,10 +22,14 @@ void initialize_game(Game *g) { g->player_teyaku.calculated = false; g->left_teyaku.calculated = false; g->right_teyaku.calculated = false; - g->player_points = 0; - g->right_points = 0; - g->left_points = 0; + g->player_points_string[0] = '\0'; + g->right_points_string[0] = '\0'; + g->left_points_string[0] = '\0'; g->kan_value = 12; + g->player_points = 10 * g->kan_value; + g->right_points = 10 * g->kan_value; + g->left_points = 10 * g->kan_value; + for (int i = 0; i < 48; i++) { CardType t = CHAFF; RibbonType rt = RIBBON_NONE; @@ -211,6 +215,11 @@ void run_frame_ai_playing(Game *g, Hand *hand, Hand *scored) { } void run_frame_dealing(Game *g) { + // TODO maybe we only need these once per game + 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); + if (g->player_hand.count < 4) { deal(&g->deck, &g->player_hand, 4, true); } else if (g->left_hand.count < 4) { @@ -288,8 +297,23 @@ void run_frame_player_choosing_target(Game *g) { } void run_frame_player_from_deck(Game *g) { - if (run_frame_from_deck(g, &g->player_scored)) + 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; + } else { + g->state = GAME_STATE_RIGHT_PLAYING; + } + } +} + +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) { + g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; + } } void run_frame_right_playing(Game *g) { @@ -298,8 +322,10 @@ void run_frame_right_playing(Game *g) { } void run_frame_right_from_deck(Game *g) { - if (run_frame_from_deck(g, &g->right_scored)) + 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) { @@ -416,6 +442,10 @@ void draw_frame(Game *g) { DrawText(s, 5, 25, 30, BLACK); } + DrawText(g->player_points_string, 40, 700, 20, BLACK); + 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); diff --git a/game.h b/game.h index 615486f..14661f6 100644 --- a/game.h +++ b/game.h @@ -8,6 +8,7 @@ typedef struct Game Game; #include "card.h" #include "field_multiplier.h" #include "teyaku.h" +#include "dekiyaku.h" #include "points.h" typedef enum GameState { @@ -18,11 +19,13 @@ typedef enum GameState { 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_CALCULATING_SCORES, + GAME_STATE_CALCULATING_DEKIYAKU_SCORE, } GameState; struct Game { @@ -35,8 +38,12 @@ struct Game { Hand player_scored, left_scored, right_scored; FieldMultiplier *field_multiplier; Teyaku player_teyaku, left_teyaku, right_teyaku; + Dekiyaku player_dekiyaku, left_dekiyaku, right_dekiyaku; + DekiyakuAction player_dekiyaku_action; + int player_dekiyaku_score, left_dekiyaku_score, right_dekiyaku_score; Card *current_play_from_hand, *current_play_target; int player_points, right_points, left_points, temp_points; + char player_points_string[20], left_points_string[20], right_points_string[20]; int kan_value; }; diff --git a/points.c b/points.c index 7483b04..fa6185e 100644 --- a/points.c +++ b/points.c @@ -1,4 +1,7 @@ +#include + #include "points.h" + int hand_points(Hand *hand) { int points = 0; for (int i = 0; i < hand->count; i++) { @@ -21,3 +24,7 @@ int hand_points(Hand *hand) { return points - 88; } + +void kan_points_string(Game *g, int points, char *string) { + sprintf(string, "%d kan %d", points / g->kan_value, points % g->kan_value); +} diff --git a/points.h b/points.h index cd77d8e..7f97b12 100644 --- a/points.h +++ b/points.h @@ -2,7 +2,9 @@ #define _HF_POINTS_ #include "card.h" +#include "game.h" int hand_points(Hand *hand); +void kan_points_string(Game *g, int points, char *string); #endif From a85cc93f674d9c6ee3d9bf4092a7a09769da683b Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Tue, 18 Feb 2025 06:26:38 -0500 Subject: [PATCH 23/51] Refactor players into their own objects --- game.c | 185 ++++++++++++++++++++++++------------------------ game.h | 11 +-- player.h | 27 +++++++ special_cases.c | 12 ++-- 4 files changed, 130 insertions(+), 105 deletions(-) create mode 100644 player.h diff --git a/game.c b/game.c index 6cceeaa..5966b34 100644 --- a/game.c +++ b/game.c @@ -19,16 +19,12 @@ void initialize_game(Game *g) { g->should_close = false; g->state = GAME_STATE_INITIALIZING; g->field_multiplier = NULL; - g->player_teyaku.calculated = false; - g->left_teyaku.calculated = false; - g->right_teyaku.calculated = false; - g->player_points_string[0] = '\0'; - g->right_points_string[0] = '\0'; - g->left_points_string[0] = '\0'; + g->player.teyaku.calculated = false; + g->left.teyaku.calculated = false; + g->right.teyaku.calculated = false; g->kan_value = 12; - g->player_points = 10 * g->kan_value; - g->right_points = 10 * g->kan_value; - g->left_points = 10 * g->kan_value; + g->current_play_from_hand = NULL; + g->current_play_target = NULL; for (int i = 0; i < 48; i++) { CardType t = CHAFF; @@ -76,27 +72,34 @@ void initialize_game(Game *g) { shuffle_hand(&g->deck); - g->player_hand.count = 0; - g->player_hand.position = (Vector2) { 300, 600 }; - g->player_hand.display_type = HAND_DISPLAY_ROW; - g->right_hand.count = 0; - g->right_hand.position = (Vector2) { 750, 125 }; - g->right_hand.display_type = HAND_DISPLAY_ROW; - g->left_hand.count = 0; - g->left_hand.position = (Vector2) { 50, 125 }; - g->left_hand.display_type = HAND_DISPLAY_ROW; + g->player.points = 10 * g->kan_value; + g->right.points = 10 * g->kan_value; + g->left.points = 10 * g->kan_value; + g->player.points_string[0] = '\0'; + g->right.points_string[0] = '\0'; + g->left.points_string[0] = '\0'; + + g->player.hand.count = 0; + g->player.hand.position = (Vector2) { 300, 600 }; + g->player.hand.display_type = HAND_DISPLAY_ROW; + g->right.hand.count = 0; + g->right.hand.position = (Vector2) { 750, 125 }; + g->right.hand.display_type = HAND_DISPLAY_ROW; + g->left.hand.count = 0; + g->left.hand.position = (Vector2) { 50, 125 }; + g->left.hand.display_type = HAND_DISPLAY_ROW; g->field.count = 0; g->field.position = (Vector2) { 400, 300 }; g->field.display_type = HAND_DISPLAY_FIELD; - g->player_scored.count = 0; - g->player_scored.position = (Vector2) { 300, 750 }; - g->player_scored.display_type = HAND_DISPLAY_SCORED; - g->right_scored.count = 0; - g->right_scored.position = (Vector2) { 750, 25 }; - g->right_scored.display_type = HAND_DISPLAY_SCORED; - g->left_scored.count = 0; - g->left_scored.position = (Vector2) { 50, 25 }; - g->left_scored.display_type = HAND_DISPLAY_SCORED; + g->player.scored.count = 0; + g->player.scored.position = (Vector2) { 300, 750 }; + g->player.scored.display_type = HAND_DISPLAY_SCORED; + g->right.scored.count = 0; + g->right.scored.position = (Vector2) { 750, 25 }; + g->right.scored.display_type = HAND_DISPLAY_SCORED; + g->left.scored.count = 0; + g->left.scored.position = (Vector2) { 50, 25 }; + g->left.scored.display_type = HAND_DISPLAY_SCORED; strcpy(teyaku_calculation, ""); @@ -112,12 +115,12 @@ void handle_input(Game *g) { case GAME_STATE_PLAYER_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 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; + g->player.hand.cards[i]->selected = true; break; } } @@ -126,23 +129,23 @@ void handle_input(Game *g) { case GAME_STATE_PLAYER_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; + 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; + for (int j = 0; j < g->player.hand.count; j++) { + g->player.hand.cards[j]->selected = false; } - g->player_hand.cards[i]->selected = true; + 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]; + 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; } } @@ -216,24 +219,24 @@ void run_frame_ai_playing(Game *g, Hand *hand, Hand *scored) { void run_frame_dealing(Game *g) { // TODO maybe we only need these once per game - 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); + 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); - if (g->player_hand.count < 4) { - deal(&g->deck, &g->player_hand, 4, true); - } else if (g->left_hand.count < 4) { - deal(&g->deck, &g->left_hand, 4, false); - } else if (g->right_hand.count < 4) { - deal(&g->deck, &g->right_hand, 4, false); + if (g->player.hand.count < 4) { + deal(&g->deck, &g->player.hand, 4, true); + } else if (g->left.hand.count < 4) { + deal(&g->deck, &g->left.hand, 4, false); + } else if (g->right.hand.count < 4) { + deal(&g->deck, &g->right.hand, 4, false); } else if (g->field.count < 3) { deal(&g->deck, &g->field, 3, true); - } else if (g->player_hand.count < 7) { - deal(&g->deck, &g->player_hand, 3, true); - } else if (g->left_hand.count < 7) { - deal(&g->deck, &g->left_hand, 3, false); - } else if (g->right_hand.count < 7) { - deal(&g->deck, &g->right_hand, 3, false); + } else if (g->player.hand.count < 7) { + deal(&g->deck, &g->player.hand, 3, true); + } else if (g->left.hand.count < 7) { + deal(&g->deck, &g->left.hand, 3, false); + } else if (g->right.hand.count < 7) { + deal(&g->deck, &g->right.hand, 3, false); } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); } else { @@ -247,7 +250,7 @@ void run_frame_calculating_field_multiplier(Game *g) { } void run_frame_calculating_teyaku(Game *g) { - calculate_teyaku(g->player_hand, &g->player_teyaku); + calculate_teyaku(g->player.hand, &g->player.teyaku); for (int i = 0; i < 48; i++) { g->cards[i].selected = false; } @@ -255,8 +258,8 @@ void run_frame_calculating_teyaku(Game *g) { } 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) { + for (int i = 0; i < g->player.hand.count; i++) { + if (g->player.hand.cards[i]->selected) { g->state = GAME_STATE_PLAYER_CHOOSING_TARGET; return; } @@ -265,8 +268,8 @@ void run_frame_player_choosing_from_hand(Game *g) { void run_frame_player_choosing_target(Game *g) { bool no_cards_selected = true; - for (int i = 0; i < g->player_hand.count; i++) { - if (g->player_hand.cards[i]->selected) { + for (int i = 0; i < g->player.hand.count; i++) { + if (g->player.hand.cards[i]->selected) { no_cards_selected = false; break; } @@ -280,15 +283,15 @@ void run_frame_player_choosing_target(Game *g) { if (g->current_play_from_hand) { if (g->current_play_target) { g->current_play_from_hand->selected = false; - remove_from_hand(&g->player_hand, g->current_play_from_hand); - add_to_hand(&g->player_scored, g->current_play_from_hand); + remove_from_hand(&g->player.hand, g->current_play_from_hand); + add_to_hand(&g->player.scored, g->current_play_from_hand); remove_from_hand(&g->field, g->current_play_target); - add_to_hand(&g->player_scored, g->current_play_target); + add_to_hand(&g->player.scored, g->current_play_target); 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); + remove_from_hand(&g->player.hand, g->current_play_from_hand); add_to_hand(&g->field, g->current_play_from_hand); g->current_play_from_hand = NULL; } @@ -297,10 +300,10 @@ void run_frame_player_choosing_target(Game *g) { } 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); + 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; } else { g->state = GAME_STATE_RIGHT_PLAYING; @@ -309,33 +312,33 @@ void run_frame_player_from_deck(Game *g) { } void run_frame_player_has_dekiyaku(Game *g) { - if (g->player_dekiyaku_action == DEKIYAKU_ACTION_SAGE) { + if (g->player.dekiyaku_action == DEKIYAKU_ACTION_SAGE) { g->state = GAME_STATE_RIGHT_PLAYING; - } else if (g->player_dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) { + } else if (g->player.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); + 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); + 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); + 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) { + 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; @@ -344,7 +347,7 @@ void run_frame_left_from_deck(Game *g) { } 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)); + printf("Hand scores: %d %d %d\n", hand_points(&g->player.scored), hand_points(&g->right.scored), hand_points(&g->left.scored)); SpecialCase special_case = calculate_special_case(g); switch(special_case.type) { @@ -356,23 +359,23 @@ void run_frame_calculating_scores(Game *g) { printf("Double eights or 16 chaff! 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); + transfer_kan(g, &g->player.points, &g->right.points, special_case.score); + transfer_kan(g, &g->player.points, &g->left.points, special_case.score); 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); + transfer_kan(g, &g->right.points, &g->player.points, special_case.score); + transfer_kan(g, &g->right.points, &g->left.points, special_case.score); 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); + transfer_kan(g, &g->left.points, &g->right.points, special_case.score); + transfer_kan(g, &g->left.points, &g->player.points, special_case.score); break; } break; default: - transfer_points(g, &g->player_points, &g->temp_points, hand_points(&g->player_scored)); - transfer_points(g, &g->right_points, &g->temp_points, hand_points(&g->right_scored)); - transfer_points(g, &g->left_points, &g->temp_points, hand_points(&g->left_scored)); + transfer_points(g, &g->player.points, &g->temp_points, hand_points(&g->player.scored)); + transfer_points(g, &g->right.points, &g->temp_points, hand_points(&g->right.scored)); + transfer_points(g, &g->left.points, &g->temp_points, hand_points(&g->left.scored)); break; } g->state = GAME_STATE_INITIALIZING; @@ -436,15 +439,15 @@ void draw_frame(Game *g) { } if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); - if (g->player_teyaku.calculated) { + if (g->player.teyaku.calculated) { char s[200]; - teyaku_to_string(&g->player_teyaku, s); + teyaku_to_string(&g->player.teyaku, s); DrawText(s, 5, 25, 30, BLACK); } - DrawText(g->player_points_string, 40, 700, 20, BLACK); - DrawText(g->right_points_string, 40, 750, 20, BLACK); - DrawText(g->left_points_string, 40, 800, 20, BLACK); + DrawText(g->player.points_string, 40, 700, 20, BLACK); + 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: diff --git a/game.h b/game.h index 14661f6..f3cf1f2 100644 --- a/game.h +++ b/game.h @@ -10,6 +10,7 @@ typedef struct Game Game; #include "teyaku.h" #include "dekiyaku.h" #include "points.h" +#include "player.h" typedef enum GameState { GAME_STATE_INITIALIZING, @@ -33,18 +34,12 @@ struct Game { bool should_close; Card cards[48]; Texture2D cards_texture; - Hand player_hand, left_hand, right_hand; Hand deck, field; - Hand player_scored, left_scored, right_scored; FieldMultiplier *field_multiplier; - Teyaku player_teyaku, left_teyaku, right_teyaku; - Dekiyaku player_dekiyaku, left_dekiyaku, right_dekiyaku; - DekiyakuAction player_dekiyaku_action; - int player_dekiyaku_score, left_dekiyaku_score, right_dekiyaku_score; Card *current_play_from_hand, *current_play_target; - int player_points, right_points, left_points, temp_points; - char player_points_string[20], left_points_string[20], right_points_string[20]; int kan_value; + Player player, right, left; + int temp_points; }; void initialize_game(Game *g); diff --git a/player.h b/player.h new file mode 100644 index 0000000..0d12fed --- /dev/null +++ b/player.h @@ -0,0 +1,27 @@ +#ifndef _HF_PLAYER_ +#define _HF_PLAYER_ + +typedef struct Player Player; +typedef enum PlayerSeat { + PLAYER, + RIGHT, + LEFT +} PlayerSeat; + +#include "card.h" + +struct Player { + PlayerSeat seat; + Hand hand; + Hand scored; + Teyaku teyaku; + Dekiyaku dekiyaku; + DekiyakuAction dekiyaku_action; + int dekiyaku_score; + int points; + char points_string[20]; + bool ai; + bool dealer; +}; + +#endif diff --git a/special_cases.c b/special_cases.c index 6ca47e9..819d0b2 100644 --- a/special_cases.c +++ b/special_cases.c @@ -13,9 +13,9 @@ int hand_count_chaff(Hand *hand) { } SpecialCase calculate_special_case(Game *g) { - int player_points = hand_points(&g->player_scored); - int right_points = hand_points(&g->right_scored); - int left_points = hand_points(&g->left_scored); + int player_points = hand_points(&g->player.scored); + int right_points = hand_points(&g->right.scored); + int left_points = hand_points(&g->left.scored); if (player_points == 0 && right_points == 0 && @@ -31,15 +31,15 @@ SpecialCase calculate_special_case(Game *g) { return (SpecialCase) { SPECIAL_CASE_DOUBLE_EIGHTS, SPECIAL_CASE_TARGET_LEFT, left_points - 70 }; - int player_chaff = hand_count_chaff(&g->player_scored); + int player_chaff = hand_count_chaff(&g->player.scored); if (player_chaff >= 16) return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_PLAYER, (2 * player_chaff) - 20 }; - int right_chaff = hand_count_chaff(&g->right_scored); + int right_chaff = hand_count_chaff(&g->right.scored); if (right_chaff >= 16) return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_RIGHT, (2 * right_chaff) - 20 }; - int left_chaff = hand_count_chaff(&g->left_scored); + int left_chaff = hand_count_chaff(&g->left.scored); if (left_chaff >= 16) return (SpecialCase) { SPECIAL_CASE_SIXTEEN_CHAFF, SPECIAL_CASE_TARGET_LEFT, (2 * left_chaff) - 20 }; From b3185914514dadd769f883af2f9bdcf5dca943bd Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Wed, 19 Feb 2025 05:05:30 -0500 Subject: [PATCH 24/51] Next card position is corrected for the field --- card.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/card.c b/card.c index 0f3bac4..2b22217 100644 --- a/card.c +++ b/card.c @@ -53,7 +53,7 @@ void remove_from_hand(Hand *h, Card *c) { h->count--; } -void add_to_hand(Hand *h, Card *c) { +int first_open_spot(Hand *h) { int order_guy[48]; int order_guy_count = 0; @@ -67,14 +67,17 @@ void add_to_hand(Hand *h, Card *c) { order_guy_count++; } - int first_open_spot = h->count; + int fos = h->count; for (int i = 0; i < order_guy_count; i++) { if (order_guy[i]) continue; - first_open_spot = i; + fos = i; break; } + return fos; +} - c->order = first_open_spot; +void add_to_hand(Hand *h, Card *c) { + c->order = first_open_spot(h); h->cards[h->count] = c; c->move.position = &c->position; @@ -82,19 +85,19 @@ void add_to_hand(Hand *h, Card *c) { c->move.origin.y = c->position.y; switch (h->display_type) { case HAND_DISPLAY_ROW: - c->move.destination.x = h->position.x + (first_open_spot * (CARD_WIDTH + 10)); + c->move.destination.x = h->position.x + (c->order * (CARD_WIDTH + 10)); c->move.destination.y = h->position.y; break; case HAND_DISPLAY_FIELD: - c->move.destination.x = h->position.x + ((first_open_spot / 2) * (CARD_WIDTH + 10)); - c->move.destination.y = h->position.y + (first_open_spot % 2 * (CARD_HEIGHT + 10)); + c->move.destination.x = h->position.x + ((c->order / 2) * (CARD_WIDTH + 10)); + c->move.destination.y = h->position.y + (c->order % 2 * (CARD_HEIGHT + 10)); break; case HAND_DISPLAY_DECK: c->move.destination.x = h->position.x; c->move.destination.y = h->position.y; break; case HAND_DISPLAY_SCORED: - c->move.destination.x = h->position.x + (first_open_spot * (CARD_WIDTH - 10)); + c->move.destination.x = h->position.x + (c->order * (CARD_WIDTH - 10)); c->move.destination.y = h->position.y; break; } @@ -119,9 +122,10 @@ void deal(Hand *from, Hand *to, int count, bool up) { } Rectangle next_card_position(Hand *h) { + int i = first_open_spot(h); return (Rectangle) { - h->position.x + ((h->count / 2) * (CARD_WIDTH + 10)), - h->position.y + (h->count % 2 * (CARD_HEIGHT + 10)), + h->position.x + ((i / 2) * (CARD_WIDTH + 10)), + h->position.y + (i % 2 * (CARD_HEIGHT + 10)), CARD_WIDTH, CARD_HEIGHT }; From 96a3b38e34d1867ea577ea60e5475b71c6c2d181 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Wed, 19 Feb 2025 06:04:10 -0500 Subject: [PATCH 25/51] Rework states to be player-agnostic --- game.c | 249 +++++++++++++++++++++++++++++++++++---------------------- game.h | 16 ++-- 2 files changed, 162 insertions(+), 103 deletions(-) diff --git a/game.c b/game.c index 5966b34..32f1484 100644 --- a/game.c +++ b/game.c @@ -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 = ¤t_player(g)->hand; + Hand *scored = ¤t_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 = ¤t_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(); diff --git a/game.h b/game.h index f3cf1f2..8da0a0d 100644 --- a/game.h +++ b/game.h @@ -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); From 6a58fa2601da7612032a48b266ce4f81cf897448 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Thu, 20 Feb 2025 07:09:57 -0500 Subject: [PATCH 26/51] Add dialogs --- card.c | 2 +- dialog.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ dialog.h | 34 ++++++++++++++++++ game.c | 13 ++++++- game.h | 2 ++ 5 files changed, 157 insertions(+), 2 deletions(-) create mode 100644 dialog.c create mode 100644 dialog.h diff --git a/card.c b/card.c index 2b22217..fc7e8cc 100644 --- a/card.c +++ b/card.c @@ -103,7 +103,7 @@ void add_to_hand(Hand *h, Card *c) { } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; - c->move.end_time = 0.5; + c->move.end_time = 0.2; h->count++; } diff --git a/dialog.c b/dialog.c new file mode 100644 index 0000000..0753c42 --- /dev/null +++ b/dialog.c @@ -0,0 +1,108 @@ +#include +#include +#include + +#include + +#include "dialog.h" + +Dialog dialogs[2]; + +void handle_click_cancel_yes(Game *g) { + g->state = GAME_STATE_CHOOSING_FROM_HAND; +} + +void handle_click_cancel_no(Game *g) { + g->state = GAME_STATE_CHOOSING_FROM_HAND; +} + +void init_dialogs(Game *g) { + Dialog *cancel_dialog = &dialogs[0]; + cancel_dialog->text = malloc(200); + strcpy(cancel_dialog->text, "Would you like to cancel?"); + cancel_dialog->text_color = BLACK; + cancel_dialog->options_count = 2; + cancel_dialog->game = g; + + cancel_dialog->options[0].text = malloc(50); + strcpy(cancel_dialog->options[0].text, "Yes"); + cancel_dialog->options[0].color = GREEN; + cancel_dialog->options[0].handle = &handle_click_cancel_yes; + + cancel_dialog->options[1].text = malloc(50); + strcpy(cancel_dialog->options[1].text, "No"); + cancel_dialog->options[1].color = RED; + cancel_dialog->options[1].handle = &handle_click_cancel_no; + + + Dialog *shoubu_dialog = &dialogs[1]; + shoubu_dialog->text = malloc(200); + strcpy(shoubu_dialog->text, "You have dekiyaku! Sage or shoubu?"); + shoubu_dialog->text_color = BLACK; + shoubu_dialog->options_count = 2; + shoubu_dialog->game = g; + + shoubu_dialog->options[0].text = malloc(50); + strcpy(shoubu_dialog->options[0].text, "Sage"); + shoubu_dialog->options[0].color = GREEN; + shoubu_dialog->options[0].handle = NULL; + + shoubu_dialog->options[1].text = malloc(50); + strcpy(shoubu_dialog->options[1].text, "Shoubu"); + shoubu_dialog->options[1].color = RED; + shoubu_dialog->options[1].handle = NULL; +} + +Dialog *cancel_dialog() { return &dialogs[0]; } +Dialog *shoubu_dialog() { return &dialogs[1]; } + +Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { + return (Rectangle) { + ((960 * (i + 1)) / (d->options_count + 1)) - 10 + 200, + 500, + MeasureText(d->options[i].text, DIALOG_OPTION_FONT_SIZE) + 20, + 40, + }; +} + +Rectangle dialog_option_inner_rectangle(Dialog *d, int i) { + Rectangle outer = dialog_option_outer_rectangle(d, i); + return (Rectangle) { + outer.x + 3, + outer.y + 3, + outer.width - 6, + outer.height - 6, + }; +} + +void dialog_draw(Dialog *d) { + int text_width; + DrawRectangleRec(DIALOG_OUTER_RECTANGLE, BLACK); + DrawRectangleRec(DIALOG_INNER_RECTANGLE, WHITE); + text_width = MeasureText(d->text, DIALOG_TEXT_FONT_SIZE); + DrawText(d->text, 700 - (text_width / 2), 400, DIALOG_TEXT_FONT_SIZE, d->text_color); + + for (int i = 0; i < d->options_count; i++) { + DialogOption *o = &d->options[i]; + Rectangle outer = dialog_option_outer_rectangle(d, i); + Rectangle inner = dialog_option_inner_rectangle(d, i); + DrawRectangleRec(outer, BLACK); + DrawRectangleRec(inner, o->color); + DrawText(o->text, inner.x + 3, inner.y + 3, DIALOG_OPTION_FONT_SIZE, BLACK); + } +} + +void dialog_handle_input(Dialog *d) { + if (IsMouseButtonPressed(0)) { + Vector2 mouse_pos = GetMousePosition(); + for (int i = 0; i < d->options_count; i++) { + DialogOption *o = &d->options[i]; + Rectangle outer = dialog_option_outer_rectangle(d, i); + if (CheckCollisionPointRec(mouse_pos, outer)) { + o->handle(d->game); + d->game->dialog = NULL; + break; + } + } + } +} diff --git a/dialog.h b/dialog.h new file mode 100644 index 0000000..d762313 --- /dev/null +++ b/dialog.h @@ -0,0 +1,34 @@ +#ifndef _HF_DIALOG_ +#define _HF_DIALOG_ + +typedef struct DialogOption DialogOption; +typedef struct Dialog Dialog; + +#include "game.h" + +#define DIALOG_OUTER_RECTANGLE (Rectangle) { 200, 200, 1000, 500 } +#define DIALOG_INNER_RECTANGLE (Rectangle) { 220, 220, 960, 460 } +#define DIALOG_TEXT_FONT_SIZE 60 +#define DIALOG_OPTION_FONT_SIZE 30 + +struct DialogOption { + char *text; + Color color; + void (*handle) (Game *g); +}; + +struct Dialog { + char *text; + Color text_color; + DialogOption options[3]; + int options_count; + Game *game; +}; + +void init_dialogs(Game *g); +Dialog *cancel_dialog(); +Dialog *shoubu_dialog(); +void dialog_draw(Dialog *d); +void dialog_handle_input(Dialog *d); + +#endif diff --git a/game.c b/game.c index 32f1484..5587c3b 100644 --- a/game.c +++ b/game.c @@ -8,6 +8,7 @@ #include "field_multiplier.h" #include "special_cases.h" #include "play.h" +#include "dialog.h" Vector2 mouse_pos; char teyaku_calculation[400]; @@ -28,7 +29,9 @@ void initialize_game(Game *g) { g->kan_value = 12; g->current_play_from_hand = NULL; g->current_play_target = NULL; - g->turn_number = 0; + g->turn_number = -1; + g->dialog = NULL; + init_dialogs(g); for (int i = 0; i < 48; i++) { CardType t = CHAFF; @@ -132,6 +135,7 @@ bool is_player_turn(Game *g) { bool stale_calculation = true; void handle_input(Game *g) { if (!is_player_turn(g)) return; + if (g->dialog) return dialog_handle_input(g->dialog); switch (g->state) { case GAME_STATE_CHOOSING_FROM_HAND: @@ -267,6 +271,9 @@ void run_frame_start_of_turn(Game *g) { } void run_frame_checking_for_cancel(Game *g) { + if (g->dialog) return; + if (is_player_turn(g)) { g->dialog = cancel_dialog(); return; } + if (current_player(g)->dekiyaku_action == DEKIYAKU_ACTION_SAGE) { if (is_player_turn(g)) { // check for player canceling @@ -520,6 +527,10 @@ void draw_frame(Game *g) { } } + if (g->dialog) { + dialog_draw(g->dialog); + } + EndDrawing(); } diff --git a/game.h b/game.h index 8da0a0d..e209e4c 100644 --- a/game.h +++ b/game.h @@ -11,6 +11,7 @@ typedef struct Game Game; #include "dekiyaku.h" #include "points.h" #include "player.h" +#include "dialog.h" typedef enum GameState { GAME_STATE_INITIALIZING, @@ -40,6 +41,7 @@ struct Game { Player player, right, left; int temp_points; int turn_number; + Dialog *dialog; }; void initialize_game(Game *g); From 4963835a13dea71a8ff784452d32ca2e8fca2faa Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Thu, 20 Feb 2025 19:21:03 -0500 Subject: [PATCH 27/51] Development idk --- dekiyaku.h | 1 + dialog.c | 13 ++++++++++- game.c | 65 ++++++++++++++++++++++++++++++++---------------------- player.h | 3 +-- 4 files changed, 53 insertions(+), 29 deletions(-) diff --git a/dekiyaku.h b/dekiyaku.h index 48bb7f6..3d4566e 100644 --- a/dekiyaku.h +++ b/dekiyaku.h @@ -7,6 +7,7 @@ typedef enum DekiyakuAction { DEKIYAKU_ACTION_NONE, DEKIYAKU_ACTION_SAGE, DEKIYAKU_ACTION_SHOUBU, + DEKIYAKU_ACTION_CANCEL, } DekiyakuAction; typedef enum DekiyakuMeldType { diff --git a/dialog.c b/dialog.c index 0753c42..506ea81 100644 --- a/dialog.c +++ b/dialog.c @@ -9,13 +9,24 @@ Dialog dialogs[2]; void handle_click_cancel_yes(Game *g) { - g->state = GAME_STATE_CHOOSING_FROM_HAND; + g->player.dekiyaku_action = DEKIYAKU_ACTION_CANCEL; + g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; } void handle_click_cancel_no(Game *g) { g->state = GAME_STATE_CHOOSING_FROM_HAND; } +void handle_click_shoubu(Game *g) { + g->player.dekiyaku_action = DEKIYAKU_ACTION_SHOUBU; + g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; +} + +void handle_click_sage(Game *g) { + g->player.dekiyaku_action = DEKIYAKU_ACTION_SAGE; + g->state = GAME_STATE_CHOOSING_FROM_HAND; +} + void init_dialogs(Game *g) { Dialog *cancel_dialog = &dialogs[0]; cancel_dialog->text = malloc(200); diff --git a/game.c b/game.c index 5587c3b..919e957 100644 --- a/game.c +++ b/game.c @@ -87,6 +87,10 @@ void initialize_game(Game *g) { g->right.points_string[0] = '\0'; g->left.points_string[0] = '\0'; + g->player.dekiyaku_action = DEKIYAKU_ACTION_NONE; + g->right.dekiyaku_action = DEKIYAKU_ACTION_NONE; + g->left.dekiyaku_action = DEKIYAKU_ACTION_NONE; + g->player.hand.count = 0; g->player.hand.position = (Vector2) { 300, 600 }; g->player.hand.display_type = HAND_DISPLAY_ROW; @@ -114,7 +118,7 @@ void initialize_game(Game *g) { Image cards_image = LoadImage("img/cards.png"); g->cards_texture = LoadTextureFromImage(cards_image); UnloadImage(cards_image); - g->state = GAME_STATE_DEALING; + g->state = GAME_STATE_INITIALIZING; } Player *current_player(Game *g) { @@ -126,13 +130,14 @@ Player *current_player(Game *g) { case 2: return &g->left; } + + return NULL; } 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; if (g->dialog) return dialog_handle_input(g->dialog); @@ -222,12 +227,14 @@ void run_frame_ai_playing(Game *g) { } } -void run_frame_dealing(Game *g) { - // TODO maybe we only need these once per game +void run_frame_initializing(Game *g) { 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; +} +void run_frame_dealing(Game *g) { if (g->player.hand.count < 4) { deal(&g->deck, &g->player.hand, 4, true); } else if (g->left.hand.count < 4) { @@ -271,21 +278,11 @@ void run_frame_start_of_turn(Game *g) { } void run_frame_checking_for_cancel(Game *g) { - if (g->dialog) return; - if (is_player_turn(g)) { g->dialog = cancel_dialog(); return; } - 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; + g->dialog = cancel_dialog(); } else { - // AI decides whether to cancel or not - // if they do: - // g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; - // else + // TODO: the AI might want to cancel at some point g->state = GAME_STATE_CHOOSING_FROM_HAND; } } else { @@ -380,8 +377,13 @@ void run_frame_checking_for_new_dekiyaku(Game *g) { 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; + if (is_player_turn(g)) { + g->dialog = shoubu_dialog(); + } else { + // TODO: better AI + cp->dekiyaku_action = DEKIYAKU_ACTION_SHOUBU; + g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; + } } else { g->state = GAME_STATE_START_OF_TURN; } @@ -392,8 +394,7 @@ void run_frame_selecting_dekiyaku_action(Game *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; + g->dialog = shoubu_dialog(); } } else { // TODO: better AI @@ -442,19 +443,31 @@ void run_frame_calculating_dekiyaku_score(Game *g) { g->state = GAME_STATE_INITIALIZING; } -void run_frame(Game *g) { - handle_input(g); - +void move_cards(Game *g) { float delta = GetFrameTime(); - bool done_moving = true; for (int i = 0; i < 48; i++) { move_position(&g->cards[i].move, delta); - if (!card_done_moving(&g->cards[i])) done_moving = false; } - if (!done_moving) return; +} + +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 (!done_moving(g)) return; switch (g->state) { case GAME_STATE_INITIALIZING: + run_frame_initializing(g); return; case GAME_STATE_DEALING: run_frame_dealing(g); diff --git a/player.h b/player.h index 0d12fed..9b1a815 100644 --- a/player.h +++ b/player.h @@ -12,8 +12,7 @@ typedef enum PlayerSeat { struct Player { PlayerSeat seat; - Hand hand; - Hand scored; + Hand hand, scored; Teyaku teyaku; Dekiyaku dekiyaku; DekiyakuAction dekiyaku_action; From 453060ee07c3030e82407344348062a6f8d2e9bd Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Thu, 20 Feb 2025 19:54:55 -0500 Subject: [PATCH 28/51] Rewind the game after a round!! --- game.c | 64 +++++++++++++++++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 25 deletions(-) diff --git a/game.c b/game.c index 919e957..a12dc98 100644 --- a/game.c +++ b/game.c @@ -14,23 +14,19 @@ Vector2 mouse_pos; char teyaku_calculation[400]; void initialize_game(Game *g) { + Image cards_image = LoadImage("img/cards.png"); + g->cards_texture = LoadTextureFromImage(cards_image); + UnloadImage(cards_image); + g->deck.count = 0; g->deck.position = (Vector2) { 800, 400 }; g->deck.display_type = HAND_DISPLAY_DECK; g->should_close = false; g->state = GAME_STATE_INITIALIZING; g->field_multiplier = NULL; - 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 = -1; g->dialog = NULL; + init_dialogs(g); for (int i = 0; i < 48; i++) { @@ -74,8 +70,6 @@ void initialize_game(Game *g) { 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++; } shuffle_hand(&g->deck); @@ -87,37 +81,27 @@ void initialize_game(Game *g) { g->right.points_string[0] = '\0'; g->left.points_string[0] = '\0'; - g->player.dekiyaku_action = DEKIYAKU_ACTION_NONE; - g->right.dekiyaku_action = DEKIYAKU_ACTION_NONE; - g->left.dekiyaku_action = DEKIYAKU_ACTION_NONE; + g->player.teyaku.calculated = false; + g->right.teyaku.calculated = false; + g->left.teyaku.calculated = false; - g->player.hand.count = 0; g->player.hand.position = (Vector2) { 300, 600 }; g->player.hand.display_type = HAND_DISPLAY_ROW; - g->right.hand.count = 0; g->right.hand.position = (Vector2) { 750, 125 }; g->right.hand.display_type = HAND_DISPLAY_ROW; - g->left.hand.count = 0; g->left.hand.position = (Vector2) { 50, 125 }; g->left.hand.display_type = HAND_DISPLAY_ROW; - g->field.count = 0; g->field.position = (Vector2) { 400, 300 }; g->field.display_type = HAND_DISPLAY_FIELD; - g->player.scored.count = 0; g->player.scored.position = (Vector2) { 300, 750 }; g->player.scored.display_type = HAND_DISPLAY_SCORED; - g->right.scored.count = 0; g->right.scored.position = (Vector2) { 750, 25 }; g->right.scored.display_type = HAND_DISPLAY_SCORED; - g->left.scored.count = 0; g->left.scored.position = (Vector2) { 50, 25 }; g->left.scored.display_type = HAND_DISPLAY_SCORED; strcpy(teyaku_calculation, ""); - Image cards_image = LoadImage("img/cards.png"); - g->cards_texture = LoadTextureFromImage(cards_image); - UnloadImage(cards_image); g->state = GAME_STATE_INITIALIZING; } @@ -228,6 +212,35 @@ void run_frame_ai_playing(Game *g) { } void run_frame_initializing(Game *g) { + // TODO: choose the dealer in a more effective manner + g->turn_number = -1; + + 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; + + g->current_play_from_hand = NULL; + g->current_play_target = NULL; + + for (int i = 0; i < 48; i++) { + Card *c = &g->cards[i]; + c->visible = false; + add_to_hand(&g->deck, c); + } + + shuffle_hand(&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); @@ -439,7 +452,7 @@ void run_frame_calculating_scores(Game *g) { } void run_frame_calculating_dekiyaku_score(Game *g) { - printf("Somebody won with dekiyaku. Cool.\n"); + printf("Somebody won with dekiyaku. Cool.\n"); fflush(stdout); g->state = GAME_STATE_INITIALIZING; } @@ -516,6 +529,7 @@ void draw_frame(Game *g) { } if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); + if (g->player.teyaku.calculated) { char s[200]; teyaku_to_string(&g->player.teyaku, s); From 08823cc3b9e55a6f1bb90d665f95eaf386bfa533 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Fri, 21 Feb 2025 06:15:08 -0500 Subject: [PATCH 29/51] Put "capture three" logic in one place --- game.c | 57 +++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 43 insertions(+), 14 deletions(-) diff --git a/game.c b/game.c index a12dc98..0498361 100644 --- a/game.c +++ b/game.c @@ -72,8 +72,6 @@ void initialize_game(Game *g) { g->cards[i].selected = false; } - shuffle_hand(&g->deck); - g->player.points = 10 * g->kan_value; g->right.points = 10 * g->kan_value; g->left.points = 10 * g->kan_value; @@ -123,6 +121,10 @@ bool is_player_turn(Game *g) { } void handle_input(Game *g) { + if (IsKeyPressed(KEY_R)) { + g->state = GAME_STATE_INITIALIZING; + return; + } if (!is_player_turn(g)) return; if (g->dialog) return dialog_handle_input(g->dialog); @@ -193,6 +195,31 @@ void handle_input(Game *g) { } } +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); + + 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]); + } + } else { + remove_from_hand(&g->field, target); + add_to_hand(scored, target); + } +} + void run_frame_ai_playing(Game *g) { Hand *hand = ¤t_player(g)->hand; Hand *scored = ¤t_player(g)->scored; @@ -201,10 +228,7 @@ void run_frame_ai_playing(Game *g) { play.played->visible = true; if (play.target) { - remove_from_hand(hand, play.played); - add_to_hand(scored, play.played); - remove_from_hand(&g->field, play.target); - add_to_hand(scored, 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); @@ -233,6 +257,7 @@ void run_frame_initializing(Game *g) { g->current_play_from_hand = NULL; g->current_play_target = NULL; + g->deck.count = 0; for (int i = 0; i < 48; i++) { Card *c = &g->cards[i]; c->visible = false; @@ -265,6 +290,7 @@ void run_frame_dealing(Game *g) { } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); } else { + // TODO: check for misdeals g->state = GAME_STATE_CALCULATING_FIELD_MULTIPLIER; } } @@ -343,10 +369,16 @@ void run_frame_choosing_target(Game *g) { if (g->current_play_from_hand) { if (g->current_play_target) { g->current_play_from_hand->selected = false; - remove_from_hand(&g->player.hand, g->current_play_from_hand); - add_to_hand(&g->player.scored, g->current_play_from_hand); - remove_from_hand(&g->field, g->current_play_target); - add_to_hand(&g->player.scored, g->current_play_target); + + 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 { @@ -366,10 +398,7 @@ void run_frame_playing_from_deck(Game *g) { 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); + capture_card_from_field(g, top_card, target, &g->deck, to_hand); } else { remove_from_hand(&g->deck, top_card); add_to_hand(&g->field, top_card); From 5ad8fa1534676ba1b8ce3776a5065be25e45696c Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Fri, 21 Feb 2025 06:38:24 -0500 Subject: [PATCH 30/51] Misdeal detection --- game.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/game.c b/game.c index 0498361..2f42941 100644 --- a/game.c +++ b/game.c @@ -272,6 +272,19 @@ void run_frame_initializing(Game *g) { 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 (g->player.hand.count < 4) { deal(&g->deck, &g->player.hand, 4, true); @@ -290,8 +303,12 @@ void run_frame_dealing(Game *g) { } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); } else { - // TODO: check for misdeals - g->state = GAME_STATE_CALCULATING_FIELD_MULTIPLIER; + if (misdeal(g)) { + printf("misdeal\n"); + g->state = GAME_STATE_INITIALIZING; + } else { + g->state = GAME_STATE_CALCULATING_FIELD_MULTIPLIER; + } } } From 21adb38b005106e2f6f3d6178d86f94f0a534735 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 07:36:55 -0500 Subject: [PATCH 31/51] Choose the dealer correctly --- game.c | 61 +++++++++++++++++++++++++++++++++++++++++----------------- game.h | 1 + 2 files changed, 44 insertions(+), 18 deletions(-) diff --git a/game.c b/game.c index 2f42941..728cf98 100644 --- a/game.c +++ b/game.c @@ -100,6 +100,18 @@ void initialize_game(Game *g) { 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->state = GAME_STATE_INITIALIZING; } @@ -236,8 +248,7 @@ void run_frame_ai_playing(Game *g) { } void run_frame_initializing(Game *g) { - // TODO: choose the dealer in a more effective manner - g->turn_number = -1; + g->turn_number = g->dealer->seat; g->player.hand.count = 0; g->right.hand.count = 0; @@ -286,20 +297,14 @@ bool misdeal(Game *g) { } void run_frame_dealing(Game *g) { - if (g->player.hand.count < 4) { - deal(&g->deck, &g->player.hand, 4, true); - } else if (g->left.hand.count < 4) { - deal(&g->deck, &g->left.hand, 4, false); - } else if (g->right.hand.count < 4) { - deal(&g->deck, &g->right.hand, 4, false); + if (current_player(g)->hand.count < 4) { + deal(&g->deck, ¤t_player(g)->hand, 4, true); + g->turn_number++; } else if (g->field.count < 3) { deal(&g->deck, &g->field, 3, true); - } else if (g->player.hand.count < 7) { - deal(&g->deck, &g->player.hand, 3, true); - } else if (g->left.hand.count < 7) { - deal(&g->deck, &g->left.hand, 3, false); - } else if (g->right.hand.count < 7) { - deal(&g->deck, &g->right.hand, 3, false); + } else if (current_player(g)->hand.count < 7) { + deal(&g->deck, ¤t_player(g)->hand, 3, true); + g->turn_number++; } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); } else { @@ -307,6 +312,7 @@ void run_frame_dealing(Game *g) { printf("misdeal\n"); g->state = GAME_STATE_INITIALIZING; } else { + g->turn_number++; g->state = GAME_STATE_CALCULATING_FIELD_MULTIPLIER; } } @@ -463,12 +469,19 @@ void run_frame_selecting_dekiyaku_action(Game *g) { } 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)); + int hp[3]; + hp[0] = hand_points(&g->player.scored); + hp[1] = hand_points(&g->right.scored); + hp[2] = hand_points(&g->left.scored); + printf("Hand scores: %d %d %d\n", hp[0], hp[1], hp[2]); SpecialCase special_case = calculate_special_case(g); switch(special_case.type) { case SPECIAL_CASE_ALL_EIGHTS: printf("All eights! Dealer gets %d kan\n", 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: @@ -477,21 +490,33 @@ void run_frame_calculating_scores(Game *g) { 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: - transfer_points(g, &g->player.points, &g->temp_points, hand_points(&g->player.scored)); - transfer_points(g, &g->right.points, &g->temp_points, hand_points(&g->right.scored)); - transfer_points(g, &g->left.points, &g->temp_points, hand_points(&g->left.scored)); + 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; + } break; } g->state = GAME_STATE_INITIALIZING; diff --git a/game.h b/game.h index e209e4c..3a5a217 100644 --- a/game.h +++ b/game.h @@ -42,6 +42,7 @@ struct Game { int temp_points; int turn_number; Dialog *dialog; + Player *dealer; }; void initialize_game(Game *g); From 881e3928f9de85b023aaf4c437f89ea233827258 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 07:51:32 -0500 Subject: [PATCH 32/51] Seat inintialization --- game.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/game.c b/game.c index 728cf98..c668fa7 100644 --- a/game.c +++ b/game.c @@ -83,6 +83,10 @@ void initialize_game(Game *g) { 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 }; From 2651157b3a7a7affce4f21af4142b2c6dccee94c Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 07:53:36 -0500 Subject: [PATCH 33/51] Draw cards in the correct order so they don't overlap --- game.c | 43 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/game.c b/game.c index c668fa7..984dca9 100644 --- a/game.c +++ b/game.c @@ -79,6 +79,17 @@ void initialize_game(Game *g) { g->right.points_string[0] = '\0'; g->left.points_string[0] = '\0'; + 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; @@ -302,12 +313,12 @@ bool misdeal(Game *g) { void run_frame_dealing(Game *g) { if (current_player(g)->hand.count < 4) { - deal(&g->deck, ¤t_player(g)->hand, 4, true); + deal(&g->deck, ¤t_player(g)->hand, 4, is_player_turn(g)); g->turn_number++; } else if (g->field.count < 3) { deal(&g->deck, &g->field, 3, true); } else if (current_player(g)->hand.count < 7) { - deal(&g->deck, ¤t_player(g)->hand, 3, true); + deal(&g->deck, ¤t_player(g)->hand, 3, is_player_turn(g)); g->turn_number++; } else if (g->field.count < 6) { deal(&g->deck, &g->field, 3, true); @@ -596,12 +607,34 @@ void run_frame(Game *g) { } } +void draw_player_cards(Game *g, Player *p) { + for (int i = 0; i < p->hand.count; i++) { + draw_card(p->hand.cards[i], &g->cards_texture); + } + + for (int i = 0; i < p->scored.count; i++) { + draw_card(p->scored.cards[i], &g->cards_texture); + } +} + +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], &g->cards_texture); + } + + for (int i = 0; i < g->deck.count; i++) { + draw_card(g->deck.cards[i], &g->cards_texture); + } +} + void draw_frame(Game *g) { BeginDrawing(); ClearBackground(RAYWHITE); - for (int i = 0; i < 48; i++) { - draw_card(&g->cards[i], &g->cards_texture); - } + + draw_cards(g); if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); From c76efc3e31247134b3f79f37fa0ff125487c88f9 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 10:14:38 -0500 Subject: [PATCH 34/51] Allow player to choose target when playing from deck --- game.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++----------- game.h | 2 ++ play.c | 11 ++++++++ play.h | 1 + 4 files changed, 83 insertions(+), 15 deletions(-) diff --git a/game.c b/game.c index 984dca9..c9df404 100644 --- a/game.c +++ b/game.c @@ -217,6 +217,23 @@ void handle_input(Game *g) { } } 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; } @@ -381,7 +398,7 @@ void run_frame_choosing_from_hand(Game *g) { run_frame_player_choosing_from_hand(g); } else { run_frame_ai_playing(g); - g->state = GAME_STATE_PLAYING_FROM_DECK; + g->state = GAME_STATE_SHOWING_CARD_FROM_DECK; } } @@ -425,29 +442,60 @@ void run_frame_choosing_target(Game *g) { add_to_hand(&g->field, g->current_play_from_hand); g->current_play_from_hand = NULL; } - g->state = GAME_STATE_PLAYING_FROM_DECK; + 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); + top_card->visible = true; + top_card->move.end_time = 0.3; + top_card->move.destination.x = top_card->move.destination.x + 100; + g->state = GAME_STATE_PLAYING_FROM_DECK; +} + void run_frame_playing_from_deck(Game *g) { Hand *to_hand = ¤t_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) { - capture_card_from_field(g, top_card, target, &g->deck, to_hand); - } else { - remove_from_hand(&g->deck, top_card); - add_to_hand(&g->field, top_card); - } + Card *targets[4]; + int target_count = 0; + valid_targets(top_card, &g->field, &targets[0], &target_count); + Card *target = NULL; + + 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->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; + g->state = GAME_STATE_CHOOSING_TARGET_FROM_DECK; + return; + } +} + +void run_frame_choosing_target_from_deck(Game *g) { + Hand *to_hand = ¤t_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); + Card *target = NULL; + + if (is_player_turn(g)) { + if (g->current_play_target) { + capture_card_from_field(g, top_card, g->current_play_target, &g->deck, to_hand); + g->state = GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU; + } + } 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; } } @@ -589,9 +637,15 @@ void run_frame(Game *g) { 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; diff --git a/game.h b/game.h index 3a5a217..13592db 100644 --- a/game.h +++ b/game.h @@ -22,7 +22,9 @@ typedef enum GameState { GAME_STATE_CHECKING_FOR_CANCEL, GAME_STATE_CHOOSING_FROM_HAND, GAME_STATE_CHOOSING_TARGET, + GAME_STATE_SHOWING_CARD_FROM_DECK, GAME_STATE_PLAYING_FROM_DECK, + GAME_STATE_CHOOSING_TARGET_FROM_DECK, GAME_STATE_CHECKING_FOR_NEW_DEKIYAKU, GAME_STATE_SELECTING_DEKIYAKU_ACTION, GAME_STATE_CALCULATING_SCORES, diff --git a/play.c b/play.c index 49f8181..a93464d 100644 --- a/play.c +++ b/play.c @@ -1,4 +1,5 @@ #include +#include #include #include "play.h" @@ -25,6 +26,16 @@ bool valid_play(Hand *field, Card *played, Card *target) { } } +void valid_targets(Card *active, Hand *field, Card **targets, int *target_count) { + *target_count = 0; + for (int i = 0; i < field->count; i++) { + if (field->cards[i]->month == active->month) { + targets[(*target_count)++] = field->cards[i]; + } + } + targets[*target_count] = NULL; // Sentinel +} + Card *valid_target(Card *active, Hand *field) { for (int i = 0; i < field->count; i++) { if (field->cards[i]->month == active->month) { diff --git a/play.h b/play.h index c580c45..4aaf5ef 100644 --- a/play.h +++ b/play.h @@ -13,6 +13,7 @@ struct Play { }; bool valid_play(Hand *field, Card *played, Card *target); +void valid_targets(Card *active, Hand *field, Card **targets, int *target_count); Card *valid_target(Card *active, Hand *field); Play ai_play(Hand *hand, Hand *field); From d31defec74c7ab7501a9dbc95e530ceb11babde1 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 10:48:48 -0500 Subject: [PATCH 35/51] Fix shoubu dialog --- card.c | 28 ++++++++++++++++++++++++++++ dialog.c | 9 +++++---- dialog.h | 4 ++-- game.c | 16 +++++++++------- 4 files changed, 44 insertions(+), 13 deletions(-) diff --git a/card.c b/card.c index fc7e8cc..5aba3ee 100644 --- a/card.c +++ b/card.c @@ -44,6 +44,34 @@ void shuffle_hand(Hand *h) { } } +void order_deck(Hand *h) { + Card *swap; + + swap = h->cards[1]; + h->cards[1] = h->cards[47-0]; + h->cards[47-0] = swap; + + swap = h->cards[5]; + h->cards[5] = h->cards[47-1]; + h->cards[47-1] = swap; + + swap = h->cards[9]; + h->cards[9] = h->cards[47-2]; + h->cards[47-2] = swap; + + swap = h->cards[0]; + h->cards[0] = h->cards[47-12]; + h->cards[47-12] = swap; + + swap = h->cards[4]; + h->cards[4] = h->cards[47-13]; + h->cards[47-13] = swap; + + swap = h->cards[8]; + h->cards[8] = h->cards[47-14]; + h->cards[47-14] = swap; +} + void remove_from_hand(Hand *h, Card *c) { bool card_found = false; for (int i = 0; i < h->count - 1; i++) { diff --git a/dialog.c b/dialog.c index 506ea81..e729da2 100644 --- a/dialog.c +++ b/dialog.c @@ -24,6 +24,7 @@ void handle_click_shoubu(Game *g) { void handle_click_sage(Game *g) { g->player.dekiyaku_action = DEKIYAKU_ACTION_SAGE; + g->turn_number++; g->state = GAME_STATE_CHOOSING_FROM_HAND; } @@ -56,16 +57,16 @@ void init_dialogs(Game *g) { shoubu_dialog->options[0].text = malloc(50); strcpy(shoubu_dialog->options[0].text, "Sage"); shoubu_dialog->options[0].color = GREEN; - shoubu_dialog->options[0].handle = NULL; + shoubu_dialog->options[0].handle = &handle_click_sage; shoubu_dialog->options[1].text = malloc(50); strcpy(shoubu_dialog->options[1].text, "Shoubu"); shoubu_dialog->options[1].color = RED; - shoubu_dialog->options[1].handle = NULL; + shoubu_dialog->options[1].handle = &handle_click_shoubu; } -Dialog *cancel_dialog() { return &dialogs[0]; } -Dialog *shoubu_dialog() { return &dialogs[1]; } +void cancel_dialog(Game *g) { g->dialog = &dialogs[0]; } +void shoubu_dialog(Game *g) { g->dialog = &dialogs[1]; } Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { return (Rectangle) { diff --git a/dialog.h b/dialog.h index d762313..e304fa5 100644 --- a/dialog.h +++ b/dialog.h @@ -26,8 +26,8 @@ struct Dialog { }; void init_dialogs(Game *g); -Dialog *cancel_dialog(); -Dialog *shoubu_dialog(); +void cancel_dialog(Game *g); +void shoubu_dialog(Game *g); void dialog_draw(Dialog *d); void dialog_handle_input(Dialog *d); diff --git a/game.c b/game.c index c9df404..5444d42 100644 --- a/game.c +++ b/game.c @@ -127,6 +127,7 @@ void initialize_game(Game *g) { g->dealer = &g->left; break; } + g->dealer = &g->player; g->state = GAME_STATE_INITIALIZING; } @@ -153,7 +154,9 @@ void handle_input(Game *g) { return; } if (!is_player_turn(g)) return; - if (g->dialog) return dialog_handle_input(g->dialog); + if (g->dialog) { + return dialog_handle_input(g->dialog); + } switch (g->state) { case GAME_STATE_CHOOSING_FROM_HAND: @@ -307,7 +310,8 @@ void run_frame_initializing(Game *g) { add_to_hand(&g->deck, c); } - shuffle_hand(&g->deck); + // 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); @@ -374,7 +378,7 @@ void run_frame_start_of_turn(Game *g) { void run_frame_checking_for_cancel(Game *g) { if (current_player(g)->dekiyaku_action == DEKIYAKU_ACTION_SAGE) { if (is_player_turn(g)) { - g->dialog = cancel_dialog(); + cancel_dialog(g); } else { // TODO: the AI might want to cancel at some point g->state = GAME_STATE_CHOOSING_FROM_HAND; @@ -463,7 +467,6 @@ void run_frame_playing_from_deck(Game *g) { Card *targets[4]; int target_count = 0; valid_targets(top_card, &g->field, &targets[0], &target_count); - Card *target = NULL; if (target_count == 1) { capture_card_from_field(g, top_card, targets[0], &g->deck, to_hand); @@ -485,7 +488,6 @@ void run_frame_choosing_target_from_deck(Game *g) { Card *targets[4]; int target_count = 0; valid_targets(top_card, &g->field, &targets[0], &target_count); - Card *target = NULL; if (is_player_turn(g)) { if (g->current_play_target) { @@ -506,7 +508,7 @@ void run_frame_checking_for_new_dekiyaku(Game *g) { if (new_score != cp->dekiyaku_score) { cp->dekiyaku_score = new_score; if (is_player_turn(g)) { - g->dialog = shoubu_dialog(); + shoubu_dialog(g); } else { // TODO: better AI cp->dekiyaku_action = DEKIYAKU_ACTION_SHOUBU; @@ -522,7 +524,7 @@ void run_frame_selecting_dekiyaku_action(Game *g) { if (g->player.dekiyaku_action != DEKIYAKU_ACTION_NONE) { g->state = GAME_STATE_CALCULATING_DEKIYAKU_SCORE; } else { - g->dialog = shoubu_dialog(); + shoubu_dialog(g); } } else { // TODO: better AI From e585551df01598938414ca20ff064cf805d46251 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 11:47:34 -0500 Subject: [PATCH 36/51] End of round screen --- dialog.c | 43 +++++++++++++++++++++++++++++++++++-------- dialog.h | 4 +++- game.c | 27 +++++++++++++++++---------- 3 files changed, 55 insertions(+), 19 deletions(-) diff --git a/dialog.c b/dialog.c index e729da2..5d4b78b 100644 --- a/dialog.c +++ b/dialog.c @@ -1,4 +1,5 @@ #include +#include #include #include @@ -6,7 +7,7 @@ #include "dialog.h" -Dialog dialogs[2]; +Dialog dialogs[6]; void handle_click_cancel_yes(Game *g) { g->player.dekiyaku_action = DEKIYAKU_ACTION_CANCEL; @@ -28,10 +29,15 @@ void handle_click_sage(Game *g) { g->state = GAME_STATE_CHOOSING_FROM_HAND; } +void handle_click_ok_end_of_game(Game *g) { + g->state = GAME_STATE_INITIALIZING; +} + void init_dialogs(Game *g) { Dialog *cancel_dialog = &dialogs[0]; - cancel_dialog->text = malloc(200); - strcpy(cancel_dialog->text, "Would you like to cancel?"); + cancel_dialog->text_count = 1; + cancel_dialog->text[0] = malloc(200); + strcpy(cancel_dialog->text[0], "Would you like to cancel?"); cancel_dialog->text_color = BLACK; cancel_dialog->options_count = 2; cancel_dialog->game = g; @@ -46,10 +52,10 @@ void init_dialogs(Game *g) { cancel_dialog->options[1].color = RED; cancel_dialog->options[1].handle = &handle_click_cancel_no; - Dialog *shoubu_dialog = &dialogs[1]; - shoubu_dialog->text = malloc(200); - strcpy(shoubu_dialog->text, "You have dekiyaku! Sage or shoubu?"); + shoubu_dialog->text_count = 1; + shoubu_dialog->text[0] = malloc(200); + strcpy(shoubu_dialog->text[0], "You have dekiyaku! Sage or shoubu?"); shoubu_dialog->text_color = BLACK; shoubu_dialog->options_count = 2; shoubu_dialog->game = g; @@ -63,10 +69,28 @@ void init_dialogs(Game *g) { strcpy(shoubu_dialog->options[1].text, "Shoubu"); shoubu_dialog->options[1].color = RED; shoubu_dialog->options[1].handle = &handle_click_shoubu; + + Dialog *no_dekiyaku_end_of_round_dialog = &dialogs[2]; + no_dekiyaku_end_of_round_dialog->text_count = 3; + no_dekiyaku_end_of_round_dialog->text[0] = malloc(200); + no_dekiyaku_end_of_round_dialog->text[1] = malloc(200); + no_dekiyaku_end_of_round_dialog->text[2] = malloc(200); + strcpy(no_dekiyaku_end_of_round_dialog->text[0], "Player score"); + strcpy(no_dekiyaku_end_of_round_dialog->text[1], "Right score"); + strcpy(no_dekiyaku_end_of_round_dialog->text[2], "Left score"); + no_dekiyaku_end_of_round_dialog->text_color = BLACK; + no_dekiyaku_end_of_round_dialog->options_count = 1; + no_dekiyaku_end_of_round_dialog->game = g; + + no_dekiyaku_end_of_round_dialog->options[0].text = malloc(50); + strcpy(no_dekiyaku_end_of_round_dialog->options[0].text, "Okay"); + no_dekiyaku_end_of_round_dialog->options[0].color = GREEN; + no_dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_game; } void cancel_dialog(Game *g) { g->dialog = &dialogs[0]; } void shoubu_dialog(Game *g) { g->dialog = &dialogs[1]; } +void no_dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[2]; } Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { return (Rectangle) { @@ -91,8 +115,11 @@ void dialog_draw(Dialog *d) { int text_width; DrawRectangleRec(DIALOG_OUTER_RECTANGLE, BLACK); DrawRectangleRec(DIALOG_INNER_RECTANGLE, WHITE); - text_width = MeasureText(d->text, DIALOG_TEXT_FONT_SIZE); - DrawText(d->text, 700 - (text_width / 2), 400, DIALOG_TEXT_FONT_SIZE, d->text_color); + + for (int i = 0; i < d->text_count; i++) { + text_width = MeasureText(d->text[i], DIALOG_TEXT_FONT_SIZE); + DrawText(d->text[i], 700 - (text_width / 2), 300 + (70 * (i - 1)), DIALOG_TEXT_FONT_SIZE, d->text_color); + } for (int i = 0; i < d->options_count; i++) { DialogOption *o = &d->options[i]; diff --git a/dialog.h b/dialog.h index e304fa5..c8716ba 100644 --- a/dialog.h +++ b/dialog.h @@ -18,7 +18,8 @@ struct DialogOption { }; struct Dialog { - char *text; + char *text[3]; + int text_count; Color text_color; DialogOption options[3]; int options_count; @@ -28,6 +29,7 @@ struct Dialog { void init_dialogs(Game *g); void cancel_dialog(Game *g); void shoubu_dialog(Game *g); +void no_dekiyaku_end_of_round_dialog(Game *g); void dialog_draw(Dialog *d); void dialog_handle_input(Dialog *d); diff --git a/game.c b/game.c index 5444d42..cb2c310 100644 --- a/game.c +++ b/game.c @@ -72,9 +72,9 @@ void initialize_game(Game *g) { g->cards[i].selected = false; } - g->player.points = 10 * g->kan_value; - g->right.points = 10 * g->kan_value; - g->left.points = 10 * g->kan_value; + 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'; @@ -153,11 +153,13 @@ void handle_input(Game *g) { g->state = GAME_STATE_INITIALIZING; return; } - if (!is_player_turn(g)) return; + if (g->dialog) { return dialog_handle_input(g->dialog); } + if (!is_player_turn(g)) return; + switch (g->state) { case GAME_STATE_CHOOSING_FROM_HAND: if (IsMouseButtonPressed(0)) { @@ -310,8 +312,8 @@ void run_frame_initializing(Game *g) { add_to_hand(&g->deck, c); } - // shuffle_hand(&g->deck); - order_deck(&g->deck); + 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); @@ -534,23 +536,26 @@ void run_frame_selecting_dekiyaku_action(Game *g) { } 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); - printf("Hand scores: %d %d %d\n", hp[0], hp[1], hp[2]); SpecialCase special_case = calculate_special_case(g); switch(special_case.type) { case SPECIAL_CASE_ALL_EIGHTS: - printf("All eights! Dealer gets %d kan\n", special_case.score); + 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: - printf("Double eights or 16 chaff! Player %d gets %d kan\n", special_case.target, special_case.score); + sprintf(g->dialog->text[0], "Double eights or 16 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); @@ -570,6 +575,9 @@ void run_frame_calculating_scores(Game *g) { } 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]); @@ -584,7 +592,6 @@ void run_frame_calculating_scores(Game *g) { } break; } - g->state = GAME_STATE_INITIALIZING; } void run_frame_calculating_dekiyaku_score(Game *g) { From 5d966ecfd00057e45b64a9f45e584ee8f5951eca Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 12:01:00 -0500 Subject: [PATCH 37/51] Allow the game to end --- dialog.c | 22 ++++++++++++++++++++-- dialog.h | 1 + game.c | 25 ++++++++++++++++++++++++- game.h | 5 +++++ 4 files changed, 50 insertions(+), 3 deletions(-) diff --git a/dialog.c b/dialog.c index 5d4b78b..43e1206 100644 --- a/dialog.c +++ b/dialog.c @@ -29,8 +29,12 @@ void handle_click_sage(Game *g) { g->state = GAME_STATE_CHOOSING_FROM_HAND; } +void handle_click_ok_end_of_round(Game *g) { + g->state = GAME_STATE_END_OF_ROUND; +} + void handle_click_ok_end_of_game(Game *g) { - g->state = GAME_STATE_INITIALIZING; + g->state = GAME_STATE_TITLE_SCREEN; } void init_dialogs(Game *g) { @@ -85,12 +89,26 @@ void init_dialogs(Game *g) { no_dekiyaku_end_of_round_dialog->options[0].text = malloc(50); strcpy(no_dekiyaku_end_of_round_dialog->options[0].text, "Okay"); no_dekiyaku_end_of_round_dialog->options[0].color = GREEN; - no_dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_game; + no_dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_round; + + Dialog *end_of_game_dialog = &dialogs[3]; + end_of_game_dialog->text_count = 3; + end_of_game_dialog->text[0] = malloc(200); + strcpy(end_of_game_dialog->text[0], "Game over something"); + end_of_game_dialog->text_color = BLACK; + end_of_game_dialog->options_count = 1; + end_of_game_dialog->game = g; + + end_of_game_dialog->options[0].text = malloc(50); + strcpy(end_of_game_dialog->options[0].text, "Okay"); + end_of_game_dialog->options[0].color = GREEN; + end_of_game_dialog->options[0].handle = &handle_click_ok_end_of_game; } void cancel_dialog(Game *g) { g->dialog = &dialogs[0]; } void shoubu_dialog(Game *g) { g->dialog = &dialogs[1]; } void no_dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[2]; } +void end_of_game_dialog(Game *g) { g->dialog = &dialogs[3]; } Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { return (Rectangle) { diff --git a/dialog.h b/dialog.h index c8716ba..2ee34a3 100644 --- a/dialog.h +++ b/dialog.h @@ -30,6 +30,7 @@ void init_dialogs(Game *g); void cancel_dialog(Game *g); void shoubu_dialog(Game *g); void no_dekiyaku_end_of_round_dialog(Game *g); +void end_of_game_dialog(Game *g); void dialog_draw(Dialog *d); void dialog_handle_input(Dialog *d); diff --git a/game.c b/game.c index cb2c310..9dbce4e 100644 --- a/game.c +++ b/game.c @@ -128,6 +128,9 @@ void initialize_game(Game *g) { break; } g->dealer = &g->player; + + g->number_of_rounds = 3; + g->current_round = 0; g->state = GAME_STATE_INITIALIZING; } @@ -554,7 +557,8 @@ void run_frame_calculating_scores(Game *g) { break; case SPECIAL_CASE_DOUBLE_EIGHTS: case SPECIAL_CASE_SIXTEEN_CHAFF: - sprintf(g->dialog->text[0], "Double eights or 16 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: @@ -599,6 +603,19 @@ void run_frame_calculating_dekiyaku_score(Game *g) { g->state = GAME_STATE_INITIALIZING; } +void run_frame_end_of_round(Game *g) { + 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 run_frame_end_of_game(Game *g) { + end_of_game_dialog(g); +} + void move_cards(Game *g) { float delta = GetFrameTime(); for (int i = 0; i < 48; i++) { @@ -667,6 +684,12 @@ void run_frame(Game *g) { 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; } } diff --git a/game.h b/game.h index 13592db..ae1c494 100644 --- a/game.h +++ b/game.h @@ -29,6 +29,9 @@ typedef enum GameState { GAME_STATE_SELECTING_DEKIYAKU_ACTION, GAME_STATE_CALCULATING_SCORES, GAME_STATE_CALCULATING_DEKIYAKU_SCORE, + GAME_STATE_END_OF_ROUND, + GAME_STATE_END_OF_GAME, + GAME_STATE_TITLE_SCREEN, } GameState; struct Game { @@ -45,6 +48,8 @@ struct Game { int turn_number; Dialog *dialog; Player *dealer; + int number_of_rounds; + int current_round; }; void initialize_game(Game *g); From 7d6a0291b7c68f766cc74335dce1ea1134bccf01 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 12:03:04 -0500 Subject: [PATCH 38/51] "Dealing..." text --- game.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/game.c b/game.c index 9dbce4e..62a92bb 100644 --- a/game.c +++ b/game.c @@ -722,7 +722,8 @@ void draw_frame(Game *g) { draw_cards(g); - if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); + if (g->state == GAME_STATE_DEALING) DrawText("Dealing....", 60, 385, 40, BLACK); + else if (g->field_multiplier) DrawText(g->field_multiplier->name, 60, 385, 40, BLACK); if (g->player.teyaku.calculated) { char s[200]; From 35c676646c29296384470b0c51f5d76afc92c5f2 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 13:44:18 -0500 Subject: [PATCH 39/51] The game can now end with dekiyaku --- dialog.c | 18 ++++++++++++++++++ dialog.h | 1 + game.c | 48 +++++++++++++++++++++++++++++++++++++++++++----- player.h | 1 + 4 files changed, 63 insertions(+), 5 deletions(-) diff --git a/dialog.c b/dialog.c index 43e1206..6db2251 100644 --- a/dialog.c +++ b/dialog.c @@ -103,12 +103,30 @@ void init_dialogs(Game *g) { strcpy(end_of_game_dialog->options[0].text, "Okay"); end_of_game_dialog->options[0].color = GREEN; end_of_game_dialog->options[0].handle = &handle_click_ok_end_of_game; + + Dialog *dekiyaku_end_of_round_dialog = &dialogs[4]; + dekiyaku_end_of_round_dialog->text_count = 3; + dekiyaku_end_of_round_dialog->text[0] = malloc(200); + dekiyaku_end_of_round_dialog->text[1] = malloc(200); + dekiyaku_end_of_round_dialog->text[2] = malloc(200); + strcpy(dekiyaku_end_of_round_dialog->text[0], "Player score"); + strcpy(dekiyaku_end_of_round_dialog->text[1], "Right score"); + strcpy(dekiyaku_end_of_round_dialog->text[2], "Left score"); + dekiyaku_end_of_round_dialog->text_color = BLACK; + dekiyaku_end_of_round_dialog->options_count = 1; + dekiyaku_end_of_round_dialog->game = g; + + dekiyaku_end_of_round_dialog->options[0].text = malloc(50); + strcpy(dekiyaku_end_of_round_dialog->options[0].text, "Okay"); + dekiyaku_end_of_round_dialog->options[0].color = GREEN; + dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_round; } void cancel_dialog(Game *g) { g->dialog = &dialogs[0]; } void shoubu_dialog(Game *g) { g->dialog = &dialogs[1]; } void no_dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[2]; } void end_of_game_dialog(Game *g) { g->dialog = &dialogs[3]; } +void dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[4]; } Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { return (Rectangle) { diff --git a/dialog.h b/dialog.h index 2ee34a3..6468947 100644 --- a/dialog.h +++ b/dialog.h @@ -31,6 +31,7 @@ void cancel_dialog(Game *g); void shoubu_dialog(Game *g); void no_dekiyaku_end_of_round_dialog(Game *g); void end_of_game_dialog(Game *g); +void dekiyaku_end_of_round_dialog(Game *g); void dialog_draw(Dialog *d); void dialog_handle_input(Dialog *d); diff --git a/game.c b/game.c index 62a92bb..bffc62d 100644 --- a/game.c +++ b/game.c @@ -78,6 +78,9 @@ void initialize_game(Game *g) { g->player.points_string[0] = '\0'; g->right.points_string[0] = '\0'; g->left.points_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; @@ -315,8 +318,8 @@ void run_frame_initializing(Game *g) { add_to_hand(&g->deck, c); } - shuffle_hand(&g->deck); - // order_deck(&g->deck); + //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); @@ -598,9 +601,44 @@ void run_frame_calculating_scores(Game *g) { } } +void 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)); + } 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); + } + } +} + void run_frame_calculating_dekiyaku_score(Game *g) { - printf("Somebody won with dekiyaku. Cool.\n"); fflush(stdout); - g->state = GAME_STATE_INITIALIZING; + 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 { + // Hands are exhausted + } } void run_frame_end_of_round(Game *g) { @@ -738,7 +776,7 @@ void draw_frame(Game *g) { if (is_player_turn(g)) { switch (g->state) { case GAME_STATE_CHOOSING_FROM_HAND: - DrawText("Choose a card to play", 60, 485, 20, BLACK); + 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); diff --git a/player.h b/player.h index 9b1a815..d7f6465 100644 --- a/player.h +++ b/player.h @@ -12,6 +12,7 @@ typedef enum PlayerSeat { struct Player { PlayerSeat seat; + char *name; Hand hand, scored; Teyaku teyaku; Dekiyaku dekiyaku; From f9e7b8a3cdf73733d3f529c4a225de42dd4433df Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 13:50:38 -0500 Subject: [PATCH 40/51] Slightly better layout --- field_multiplier.c | 6 +++--- field_multiplier.h | 1 + game.c | 21 +++++++++++++-------- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/field_multiplier.c b/field_multiplier.c index 6d0a38e..c9e91eb 100644 --- a/field_multiplier.c +++ b/field_multiplier.c @@ -3,9 +3,9 @@ #include "field_multiplier.h" #include "card.h" -static FieldMultiplier small_field = { "Small Field", 1 }; -static FieldMultiplier large_field = { "Large Field", 2 }; -static FieldMultiplier grand_field = { "Grand Field", 4 }; +static FieldMultiplier small_field = { "Small Field", "", 1 }; +static FieldMultiplier large_field = { "Large Field", "Score transfers are doubled", 2 }; +static FieldMultiplier grand_field = { "Grand Field", "Score transfers are quadrupled" ,4 }; FieldMultiplier *calculate_field_multiplier(Hand *h) { bool large = false; diff --git a/field_multiplier.h b/field_multiplier.h index c9ea8a2..82e0ec6 100644 --- a/field_multiplier.h +++ b/field_multiplier.h @@ -7,6 +7,7 @@ typedef struct FieldMultiplier FieldMultiplier; struct FieldMultiplier { char *name; + char *explanation; int value; }; diff --git a/game.c b/game.c index bffc62d..fada3c1 100644 --- a/game.c +++ b/game.c @@ -19,7 +19,7 @@ void initialize_game(Game *g) { UnloadImage(cards_image); g->deck.count = 0; - g->deck.position = (Vector2) { 800, 400 }; + g->deck.position = (Vector2) { 500, 300 }; g->deck.display_type = HAND_DISPLAY_DECK; g->should_close = false; g->state = GAME_STATE_INITIALIZING; @@ -64,10 +64,10 @@ void initialize_game(Game *g) { case 41: t = ANIMAL; break; } - g->cards[i] = (Card) { i, t, rt, month, { 800, 100 }, false }; + 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) { 800, 400 }; + g->cards[i].move.destination = (Vector2) { 500, 300 }; g->cards[i].order = i; g->cards[i].selected = false; } @@ -107,8 +107,6 @@ void initialize_game(Game *g) { g->right.hand.display_type = HAND_DISPLAY_ROW; g->left.hand.position = (Vector2) { 50, 125 }; g->left.hand.display_type = HAND_DISPLAY_ROW; - g->field.position = (Vector2) { 400, 300 }; - g->field.display_type = HAND_DISPLAY_FIELD; g->player.scored.position = (Vector2) { 300, 750 }; g->player.scored.display_type = HAND_DISPLAY_SCORED; g->right.scored.position = (Vector2) { 750, 25 }; @@ -116,6 +114,9 @@ void initialize_game(Game *g) { 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; @@ -464,7 +465,7 @@ void run_frame_showing_card_from_deck(Game *g) { 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; + top_card->move.destination.y = top_card->move.destination.y + 150; g->state = GAME_STATE_PLAYING_FROM_DECK; } @@ -760,8 +761,12 @@ void draw_frame(Game *g) { 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, 40, BLACK); + 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); + } if (g->player.teyaku.calculated) { char s[200]; From 26f7ab5653283bd96b89156f71ad4dbb8434fdf7 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 13:58:05 -0500 Subject: [PATCH 41/51] Fix bug where player doesn't get to choose a target --- game.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/game.c b/game.c index fada3c1..77d05bd 100644 --- a/game.c +++ b/game.c @@ -319,8 +319,8 @@ void run_frame_initializing(Game *g) { add_to_hand(&g->deck, c); } - //shuffle_hand(&g->deck); - order_deck(&g->deck); + 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); @@ -502,6 +502,8 @@ void run_frame_choosing_target_from_deck(Game *g) { if (g->current_play_target) { 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 From 83b1ae2cb975a428044f5df472086c26de94aec5 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 13:58:22 -0500 Subject: [PATCH 42/51] Slightly smaller layout --- card.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/card.c b/card.c index 5aba3ee..6bf9fa8 100644 --- a/card.c +++ b/card.c @@ -125,7 +125,7 @@ void add_to_hand(Hand *h, Card *c) { c->move.destination.y = h->position.y; break; case HAND_DISPLAY_SCORED: - c->move.destination.x = h->position.x + (c->order * (CARD_WIDTH - 10)); + c->move.destination.x = h->position.x + (c->order * (CARD_WIDTH - 30)); c->move.destination.y = h->position.y; break; } From 040a807c7fd2fa65362efbf44d5a056a8ead3469 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 14:02:32 -0500 Subject: [PATCH 43/51] Display the final score ha haaaaa --- game.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/game.c b/game.c index 77d05bd..83279db 100644 --- a/game.c +++ b/game.c @@ -645,6 +645,9 @@ void run_frame_calculating_dekiyaku_score(Game *g) { } void run_frame_end_of_round(Game *g) { + 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; From 91dae251b898529c0628b3e13d7b81cbb0a18e9d Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 14:32:09 -0500 Subject: [PATCH 44/51] Fix up the end-of-game dialog --- dialog.c | 24 ++++++++++++++++----- dialog.h | 2 +- game.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++------- game.h | 1 + 4 files changed, 77 insertions(+), 14 deletions(-) diff --git a/dialog.c b/dialog.c index 6db2251..f832c2f 100644 --- a/dialog.c +++ b/dialog.c @@ -37,6 +37,14 @@ void handle_click_ok_end_of_game(Game *g) { g->state = GAME_STATE_TITLE_SCREEN; } +void handle_click_play_again(Game *g) { + g->state = GAME_STATE_NEW_GAME; +} + +void handle_click_quit(Game *g) { + g->should_close = true; +} + void init_dialogs(Game *g) { Dialog *cancel_dialog = &dialogs[0]; cancel_dialog->text_count = 1; @@ -92,17 +100,23 @@ void init_dialogs(Game *g) { no_dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_round; Dialog *end_of_game_dialog = &dialogs[3]; - end_of_game_dialog->text_count = 3; + end_of_game_dialog->text_count = 4; end_of_game_dialog->text[0] = malloc(200); - strcpy(end_of_game_dialog->text[0], "Game over something"); + end_of_game_dialog->text[1] = malloc(200); + end_of_game_dialog->text[2] = malloc(200); + end_of_game_dialog->text[3] = malloc(200); end_of_game_dialog->text_color = BLACK; - end_of_game_dialog->options_count = 1; + end_of_game_dialog->options_count = 2; end_of_game_dialog->game = g; end_of_game_dialog->options[0].text = malloc(50); - strcpy(end_of_game_dialog->options[0].text, "Okay"); + strcpy(end_of_game_dialog->options[0].text, "Play Again"); end_of_game_dialog->options[0].color = GREEN; - end_of_game_dialog->options[0].handle = &handle_click_ok_end_of_game; + end_of_game_dialog->options[0].handle = &handle_click_play_again; + end_of_game_dialog->options[1].text = malloc(50); + strcpy(end_of_game_dialog->options[1].text, "Quit"); + end_of_game_dialog->options[1].color = GREEN; + end_of_game_dialog->options[1].handle = &handle_click_quit; Dialog *dekiyaku_end_of_round_dialog = &dialogs[4]; dekiyaku_end_of_round_dialog->text_count = 3; diff --git a/dialog.h b/dialog.h index 6468947..5041e8c 100644 --- a/dialog.h +++ b/dialog.h @@ -18,7 +18,7 @@ struct DialogOption { }; struct Dialog { - char *text[3]; + char *text[8]; int text_count; Color text_color; DialogOption options[3]; diff --git a/game.c b/game.c index 83279db..c4b7566 100644 --- a/game.c +++ b/game.c @@ -131,9 +131,8 @@ void initialize_game(Game *g) { g->dealer = &g->left; break; } - g->dealer = &g->player; - g->number_of_rounds = 3; + g->number_of_rounds = 1; g->current_round = 0; g->state = GAME_STATE_INITIALIZING; } @@ -656,8 +655,60 @@ void run_frame_end_of_round(Game *g) { } } +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) { @@ -734,6 +785,9 @@ void run_frame(Game *g) { case GAME_STATE_END_OF_GAME: run_frame_end_of_game(g); break; + case GAME_STATE_NEW_GAME: + run_frame_new_game(g); + break; } } @@ -773,12 +827,6 @@ void draw_frame(Game *g) { DrawText(g->field_multiplier->explanation, 60, 445, 20, BLACK); } - if (g->player.teyaku.calculated) { - char s[200]; - teyaku_to_string(&g->player.teyaku, s); - DrawText(s, 5, 25, 30, BLACK); - } - DrawText(g->player.points_string, 40, 700, 20, BLACK); DrawText(g->right.points_string, 40, 750, 20, BLACK); DrawText(g->left.points_string, 40, 800, 20, BLACK); diff --git a/game.h b/game.h index ae1c494..b7296e1 100644 --- a/game.h +++ b/game.h @@ -31,6 +31,7 @@ typedef enum GameState { GAME_STATE_CALCULATING_DEKIYAKU_SCORE, GAME_STATE_END_OF_ROUND, GAME_STATE_END_OF_GAME, + GAME_STATE_NEW_GAME, GAME_STATE_TITLE_SCREEN, } GameState; From a836a9e5e4488c4558405f9add0ca661f7289d98 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sat, 22 Feb 2025 14:36:31 -0500 Subject: [PATCH 45/51] Display the current round --- game.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/game.c b/game.c index c4b7566..969e2c9 100644 --- a/game.c +++ b/game.c @@ -831,6 +831,14 @@ void draw_frame(Game *g) { DrawText(g->right.points_string, 40, 750, 20, BLACK); DrawText(g->left.points_string, 40, 800, 20, BLACK); + char round_text[20]; + 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: From a0f669b357ae8f485996f6e44133c6eab8f061fc Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 05:10:42 -0500 Subject: [PATCH 46/51] Show incoming teyaku --- game.c | 13 +++++++++++-- player.h | 1 + teyaku.c | 4 +++- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/game.c b/game.c index 969e2c9..e479b0c 100644 --- a/game.c +++ b/game.c @@ -78,6 +78,9 @@ void initialize_game(Game *g) { 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"; @@ -369,8 +372,11 @@ void run_frame_calculating_field_multiplier(Game *g) { 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); g->state = GAME_STATE_START_OF_TURN; } @@ -827,9 +833,12 @@ void draw_frame(Game *g) { DrawText(g->field_multiplier->explanation, 60, 445, 20, BLACK); } - DrawText(g->player.points_string, 40, 700, 20, BLACK); - DrawText(g->right.points_string, 40, 750, 20, BLACK); + DrawText(g->player.points_string, 40, 650, 20, BLACK); + DrawText(g->player.teyaku_string, 40, 680, 20, BLACK); + DrawText(g->right.points_string, 40, 725, 20, BLACK); + DrawText(g->right.teyaku_string, 40, 755, 20, BLACK); DrawText(g->left.points_string, 40, 800, 20, BLACK); + DrawText(g->left.teyaku_string, 40, 830, 20, BLACK); char round_text[20]; if (g->current_round < g->number_of_rounds) diff --git a/player.h b/player.h index d7f6465..a3212c3 100644 --- a/player.h +++ b/player.h @@ -20,6 +20,7 @@ struct Player { int dekiyaku_score; int points; char points_string[20]; + char teyaku_string[50]; bool ai; bool dealer; }; diff --git a/teyaku.c b/teyaku.c index 6a3373a..b4cc0b2 100644 --- a/teyaku.c +++ b/teyaku.c @@ -92,5 +92,7 @@ void calculate_teyaku(const Hand h, Teyaku *t) { void teyaku_to_string(Teyaku *t, char *str) { int set_points = set_teyaku_points(t->set); int chaff_points = chaff_teyaku_points(t->chaff); - sprintf(str, "Set: %s(%d) / Chaff: %s(%d) / Total: %d", set_teyaku_english(t->set), set_points, chaff_teyaku_english(t->chaff), chaff_points, set_points + chaff_points); + // sprintf(str, "Set: %s(%d) / Chaff: %s(%d) / Total: %d", set_teyaku_english(t->set), set_points, chaff_teyaku_english(t->chaff), chaff_points, set_points + chaff_points); + if (set_points + chaff_points > 0) sprintf(str, "Teyaku: %d", set_points + chaff_points); + else sprintf(str, ""); } From 76da2656b401b98dcb0c217a0ae7da3665c0d062 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 05:42:31 -0500 Subject: [PATCH 47/51] Allow the player to choose their teyaku --- dialog.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++----- dialog.h | 3 ++- game.c | 15 ++++++++++-- teyaku.c | 12 +++++++++ teyaku.h | 3 +++ 5 files changed, 99 insertions(+), 9 deletions(-) diff --git a/dialog.c b/dialog.c index f832c2f..60695bb 100644 --- a/dialog.c +++ b/dialog.c @@ -45,6 +45,29 @@ void handle_click_quit(Game *g) { g->should_close = true; } +void handle_click_claim_set_teyaku(Game *g) { + g->player.teyaku.chaff = CHAFF_TEYAKU_NONE; + teyaku_to_string(&g->player.teyaku, g->player.teyaku_string); + g->state = GAME_STATE_START_OF_TURN; +} + +void handle_click_claim_chaff_teyaku(Game *g) { + g->player.teyaku.set = SET_TEYAKU_NONE; + teyaku_to_string(&g->player.teyaku, g->player.teyaku_string); + g->state = GAME_STATE_START_OF_TURN; +} + +void handle_click_claim_both_teyaku(Game *g) { + g->state = GAME_STATE_START_OF_TURN; +} + +void handle_click_dont_claim_teyaku(Game *g) { + (&g->player.teyaku)->chaff = CHAFF_TEYAKU_NONE; + g->player.teyaku.set = SET_TEYAKU_NONE; + teyaku_to_string(&g->player.teyaku, g->player.teyaku_string); + g->state = GAME_STATE_START_OF_TURN; +} + void init_dialogs(Game *g) { Dialog *cancel_dialog = &dialogs[0]; cancel_dialog->text_count = 1; @@ -134,6 +157,36 @@ void init_dialogs(Game *g) { strcpy(dekiyaku_end_of_round_dialog->options[0].text, "Okay"); dekiyaku_end_of_round_dialog->options[0].color = GREEN; dekiyaku_end_of_round_dialog->options[0].handle = &handle_click_ok_end_of_round; + + Dialog *teyaku_dialog = &dialogs[5]; + teyaku_dialog->text_count = 3; + teyaku_dialog->text[0] = malloc(200); + teyaku_dialog->text[1] = malloc(200); + teyaku_dialog->text[2] = malloc(200); + strcpy(teyaku_dialog->text[0], "You can claim some teyaku"); + teyaku_dialog->text_color = BLACK; + teyaku_dialog->options_count = 4; + teyaku_dialog->game = g; + + teyaku_dialog->options[0].text = malloc(50); + strcpy(teyaku_dialog->options[0].text, "Claim Set Teyaku"); + teyaku_dialog->options[0].color = SKYBLUE; + teyaku_dialog->options[0].handle = &handle_click_claim_set_teyaku; + + teyaku_dialog->options[1].text = malloc(50); + strcpy(teyaku_dialog->options[1].text, "Claim Chaff Teyaku"); + teyaku_dialog->options[1].color = SKYBLUE; + teyaku_dialog->options[1].handle = &handle_click_claim_chaff_teyaku; + + teyaku_dialog->options[2].text = malloc(50); + strcpy(teyaku_dialog->options[2].text, "Claim Both Teyaku"); + teyaku_dialog->options[2].color = GREEN; + teyaku_dialog->options[2].handle = &handle_click_claim_both_teyaku; + + teyaku_dialog->options[3].text = malloc(50); + strcpy(teyaku_dialog->options[3].text, "Don't Claim"); + teyaku_dialog->options[3].color = RED; + teyaku_dialog->options[3].handle = &handle_click_dont_claim_teyaku; } void cancel_dialog(Game *g) { g->dialog = &dialogs[0]; } @@ -141,14 +194,24 @@ void shoubu_dialog(Game *g) { g->dialog = &dialogs[1]; } void no_dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[2]; } void end_of_game_dialog(Game *g) { g->dialog = &dialogs[3]; } void dekiyaku_end_of_round_dialog(Game *g) { g->dialog = &dialogs[4]; } +void teyaku_dialog(Game *g) { g->dialog = &dialogs[5]; } Rectangle dialog_option_outer_rectangle(Dialog *d, int i) { - return (Rectangle) { - ((960 * (i + 1)) / (d->options_count + 1)) - 10 + 200, - 500, - MeasureText(d->options[i].text, DIALOG_OPTION_FONT_SIZE) + 20, - 40, - }; + if (d->options_count < 4) { + return (Rectangle) { + ((960 * (i + 1)) / (d->options_count + 1)) - 10 + 200, + 500, + MeasureText(d->options[i].text, DIALOG_OPTION_FONT_SIZE) + 20, + 40, + }; + } else { + return (Rectangle) { + ((960 * (i % 2)) / ((d->options_count / 2) + 1)) - 10 + 250, + 500 + ((i / 2) * 50), + MeasureText(d->options[i].text, DIALOG_OPTION_FONT_SIZE) + 20, + 40, + }; + } } Rectangle dialog_option_inner_rectangle(Dialog *d, int i) { diff --git a/dialog.h b/dialog.h index 5041e8c..ea75d32 100644 --- a/dialog.h +++ b/dialog.h @@ -21,7 +21,7 @@ struct Dialog { char *text[8]; int text_count; Color text_color; - DialogOption options[3]; + DialogOption options[4]; int options_count; Game *game; }; @@ -32,6 +32,7 @@ void shoubu_dialog(Game *g); void no_dekiyaku_end_of_round_dialog(Game *g); void end_of_game_dialog(Game *g); void dekiyaku_end_of_round_dialog(Game *g); +void teyaku_dialog(Game *g); void dialog_draw(Dialog *d); void dialog_handle_input(Dialog *d); diff --git a/game.c b/game.c index e479b0c..39fe8bb 100644 --- a/game.c +++ b/game.c @@ -311,6 +311,10 @@ void run_frame_initializing(Game *g) { 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; @@ -377,7 +381,14 @@ void run_frame_calculating_teyaku(Game *g) { 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); - g->state = GAME_STATE_START_OF_TURN; + + 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) { @@ -840,7 +851,7 @@ void draw_frame(Game *g) { DrawText(g->left.points_string, 40, 800, 20, BLACK); DrawText(g->left.teyaku_string, 40, 830, 20, BLACK); - char round_text[20]; + 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 diff --git a/teyaku.c b/teyaku.c index b4cc0b2..d4e397b 100644 --- a/teyaku.c +++ b/teyaku.c @@ -75,6 +75,10 @@ int chaff_teyaku_points(ChaffTeyaku ct) { return chaff_teyaku_points_array[ct]; } +int teyaku_points(Teyaku *t) { + return set_teyaku_points(t->set) + chaff_teyaku_points(t->chaff); +} + char *set_teyaku_english(SetTeyaku st) { return set_teyaku_english_array[st]; } @@ -89,6 +93,14 @@ void calculate_teyaku(const Hand h, Teyaku *t) { t->calculated = true; } +void set_teyaku_to_string(Teyaku *t, char *str) { + sprintf(str, "Set: %s(%d)", set_teyaku_english(t->set), set_teyaku_points(t->set)); +} + +void chaff_teyaku_to_string(Teyaku *t, char *str) { + sprintf(str, "Chaff: %s(%d)", chaff_teyaku_english(t->chaff), chaff_teyaku_points(t->chaff)); +} + void teyaku_to_string(Teyaku *t, char *str) { int set_points = set_teyaku_points(t->set); int chaff_points = chaff_teyaku_points(t->chaff); diff --git a/teyaku.h b/teyaku.h index 51d210e..20d4e3c 100644 --- a/teyaku.h +++ b/teyaku.h @@ -34,7 +34,10 @@ typedef struct Teyaku { bool calculated; } Teyaku; +int teyaku_points(Teyaku *t); void calculate_teyaku(const Hand h, Teyaku *t); +void set_teyaku_to_string(Teyaku *t, char *str); +void chaff_teyaku_to_string(Teyaku *t, char *str); void teyaku_to_string(Teyaku *t, char *str); #endif From e8a1389cdaaead089ea5bf9f59cc3ef1b9558202 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 05:53:55 -0500 Subject: [PATCH 48/51] Teyaku is paid to the appropriate players --- game.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/game.c b/game.c index 39fe8bb..46e8419 100644 --- a/game.c +++ b/game.c @@ -560,6 +560,19 @@ void run_frame_selecting_dekiyaku_action(Game *g) { } } +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); @@ -616,6 +629,7 @@ void run_frame_calculating_scores(Game *g) { if (hp[1] > hp[2]) g->dealer = &g->right; else g->dealer = &g->left; } + pay_teyaku(g); break; } } @@ -656,8 +670,9 @@ void run_frame_calculating_dekiyaku_score(Game *g) { } else if (g->left.dekiyaku_action == DEKIYAKU_ACTION_CANCEL || g->left.dekiyaku_action == DEKIYAKU_ACTION_SHOUBU) { calculate_dekiyaku_score(g, &g->left); } else { - // Hands are exhausted + // TODO: Hands are exhausted } + pay_teyaku(g); } void run_frame_end_of_round(Game *g) { From 1e8b280271e403056301e761892d2d28700d4fee Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 06:09:57 -0500 Subject: [PATCH 49/51] Add some options --- card.c | 8 ++++---- card.h | 4 ++-- game.c | 25 +++++++++++++------------ game.h | 2 ++ options.c | 15 +++++++++++++++ options.h | 18 ++++++++++++++++++ 6 files changed, 54 insertions(+), 18 deletions(-) create mode 100644 options.c create mode 100644 options.h diff --git a/card.c b/card.c index 6bf9fa8..4f8983a 100644 --- a/card.c +++ b/card.c @@ -104,7 +104,7 @@ int first_open_spot(Hand *h) { return fos; } -void add_to_hand(Hand *h, Card *c) { +void add_to_hand(Hand *h, Card *c, float deal_speed) { c->order = first_open_spot(h); h->cards[h->count] = c; @@ -131,7 +131,7 @@ void add_to_hand(Hand *h, Card *c) { } c->move.curve = CURVE_EASE_IN_OUT; c->move.current_time = 0.; - c->move.end_time = 0.2; + c->move.end_time = deal_speed; h->count++; } @@ -140,11 +140,11 @@ bool card_done_moving(Card *c) { return c->move.current_time > c->move.end_time; } -void deal(Hand *from, Hand *to, int count, bool up) { +void deal(Hand *from, Hand *to, int count, bool up, float deal_speed) { for (int i = 0; i < count; i++) { Card *c = from->cards[from->count - 1]; c->visible = up; - add_to_hand(to, c); + add_to_hand(to, c, deal_speed); from->count--; } } diff --git a/card.h b/card.h index 69d79d9..7e1844c 100644 --- a/card.h +++ b/card.h @@ -76,9 +76,9 @@ struct Hand { void draw_card(Card *c, Texture2D *cards_texture); bool point_within_card(Card *c, Vector2 v); void shuffle_hand(Hand *h); -void deal(Hand *from, Hand *to, int count, bool up); +void deal(Hand *from, Hand *to, int count, bool up, float deal_speed); void remove_from_hand(Hand *h, Card *c); -void add_to_hand(Hand *h, Card *c); +void add_to_hand(Hand *h, Card *c, float deal_speed); bool card_done_moving(Card *c); Rectangle next_card_position(Hand *h); diff --git a/game.c b/game.c index 46e8419..2a2ba9f 100644 --- a/game.c +++ b/game.c @@ -26,6 +26,7 @@ void initialize_game(Game *g) { g->field_multiplier = NULL; g->kan_value = 12; g->dialog = NULL; + g->deal_speed = 0.2; init_dialogs(g); @@ -265,16 +266,16 @@ void capture_card_from_field(Game *g, Card *played, Card *target, Hand *hand, Ha } remove_from_hand(hand, played); - add_to_hand(scored, 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]); + add_to_hand(scored, same_month_card[i], g->deal_speed); } } else { remove_from_hand(&g->field, target); - add_to_hand(scored, target); + add_to_hand(scored, target, g->deal_speed); } } @@ -289,7 +290,7 @@ void run_frame_ai_playing(Game *g) { 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); + add_to_hand(&g->field, play.played, g->deal_speed); } } @@ -322,7 +323,7 @@ void run_frame_initializing(Game *g) { for (int i = 0; i < 48; i++) { Card *c = &g->cards[i]; c->visible = false; - add_to_hand(&g->deck, c); + add_to_hand(&g->deck, c, g->deal_speed); } shuffle_hand(&g->deck); @@ -349,15 +350,15 @@ bool misdeal(Game *g) { void run_frame_dealing(Game *g) { if (current_player(g)->hand.count < 4) { - deal(&g->deck, ¤t_player(g)->hand, 4, is_player_turn(g)); + deal(&g->deck, ¤t_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); + deal(&g->deck, &g->field, 3, true, g->deal_speed); } else if (current_player(g)->hand.count < 7) { - deal(&g->deck, ¤t_player(g)->hand, 3, is_player_turn(g)); + deal(&g->deck, ¤t_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); + deal(&g->deck, &g->field, 3, true, g->deal_speed); } else { if (misdeal(g)) { printf("misdeal\n"); @@ -468,7 +469,7 @@ void run_frame_choosing_target(Game *g) { } 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); + add_to_hand(&g->field, g->current_play_from_hand, g->deal_speed); g->current_play_from_hand = NULL; } g->state = GAME_STATE_SHOWING_CARD_FROM_DECK; @@ -478,7 +479,7 @@ void run_frame_choosing_target(Game *g) { 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); + 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; @@ -498,7 +499,7 @@ void run_frame_playing_from_deck(Game *g) { 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); + 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; diff --git a/game.h b/game.h index b7296e1..5faee56 100644 --- a/game.h +++ b/game.h @@ -50,6 +50,8 @@ struct Game { Dialog *dialog; Player *dealer; int number_of_rounds; + Color card_backs; + float deal_speed; int current_round; }; diff --git a/options.c b/options.c new file mode 100644 index 0000000..67bdde2 --- /dev/null +++ b/options.c @@ -0,0 +1,15 @@ +#include "options.h" + +void load_options_from_game(Game *g, Options *o) { + o->kan_value = g->kan_value; + o->number_of_rounds = g->number_of_rounds; + o->card_backs = g->card_backs; + o->deal_speed = g->deal_speed; +} + +void save_options_to_game(Game *g, Options *o) { + g->kan_value = o->kan_value; + g->number_of_rounds = o->number_of_rounds; + g->card_backs = o->card_backs; + g->deal_speed = o->deal_speed; +} diff --git a/options.h b/options.h new file mode 100644 index 0000000..fc50954 --- /dev/null +++ b/options.h @@ -0,0 +1,18 @@ +#ifndef _HF_OPTIONS_ +#define _HF_OPTIONS_ + +typedef struct Options Options; + +#include "game.h" + +struct Options { + int kan_value; + int number_of_rounds; + Color card_backs; + float deal_speed; +}; + +void load_options_from_game(Game *g, Options *o); +void save_options_to_game(Game *g, Options *o); + +#endif From 6ca6bf06a9a8dd73e3d123eae75bbce350360c2d Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 09:17:25 -0500 Subject: [PATCH 50/51] Display and allow user to select option choices --- game.c | 29 +++++++++++--- game.h | 11 +++-- options.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++++----- options.h | 18 +++++++-- 4 files changed, 151 insertions(+), 24 deletions(-) diff --git a/game.c b/game.c index 2a2ba9f..7bd6a93 100644 --- a/game.c +++ b/game.c @@ -1,4 +1,5 @@ #include +#include #include #include "game.h" @@ -24,9 +25,14 @@ void initialize_game(Game *g) { g->should_close = false; g->state = GAME_STATE_INITIALIZING; g->field_multiplier = NULL; - g->kan_value = 12; 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)); + load_options_from_game(g); init_dialogs(g); @@ -136,9 +142,8 @@ void initialize_game(Game *g) { break; } - g->number_of_rounds = 1; g->current_round = 0; - g->state = GAME_STATE_INITIALIZING; + g->state = GAME_STATE_OPTIONS; } Player *current_player(Game *g) { @@ -159,15 +164,19 @@ bool is_player_turn(Game *g) { } void handle_input(Game *g) { - if (IsKeyPressed(KEY_R)) { - g->state = GAME_STATE_INITIALIZING; - return; + if (g->state == GAME_STATE_OPTIONS) { + return options_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) { @@ -821,6 +830,8 @@ void run_frame(Game *g) { case GAME_STATE_NEW_GAME: run_frame_new_game(g); break; + case GAME_STATE_OPTIONS: + break; } } @@ -853,6 +864,12 @@ void draw_frame(Game *g) { draw_cards(g); + if (g->state == GAME_STATE_OPTIONS) { + options_draw(g); + EndDrawing(); + return; + } + if (g->state == GAME_STATE_DEALING) { DrawText("Dealing....", 60, 385, 40, BLACK); } else if (g->field_multiplier) { diff --git a/game.h b/game.h index 5faee56..8e14999 100644 --- a/game.h +++ b/game.h @@ -12,6 +12,7 @@ typedef struct Game Game; #include "points.h" #include "player.h" #include "dialog.h" +#include "options.h" typedef enum GameState { GAME_STATE_INITIALIZING, @@ -33,6 +34,7 @@ typedef enum GameState { GAME_STATE_END_OF_GAME, GAME_STATE_NEW_GAME, GAME_STATE_TITLE_SCREEN, + GAME_STATE_OPTIONS, } GameState; struct Game { @@ -43,16 +45,17 @@ struct Game { Hand deck, field; FieldMultiplier *field_multiplier; Card *current_play_from_hand, *current_play_target; - int kan_value; Player player, right, left; int temp_points; int turn_number; Dialog *dialog; Player *dealer; - int number_of_rounds; - Color card_backs; - float deal_speed; int current_round; + int kan_value; + int number_of_rounds; + bool black_card_backs; + float deal_speed; + Options *options; }; void initialize_game(Game *g); diff --git a/options.c b/options.c index 67bdde2..db6a2dc 100644 --- a/options.c +++ b/options.c @@ -1,15 +1,112 @@ #include "options.h" -void load_options_from_game(Game *g, Options *o) { - o->kan_value = g->kan_value; - o->number_of_rounds = g->number_of_rounds; - o->card_backs = g->card_backs; - o->deal_speed = g->deal_speed; +int kan_value_from_index(int index) { return index == 0 ? 10 : 12; } +int index_from_kan_value(int kan_value) { return kan_value == 10 ? 0 : 1; } +int number_of_rounds_from_index(int index) { + int r[] = { 1, 3, 6, 12 }; + return r[index]; +} +int index_from_number_of_rounds(int number_of_rounds) { + int r[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 3 }; + return r[number_of_rounds]; +} +float deal_speed_from_index(int index) { return (index + 1) / 10. ; } +float index_from_deal_speed(float deal_speed) { return (int) (deal_speed * 10) - 1 ; } + +void load_options_from_game(Game *g) { + g->options->kan_value = index_from_kan_value(g->kan_value); + g->options->number_of_rounds = index_from_number_of_rounds(g->number_of_rounds); + g->options->card_backs = g->black_card_backs; + g->options->deal_speed = index_from_deal_speed(g->deal_speed); } -void save_options_to_game(Game *g, Options *o) { - g->kan_value = o->kan_value; - g->number_of_rounds = o->number_of_rounds; - g->card_backs = o->card_backs; - g->deal_speed = o->deal_speed; +void save_options_to_game(Game *g) { + g->kan_value = kan_value_from_index(g->options->kan_value); + g->number_of_rounds = number_of_rounds_from_index(g->options->number_of_rounds); + g->black_card_backs = g->options->card_backs; + g->deal_speed = deal_speed_from_index(g->options->deal_speed); +} + +void handle_options_save(Game *g) { + save_options_to_game(g); + g->state = GAME_STATE_INITIALIZING; +} + +void handle_options_cancel(Game *g) { + load_options_from_game(g); + g->state = GAME_STATE_INITIALIZING; +} + +void handle_select_kan(Game *g, int index) { + g->options->kan_value = index; +} + +void handle_select_number_of_rounds(Game *g, int index) { + g->options->number_of_rounds = index; +} + +void handle_select_card_backs(Game *g, int index) { + g->options->card_backs = index; +} + +void handle_select_deal_speed(Game *g, int index) { + g->options->deal_speed = index; +} + +OptionsChoices kan_choices = { { "Ten", "Twelve" }, 2, 250, &handle_select_kan }; +OptionsChoices number_of_rounds_choices = { { "One", "Three", "Six", "Twelve" }, 4, 400, &handle_select_number_of_rounds }; +OptionsChoices card_backs_choices = { { "Red", "Black" }, 2, 550, &handle_select_card_backs }; +OptionsChoices deal_speed_choices = { { "Very Slow", "Slow", "Medium", "Fast", "Very Fast" }, 5, 700, &handle_select_deal_speed }; +OptionsChoices *oc[4] = { &kan_choices, &number_of_rounds_choices, &card_backs_choices, &deal_speed_choices }; + +void options_handle_input(Game *g) { + if (!IsMouseButtonPressed(0)) return; + + int left = 250; + int width = 900; + + Vector2 mouse_pos = GetMousePosition(); + int x = mouse_pos.x, y = mouse_pos.y; + for (int i = 0; i < 4; i++) { + OptionsChoices *choices = oc[i]; + if (y < choices->y || y > choices->y + 30) continue; + + for (int j = 0; j < choices->count; j++) { + char *choice = choices->choice[j]; + int w = MeasureText(choice, 30); + int center = left + (width / (choices->count + 1)) * (j + 1); + int min = center - (w/2); + int max = center + (w/2); + if (x > min && x < max) { + choices->handle(g, j); + return; + } + } + } +} + +void DrawTextCentered(char *text, int center_x, int y, int point, Color color) { + int width = MeasureText(text, point); + DrawText(text, center_x - (width / 2), y, point, color); +} + +void draw_option_choices(OptionsChoices *choices, int selected_index) { + int left = 250; + int width = 900; + for (int i = 0; i < choices->count; i++) { + Color color = i == selected_index ? RED : BLACK; + DrawTextCentered(choices->choice[i], left + (width / (choices->count + 1)) * (i + 1), choices->y, 30, color); + } +} + +void options_draw(Game *g) { + DrawTextCentered("Options", 700, 50, 60, BLACK); + DrawTextCentered("Kan Value", 700, 175, 40, BLACK); + draw_option_choices(&kan_choices, g->options->kan_value); + DrawTextCentered("Number of Rounds", 700, 325, 40, BLACK); + draw_option_choices(&number_of_rounds_choices, g->options->number_of_rounds); + DrawTextCentered("Card Backs", 700, 475, 40, BLACK); + draw_option_choices(&card_backs_choices, g->options->card_backs); + DrawTextCentered("Deal Speed", 700, 625, 40, BLACK); + draw_option_choices(&deal_speed_choices, g->options->deal_speed); } diff --git a/options.h b/options.h index fc50954..52f4a79 100644 --- a/options.h +++ b/options.h @@ -2,17 +2,27 @@ #define _HF_OPTIONS_ typedef struct Options Options; +typedef struct OptionsChoices OptionsChoices; #include "game.h" struct Options { int kan_value; int number_of_rounds; - Color card_backs; - float deal_speed; + int card_backs; + int deal_speed; }; -void load_options_from_game(Game *g, Options *o); -void save_options_to_game(Game *g, Options *o); +struct OptionsChoices { + char *choice[5]; + int count; + int y; + void (*handle)(Game*, int); +}; + +void load_options_from_game(Game *g); +void save_options_to_game(Game *g); +void options_handle_input(Game *g); +void options_draw(Game *g); #endif From 879e01a32bdee44eb5fa8df7967e05723d7cc371 Mon Sep 17 00:00:00 2001 From: Bill Rossi Date: Sun, 23 Feb 2025 09:27:48 -0500 Subject: [PATCH 51/51] Save and cancel options --- options.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/options.c b/options.c index db6a2dc..0cecc2a 100644 --- a/options.c +++ b/options.c @@ -56,7 +56,7 @@ void handle_select_deal_speed(Game *g, int index) { OptionsChoices kan_choices = { { "Ten", "Twelve" }, 2, 250, &handle_select_kan }; OptionsChoices number_of_rounds_choices = { { "One", "Three", "Six", "Twelve" }, 4, 400, &handle_select_number_of_rounds }; OptionsChoices card_backs_choices = { { "Red", "Black" }, 2, 550, &handle_select_card_backs }; -OptionsChoices deal_speed_choices = { { "Very Slow", "Slow", "Medium", "Fast", "Very Fast" }, 5, 700, &handle_select_deal_speed }; +OptionsChoices deal_speed_choices = { { "Very Fast", "Fast", "Medium", "Slow", "Very Slow" }, 5, 700, &handle_select_deal_speed }; OptionsChoices *oc[4] = { &kan_choices, &number_of_rounds_choices, &card_backs_choices, &deal_speed_choices }; void options_handle_input(Game *g) { @@ -83,6 +83,15 @@ void options_handle_input(Game *g) { } } } + + if (x > 400 && x < 400 + MeasureText("Save", 30) + 12 && y > 800 && y < 836) { + handle_options_save(g); + return; + } + if (x > 900 && x < 900 + MeasureText("Cancel", 30) + 12 && y > 800 && y < 836) { + handle_options_cancel(g); + return; + } } void DrawTextCentered(char *text, int center_x, int y, int point, Color color) { @@ -109,4 +118,12 @@ void options_draw(Game *g) { draw_option_choices(&card_backs_choices, g->options->card_backs); DrawTextCentered("Deal Speed", 700, 625, 40, BLACK); draw_option_choices(&deal_speed_choices, g->options->deal_speed); + + DrawRectangle(400, 800, MeasureText("Save", 30) + 12, 36, BLACK); + DrawRectangle(403, 803, MeasureText("Save", 30) + 6, 30, GREEN); + DrawText("Save", 406, 806, 30, BLACK); + + DrawRectangle(900, 800, MeasureText("Cancel", 30) + 12, 36, BLACK); + DrawRectangle(903, 803, MeasureText("Cancel", 30) + 6, 30, RED); + DrawText("Cancel", 906, 806, 30, BLACK); }