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