fix overlap, save splits

lss_builder.rb

@@ -26,4 +26,5 @@ out = both.map { |x|
 	name_tag = wrap("Name", x[0].strip)
 	segment_tag = wrap("Segment", name_tag + splittimes)
 }
+
 File.write("output.txt", out.join(""))

src/controller.c

@@ -1,9 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "controller.h"
 #include "segment_renderer.h"
-#include <stdio.h>
+#include "file.h"
 
 #define debug(x) printf("DEBUG: %s\n", (x));
 
+enum {
+	SEGNAME = 0,
+	SEGDELTA,
+	SEGTIME
+};
+
 int *splits = 0;
 
 //pause for igt only
@@ -32,6 +41,7 @@ inline void ctrl_pause(ghost timer) {
 void ctrl_record_segment(ctrl_binder *cb) {
 	ghost ghost = cb->timer;
 	segment *segment = &cb->live_sl->segments[cb->current_segment];
+	cb->live_sl->segments[cb->current_segment].name = cb->rec_sl->segments[cb->current_segment].name;
 
 	segment->realtime = ghtimer_time(ghost.rta);
 	segment->gametime = ghtimer_time(ghost.igt);
@@ -67,12 +77,26 @@ void ctrl_record_segment(ctrl_binder *cb) {
 	cb->delta_sl->segments[cb->current_segment].gametime = subts(segment->gametime, segment->gametime);
 }
 
+//a quick fix for text overlapping
+void ctrl_adjust_scrollers(ctrl_binder *cb) {
+	scroller *sc_names, *sc_delta, *sc_times;
+	sc_names = cb->scrollers[SEGNAME];
+	sc_delta = cb->scrollers[SEGDELTA];
+	sc_times = cb->scrollers[SEGTIME];
+
+	for (int i = sc_names->view_index; i < sc_names->count + sc_names->view_index; i++) {
+		txt_pos(sc_delta->txtcol->column[i], (Vector2){scroll_widest_visible(sc_names) + 15, sc_delta->txtcol->column[i]->pos.y});
+	}
+}
+
 //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) {
+			ctrl_adjust_scrollers(cb);
+
             if (cb->current_segment < cb->live_sl->count) {
 				ctrl_record_segment(cb);
             } else {
@@ -85,10 +109,14 @@ void ctrl_start(ctrl_binder *cb) {
 			
         } else {
 STOP:
+			//save
+			char *data = save_fmt(cb->live_sl);
+			file_save(data, "save.lss");
+
             cb->current_segment = 0;
 			ghost_op(cb->timer, ghtimer_stop);
 			ctrl_scroller_op(cb, scroll_reset);
-			txtcol_op(cb->scrollers[1]->txtcol, txt_clear); //clear deltas
+			txtcol_op(cb->scrollers[SEGDELTA]->txtcol, txt_clear); //clear deltas
         }
 
         //pause timer if last split

src/file.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "file.h"
+
+
+char buffer[32];
+#define file_log(x) printf("FILE: %s\n", (x))
+#define file_fmt(x) sprintf(buffer, "%d", (x))
+
+void file_save(char *data, char *filename) {
+	file_log("Saving file...");
+	char buffer[16000];
+	char *bfp = &buffer[0];
+	sprintf(bfp, "ruby src/test.rb %s %s", data, filename);
+	printf("SYSTEM: %s\n", bfp);
+	system(bfp);
+}
+
+void test(void) {
+	file_fmt(system("ruby src/test.rb"));
+	file_log(buffer);
+}

src/file.h

@@ -1,6 +1,14 @@
 #ifndef FILE_H
 #define FILE_H
 
+//#include <stdio.h>
 
+typedef struct lss_file {
+	//FILE *lss;
+	char *filename;
+	char *data;
+} lss_file;
+
+void file_save(char *data, char *filename);
 
 #endif

src/main.c

@@ -4,6 +4,7 @@
 #include "segment_renderer.h"
 #include "controller.h"
 #include "splits.h"
+#include "file.h"
 #include <stdio.h>
 
 #if defined(PLATFORM_DESKTOP)
@@ -41,6 +42,16 @@ void control(void) {
     last_state = remote_state;
 }
 
+/*
+	autosplitter
+
+	for accuracy have the timer and memory scanner on separate threads
+	the timer and scanner would each have their own tickrate
+
+	the scanner acts as its own controller for the timer
+	calling timer_pause and timer_unpause
+*/
+
 int main(int argc, char *argv[]) {
 	if (argc < 2) {
 		error("gimme file");
@@ -58,7 +69,7 @@ int main(int argc, char *argv[]) {
     Shader shader = LoadShader(0, "shaders/frag.glsl");
     UnloadImage(blank);
 
-	font = LoadFontEx("/usr/share/fonts/CozetteVector.ttf", 400, 0, 0);
+	font = LoadFontEx("/usr/share/fonts/dejavu/DejaVuSans.ttf", 400, 0, 0);
     GenTextureMipmaps(&font.texture);
 	
     ghost ghost = ghost_new();
@@ -89,13 +100,13 @@ int main(int argc, char *argv[]) {
 		txtcol_set(seg_delta, "     ", i);
 		txtcol_set(seg_times, buffer, i);
 		txt_pos(seg_names->column[i], (Vector2){0, i * font.baseSize/16});
-		txt_pos(seg_delta->column[i], (Vector2){txtcol_widest(seg_names) + 10, i * font.baseSize/16});
+		txt_pos(seg_delta->column[i], (Vector2){txtcol_widest(seg_names), i * font.baseSize/16});
 		txt_pos(seg_times->column[i], (Vector2){0, i * font.baseSize/16});
 	}
 
 	//lol
-	txtcol_adjacent(seg_names, seg_delta, 10);
+	//txtcol_adjacent(seg_names, seg_delta, 10);
-	txtcol_adjacent(seg_delta, seg_times, 10);
+	//txtcol_adjacent(seg_delta, seg_times, 10);
 	
 	scroller *scr1 = scroll_new(15, seg_names);
 	scroller *scr2 = scroll_new(15, seg_delta);
@@ -112,11 +123,19 @@ int main(int argc, char *argv[]) {
     while (!WindowShouldClose()) {
         ghost_tick(ghost);
 
+		//need to make an input handler
+		//so the loop doesnt get cluttered
         if (IsKeyPressed(KEY_P)) {
 			ctrl_start(binder);
+			//ctrl_adjust_scrollers(binder);
 			txtcol_op(seg_times, txt_left);
         }
 
+        if (IsKeyPressed(KEY_S)) {
+			char *data = save_fmt(&segs);
+			file_save(data, "rubytest.lss");
+        }		
+
         BeginDrawing();
             ClearBackground(BLACK);
 			ctrl_scroller_op(binder, scroll_draw); //yummy

src/segment_renderer.c

@@ -135,6 +135,21 @@ void txtcol_adjacent(text_column *tc1, text_column *tc2, int offset) {
 	tc2->pos.x = tc1->pos.x + m.x + offset;
 }
 
+//old save function
+void txtcol_save(text_column *tc) {
+	FILE *file = fopen("save.txt", "w");
+	if (file == NULL) {
+		return;
+	}
+
+	for (int i = 0; i < tc->count; i++) {
+		fwrite(tc->column[i]->string, 1, strlen(tc->column[i]->string), file);
+		fwrite("\n", 1, 1, file);
+	}
+
+	fclose(file);
+}
+
 //left justify a txtcol
 
 //scroller funcs
@@ -182,10 +197,21 @@ void scroll_reset(scroller *s) {
 void scroll_draw(scroller *s) {
 	for (int i = s->view_index; i < s->count + s->view_index; i++) {
 		txt_draw(txtcol_get(s->txtcol, i));
-		//txt_print(txtcol_get(s->txtcol, i));
 	}
 }
 
+int scroll_widest_visible(scroller *s) {
+	int widest = 0;
+	for (int i = s->view_index; i < s->count + s->view_index; i++) {
+		int w = txt_width(s->txtcol->column[i]);
+		if (widest < w) {
+			widest = w;
+		}
+	}
+
+	return widest;
+}
+
 void destroy_scroller(scroller *s) {
 	free(s);
 }

src/segment_renderer.h

@@ -31,6 +31,7 @@ void txt_print(text *t);
 void txt_color(text *t, Color color);
 void txt_pos(text *t, Vector2 pos);
 void txt_left(text *t);
+int txt_width(text *t);
 void txt_clear(text *t);
 
 //a list of text structs
@@ -51,6 +52,7 @@ int txtcol_widest(text_column *tc);
 void txtcol_op(text_column *tc, void (*op)(text *));
 void txtcol_adjacent(text_column *tc1, text_column *tc2, int offset);
 //void txtcol_left(text_column *tc, int offset);
+void txtcol_save(text_column *tc);
 
 typedef struct delta { //dont need this
 	segment *seg;
@@ -69,6 +71,7 @@ scroller *scroll_new(int c, text_column *tc);
 void scroll_down(scroller *s);
 void scroll_reset(scroller *s);
 void scroll_draw(scroller *s);
+int scroll_widest_visible(scroller *s);
 
 typedef struct segment_renderer {
     float pos;

src/splits.c

@@ -246,7 +246,26 @@ segment_list open_splits_file(const char *path) {
 	return seglist;
 }
 
+char *save_fmt(segment_list *sl) {
+#define buffer_size 8192
+	static char buffer[buffer_size];
+	char *bfp;
+	bfp = &buffer[0];
+	memset(bfp, 0, buffer_size);
+
+	char unparse_buffer[64];
+	char *unp;
+	
+	for (int i = 0; i < sl->count; i++) {
+		unp = time_unparse(unparse_buffer, 64, &sl->segments[i].realtime);
+		sprintf(bfp, "%s=%s%%", sl->segments[i].name, unp);
+		bfp += strlen(bfp);
+	}
 
+	printf("%s\n", buffer);
+	return buffer;
+#undef buffer_size
+}
 /*void render_splits(segment_list *segments) {
     char buffer[100];
     

src/splits.h

@@ -27,6 +27,7 @@ typedef struct segment_binder {
 	segment_list *igt;
 } segment_binder; //why do i need this
 
+char *save_fmt(segment_list *sl);
 segment_list open_splits_file(const char *path);
 void render_splits(segment_list *segments);
 void debug_print_list(segment_list *segments);

src/test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby
+
+#need more data to make a complete lss file
+#make some kind of calling convention with the argv
+
+def wrap(tag, str)
+	return "<#{tag}>#{str}</#{tag}>\n"
+end
+
+splits = ARGV[0].split("%")
+out = splits.map do |x|
+	y = x.split("=")
+
+	realtime = wrap("RealTime", y[1])
+	splittime = wrap("SplitTime", realtime)
+	splittimes = wrap("SplitTimes", splittime)
+	name_tag = wrap("Name", y[0])
+	segment_tag = wrap("Segment", name_tag + splittimes)
+	#segments = wrap("Segments", segment_tag)
+	#run = wrap("Run", segments)
+end
+
+out = wrap("Segments", out.join(""))
+out = wrap("Run", out)
+
+File.write(ARGV[1], out)