From f1703f9c87e3c9fd3a5716b8a2d1a48c8d71438c Mon Sep 17 00:00:00 2001 From: sandyx Date: Fri, 10 Jan 2025 01:36:53 -0600 Subject: [PATCH] deltas --- hl2.lss | 705 +++++++++++++++++++++++++++++++++++++++++ lss_builder.rb | 29 ++ src/controller.c | 82 ++++- src/controller.h | 3 +- src/main.c | 28 +- src/segment_renderer.c | 34 +- src/segment_renderer.h | 9 +- src/splits.c | 48 ++- src/splits.h | 6 +- src/timer.c | 33 +- src/timer.h | 18 +- src/timer_renderer.c | 4 +- 12 files changed, 946 insertions(+), 53 deletions(-) create mode 100644 hl2.lss create mode 100644 lss_builder.rb diff --git a/hl2.lss b/hl2.lss new file mode 100644 index 0000000..66015ed --- /dev/null +++ b/hl2.lss @@ -0,0 +1,705 @@ + + + Half-Life 2 + Xbox Scripted + + + + + + + 00:00:00 + 0 + + + + d1_trainstation_01 + + + 00:00:10.00 + + + + + d1_trainstation_02 + + + 00:03:48.00 + + + + + d1_trainstation_03 + + + 00:04:27.00 + + + + + d1_trainstation_04 + + + 00:06:31.00 + + + + + d1_trainstation_05 + + + 00:14:30.00 + + + + + d1_trainstation_06 + + + 00:16:18.00 + + + + + d1_canals_01 + + + 00:18:31.00 + + + + + d1_canals_01a + + + 00:20:14.00 + + + + + d1_canals_01b + + + 00:21:27.00 + + + + + d1_canals_02 + + + 00:22:03.00 + + + + + d1_canals_03 + + + 00:24:22.00 + + + + + d1_canals_04 + + + 00:26:12.00 + + + + + d1_canals_05a + + + 00:26:49.00 + + + + + d1_canals_05b + + + 00:27:57.00 + + + + + d1_canals_06a + + + 00:29:17.00 + + + + + d1_canals_06b + + + 00:30:46.00 + + + + + d1_canals_07a + + + 00:32:39.00 + + + + + d1_canals_07b + + + 00:34:10.00 + + + + + d1_canals_08 + + + 00:35:56.00 + + + + + d1_canals_09 + + + 00:37:36.00 + + + + + d1_canals_10a + + + 00:38:07.00 + + + + + d1_canals_10b + + + 00:39:44.00 + + + + + d1_canals_11a + + + 00:40:18.00 + + + + + d1_canals_11b + + + 00:41:59.00 + + + + + d1_canals_12a + + + 00:42:48.00 + + + + + d1_canals_12b + + + 00:44:21.00 + + + + + d1_canals_13 + + + 00:45:18.00 + + + + + d1_eli_01 + + + 00:52:51.00 + + + + + d1_eli_02 + + + 00:53:55.00 + + + + + d1_town_01 + + + 00:54:33.00 + + + + + d1_town_01a + + + 00:56:15.00 + + + + + d1_town_01b + + + 00:57:17.00 + + + + + d1_town_02 + + + 00:59:43.00 + + + + + d1_town_02a + + + 01:00:00.00 + + + + + d1_town_04 + + + 01:01:00.00 + + + + + d1_town_05 + + + 01:03:00.00 + + + + + d2_coast_01 + + + 01:04:00.00 + + + + + d2_coast_03a + + + 01:06:00.00 + + + + + d2_coast_03b + + + 01:06:30.00 + + + + + d2_coast_04 + + + 01:08:00.00 + + + + + d2_coast_05 + + + 01:10:00.00 + + + + + d2_coast_07 + + + 01:12:00.00 + + + + + d2_coast_09a + + + 01:13:00.00 + + + + + d2_coast_09b + + + 01:15:00.00 + + + + + d2_coast_10 + + + 01:16:00.00 + + + + + d2_coast_11a + + + 01:17:00.00 + + + + + d2_coast_11b + + + 01:19:00.00 + + + + + d2_coast_12 + + + 01:21:00.00 + + + + + d2_prison_01 + + + 01:23:00.00 + + + + + d2_prison_02 + + + 01:23:30.00 + + + + + d2_prison_03a + + + 01:24:00.00 + + + + + d2_prison_03b + + + 01:25:00.00 + + + + + d2_prison_04 + + + 01:26:00.00 + + + + + d2_prison_05a + + + 01:27:00.00 + + + + + d2_prison_05b + + + 01:29:00.00 + + + + + d2_prison_06a + + + 01:31:00.00 + + + + + d2_prison_06b + + + 01:32:00.00 + + + + + d2_prison_07a + + + 01:32:30.00 + + + + + d2_prison_07b + + + 01:33:00.00 + + + + + d2_prison_08 + + + 01:39:00.00 + + + + + d3_c17_01 + + + 01:40:00.00 + + + + + d3_c17_02 + + + 01:41:00.00 + + + + + d3_c17_03 + + + 01:42:00.00 + + + + + d3_c17_04 + + + 01:43:00.00 + + + + + d3_c17_05 + + + 01:46:00.00 + + + + + d3_c17_06 + + + 01:46:30.00 + + + + + d3_c17_06a + + + 01:48:00.00 + + + + + d3_c17_06b + + + 01:49:00.00 + + + + + d3_c17_07 + + + 01:50:00.00 + + + + + d3_c17_08 + + + 01:51:00.00 + + + + + d3_c17_08a + + + 01:52:00.00 + + + + + d3_c17_09 + + + 01:54:00.00 + + + + + d3_c17_10a + + + 01:56:00.00 + + + + + d3_c17_10b + + + 01:57:00.00 + + + + + d3_c17_11 + + + 01:59:00.00 + + + + + d3_c17_12 + + + 02:01:00.00 + + + + + d3_c17_12b + + + 02:02:00.00 + + + + + d3_c17_13 + + + 02:03:00.00 + + + + + d3_citadel_01 + + + 02:08:00.00 + + + + + d3_citadel_02 + + + 02:11:00.00 + + + + + d3_citadel_03 + + + 02:12:00.00 + + + + + d3_citadel_04a + + + 02:16:00.00 + + + + + d3_citadel_04b + + + 02:17:30.00 + + + + + d3_citadel_05 + + + 02:19:00.00 + + + + + d3_breen_01a + + + 02:24:00.00 + + + + + d3_breen_01b + + + 02:30:06.78 + + + + + + diff --git a/lss_builder.rb b/lss_builder.rb new file mode 100644 index 0000000..69f7ac8 --- /dev/null +++ b/lss_builder.rb @@ -0,0 +1,29 @@ +#lss_builder.rb + +#just make a list of names +#and a list of times +# +#make sure they have the same +#number of lines + +#maybe ill make a splits editor sometime + +def wrap(tag, str) + return "<#{tag}>#{str}" +end + +name_lines = File.readlines("splits.txt") +time_lines = File.readlines("times.txt") + +both = name_lines.zip(time_lines) +print both + +out = both.map { |x| + realtime = wrap("RealTime", x[1].strip) + splittime = wrap("SplitTime", realtime) + splittimes = wrap("SplitTimes", splittime) + + name_tag = wrap("Name", x[0].strip) + segment_tag = wrap("Segment", name_tag + splittimes) +} +File.write("output.txt", out.join("")) diff --git a/src/controller.c b/src/controller.c index f2eaa35..826919b 100644 --- a/src/controller.c +++ b/src/controller.c @@ -1,5 +1,6 @@ #include "controller.h" #include "segment_renderer.h" +#include int *splits = 0; @@ -26,17 +27,53 @@ inline void ctrl_pause(ghost timer) { ctrl_pause_igt(timer); } +void ctrl_record_segment(ctrl_binder *cb) { + ghost ghost = cb->timer; + segment *segment = &cb->live_sl->segments[cb->current_segment]; + + segment->realtime = ghtimer_time(ghost.rta); + segment->gametime = ghtimer_time(ghost.igt); + + //need a condition for igt here + //cb->delta_sl->segments[cb->current_segment].realtime = subts(segment->realtime, cb->rec_sl->segments[cb->current_segment].realtime); + struct timespec a, b; + a = segment->realtime; + b = cb->rec_sl->segments[cb->current_segment].realtime; + //b = (struct timespec) {10}; + char abuf[64]; + char bbuf[64]; + char dbuf[64]; + + struct timespec d = subts(a, b); + time_unparse(dbuf, FMT_SIZE, &d); + + if (time_cmp(b, a)) { + //printf("GRN: %s - %s = %s\n", time_unparse(abuf, FMT_SIZE, &a), time_unparse(bbuf, FMT_SIZE, &b), dbuf); + cb->delta_sl->segments[cb->current_segment].realtime = subts(b, a); + cb->delta_sl->segments[cb->current_segment].positive = 1; + } else { + //printf("RED: %s - %s = %s\n", time_unparse(abuf, FMT_SIZE, &a), time_unparse(bbuf, FMT_SIZE, &b), dbuf); + cb->delta_sl->segments[cb->current_segment].realtime = subts(a, b); + cb->delta_sl->segments[cb->current_segment].positive = 0; + } + + //cb->delta_sl->segments[cb->current_segment].realtime = subts((struct timespec){10}, segment->realtime); + cb->delta_sl->segments[cb->current_segment].gametime = subts(segment->gametime, segment->gametime); +} + +//this function handles everything void ctrl_start(ctrl_binder *cb) { + //vars for easier code reading + segment *current_segment = &cb->live_sl->segments[cb->current_segment]; + if (cb->timer.rta->running) { if (cb->rec_sl != NULL) { if (cb->current_segment < cb->live_sl->count) { - cb->live_sl->segments[cb->current_segment].realtime = ghtimer_time(cb->timer.rta); - //need to add a condition for igt - //cb->sr->scroller = scroll(cb->sr->scroller); - + ctrl_record_segment(cb); } else { goto STOP; } + cb->current_segment++; cb->sr->current = cb->current_segment; scroll_down(cb->sr->scroller); @@ -45,14 +82,14 @@ STOP: cb->current_segment = 0; cb->sr->running = false; cb->sr->current = cb->current_segment; - ghtimer_stop(cb->timer.rta); //stop or reset, save splits + ghost_op(cb->timer, ghtimer_stop); scroll_reset(cb->sr->scroller); } //pause timer if last split if (cb->current_segment == cb->live_sl->count) { cb->sr->running = false; - ghtimer_pause(cb->timer.rta); + ghost_op(cb->timer, ghtimer_pause); //for both igt and rta return; } } else { @@ -68,13 +105,40 @@ void ctrl_bind_timer_renderer(ctrl_binder *cb, timer_renderer *timer) { } void ctrl_bind_segment_renderer(ctrl_binder *cb, segment_renderer *segmer) { cb->sr = segmer; + + //yikes + cb->sr->scroller->delta_sl = *cb->delta_sl; + cb->sr->scroller->delta_segs = cb->delta_sl->segments; } ctrl_binder *create_ctrl_binder(ghost timer, segment_list *sl) { - ctrl_binder *binder = calloc(1, sizeof(ctrl_binder)); + segment_list *zero = calloc(1, sizeof(segment_list)); + zero->count = sl->count; + zero->segments = calloc(zero->count, sizeof(segment)); + + for (int i = 0; i < zero->count; i++) { + zero->segments[i].realtime = (struct timespec){0}; + } + + ctrl_binder *binder = calloc(1, sizeof(*binder)); binder->timer = timer; - binder->rec_sl = sl; - binder->live_sl = sl; + //binder->rec_sl = zero; + binder->live_sl = zero; + + //allocate an array for the delta times + binder->delta_sl = calloc(1, sizeof(*binder->delta_sl)); + binder->delta_sl->count = sl->count; + binder->delta_sl->segments = calloc(binder->delta_sl->count, sizeof(segment)); return binder; } + +//bind recorded segments from file +void ctrl_bind_segments(ctrl_binder *cb, segment_list *rec) { + cb->rec_sl = rec; +} + +void destroy_ctrl_binder(ctrl_binder *cb) { + free(cb->delta_sl); + free(cb); +} diff --git a/src/controller.h b/src/controller.h index 3378d13..83df1c2 100644 --- a/src/controller.h +++ b/src/controller.h @@ -12,7 +12,7 @@ typedef struct ctrl_binder { ghost timer; - segment_list *rec_sl, *live_sl; + segment_list *rec_sl, *live_sl, *delta_sl; timer_renderer *tr; segment_renderer *sr; int current_segment; @@ -21,6 +21,7 @@ typedef struct ctrl_binder { ctrl_binder *create_ctrl_binder(ghost timer, segment_list *sl); void ctrl_bind_timer_renderer(ctrl_binder *cb, timer_renderer *timer); void ctrl_bind_segment_renderer(ctrl_binder *cb, segment_renderer *segmer); +void ctrl_bind_segments(ctrl_binder *cb, segment_list *sl); void ctrl_start(ctrl_binder *cb); void ctrl_pause(ghost timer); void ctrl_pause_igt(ghost timer); diff --git a/src/main.c b/src/main.c index 2374619..bd4382d 100644 --- a/src/main.c +++ b/src/main.c @@ -4,9 +4,7 @@ //#include "fmt.h" #include "segment_renderer.h" #include "controller.h" -//#include "scanner.h" #include "splits.h" -//#include "parser.c" #include #if defined(PLATFORM_DESKTOP) @@ -25,7 +23,7 @@ int remote_state = 0; Font font; -//extern this for other files +//extern this in other files void error(const char *msg) { fprintf(stderr, ERROR, msg); exit(EXIT_FAILURE); @@ -43,10 +41,6 @@ void control(void) { } int main(int argc, char *argv[]) { - - //font = LoadFontEx("/usr/share/fonts/CozetteVector.ttf", 400, 0, 0); - // GenTextureMipmaps(&font.texture); - if (argc < 2) { error("gimme file"); exit(EXIT_FAILURE); @@ -69,39 +63,37 @@ int main(int argc, char *argv[]) { ghost ghost = ghost_new(); ctrl_binder *binder = create_ctrl_binder(ghost, &segs); + ctrl_bind_segments(binder, &segs); //make a layout manager for these - timer_renderer *tr = create_timer_renderer(ghost, (Vector2){0.0f, windowHeight/8 * 6}, (Vector2){(float)windowWidth, (float)windowHeight/8}); + timer_renderer *tr = create_timer_renderer( + ghost, + (Vector2){0.0f, windowHeight/8 * 6}, + (Vector2){(float)windowWidth, (float)windowHeight/8} + ); + segment_renderer *sr = create_segment_renderer(segs, 0.0f, 0.0f); ctrl_bind_timer_renderer(binder, tr); ctrl_bind_segment_renderer(binder, sr); - //uint8_t buffer[1024]; - // float fontSize = (float)font.baseSize; + float fontSize = (float)font.baseSize; while (!WindowShouldClose()) { ghost_tick(ghost); - //ghtimer_timestring(ghost.rta, buffer); if (IsKeyPressed(KEY_P)) { ctrl_start(binder); } BeginDrawing(); - //BeginShaderMode(shader); ClearBackground(BLACK); - //DrawTexture(texture, 0, 0, WHITE); - //EndShaderMode(); - //need to make this not weird render_segments(sr); render_timer(tr); - //EndShaderMode(); - //printf("cunt\n"); EndDrawing(); } - //ghost_delete(ghost); + ghost_delete(ghost); CloseWindow(); } diff --git a/src/segment_renderer.c b/src/segment_renderer.c index 9b6ffe8..ecda5be 100644 --- a/src/segment_renderer.c +++ b/src/segment_renderer.c @@ -24,8 +24,10 @@ void scroll_down(scroller *s) { if (s->view_index >= s->sl.count - s->count) { return; } + s->view_index++; s->segs = &s->sl.segments[s->view_index]; + s->delta_segs = &s->delta_sl.segments[s->view_index]; //printf("%d %d\n", s->view_index, s->sl.count - s->count); } @@ -35,6 +37,10 @@ void scroll_reset(scroller *s) { s->segs = &s->sl.segments[s->view_index]; } +void destroy_scroller(scroller *s) { + free(s); +} + segment_renderer *create_segment_renderer(segment_list sl, float y, float h) { segment_renderer *sr = (segment_renderer *)calloc(1, sizeof(*sr)); sr->pos = y; @@ -44,8 +50,7 @@ segment_renderer *create_segment_renderer(segment_list sl, float y, float h) { sr->current = 0; sr->running = false; sr->shader = NULL; - sr->scroller = create_scroller(13, sl); - //printf("cunt %p\n%p\n", s, sr->scroller); + sr->scroller = create_scroller(15, sl); return sr; } @@ -58,12 +63,13 @@ void set_segment_count(segment_renderer *sr, int c) { } void destroy_segment_renderer(segment_renderer *sr) { + free(sr->scroller); free(sr); } -void render_segments(segment_renderer *sr) { - +Color color[2] = {RED, GREEN}; +void render_segments(segment_renderer *sr) { //need to not draw it if its the last split //or if the timer isnt running if (sr->running) { @@ -72,10 +78,26 @@ void render_segments(segment_renderer *sr) { //draw a big rectangle the size of the segment thing //DrawRectangle(0, 0, windowWidth, 90, BLACK); + + //for (int i = 0; i < sr->scroller->index; i++) { + //DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->scroller->delta_segs[i].realtime), (Vector2){280, 30 * i}, (float)font.baseSize/20, 2, GREEN); + //} for (int i = 0; i < sr->scroller->count; i++) { + //int j = i + sr->scroller->index; //DrawText(sr->scroller->segs[i].name, (Vector2){10, 30 * i}.x, (Vector2){10, 30 * i}.y, 20, WHITE); - DrawTextEx(font, sr->scroller->segs[i].name, (Vector2){10, 30 * i}, 20, 2, WHITE); - DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->scroller->segs[i].realtime), (Vector2){350, 30 * i}, (float)font.baseSize/16, 2, WHITE); + DrawTextEx(font, sr->scroller->segs[i].name, (Vector2){10, 30 * i}, (float)font.baseSize/16, 2, WHITE); + + //if the segment has been splitted upon, display the delta instead + if (sr->scroller->index <= i) { + char *time = time_unparse(sr->strfmt, FMT_SIZE, &sr->scroller->segs[i].realtime); + Vector2 m = MeasureTextEx(font, time, font.baseSize/16, 2); + DrawTextEx(font, time, (Vector2){410 - m.x, 30 * i}, (float)font.baseSize/16, 2, WHITE); + } else { + char *time = time_unparse(sr->strfmt, FMT_SIZE, &sr->scroller->delta_segs[i].realtime); + Vector2 m = MeasureTextEx(font, time, font.baseSize/16, 2); + DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->scroller->delta_segs[i].realtime), (Vector2){410 - m.x, 30 * i}, (float)font.baseSize/16, 2, color[sr->scroller->delta_segs[i].positive]); + } + } } diff --git a/src/segment_renderer.h b/src/segment_renderer.h index 1ec38ae..d8fe9c6 100644 --- a/src/segment_renderer.h +++ b/src/segment_renderer.h @@ -13,12 +13,17 @@ extern Font font; //need to implement scrolling when total_splits > visible +typedef struct delta { + segment *seg; + bool positive; +} delta; + typedef struct scroller { int count; int index; //where the bar should be on the splits int view_index; //the first split displayed - segment *segs; - segment_list sl; + segment *segs, *delta_segs; + segment_list sl, delta_sl; } scroller; scroller *create_scroller(int c, segment_list sl); diff --git a/src/splits.c b/src/splits.c index 142c1e7..93b7c28 100644 --- a/src/splits.c +++ b/src/splits.c @@ -111,6 +111,33 @@ struct xml_string *get_name_string(struct xml_node *node) { return NULL; } +struct xml_string *get_time_string(struct xml_node *node) { + struct xml_node *iter; + + for (int i = 0; i < xml_node_children(node); i++) { + if (xml_name_compare(xml_node_child(node, i), "SplitTimes")) { + iter = xml_node_child(node, i); + break; + } + } + + for (int i = 0; i < xml_node_children(iter); i++) { + if (xml_name_compare(xml_node_child(iter, i), "SplitTime")) { + iter = xml_node_child(iter, i); + break; + } + } + + for (int i = 0; i < xml_node_children(iter); i++) { + if (xml_name_compare(xml_node_child(iter, i), "RealTime")) { + iter = xml_node_child(iter, i); + return xml_node_content(iter); + } + } + + return NULL; +} + uint8_t **extract(segment_nodes segments, struct xml_string *(operation)(struct xml_node *)) { struct xml_string **xml_strings = calloc(segments.count, sizeof(struct xml_string *)); @@ -178,7 +205,7 @@ segment_list open_splits_file(const char *path) { error("Could not parse xml"); } - printf("splits.c: parsed %s successfully\n", path); + //printf("splits.c: parsed %s successfully\n", path); int children = 0; struct xml_node *root = xml_document_root(xml); @@ -186,6 +213,7 @@ segment_list open_splits_file(const char *path) { struct xml_node *segments_node = get_segments_node(root); segment_nodes segments = get_node_children(segments_node); uint8_t **segment_names = extract(segments, get_name_string); + uint8_t **segment_times = extract(segments, get_time_string); printf("open_splits_file: %d\n", segments.count); @@ -196,17 +224,23 @@ segment_list open_splits_file(const char *path) { segment_list seglist = {0}; printf("open_splits_file: %d\n", segments.count); - printf("%ld\n", segments.count * sizeof(segment)); - long long what = segments.count * sizeof(segment); - printf("what: %lld\n", what); - segment *segs = malloc(1008); - printf("?\n"); + //printf("%ld\n", segments.count * sizeof(segment)); + //long long what = segments.count * sizeof(segment); + //printf("what: %lld\n", what); + //segment *segs = malloc(1008); + segment *segs = malloc(segments.count * sizeof(*segs)); + //printf("?\n"); for (int i = 0; i < segments.count; i++) { segs[i].name = segment_names[i]; - //segs[i].realtime = (struct timespec){0}; + if (segment_times[i] != NULL) { + segs[i].realtime = parse_time(segment_times[i]); + printf("%s\n", segment_times[i]); + } } + printf("splits.c: parsed %s successfully\n", path); + seglist.segments = segs; seglist.count = segments.count; return seglist; diff --git a/src/splits.h b/src/splits.h index 190f59b..a94823b 100644 --- a/src/splits.h +++ b/src/splits.h @@ -11,6 +11,8 @@ struct segment { struct timespec gametime; struct timespec best; char *name; + bool positive; //for delta times + //i'm too lazy to make deltas their own struct //segment *next; }; @@ -19,11 +21,11 @@ typedef struct segment_list { int count; } segment_list; -//binds two lists of segments together +//binds two lists of segments and a delta together typedef struct segment_binder { segment_list *rta; segment_list *igt; -} segment_binder; +} segment_binder; //why do i need this segment_list open_splits_file(const char *path); void render_splits(segment_list *segments); diff --git a/src/timer.c b/src/timer.c index d569269..1acfcf0 100644 --- a/src/timer.c +++ b/src/timer.c @@ -1,5 +1,8 @@ -#include "timer.h" +#include +#include +#include #include +#include "timer.h" struct timespec subts(struct timespec t1, struct timespec t2) { return (struct timespec) { @@ -19,6 +22,10 @@ double timespec_to_double(struct timespec ts) { return ((double)(ts.tv_sec) + ((double)(ts.tv_nsec) / NSEC_PER_SEC)); } +//is t1 greater than t2 +bool time_cmp(struct timespec t1, struct timespec t2) { + return timespec_to_double(t1) > timespec_to_double(t2); +} ghtimer *ghtimer_new(void) { ghtimer *timer = calloc(1, sizeof(ghtimer)); @@ -125,3 +132,27 @@ void ghost_start(ghost ghost) { ghtimer_start(ghost.rta); ghtimer_start(ghost.igt); } + +void ghost_pause(ghost ghost) { + ghtimer_pause(ghost.rta); + ghtimer_pause(ghost.igt); +} + +void ghost_resume(ghost ghost) { + ghtimer_resume(ghost.rta); + ghtimer_resume(ghost.igt); +} + +void ghost_igt_pause(ghost ghost) { + ghtimer_pause(ghost.igt); +} + +void ghost_igt_resume(ghost ghost) { + ghtimer_resume(ghost.igt); +} + +//may make things easier for the controller +void ghost_op(ghost ghost, void(*op)(ghtimer *)) { + op(ghost.rta); + op(ghost.igt); +} diff --git a/src/timer.h b/src/timer.h index 86229ab..2f82568 100644 --- a/src/timer.h +++ b/src/timer.h @@ -1,20 +1,20 @@ #ifndef TIMER_H #define TIMER_H -#include -#include -#include #include +#include #define NSEC_PER_SEC 1000000000 struct timespec subts(struct timespec t1, struct timespec t2); struct timespec addts(struct timespec t1, struct timespec t2); double timespec_to_double(struct timespec ts); +bool time_cmp(struct timespec t1, struct timespec t2); //appended GH just incase theres a conflict with anything //else named "Timer" +//a ghtimer is one individual timer typedef struct ghtimer { struct timespec start; struct timespec current; @@ -25,7 +25,10 @@ typedef struct ghtimer { int paused; } ghtimer; -//two timers tied together +/* + a ghost is a real time and + in game time timer tied together +*/ typedef struct ghost { ghtimer *rta; ghtimer *igt; @@ -48,5 +51,10 @@ ghost ghost_rta_new(void); void ghost_delete(ghost ghost); //free and set to NULL void ghost_tick(ghost ghost); void ghost_start(ghost ghost); - +void ghost_pause(ghost ghost); +void ghost_resume(ghost ghost); +void ghost_time(ghost ghost); +void ghost_igt_pause(ghost ghost); +void ghost_igt_resume(ghost ghost); +void ghost_op(ghost ghost, void(*op)(ghtimer *)); #endif diff --git a/src/timer_renderer.c b/src/timer_renderer.c index e55a228..39852f8 100644 --- a/src/timer_renderer.c +++ b/src/timer_renderer.c @@ -24,7 +24,7 @@ void destroy_timer_renderer(timer_renderer *tr) { void render_timer(timer_renderer *tr) { struct timespec ts = ghtimer_time(tr->mode ? tr->timer.igt : tr->timer.rta); time_unparse(tr->strfmt, FMT_SIZE, &ts); - Vector2 text_size = MeasureTextEx(font, tr->strfmt, (float)font.baseSize/4, 2); + Vector2 text_size = MeasureTextEx(font, tr->strfmt, (float)font.baseSize/5, 2); //set_timer_pos(tr, (Vector2)tr->pos.y - text_size.y); if (tr->shader != NULL) { @@ -38,5 +38,5 @@ void render_timer(timer_renderer *tr) { EndShaderMode(); } - DrawTextEx(font, tr->strfmt , (Vector2){(float)windowWidth - text_size.x - 2.0f, tr->pos.y}, (float)font.baseSize / 4, 2, WHITE); + DrawTextEx(font, tr->strfmt , (Vector2){(float)windowWidth - text_size.x - 2.0f, tr->pos.y}, (float)font.baseSize / 5, 2, WHITE); }