changed mind, added helpers to derive pausedTime without a global

formatspec.md

@@ -147,8 +147,6 @@ applicable, or by default is matched with the last set of metadata declared by
 the time of the run directive
 
 Run
-	Category
-		Any%
 	Route
 		Magic Swordless
 	Start

src2/client.c

@@ -13,7 +13,6 @@ int main(int argc, char *argv[]) {
 	struct hostent *server;
 
 	char buffer[256];
-	char commandcode;
 
 	if (argc < 2) {
 		fprintf(stderr,"usage %s command\n", argv[0]);
@@ -48,73 +47,27 @@ int main(int argc, char *argv[]) {
 		exit(1);
 	}
 
-	if (!strcmp(argv[1], "time")) {
-		commandcode = 1;
-	} else if (!strcmp(argv[1], "start")) {
-		commandcode = 2;
-	} else if (!strcmp(argv[1], "stop")) {
-		commandcode = 3;
-	} else if (!strcmp(argv[1], "kill")) {
-		commandcode = 4;
-	} else if (!strcmp(argv[1], "split")) {
-		commandcode = 5;
-	} else if (!strcmp(argv[1], "skip")) {
-		commandcode = 6;
-	} else if (!strcmp(argv[1], "pause")) {
-		commandcode = 7;
-	} else if (!strcmp(argv[1], "resume")) {
-		commandcode = 8;
-	} else if (!strcmp(argv[1], "undo")) {
-		commandcode = 9;
-	} else if (!strcmp(argv[1], "redo")) {
-		commandcode = 10;
-	} else if (!strcmp(argv[1], "foreground")) {
-		commandcode = 11;
-	} else if (!strcmp(argv[1], "background")) {
-		commandcode = 12;
-	} else if (!strcmp(argv[1], "save")) {
-		commandcode = 13;
-	} else {
-		perror("No valid command given");
-		exit(1);
+	bzero(buffer, 256);
+	for (int i = 1; i < argc; i++) {
+		strcat(buffer, argv[i]);
+		strcat(buffer, " ");
 	}
 
 	/* Send message to the server */
-	n = write(sockfd, &commandcode, 1);
-
+	n = write(sockfd, &buffer, 256);
 	if (n < 0) {
 		perror("ERROR writing to socket");
 		exit(1);
 	}
 
 	/* Now read server response */
-	//bzero(buffer,256);
-	
-	//read an int response
-	if (commandcode < 11) {
-		int x = -1;
-		n = read(sockfd, &x, sizeof(int));
-
-		if (n < 0) {
-			perror("ERROR reading from socket");
-			exit(1);
-		}
-
-		if (x != -1)
-			printf("%d\n",x);
-	}
-	//read a string response
-	else {
 	bzero(buffer,256);
-		n = read(sockfd, &buffer, 255);
-
+	n = read(sockfd, &buffer, 256);
 	if (n < 0) {
 		perror("ERROR reading from socket");
 		exit(1);
 	}
-
 	if (buffer != NULL)
-			printf("%s", buffer);
-	}
+		printf("%s\n", buffer);
 	return 0;
 }

src2/server.c

@@ -12,10 +12,10 @@
 #define NS_PER_S 1000000000
 
 struct timespec finish, delta;
-int pausedTime = 0;
 bool timerActive = false;
 bool paused = false;
 bool alive = true;
+bool hasUndoneAtLeastOnce = false;
 bool runUnsaved = false;
 int timerOffset = 0;
 enum event_type {
@@ -24,15 +24,24 @@ enum event_type {
 	SKIP,
 	PAUSE,
 	RESUME,
+	RESET,
 	STOP
 };
 struct run_event {
 	enum event_type type;
 	struct timespec time;
 };
+struct segment {
+	char *shortname;
+	char *longname;
+	char *description;
+};
+struct route {
+	char *name;
+	int segment_count;
+	struct segment *segments;
+};
 
-char* current_category = NULL;
-char* current_route = NULL;
 struct run_event *run;
 //Enough to hold a sm64 16 star, can realloc later
 int runMaxLength = 12;
@@ -44,8 +53,13 @@ char *default_file_name = "untitled.quest";
 int run_count = 0;
 int files = 0;
 char **filePaths = NULL;
-char **names, **values;
+char **meta_keys, **meta_values;
 int valuecount;
+struct segment *segments;
+int segment_count = 0;
+struct route *routes;
+int route_count = 0;
+struct route current_route;
 
 //functions
 void sub_timespec(struct timespec t1, struct timespec t2, struct timespec* td);
@@ -53,23 +67,39 @@ void offset_timespec(int milliseconds, struct timespec* t);
 int timespecToMS(struct timespec t);
 void extend_run();
 void add_event(enum event_type t);
+void appendRunToFile();
+void timespecToRFC3339(struct timespec t, char buf[]);
+void loadFiles();
+void add_segment(char *sname, char *lname, char *desc);
+void addFile(char *path);
+void sendInt(int sock, int value);
+void sendValue(int sock, char* name);
+void sendString(int sock, char* str);
+void process_socket_input(int sock);
+void set_metadata(char *key, char *value);
+void save_metadata_to_file(char *token, char *token2);
+void reset_timer();
+int current_ms();
+
+//basic timer commands
 void start();
-void stop();
 void split();
+void stop();
 void skip();
-void addPauseTime();
-void subtractPauseTime();
 void undo();
 void redo();
 void pause_timer();
 void resume();
-void appendRunToFile();
-void timespecToRFC3339(struct timespec t, char buf[]);
-void loadFiles();
-void addFile(char *path);
-void sendTime(int sock);
-void sendValue(int sock, char* name);
-void doprocessing (int sock);
+void reset();
+
+//convenient combination commands
+void start_split_stop();
+void start_reset();
+void start_split();
+void split_stop();
+void start_stop();
+void pause_resume();
+void undo_redo();
 
 
 void sub_timespec(struct timespec t1, struct timespec t2, struct timespec* td)
@@ -122,21 +152,30 @@ void add_event(enum event_type t)
 		offset_timespec(timerOffset, &run[runMarker].time);
 	runMarker++;
 	runMarker2 = runMarker;
+	hasUndoneAtLeastOnce = false;
+}
+
+void reset_timer()
+{
+	runMarker = 0;
+	runMarker2 = 0;
 }
 
 void start()
 {
-	//TODO: Save the old run to the file before the new one starts,
+	if (timerActive) return;
+	//Save the old run to the file before the new one starts,
 	//the reason to do this here is it gives the runner a chance to undo
 	//if they accidentally hit the stop button
 	appendRunToFile();
-	//TODO: Clear the run data first
+	reset_timer();
 	timerActive = true;
 	add_event(START);
 }
 
 void stop()
 {
+	if (!timerActive) return;
 	timerActive = false;
 	add_event(STOP);
 	//this makes sure the time clients recieve from time
@@ -145,79 +184,117 @@ void stop()
 	runUnsaved = true;
 }
 
+//Identical function to stop() but with a RESET event
+void reset()
+{
+	if (!timerActive) return;
+	timerActive = false;
+	add_event(RESET);
+	finish = run[runMarker - 1].time;
+	runUnsaved = true;
+}
+
+void start_split_stop()
+{
+	if (!timerActive) {
+		start();
+	} else {
+		if (runMarker < current_route.segment_count) {
+			split();
+		} else {
+			stop();
+		}
+	}
+}
+
+void start_split()
+{
+	if (!timerActive) start();
+	else split();
+}
+
+void split_stop()
+{
+	if (runMarker < current_route.segment_count) split();
+	else stop();
+}
+
+void start_stop()
+{
+	if (!timerActive) start();
+	else stop();
+}
+
+void start_reset()
+{
+	if (!timerActive) start();
+	else reset();
+}
+
 void split()
 {
+	if (!timerActive) return;
 	add_event(SPLIT);
 }
 
 void skip()
 {
+	if (!timerActive) return;
 	add_event(SKIP);
 }
 
-void addPauseTime()
-{
-	int pauseEvent = 0;
-	for (int i = runMarker - 2; i >= 1; i--) {
-		if (run[i].type == PAUSE) {
-			pauseEvent = i;
-			break;
-		}
-	}
-	sub_timespec(run[pauseEvent].time, run[runMarker - 1].time, &delta);
-	pausedTime += timespecToMS(delta);
-}
-
-void subtractPauseTime()
-{
-	int pauseEvent = 0;
-	for (int i = runMarker - 1; i >= i; i--) {
-		if (run[i].type == PAUSE) {
-			pauseEvent = i;
-			break;
-		}
-	}
-	sub_timespec(run[pauseEvent].time, run[runMarker].time, &delta);
-	pausedTime -= timespecToMS(delta);
-}
-
 void undo()
 {
 	if (runMarker > 0) {
 		runMarker--;
-		if (run[runMarker].type == STOP)
+		if (run[runMarker].type == STOP) {
 			timerActive = true;
+			runUnsaved = false;
+		}
 		if (run[runMarker].type == START)
 			timerActive = false;
 		if (run[runMarker].type == PAUSE)
 			paused = false;
 		if (run[runMarker].type == RESUME) {
 			paused = true;
-			subtractPauseTime();
 		}
+		hasUndoneAtLeastOnce = true;
 	}
 }
 
 void redo()
 {
+	if (!timerActive) return;
 	if (runMarker < runMarker2) {
 		runMarker++;
-		if (run[runMarker - 1].type == STOP)
+		if (run[runMarker - 1].type == STOP) {
 			timerActive = false;
+			runUnsaved = true;
+			finish = run[runMarker - 1].time;
+		}
 		if (run[runMarker - 1].type == START)
 			timerActive = true;
 		if (run[runMarker - 1].type == PAUSE)
 			paused = true;
 		if (run[runMarker - 1].type == RESUME) {
 			paused = false;
-			addPauseTime();
 		}
 	}
+	if (runMarker == runMarker2) {
+		hasUndoneAtLeastOnce = false;
+	}
+}
+
+void undo_redo()
+{
+	if (hasUndoneAtLeastOnce) redo();
+	else undo();
 }
 
 //this isnt just called pause() because that would overlap with <unistd.h>
 void pause_timer()
 {
+	if (!timerActive) return;
 	if (!paused) {
 		add_event(PAUSE);
 		paused = true;
@@ -226,13 +303,19 @@ void pause_timer()
 
 void resume()
 {
+	if (!timerActive) return;
 	if (paused) {
 		add_event(RESUME);
 		paused = false;
-		addPauseTime();
 	}
 }
 
+void pause_resume()
+{
+	if (paused) resume();
+	else pause_timer();
+}
+
 void appendRunToFile()
 {
 	if (!runUnsaved)
@@ -246,13 +329,9 @@ void appendRunToFile()
 
 	fp = fopen(save_path, "a+");
 	fprintf(fp, "%s\n", "Run");
-	if (current_category != NULL) {
-		fprintf(fp, "\t%s\n", "Category");
-		fprintf(fp, "\t\t%s\n", current_category);
-	}
-	if (current_route != NULL) {
+	if (current_route.name != NULL) {
 		fprintf(fp, "\t%s\n", "Route");
-		fprintf(fp, "\t\t%s\n", current_route);
+		fprintf(fp, "\t\t%s\n", current_route.name);
 	}
 
 	int i = 0;
@@ -277,6 +356,9 @@ void appendRunToFile()
 			case RESUME:
 				fprintf(fp, "\t%s\n", "Resume");
 				break;
+			case RESET:
+				fprintf(fp, "\t%s\n", "Reset");
+				break;
 			case STOP:
 				fprintf(fp, "\t%s\n", "Stop");
 				break;
@@ -311,19 +393,47 @@ void timespecToRFC3339(struct timespec t, char buf[])
 void loadFiles()
 {
 	FILE* fp;
-	//TODO: for now we're just looking for the metadata values
 	char buff[255];
 	char buff2[255];
 	
 	for (int i = 0; i < files; i++) {
-		printf("loading file: \"%s\"\n", filePaths[i]);
-		fp = fopen(filePaths[i], "r");
+		fp = fopen(filePaths[i], "r+");
 		while(1) {
 			if (!fgets(buff, 255, fp))
 				break;
 			if (buff[0] == '/' && buff[1] == '/' || buff[0] == '\n' || buff[0] == '\t')
 				continue;
-			if (!strcmp(buff, "Segment\n") || !strcmp(buff, "Route\n"))
+			if (!strcmp(buff, "Segment\n")) {
+				char *s = NULL;
+				char *l = NULL;
+				char *d = NULL;
+				for (int x = 0; x < 3; x++) {
+					if (!fgets(buff2, 255, fp))
+						break;
+					if (!strcmp(buff2, "\tShortname\n")) {
+						if (!fgets(buff2, 255, fp))
+							break;
+						s = malloc(strlen(buff2) - 2);
+						s = strncpy(s, buff2 + 2, strlen(buff2) - 2);
+						s[strlen(s) - 1] = '\0';
+					} else if (!strcmp(buff2, "\tLongname\n")) {
+						if (!fgets(buff2, 255, fp))
+							break;
+						l = malloc(strlen(buff2) - 2);
+						l = strncpy(l, buff2 + 2, strlen(buff2) - 2);
+						l[strlen(l) - 1] = '\0';
+					} else if (!strcmp(buff2, "\tDescription\n")) {
+						if (!fgets(buff2, 255, fp))
+							break;
+						d = malloc(strlen(buff2) - 2);
+						d = strncpy(d, buff2 + 2, strlen(buff2) - 2);
+						d[strlen(d) - 1] = '\0';
+					}
+				}
+				add_segment(s, l, d);
+				continue;
+			}
+			if (!strcmp(buff, "Route\n"))
 				continue;
 			if (!strcmp(buff, "Run\n")) {
 				run_count++;
@@ -332,28 +442,23 @@ void loadFiles()
 			if (!fgets(buff2, 255, fp))
 				break;
 			if (buff2[0] == '\t') {
-				valuecount++;
-				
-				names = realloc(names, sizeof(char*) * valuecount);
-				names[valuecount - 1] = malloc(strlen(buff));
-				strncpy(names[valuecount - 1], buff, strlen(buff) - 1);
-				names[valuecount - 1][strlen(buff)] = '\0';
-
-				values = realloc(values, sizeof(char*) * valuecount);
-				values[valuecount - 1] = malloc(strlen(buff2) - 1);
-				strncpy(values[valuecount - 1], buff2 + 1, strlen(buff2) - 1);
-				values[valuecount - 1][strlen(buff2)] = '\0';
+				buff[strlen(buff) - 1] = '\0';
+				buff2[strlen(buff2) - 1] = '\0';
+				set_metadata(buff, buff2 + 1);
 			}
 		}
 
 		fclose(fp);
 	}
+}
 
-	//Print metadata arrays
-	for (int i = 0; i < valuecount; i++) {
-		printf("%s | %s", names[i], values[i]);
-	}
-	printf("%d\n", run_count);
+void add_segment(char *sname, char *lname, char *desc)
+{
+	segment_count++;
+	segments = realloc(segments, sizeof(struct segment) * segment_count);
+	segments[segment_count - 1].shortname = sname;
+	segments[segment_count - 1].longname = lname;
+	segments[segment_count - 1].description = desc;
 }
 
 //TODO: eventually file loading should support loading multiple files
@@ -365,19 +470,23 @@ void addFile(char *path)
 	loadFiles();
 }
 
-void sendTime(int sock)
+int current_ms()
 {
-	int n, x;
 	if (timerActive)
 		clock_gettime(CLOCK_REALTIME, &finish);
-	if (paused) {
-		sub_timespec(run[0].time, run[runMarker - 1].time, &delta);
-	} else {
+	//if (paused) {
+	//	sub_timespec(run[0].time, run[runMarker - 1].time, &delta);
+	//} else {
 		sub_timespec(run[0].time, finish, &delta);
-	}
-	x = timespecToMS(delta) - pausedTime;
-	n = write(sock, &x, sizeof(int));
+	//}
+	return timespecToMS(delta);	
+}
 
+void sendInt(int sock, int value)
+{
+	char buffer[256];
+	sprintf(buffer, "%d", value);
+	int n = write(sock, &buffer, 256);
 	if (n < 0) {
 		perror("ERROR writing to socket");
 		exit(1);
@@ -386,76 +495,276 @@ void sendTime(int sock)
 
 void sendValue(int sock, char* name)
 {
+	char buffer[256];
 	int n, x;
 	bool namefound = false;
+	if (name == NULL) {
+		strcpy(buffer, "DATA NOT PRESENT");
+	} else {
 		for(int i = 0; i < valuecount; i++) {
-		if (!strcmp(names[i], name)) {
+			if (!strcmp(meta_keys[i], name)) {
 				x = i;
 				namefound = true;
 			}
 		}
 		if (namefound)
-		n = write(sock, values[x], strlen(values[x]));
+			strcpy(buffer, meta_values[x]);
 		else
-		n = write(sock, "DATA NOT PRESENT", 17);
-
+			strcpy(buffer, "DATA NOT PRESENT");
+	}
+	n = write(sock, &buffer, 256);
 	if (n < 0) {
 		perror("ERROR writing to socket");
 		exit(1);
 	}
 }
 
-void doprocessing (int sock)
+void sendString(int sock, char* str)
+{
+	char buffer[256];
+	strcpy(buffer, str);
+	int n = write(sock, &buffer, 256);
+	if (n < 0) {
+		perror("ERROR writing to socket");
+		exit(1);
+	}
+}
+
+void set_metadata(char *key, char *value)
+{
+	char key_pos = -1;
+	for (int i = 0; i < valuecount; i++)
+		if (!strcmp(meta_keys[i], key))
+			key_pos = i;
+	if (key_pos > -1) {
+		meta_values[key_pos] = realloc(meta_values[key_pos], strlen(value));
+		strncpy(meta_values[key_pos], value, strlen(value));
+		meta_values[key_pos][strlen(value)] = '\0';
+	} else {
+		valuecount++;
+				
+		meta_keys = realloc(meta_keys, sizeof(char*) * valuecount);
+		meta_keys[valuecount - 1] = malloc(strlen(key));
+		strncpy(meta_keys[valuecount - 1], key, strlen(key));
+		meta_keys[valuecount - 1][strlen(key)] = '\0';
+
+		meta_values = realloc(meta_values, sizeof(char*) * valuecount);
+		meta_values[valuecount - 1] = malloc(strlen(value));
+		strncpy(meta_values[valuecount - 1], value, strlen(value));
+		meta_values[valuecount - 1][strlen(value)] = '\0';
+	}
+}
+
+void save_metadata_to_file(char *token, char *token2)
+{
+	char* save_path = NULL;
+	if (files <= 0)
+		save_path = default_file_name;
+	else
+		save_path = filePaths[0];
+	FILE* fp;
+
+	fp = fopen(save_path, "r+");
+	fprintf(fp, "%s\n", token);
+	fprintf(fp, "\t%s\n\n", token2);
+	fclose(fp);
+}
+
+void process_socket_input(int sock)
 {
 	int n;
-	char commandcode;
-	n = read(sock,&commandcode,1);
-
+	char buffer[256];
+	n = read(sock, &buffer, 256);
 	if (n < 0) {
 		perror("ERROR reading from socket");
 		exit(1);
 	}
-	if (commandcode == 1) {
-		//printf("Recieved time command\n");
-		sendTime(sock);
-	} else if (commandcode == 2) {
-		printf("Recieved start command\n");
+	char *token = strtok(buffer, " ");
+
+	//Imperative commands
+	if (!strcmp(token, "start")) {
 		start();
-	} else if (commandcode == 3) {
-		printf("Recieved stop command\n");
+	} else if (!strcmp(token, "stop")) {
 		stop();
-	} else if (commandcode == 4) {
-		printf("Recieved kill command\n");
+	} else if (!strcmp(token, "reset")) {
+		reset();
+	} else if (!strcmp(token, "kill")) {
 		alive = false;
-	} else if (commandcode == 5) {
-		printf("Recieved split command\n");
+	} else if (!strcmp(token, "split")) {
 		split();
-	} else if (commandcode == 6) {
-		printf("Recieved skip command\n");
+	} else if (!strcmp(token, "skip")) {
 		skip();
-	} else if (commandcode == 7) {
-		printf("Recieved pause command\n");
+	} else if (!strcmp(token, "pause")) {
 		pause_timer();
-	} else if (commandcode == 8) {
-		printf("Recieved resume command\n");
+	} else if (!strcmp(token, "resume")) {
 		resume();
-	} else if (commandcode == 9) {
-		printf("Recieved undo command\n");
+	} else if (!strcmp(token, "undo")) {
 		undo();
-	} else if (commandcode == 10) {
-		printf("Recieved redo command\n");
+	} else if (!strcmp(token, "redo")) {
 		redo();
-	} else if (commandcode == 11) {
-		printf("Recieved request for foreground color\n");
-		sendValue(sock, "Foreground-Color");
-	} else if (commandcode == 12) {
-		printf("Recieved request for background color\n");
-		sendValue(sock, "Background-Color");
-	} else if (commandcode == 13) {
-		printf("Recieved save command\n");
+	} else if (!strcmp(token, "save")) {
 		appendRunToFile();
-	} else {
-		printf("Recieved invalid command code, ignoring...\n");
+	} else if (!strcmp(token, "start-split-stop")) {
+		start_split_stop();
+	} else if (!strcmp(token, "pause-resume")) {
+		pause_resume();
+	} else if (!strcmp(token, "start-stop")) {
+		start_stop();
+	} else if (!strcmp(token, "start-reset")) {
+		start_reset();
+	} else if (!strcmp(token, "start-split")) {
+		start_split();
+	} else if (!strcmp(token, "split-stop")) {
+		split_stop();
+	} else if (!strcmp(token, "undo-redo")) {
+		undo_redo();
+	
+	//Getters
+	} else if (!strcmp(token, "get")) {
+		token = strtok(NULL, " ");
+		if (!strcmp(token, "current_time")) {
+			sendInt(sock, current_ms());
+		} else if (!strcmp(token, "current_time_with_pause")) {
+			int running_pause = 0;
+			struct timespec p, r;
+			bool tracking_pause = false;
+			for (int i = 0; i < runMarker; i++) {
+				if (run[i].type == PAUSE) {
+					sub_timespec(run[0].time, run[i].time, &p);
+					tracking_pause = true;
+				}
+				if (run[i].type == RESUME) {
+					sub_timespec(run[0].time, run[i].time, &r);
+					running_pause += timespecToMS(r) - timespecToMS(p);
+					tracking_pause = false;
+				} else if (i == runMarker - 1 && tracking_pause) {
+					running_pause += current_ms() - timespecToMS(p);
+				}
+			}
+			sendInt(sock, current_ms() - running_pause);
+		} else if (!strcmp(token, "run_count")) {
+			sendInt(sock, run_count);
+		} else if (!strcmp(token, "segment_count")) {
+			sendInt(sock, segment_count);
+		} else if (!strcmp(token, "route_count")) {
+			sendInt(sock, route_count);
+		} else if (!strcmp(token, "event_count")) {
+			sendInt(sock, runMarker);
+		} else if (!strcmp(token, "segment_shortname")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			sendString(sock, segments[x].shortname);
+		} else if (!strcmp(token, "segment_longname")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			sendString(sock, segments[x].longname);
+		} else if (!strcmp(token, "segment_description")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			sendString(sock, segments[x].description);
+		} else if (!strcmp(token, "route_name")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			sendString(sock, routes[x].name);
+		} else if (!strcmp(token, "route_segment_count")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			sendInt(sock, routes[x].segment_count);
+		} else if (!strcmp(token, "route_segment_shortname")) {
+			token = strtok(NULL, " ");
+			int x = atoi(token);
+			token = strtok(NULL, " ");
+			int y = atoi(token);
+			sendString(sock, routes[x].segments[y].shortname);
+		} else if (!strcmp(token, "event_time")) {
+			token = strtok(NULL, " ");
+			int x;
+			if (!strcmp(token, "last"))
+				x = runMarker - 1;
+			else if (!strcmp(token, "first"))
+				x = 0;
+			else
+				x = atoi(token);
+			struct timespec t;
+			sub_timespec(run[0].time, run[x].time, &t);
+			sendInt(sock, timespecToMS(t));
+		} else if (!strcmp(token, "event_time_with_pause")) {
+			token = strtok(NULL, " ");
+			int x;
+			if (!strcmp(token, "last"))
+				x = runMarker - 1;
+			else if (!strcmp(token, "first"))
+				x = 0;
+			else
+				x = atoi(token);
+			int running_pause = 0;
+			struct timespec p, r;
+			bool tracking_pause = false;
+			for (int i = 0; i < x; i++) {
+				if (run[i].type == PAUSE) {
+					sub_timespec(run[0].time, run[i].time, &p);
+					tracking_pause = true;
+				}
+				if (run[i].type == RESUME) {
+					sub_timespec(run[0].time, run[i].time, &r);
+					running_pause += timespecToMS(r) - timespecToMS(p);
+					tracking_pause = false;
+				} else if (i == x - 1 && tracking_pause) {
+					sub_timespec(run[0].time, run[x].time, &r);
+					running_pause += timespecToMS(r) - timespecToMS(p);
+				}
+			}
+			struct timespec t;
+			sub_timespec(run[0].time, run[x].time, &t);
+			sendInt(sock, timespecToMS(t) - running_pause);
+		} else if (!strcmp(token, "event_type")) {
+			token = strtok(NULL, " ");
+			int x;
+			if (!strcmp(token, "last"))
+				x = runMarker - 1;
+			else if (!strcmp(token, "first"))
+				x = 0;
+			else
+				x = atoi(token);
+			char *reply;
+			switch (run[x].type) {
+				case START:
+					reply = "START";
+					break;
+				case SPLIT:
+					reply = "SPLIT";
+					break;
+				case SKIP:
+					reply = "SKIP";
+					break;
+				case PAUSE:
+					reply = "PAUSE";
+					break;
+				case RESUME:
+					reply = "RESUME";
+					break;
+				case RESET:
+					reply = "RESET";
+					break;
+				case STOP:
+					reply = "STOP";
+					break;
+			}
+			sendString(sock, reply);
+		} else if (!strcmp(token, "meta")) {
+			token = strtok(NULL, " ");
+			sendValue(sock, token);
+		}
+	
+	//Setters
+	} else if (!strcmp(token, "set")) {
+		token = strtok(NULL, " ");
+		if (!strcmp(token, "meta")) {
+			token = strtok(NULL, " ");
+			char *token2 = strtok(NULL, " ");
+			set_metadata(token, token2);
+			save_metadata_to_file(token, token2);
+		}
 	}
 }
 
@@ -502,7 +811,7 @@ int main(int argc, char *argv[])
 			perror("ERROR on accept");
 			exit(1);
 		}
-		doprocessing(newsockfd);
+		process_socket_input(newsockfd);
 		close(newsockfd);
 	}
 	free(run);

src2/tui.c

@@ -193,7 +193,7 @@ int main (int argc, char *argv[])
 	char ti[13];
 
 	//Request foreground color from config file
-	fp = popen("./result/bin/quest-log foreground", "r");
+	fp = popen("./result/bin/quest-log Foreground-Color", "r");
 	if (fgets(path, sizeof(path), fp)) {
 		if (strcmp(path, "DATA NOT PRESENT"))
 			processColorString(&f, path);
@@ -202,7 +202,7 @@ int main (int argc, char *argv[])
 	pclose(fp);
 
 	//Request background color from config file
-	fp = popen("./result/bin/quest-log background", "r");
+	fp = popen("./result/bin/quest-log Background-Color", "r");
 	if (fgets(path, sizeof(path), fp)) {
 		if (strcmp(path, "DATA NOT PRESENT"))
 			processColorString(&b, path);
@@ -217,7 +217,7 @@ int main (int argc, char *argv[])
 	}
 	while (1) {
 		int time = 0;
-		fp = popen("./result/bin/quest-log time", "r");
+		fp = popen("./result/bin/quest-log current_time", "r");
 		if (fp == NULL) {
 			printf("Failed to run command\n");
 			exit(1);