Make it possible to score points ha haaaaa

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];

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

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;
@@ -21,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;
@@ -303,8 +308,48 @@ 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));
+
+  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:
+  case SPECIAL_CASE_SIXTEEN_CHAFF:
+    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;
 }
 
 void run_frame(Game *g) {
@@ -351,6 +396,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;
   }
 }
 
@@ -389,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);
+}

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 {
@@ -34,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

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;
+}

points.h

@@ -0,0 +1,8 @@
+#ifndef _HF_POINTS_
+#define _HF_POINTS_
+
+#include "card.h"
+
+int hand_points(Hand *hand);
+
+#endif

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 };
+}
+

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