140 lines
5.4 KiB
C
140 lines
5.4 KiB
C
// Copyright 2025 Bill Rossi
|
|
//
|
|
// This file is part of Hanafuda Hachi-Hachi.
|
|
//
|
|
// Hanafuda Hachi-Hachi is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// Hanafuda Hachi-Hachi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with Hanafuda Hachi-Hachi. If not, see <https://www.gnu.org/licenses/>.
|
|
#include <stdio.h>
|
|
#include "options.h"
|
|
|
|
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) {
|
|
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_TITLE_SCREEN;
|
|
}
|
|
|
|
void handle_options_cancel(Game *g) {
|
|
load_options_from_game(g);
|
|
g->state = GAME_STATE_TITLE_SCREEN;
|
|
}
|
|
|
|
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 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) {
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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) {
|
|
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);
|
|
|
|
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);
|
|
}
|