Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-07-30 02:18:11 -07:00
Code Issues Packages Projects Releases Wiki Activity

BJ updated

Browse Source
This commit is contained in:
RogueMaster
2022-10-16 14:50:41 -04:00
parent 6f9c82650d
commit b2c9f0cc66
11 changed files with 625 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files
applications/plugins/blackjack/util.c
+170 -17
View File
@@ -1,61 +1,85 @@
#include "util.h"
static List *afterDelay;
const char *CONFIG_FILE_PATH = EXT_PATH(".blackjack.settings");
static QueueItem *afterDelay;
float lerp(float v0, float v1, float t) {
if (t > 1) return v1;
return (1 - t) * v0 + t * v1;
}
Vector lerp_2d(Vector start, Vector end, float t) {
return (Vector) {
lerp(start.x, end.x, t),
lerp(start.y, end.y, t),
};
}
Vector quadratic_2d(Vector start, Vector control, Vector end, float t) {
return lerp_2d(
lerp_2d(start, control, t),
lerp_2d(control, end, t),
t
);
}
void queue(GameState *game_state,
void (*callback)(GameState *game_state),
void (*start)(GameState *game_state),
void (*processing)(const GameState *gameState, Canvas *const canvas)
void (*processing)(const GameState *gameState, Canvas *const canvas,uint32_t duration,uint32_t margin),
uint32_t duration,uint32_t margin
) {
if (afterDelay == NULL) {
game_state->animationStart = game_state->last_tick;
afterDelay = malloc(sizeof(List));
afterDelay = malloc(sizeof(QueueItem));
afterDelay->callback = callback;
afterDelay->processing = processing;
afterDelay->start = start;
afterDelay->duration = duration;
afterDelay->margin = margin;
afterDelay->next = NULL;
} else {
List *next = afterDelay;
while (next->next != NULL) { next = (List *) (next->next); }
next->next = malloc(sizeof(List));
((List *) next->next)->callback = callback;
((List *) next->next)->processing = processing;
((List *) next->next)->start = start;
((List *) next->next)->next = NULL;
QueueItem *next = afterDelay;
while (next->next != NULL) { next = (QueueItem *) (next->next); }
next->next = malloc(sizeof(QueueItem));
((QueueItem *) next->next)->callback = callback;
((QueueItem *) next->next)->processing = processing;
((QueueItem *) next->next)->start = start;
((QueueItem *) next->next)->duration = duration;
((QueueItem *) next->next)->margin = margin;
((QueueItem *) next->next)->next = NULL;
}
}
void queue_clear() {
while (afterDelay != NULL) {
List *f = afterDelay;
QueueItem *f = afterDelay;
free(f);
afterDelay = f->next;
}
}
void dequeue(GameState *game_state) {
((List *) afterDelay)->callback(game_state);
List *f = afterDelay;
afterDelay = (List *) afterDelay->next;
((QueueItem *) afterDelay)->callback(game_state);
QueueItem *f = afterDelay;
afterDelay = (QueueItem *) afterDelay->next;
free(f);
if (afterDelay != NULL && afterDelay->start != NULL)afterDelay->start(game_state);
game_state->animationStart = game_state->last_tick;
}
void animateQueue(const GameState *game_state, Canvas *const canvas) {
if (afterDelay != NULL && ((List *) afterDelay)->processing != NULL) {
((List *) afterDelay)->processing(game_state, canvas);
if (afterDelay != NULL && ((QueueItem *) afterDelay)->processing != NULL) {
((QueueItem *) afterDelay)->processing(game_state, canvas, afterDelay->duration, afterDelay->margin);
}
}
bool run_queue(GameState *game_state) {
if (afterDelay != NULL) {
game_state->animating = true;
if ((game_state->last_tick - game_state->animationStart) > ANIMATION_TIME) {
if ((game_state->last_tick - game_state->animationStart) > afterDelay->duration) {
dequeue(game_state);
}
return true;
@@ -63,3 +87,132 @@ bool run_queue(GameState *game_state) {
game_state->animating = false;
return false;
}
void save_settings(Settings settings) {
Storage *storage = furi_record_open(RECORD_STORAGE);
FlipperFormat *file = flipper_format_file_alloc(storage);
FURI_LOG_D(APP_NAME, "Saving config");
if (flipper_format_file_open_existing(file, CONFIG_FILE_PATH)) {
FURI_LOG_D(APP_NAME, "Saving %s: %ld", CONF_ANIMATION_DURATION, settings.animation_duration);
flipper_format_update_uint32(file, CONF_ANIMATION_DURATION, &(settings.animation_duration), 1);
FURI_LOG_D(APP_NAME, "Saving %s: %ld", CONF_ANIMATION_MARGIN, settings.animation_margin);
flipper_format_update_uint32(file, CONF_ANIMATION_MARGIN, &(settings.animation_margin), 1);
FURI_LOG_D(APP_NAME, "Saving %s: %ld", CONF_MESSAGE_DURATION, settings.message_duration);
flipper_format_update_uint32(file, CONF_MESSAGE_DURATION, &(settings.message_duration), 1);
FURI_LOG_D(APP_NAME, "Saving %s: %ld", CONF_STARTING_MONEY, settings.starting_money);
flipper_format_update_uint32(file, CONF_STARTING_MONEY, &(settings.starting_money), 1);
FURI_LOG_D(APP_NAME, "Saving %s: %ld", CONF_ROUND_PRICE, settings.round_price);
flipper_format_update_uint32(file, CONF_ROUND_PRICE, &(settings.round_price), 1);
FURI_LOG_D(APP_NAME, "Saving %s: %i", CONF_SOUND_EFFECTS, settings.sound_effects?1:0);
flipper_format_update_bool(file, CONF_SOUND_EFFECTS, &(settings.sound_effects), 1);
FURI_LOG_D(APP_NAME, "Config saved");
}else{
FURI_LOG_E(APP_NAME, "Save error");
}
flipper_format_file_close(file);
flipper_format_free(file);
furi_record_close(RECORD_STORAGE);
}
void save_settings_file(FlipperFormat *file, Settings *settings) {
flipper_format_write_header_cstr(file, CONFIG_FILE_HEADER, CONFIG_FILE_VERSION);
flipper_format_write_comment_cstr(file, "Card animation duration in ms");
flipper_format_write_uint32(file, CONF_ANIMATION_DURATION, &(settings->animation_duration), 1);
flipper_format_write_comment_cstr(file,
"Card animation margin in ms (how long the card will stay besides the played hand)");
flipper_format_write_uint32(file, CONF_ANIMATION_MARGIN, &(settings->animation_margin), 1);
flipper_format_write_comment_cstr(file, "Popup message duration in ms");
flipper_format_write_uint32(file, CONF_MESSAGE_DURATION, &(settings->message_duration), 1);
flipper_format_write_comment_cstr(file, "Player's starting money");
flipper_format_write_uint32(file, CONF_STARTING_MONEY, &(settings->starting_money), 1);
flipper_format_write_comment_cstr(file, "Round price");
flipper_format_write_uint32(file, CONF_ROUND_PRICE, &(settings->round_price), 1);
flipper_format_write_comment_cstr(file, "Enable sound effects");
flipper_format_write_bool(file, CONF_SOUND_EFFECTS, &(settings->sound_effects), 1);
}
Settings load_settings() {
Settings settings;
FURI_LOG_D(APP_NAME, "Loading default settings");
settings.animation_margin = 200;
settings.animation_duration = 1500;
settings.message_duration = 1500;
settings.starting_money = 200;
settings.round_price = 10;
settings.sound_effects = true;
FURI_LOG_D(APP_NAME, "Opening storage");
Storage *storage = furi_record_open(RECORD_STORAGE);
FURI_LOG_D(APP_NAME, "Allocating file");
FlipperFormat *file = flipper_format_file_alloc(storage);
FURI_LOG_D(APP_NAME, "Allocating string");
FuriString *string_value;
string_value = furi_string_alloc();
if (storage_common_stat(storage, CONFIG_FILE_PATH, NULL) != FSE_OK) {
FURI_LOG_D(APP_NAME, "Config file %s not found, creating new one...", CONFIG_FILE_PATH);
if (!flipper_format_file_open_new(file, CONFIG_FILE_PATH)) {
FURI_LOG_E(APP_NAME, "Error creating new file %s", CONFIG_FILE_PATH);
flipper_format_file_close(file);
} else {
save_settings_file(file, &settings);
}
} else {
if (!flipper_format_file_open_existing(file, CONFIG_FILE_PATH)) {
FURI_LOG_E(APP_NAME, "Error opening existing file %s", CONFIG_FILE_PATH);
flipper_format_file_close(file);
} else {
uint32_t value;
bool valueBool;
FURI_LOG_D(APP_NAME, "Checking version");
if (!flipper_format_read_header(file, string_value, &value)) {
FURI_LOG_E(APP_NAME, "Config file mismatch");
} else {
FURI_LOG_D(APP_NAME, "Loading %s", CONF_ANIMATION_DURATION);
if (flipper_format_read_uint32(file, CONF_ANIMATION_DURATION, &value, 1)) {
settings.animation_duration = value;
FURI_LOG_D(APP_NAME, "Loaded %s: %ld", CONF_ANIMATION_DURATION, value);
}
FURI_LOG_D(APP_NAME, "Loading %s", CONF_ANIMATION_MARGIN);
if (flipper_format_read_uint32(file, CONF_ANIMATION_MARGIN, &value, 1)) {
settings.animation_margin = value;
FURI_LOG_D(APP_NAME, "Loaded %s: %ld", CONF_ANIMATION_MARGIN, value);
}
FURI_LOG_D(APP_NAME, "Loading %s", CONF_MESSAGE_DURATION);
if (flipper_format_read_uint32(file, CONF_MESSAGE_DURATION, &value, 1)) {
settings.message_duration = value;
FURI_LOG_D(APP_NAME, "Loaded %s: %ld", CONF_MESSAGE_DURATION, value);
}
FURI_LOG_D(APP_NAME, "Loading %s", CONF_STARTING_MONEY);
if (flipper_format_read_uint32(file, CONF_STARTING_MONEY, &value, 1)) {
settings.starting_money = value;
FURI_LOG_D(APP_NAME, "Loaded %s: %ld", CONF_STARTING_MONEY, value);
}
FURI_LOG_D(APP_NAME, "Loading %s", CONF_ROUND_PRICE);
if (flipper_format_read_uint32(file, CONF_ROUND_PRICE, &value, 1)) {
settings.round_price = value;
FURI_LOG_D(APP_NAME, "Loaded %s: %ld", CONF_ROUND_PRICE, value);
}
FURI_LOG_D(APP_NAME, "Loading %s", CONF_SOUND_EFFECTS);
if (flipper_format_read_bool(file, CONF_SOUND_EFFECTS, &valueBool, 1)) {
settings.sound_effects = valueBool;
FURI_LOG_D(APP_NAME, "Loaded %s: %i", CONF_ROUND_PRICE, valueBool?1:0);
}
}
flipper_format_file_close(file);
}
}
furi_string_free(string_value);
// flipper_format_file_close(file);
flipper_format_free(file);
furi_record_close(RECORD_STORAGE);
return settings;
}