Put Tile Heightmap, and AABB into their own separate

functions.

I also made a benchmark version, with hardcoded values.
I made this to get the time of a collision check,
without the overhead of getting input.

3 files changed, 629 insertions, 242 deletions

diff --git a/Makefile b/Makefile
index 25ef589..189e4c8 100644
--- a/Makefile
+++ b/Makefile
@@ -14,8 +14,10 @@ all : $(OBJS)
 	$(CC) $(OBJS) $(CFLAGS) -o $(OBJ_NAME)
 test-mvmt :
 	$(CC) test-mvmt.c $(CFLAGS) -o test-mvmt
+benchmark:
+	$(CC) clld-bench.c $(CFLAGS) -o clld-bench
 clean :
-	rm -f $(OBJ_NAME) test-mvmt
+	rm -f $(OBJ_NAME) test-mvmt clld-bench
 install :
 	install -D -m755 clld $(BIN_DIR)/clld
 uninstall :
diff --git a/clld-bench.c b/clld-bench.c
new file mode 100644
index 0000000..fbcaec6
--- /dev/null
+++ b/clld-bench.c
@@ -0,0 +1,377 @@
+/*
+ * Main Program file.
+ *
+ * Platform: 	Anything with a C compiler.
+ * Author:	mr b0nk 500 <b0nk@mrb0nk500.xyz>
+ * Notes: 	Who would even use this kind of collision checker?
+ * Created:	September 27, 2019 @ 09:25PM
+ */
+
+#include <ctype.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#define TERASGN(a, b, c, d) (a) ? (b = d) : (c = d)
+#define max(a, b) (abs(a-b)+(a+b))/2
+#define min(a, b) -max(-a, -b)
+
+enum {THM, AABB};
+
+/* Collision type */
+int colltype = -1;
+
+/* Position type */
+int postype = -1;
+
+/* Level of verbosity. */
+int verbose = 0;
+
+/* Options string. */
+const char *opts = "c:v:h";
+
+struct pos {
+	int x;
+	int y;
+	int z;
+	double fx;
+	double fy;
+	double fz;
+};
+
+struct colis {
+	/* Cursor/Floor's width, and height */
+	int w;
+	int h;
+
+	/* Cursor's X, and Y velocity. */
+	double xvel;
+	double yvel;
+
+	/* Cursor/Floor's coordinates. */
+	struct pos pos;
+
+	/* The four corners of either the Cursor, or the Floor. */
+	int a1;
+	int a2;
+	int b1;
+	int b2;
+
+	/* The four floating point corners of either the Cursor, or the Floor. */
+	double c1;
+	double c2;
+	double d1;
+	double d2;
+
+	/* Heightmap, used in Tile Heightmap collision. */
+	uint8_t *heightmap;
+
+	/* X axis collision. */
+	unsigned int clx : 1;
+
+	/* Y axis collision. */
+	unsigned int cly : 1;
+
+	/* Cursor is on the ground. */
+	unsigned int gnded : 1;
+
+	/* Vertical flip flag. */
+	unsigned int flp : 1;
+};
+
+static int usage() {
+	printf(
+		"clld Version MFIYA.\n"
+		"Usage: clld [options]\n"
+		"Options:\n"
+		"	-c[type]	Force the collision type to be\n"
+		"			the specified type (THM=0, AABB=1).\n"
+		"	-v[level]	Sets the verbosity level (0-3).\n"
+		"	-h		What do you fucking think it does.\n"
+		"			Anyways, it brings up this cool help\n"
+		"			message.\n"
+	      );
+	return 0;
+}
+
+/* Tile Heightmap Collision. */
+int thm(uint8_t flt, int hmpeak, struct colis cursor, struct colis floor) {
+	int newy = 0;
+	if (!flt) {
+		cursor.a1 = cursor.pos.x;
+		cursor.a2 = cursor.pos.x+cursor.w;
+		cursor.b1 = cursor.pos.y;
+		cursor.b2 = cursor.pos.y+cursor.h;
+		floor.a1 = floor.pos.x;
+                floor.a2 = floor.pos.x+floor.w;
+                floor.b1 = floor.pos.y;
+                floor.b2 = floor.pos.y+floor.h;
+
+		cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
+		/* Check for a collision, on the y axis. */
+		cursor.cly = ((cursor.b2 >= (floor.b1-hmpeak)-(int)cursor.yvel && cursor.a2 >= floor.a1) && (cursor.b1 <= (floor.b2+hmpeak)-(int)cursor.yvel && cursor.a1 <= floor.a2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.a2-floor.a1 < 0 || cursor.a2-floor.a1 > floor.w) {
+				/* Is the Cursor coming from the left? */
+				if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b2-cursor.b2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
+					cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+				else if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b2-cursor.b2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
+					cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
+				/* Is the Cursor coming from the right? */
+				if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel < 0)
+					cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
+				else if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel > 0)
+					cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+				cursor.xvel = 0;
+			}
+		}
+		if (cursor.cly) {
+			if (cursor.a2-floor.a1 < floor.w) {
+				cursor.yvel = 0;
+				newy = (int)floor.heightmap[cursor.a2-floor.a1];
+				/* Is the Floor, really a floor? */
+				if (cursor.b2 > (floor.b2-hmpeak)-(int)cursor.yvel && floor.b2-cursor.b2 >= 0 && !floor.flp)
+					cursor.pos.y = ((floor.b2-cursor.h)-newy)-(int)cursor.yvel;
+				else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && floor.b2-cursor.b1 <= 0 && !floor.flp)
+					cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
+				/* Is the Floor, actually a ceiling? */
+				if (cursor.b1 < (floor.b1+hmpeak)-(int)cursor.yvel && cursor.b1-floor.b1 >= 0 && floor.flp)
+					cursor.pos.y = (floor.pos.y+newy)-(int)cursor.yvel;
+				else if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.b2-floor.b1 < 0 && cursor.yvel > 0 && floor.flp)
+					cursor.pos.y = (floor.pos.y-(int)cursor.yvel-1)-cursor.h;
+			}
+		}
+		cursor.gnded = (cursor.pos.y == ((floor.b2-cursor.h)-newy)-(int)cursor.yvel) ? 1 : 0;
+		if (verbose >= 1) {
+			printf(
+				"cursor.a1-(floor.a2-(floor.w/2)): %i\n"
+				"cursor.a2-(floor.a2-(floor.w/2)): %i\n"
+				"(cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2)): %i\n"
+				"(cursor.a2-(cursor.w/2)): %i\n"
+				, cursor.a1-(floor.a2-(floor.w/2))
+				, cursor.a2-(floor.a2-(floor.w/2))
+				, (cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2))
+				, (cursor.a2-(cursor.w/2)));
+		}
+		printf("cursor.w: %i, cursor.h: %i\n", cursor.w, cursor.h);
+		printf("%u, %u\n%u\n%i\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
+	} else {
+		cursor.c1 = cursor.pos.fx;
+		cursor.c2 = cursor.pos.fx+cursor.w;
+		cursor.d1 = cursor.pos.fy;
+		cursor.d2 = cursor.pos.fy+cursor.h;
+		floor.c1 = floor.pos.fx;
+		floor.c2 = floor.pos.fx+floor.w;
+		floor.d1 = floor.pos.fy;
+		floor.d2 = floor.pos.fy+floor.h;
+
+		cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
+		/* Check for a collision, on the y axis. */
+		cursor.cly = ((cursor.d2 >= (floor.d1-hmpeak)-cursor.yvel && cursor.c2 >= floor.c1) && (cursor.d1 <= (floor.d2+hmpeak)-cursor.yvel && cursor.c1 <= floor.c2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.c2-floor.c1 < -1 || cursor.c2-floor.c1 > floor.w) {
+				/* Is the Cursor coming from the left? */
+				if (cursor.c2 > floor.c1-cursor.xvel-1 && floor.d2-cursor.d2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
+					cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
+				else if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && floor.d2-cursor.d2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
+					cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
+				/* Is the Cursor coming from the right? */
+				if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel < 0)
+					cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
+				else if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel > 0)
+					cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
+				cursor.xvel = 0;
+			}
+		}
+		if (cursor.cly) {
+			if (cursor.c2-floor.c1 < floor.w) {
+				cursor.yvel = 0;
+				newy = (int)floor.heightmap[(int)cursor.c2-(int)floor.c1];
+				/* Is the Floor, really a floor? */
+				if (cursor.d2 > (floor.d2-hmpeak)-cursor.yvel && floor.d2-cursor.d2 >= 0 && !floor.flp)
+					cursor.pos.fy = ((floor.d2-cursor.h)-newy)-cursor.yvel;
+				else if (cursor.d1 < floor.d2-cursor.yvel+1 && floor.d2-cursor.d1 <= 0 && !floor.flp)
+					cursor.pos.fy = (floor.d2)-cursor.yvel+1;
+				/* Is the Floor, actually a ceiling? */
+				if (cursor.d1 < (floor.d1+hmpeak)-cursor.yvel && cursor.d1-floor.d1 >= 0 && floor.flp)
+					cursor.pos.fy = (floor.pos.fy+newy)-cursor.yvel;
+				else if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.d2-floor.d1 < 0 && cursor.yvel > 0 && floor.flp)
+					cursor.pos.fy = (floor.pos.fy-cursor.yvel-1)-cursor.h;
+			}
+		}
+		cursor.gnded = (cursor.pos.fy == ((floor.d2-cursor.h)-newy)-cursor.yvel) ? 1 : 0;
+		printf("cursor.c2-floor.c1: %07.06f\n", cursor.c2-floor.c1);
+		printf("%u, %u\n%u\n%i\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
+	}
+	return 0;
+}
+
+/* Axis Aligned Bounding Box Collision. */
+int aabb(uint8_t flt, struct colis cursor, struct colis floor) {
+	if (!flt) {
+		cursor.a1 = cursor.pos.x;
+		cursor.a2 = cursor.pos.x+cursor.w;
+		cursor.b1 = cursor.pos.y;
+		cursor.b2 = cursor.pos.y+cursor.h;
+		floor.a1 = floor.pos.x;
+		floor.a2 = floor.pos.x+floor.w;
+		floor.b1 = floor.pos.y;
+		floor.b2 = floor.pos.y+floor.h;
+		/* Is the Cursor is on the ground? */
+		cursor.gnded = (cursor.b2 == floor.b1-(int)cursor.yvel-1) ? 1 : 0;
+
+		/* Check for collisions, on both axies. */
+		cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
+		cursor.cly = ((cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.a2 > floor.a1) && (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.a1 < floor.a2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			/* Is the Cursor coming from the left? */
+			if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.xvel > 0)
+				cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+			/* Is the Cursor coming from the right? */
+			else if (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.xvel < 0)
+				cursor.pos.x = (floor.pos.x+floor.w)-(int)cursor.xvel+1;
+			cursor.xvel = 0;
+		}
+		if (cursor.cly) {
+			/* Is the Cursor coming from the top? */
+			if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.yvel > 0)
+				cursor.pos.y = (floor.pos.y-(int)cursor.yvel)-cursor.h-1;
+			/* Is the Cursor coming from the bottom? */
+			else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.yvel < 0)
+				cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
+			cursor.yvel = 0;
+		}
+
+		if (verbose >= 1) {
+			printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
+			printf("x: %i, y: %i\n", cursor.pos.x, cursor.pos.y);
+			printf("floor.x: %i, floor.y: %i\n", floor.pos.x, floor.pos.y);
+			printf ("r: %i\n", (floor.pos.x+floor.w)-(int)cursor.xvel+1);
+		}
+		printf("%u, %u\n%u\n%i, %i\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
+	} else {
+		cursor.c1 = cursor.pos.fx;
+		cursor.c2 = cursor.pos.fx+cursor.w;
+		cursor.d1 = cursor.pos.fy;
+		cursor.d2 = cursor.pos.fy+cursor.h;
+		floor.c1 = floor.pos.fx;
+		floor.c2 = floor.pos.fx+floor.w;
+		floor.d1 = floor.pos.fy;
+		floor.d2 = floor.pos.fy+floor.h;
+
+		cursor.gnded = (cursor.d2 == floor.d1-cursor.yvel-1) ? 1 : 0;
+		cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
+		cursor.cly = ((cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1) && (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.xvel > 0)
+				cursor.pos.fx = (floor.pos.fx-cursor.xvel)-(double)cursor.w-1;
+			else if (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.xvel < 0)
+				cursor.pos.fx = (floor.pos.fx+(double)floor.w)-cursor.xvel+1;
+			cursor.xvel = 0;
+		}
+		if (cursor.cly) {
+			if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.yvel > 0)
+				cursor.pos.fy = (floor.pos.fy-cursor.yvel)-(double)cursor.h-1;
+			else if (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.yvel < 0)
+				cursor.pos.fy = (floor.pos.fy+(double)floor.h)-cursor.yvel+1;
+			cursor.yvel = 0;
+		}
+		if (verbose >= 1) {
+			printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
+			printf("fx: %07.06f, fy: %07.06f\n", cursor.pos.fx, cursor.pos.fy);
+			printf("floor.fx: %07.06f, floor.fy: %07.06f\n", floor.pos.fx, floor.pos.fy);
+		}
+		printf("%u, %u\n%u\n%07.06f, %07.06f\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
+	}
+	return 0;
+}
+
+
+int main(int argc, char **argv) {
+	int c;
+	/* Enable custom error messages, and optional arguments/ */
+	opterr = 0;
+	/* Get options. */
+	while ((c = getopt(argc, argv, opts)) != -1) {
+		switch(c) {
+			case 'c':
+				colltype = atoi(optarg);
+				break;
+			case 'v':
+				verbose = atoi(optarg);
+				break;
+			case 'h':
+				usage();
+				return 2;
+			case '?':
+				if (isprint(optopt)) {
+					if (optopt == 'c') {
+						fprintf(stderr, "Setting colltype to default.\n");
+						colltype = -1;
+						break;
+					} else if (optopt == 'v') {
+						fprintf(stderr, "Enabling single level verbosity.\n");
+						verbose = 1;
+						break;
+					} else {
+						fprintf(stderr
+							, "The option that you have typed in, which in this case\n"
+							  "is -%c, does not exist.\n"
+							  "Try looking at the help message, or RTFM, next time.\n"
+							, optopt);
+					}
+				} else {
+					fprintf(stderr
+						, "What the fuck are you trying to type in, a binary blob?\n"
+						  "Because of this, clld will exit, so, stop acting like a\n"
+						  "jackass.\n");
+				}
+				return -1;
+			default: ;
+		}
+	}
+
+	/* Create the Cursor, and the Floor */
+	struct colis cursor;
+	struct colis floor;
+	colltype = THM;
+	cursor.h = 16;
+	cursor.w = 16;
+	cursor.pos.x = 17;
+	cursor.pos.y = 32;
+	cursor.xvel = 1;
+	cursor.yvel = 0;
+	floor.w = 16;
+	floor.h = 16;
+	floor.flp = 0;
+	int hmpeak;
+	if (colltype == THM) {
+		floor.heightmap = malloc(sizeof(uint8_t *)*floor.w);
+		for (int i = 0; i <floor.w; i++)
+			floor.heightmap[i] = i+1;
+		hmpeak = floor.heightmap[floor.w-1];
+	}
+	uint8_t flt = 0;
+	floor.pos.x = 32;
+	floor.pos.y = 32;
+
+	if (colltype == THM)
+		thm(flt, hmpeak, cursor, floor);
+	/* Axis Aligned Bounding Box Collision. */
+	if (colltype == AABB)
+		aabb(flt, cursor, floor);
+	/*uint8_t a = 0;
+	unsigned int i = 0;
+	free(buf);*/
+	if(colltype == THM) {
+		free(floor.heightmap);
+	}
+	fflush(stdout);
+
+	return 0;
+}
diff --git a/clld.c b/clld.c
index 0556bdd..6cef7b5 100644
--- a/clld.c
+++ b/clld.c
@@ -31,6 +31,54 @@ int verbose = 0;
 /* Options string. */
 const char *opts = "c:v:h";
 
+struct pos {
+	int x;
+	int y;
+	int z;
+	double fx;
+	double fy;
+	double fz;
+};
+
+struct colis {
+	/* Cursor/Floor's width, and height */
+	int w;
+	int h;
+
+	/* Cursor's X, and Y velocity. */
+	double xvel;
+	double yvel;
+
+	/* Cursor/Floor's coordinates. */
+	struct pos pos;
+
+	/* The four corners of either the Cursor, or the Floor. */
+	int a1;
+	int a2;
+	int b1;
+	int b2;
+
+	/* The four floating point corners of either the Cursor, or the Floor. */
+	double c1;
+	double c2;
+	double d1;
+	double d2;
+
+	/* Heightmap, used in Tile Heightmap collision. */
+	uint8_t *heightmap;
+
+	/* X axis collision. */
+	unsigned int clx : 1;
+
+	/* Y axis collision. */
+	unsigned int cly : 1;
+
+	/* Cursor is on the ground. */
+	unsigned int gnded : 1;
+
+	/* Vertical flip flag. */
+	unsigned int flp : 1;
+};
 
 static int usage() {
 	printf(
@@ -47,56 +95,204 @@ static int usage() {
 	return 0;
 }
 
-int main(int argc, char **argv) {
-	struct pos {
-		int x;
-		int y;
-		int z;
-		double fx;
-		double fy;
-		double fz;
-	};
-
-	struct colis {
-		/* Cursor/Floor's width, and height */
-		int w;
-		int h;
-
-		/* Cursor's X, and Y velocity. */
-		double xvel;
-		double yvel;
-
-		/* Cursor/Floor's coordinates. */
-        	struct pos pos;
-
-		/* The four corners of either the Cursor, or the Floor. */
-		int a1;
-		int a2;
-		int b1;
-		int b2;
-
-		/* The four floating point corners of either the Cursor, or the Floor. */
-		double c1;
-		double c2;
-		double d1;
-		double d2;
-
-		/* Heightmap, used in Tile Heightmap collision. */
-		uint8_t *heightmap;
-
-		/* X axis collision. */
-		unsigned int clx : 1;
-
-		/* Y axis collision. */
-		unsigned int cly : 1;
-
-		/* Cursor is on the ground. */
-		unsigned int gnded : 1;
-
-		/* Vertical flip flag. */
-		unsigned int flp : 1;
-	};
+/* Tile Heightmap Collision. */
+int thm(uint8_t flt, int hmpeak, struct colis cursor, struct colis floor) {
+	int newy = 0;
+	if (!flt) {
+		cursor.a1 = cursor.pos.x;
+		cursor.a2 = cursor.pos.x+cursor.w;
+		cursor.b1 = cursor.pos.y;
+		cursor.b2 = cursor.pos.y+cursor.h;
+		floor.a1 = floor.pos.x;
+                floor.a2 = floor.pos.x+floor.w;
+                floor.b1 = floor.pos.y;
+                floor.b2 = floor.pos.y+floor.h;
+
+		cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
+		/* Check for a collision, on the y axis. */
+		cursor.cly = ((cursor.b2 >= (floor.b1-hmpeak)-(int)cursor.yvel && cursor.a2 >= floor.a1) && (cursor.b1 <= (floor.b2+hmpeak)-(int)cursor.yvel && cursor.a1 <= floor.a2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.a2-floor.a1 < 0 || cursor.a2-floor.a1 > floor.w) {
+				/* Is the Cursor coming from the left? */
+				if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b2-cursor.b2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
+					cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+				else if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b2-cursor.b2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
+					cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
+				/* Is the Cursor coming from the right? */
+				if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel < 0)
+					cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
+				else if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel > 0)
+					cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+				cursor.xvel = 0;
+			}
+		}
+		if (cursor.cly) {
+			if (cursor.a2-floor.a1 < floor.w) {
+				cursor.yvel = 0;
+				newy = (int)floor.heightmap[cursor.a2-floor.a1];
+				/* Is the Floor, really a floor? */
+				if (cursor.b2 > (floor.b2-hmpeak)-(int)cursor.yvel && floor.b2-cursor.b2 >= 0 && !floor.flp)
+					cursor.pos.y = ((floor.b2-cursor.h)-newy)-(int)cursor.yvel;
+				else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && floor.b2-cursor.b1 <= 0 && !floor.flp)
+					cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
+				/* Is the Floor, actually a ceiling? */
+				if (cursor.b1 < (floor.b1+hmpeak)-(int)cursor.yvel && cursor.b1-floor.b1 >= 0 && floor.flp)
+					cursor.pos.y = (floor.pos.y+newy)-(int)cursor.yvel;
+				else if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.b2-floor.b1 < 0 && cursor.yvel > 0 && floor.flp)
+					cursor.pos.y = (floor.pos.y-(int)cursor.yvel-1)-cursor.h;
+			}
+		}
+		cursor.gnded = (cursor.pos.y == ((floor.b2-cursor.h)-newy)-(int)cursor.yvel) ? 1 : 0;
+		if (verbose >= 1) {
+			printf(
+				"cursor.a1-(floor.a2-(floor.w/2)): %i\n"
+				"cursor.a2-(floor.a2-(floor.w/2)): %i\n"
+				"(cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2)): %i\n"
+				"(cursor.a2-(cursor.w/2)): %i\n"
+				, cursor.a1-(floor.a2-(floor.w/2))
+				, cursor.a2-(floor.a2-(floor.w/2))
+				, (cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2))
+				, (cursor.a2-(cursor.w/2)));
+		}
+		printf("cursor.w: %i, cursor.h: %i\n", cursor.w, cursor.h);
+		printf("%u, %u\n%u\n%i\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
+	} else {
+		cursor.c1 = cursor.pos.fx;
+		cursor.c2 = cursor.pos.fx+cursor.w;
+		cursor.d1 = cursor.pos.fy;
+		cursor.d2 = cursor.pos.fy+cursor.h;
+		floor.c1 = floor.pos.fx;
+		floor.c2 = floor.pos.fx+floor.w;
+		floor.d1 = floor.pos.fy;
+		floor.d2 = floor.pos.fy+floor.h;
+
+		cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
+		/* Check for a collision, on the y axis. */
+		cursor.cly = ((cursor.d2 >= (floor.d1-hmpeak)-cursor.yvel && cursor.c2 >= floor.c1) && (cursor.d1 <= (floor.d2+hmpeak)-cursor.yvel && cursor.c1 <= floor.c2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.c2-floor.c1 < -1 || cursor.c2-floor.c1 > floor.w) {
+				/* Is the Cursor coming from the left? */
+				if (cursor.c2 > floor.c1-cursor.xvel-1 && floor.d2-cursor.d2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
+					cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
+				else if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && floor.d2-cursor.d2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
+					cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
+				/* Is the Cursor coming from the right? */
+				if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel < 0)
+					cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
+				else if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel > 0)
+					cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
+				cursor.xvel = 0;
+			}
+		}
+		if (cursor.cly) {
+			if (cursor.c2-floor.c1 < floor.w) {
+				cursor.yvel = 0;
+				newy = (int)floor.heightmap[(int)cursor.c2-(int)floor.c1];
+				/* Is the Floor, really a floor? */
+				if (cursor.d2 > (floor.d2-hmpeak)-cursor.yvel && floor.d2-cursor.d2 >= 0 && !floor.flp)
+					cursor.pos.fy = ((floor.d2-cursor.h)-newy)-cursor.yvel;
+				else if (cursor.d1 < floor.d2-cursor.yvel+1 && floor.d2-cursor.d1 <= 0 && !floor.flp)
+					cursor.pos.fy = (floor.d2)-cursor.yvel+1;
+				/* Is the Floor, actually a ceiling? */
+				if (cursor.d1 < (floor.d1+hmpeak)-cursor.yvel && cursor.d1-floor.d1 >= 0 && floor.flp)
+					cursor.pos.fy = (floor.pos.fy+newy)-cursor.yvel;
+				else if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.d2-floor.d1 < 0 && cursor.yvel > 0 && floor.flp)
+					cursor.pos.fy = (floor.pos.fy-cursor.yvel-1)-cursor.h;
+			}
+		}
+		cursor.gnded = (cursor.pos.fy == ((floor.d2-cursor.h)-newy)-cursor.yvel) ? 1 : 0;
+		printf("cursor.c2-floor.c1: %07.06f\n", cursor.c2-floor.c1);
+		printf("%u, %u\n%u\n%i\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
+	}
+	return 0;
+}
+
+/* Axis Aligned Bounding Box Collision. */
+int aabb(uint8_t flt, struct colis cursor, struct colis floor) {
+	if (!flt) {
+		cursor.a1 = cursor.pos.x;
+		cursor.a2 = cursor.pos.x+cursor.w;
+		cursor.b1 = cursor.pos.y;
+		cursor.b2 = cursor.pos.y+cursor.h;
+		floor.a1 = floor.pos.x;
+		floor.a2 = floor.pos.x+floor.w;
+		floor.b1 = floor.pos.y;
+		floor.b2 = floor.pos.y+floor.h;
+		/* Is the Cursor is on the ground? */
+		cursor.gnded = (cursor.b2 == floor.b1-(int)cursor.yvel-1) ? 1 : 0;
+
+		/* Check for collisions, on both axies. */
+		cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
+		cursor.cly = ((cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.a2 > floor.a1) && (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.a1 < floor.a2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			/* Is the Cursor coming from the left? */
+			if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.xvel > 0)
+				cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
+			/* Is the Cursor coming from the right? */
+			else if (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.xvel < 0)
+				cursor.pos.x = (floor.pos.x+floor.w)-(int)cursor.xvel+1;
+			cursor.xvel = 0;
+		}
+		if (cursor.cly) {
+			/* Is the Cursor coming from the top? */
+			if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.yvel > 0)
+				cursor.pos.y = (floor.pos.y-(int)cursor.yvel)-cursor.h-1;
+			/* Is the Cursor coming from the bottom? */
+			else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.yvel < 0)
+				cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
+			cursor.yvel = 0;
+		}
+
+		if (verbose >= 1) {
+			printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
+			printf("x: %i, y: %i\n", cursor.pos.x, cursor.pos.y);
+			printf("floor.x: %i, floor.y: %i\n", floor.pos.x, floor.pos.y);
+			printf ("r: %i\n", (floor.pos.x+floor.w)-(int)cursor.xvel+1);
+		}
+		/*printf("cursor.w: %i, cursor.h: %i\n", cursor.w, cursor.h);*/
+		printf("%u, %u\n%u\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
+	} else {
+		cursor.c1 = cursor.pos.fx;
+		cursor.c2 = cursor.pos.fx+cursor.w;
+		cursor.d1 = cursor.pos.fy;
+		cursor.d2 = cursor.pos.fy+cursor.h;
+		floor.c1 = floor.pos.fx;
+		floor.c2 = floor.pos.fx+floor.w;
+		floor.d1 = floor.pos.fy;
+		floor.d2 = floor.pos.fy+floor.h;
+
+		cursor.gnded = (cursor.d2 == floor.d1-cursor.yvel-1) ? 1 : 0;
+		cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
+		cursor.cly = ((cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1) && (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2)) ? 1 : 0;
+
+		if (cursor.clx) {
+			if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.xvel > 0)
+				cursor.pos.fx = (floor.pos.fx-cursor.xvel)-(double)cursor.w-1;
+			else if (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.xvel < 0)
+				cursor.pos.fx = (floor.pos.fx+(double)floor.w)-cursor.xvel+1;
+			cursor.xvel = 0;
+		}
+		if (cursor.cly) {
+			if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.yvel > 0)
+				cursor.pos.fy = (floor.pos.fy-cursor.yvel)-(double)cursor.h-1;
+			else if (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.yvel < 0)
+				cursor.pos.fy = (floor.pos.fy+(double)floor.h)-cursor.yvel+1;
+			cursor.yvel = 0;
+		}
+		if (verbose >= 1) {
+			printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
+			printf("fx: %07.06f, fy: %07.06f\n", cursor.pos.fx, cursor.pos.fy);
+			printf("floor.fx: %07.06f, floor.fy: %07.06f\n", floor.pos.fx, floor.pos.fy);
+		}
+		printf("%u, %u\n%u\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
+	}
+	return 0;
+}
 
+int main(int argc, char **argv) {
 	int c;
 	/* Enable custom error messages, and optional arguments/ */
 	opterr = 0;
@@ -259,199 +455,11 @@ int main(int argc, char **argv) {
 			cursor.yvel = atof(strtok(NULL, "\n"));
 		}
 
-		/* Tile Heightmap Collision. */
-		if (colltype == THM && coll) {
-			if (!flt) {
-				cursor.a1 = cursor.pos.x;
-				cursor.a2 = cursor.pos.x+cursor.w;
-				cursor.b1 = cursor.pos.y;
-				cursor.b2 = cursor.pos.y+cursor.h;
-				floor.a1 = floor.pos.x;
-                                floor.a2 = floor.pos.x+floor.w;
-                                floor.b1 = floor.pos.y;
-                                floor.b2 = floor.pos.y+floor.h;
-
-				cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
-				/* Check for a collision, on the y axis. */
-				cursor.cly = ((cursor.b2 >= (floor.b1-hmpeak)-(int)cursor.yvel && cursor.a2 >= floor.a1) && (cursor.b1 <= (floor.b2+hmpeak)-(int)cursor.yvel && cursor.a1 <= floor.a2)) ? 1 : 0;
-
-				int newy = 0;
-				if (cursor.clx) {
-					if (cursor.a2-floor.a1 < 0 || cursor.a2-floor.a1 > floor.w) {
-						/* Is the Cursor coming from the left? */
-						if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && floor.b2-cursor.b2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
-							cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
-						else if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && floor.b2-cursor.b2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
-							cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
-						/* Is the Cursor coming from the right? */
-						if (cursor.a1 < (floor.a2-cursor.w)-(int)cursor.xvel+1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel < 0)
-							cursor.pos.x = (floor.a2-cursor.w)-(int)cursor.xvel+1;
-						else if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b1-floor.b1 < 0 && floor.flp && cursor.xvel > 0)
-							cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
-						cursor.xvel = 0;
-					}
-				}
-				if (cursor.cly) {
-					if (cursor.a2-floor.a1 < floor.w) {
-						cursor.yvel = 0;
-						newy = (int)floor.heightmap[cursor.a2-floor.a1];
-						/* Is the Floor, really a floor? */
-						if (cursor.b2 > (floor.b2-hmpeak)-(int)cursor.yvel && floor.b2-cursor.b2 >= 0 && !floor.flp)
-							cursor.pos.y = ((floor.b2-cursor.h)-newy)-(int)cursor.yvel;
-						else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && floor.b2-cursor.b1 <= 0 && !floor.flp)
-							cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
-						/* Is the Floor, actually a ceiling? */
-						if (cursor.b1 < (floor.b1+hmpeak)-(int)cursor.yvel && cursor.b1-floor.b1 >= 0 && floor.flp)
-							cursor.pos.y = (floor.pos.y+newy)-(int)cursor.yvel;
-						else if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.b2-floor.b1 < 0 && cursor.yvel > 0 && floor.flp)
-							cursor.pos.y = (floor.pos.y-(int)cursor.yvel-1)-cursor.h;
-					}
-				}
-				cursor.gnded = (cursor.pos.y == ((floor.b2-cursor.h)-newy)-(int)cursor.yvel) ? 1 : 0;
-				if (verbose >= 1) {
-					printf(
-						"cursor.a1-(floor.a2-(floor.w/2)): %i\n"
-						"cursor.a2-(floor.a2-(floor.w/2)): %i\n"
-						"(cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2)): %i\n"
-						"(cursor.a2-(cursor.w/2)): %i\n"
-						, cursor.a1-(floor.a2-(floor.w/2))
-						, cursor.a2-(floor.a2-(floor.w/2))
-						, (cursor.a2-(cursor.w/2))-(floor.a2-(floor.w/2))
-						, (cursor.a2-(cursor.w/2)));
-				}
-				printf("%u, %u\n%u\n%i\n%i, %i\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
-			} else {
-				cursor.c1 = cursor.pos.fx;
-				cursor.c2 = cursor.pos.fx+cursor.w;
-				cursor.d1 = cursor.pos.fy;
-				cursor.d2 = cursor.pos.fy+cursor.h;
-				floor.c1 = floor.pos.fx;
-				floor.c2 = floor.pos.fx+floor.w;
-				floor.d1 = floor.pos.fy;
-				floor.d2 = floor.pos.fy+floor.h;
-
-				cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
-				/* Check for a collision, on the y axis. */
-				cursor.cly = ((cursor.d2 >= (floor.d1-hmpeak)-cursor.yvel && cursor.c2 >= floor.c1) && (cursor.d1 <= (floor.d2+hmpeak)-cursor.yvel && cursor.c1 <= floor.c2)) ? 1 : 0;
-
-				int newy = 0;
-				if (cursor.clx) {
-					if (cursor.c2-floor.c1 < -1 || cursor.c2-floor.c1 > floor.w) {
-						/* Is the Cursor coming from the left? */
-						if (cursor.c2 > floor.c1-cursor.xvel-1 && floor.d2-cursor.d2 < (int)floor.heightmap[0] && !floor.flp && cursor.xvel > 0)
-							cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
-						else if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && floor.d2-cursor.d2 < (int)floor.heightmap[floor.w-1] && !floor.flp && cursor.xvel < 0)
-							cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
-						/* Is the Cursor coming from the right? */
-						if (cursor.c1 < (floor.c2-cursor.w)-cursor.xvel+1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel < 0)
-							cursor.pos.fx = (floor.c2-cursor.w)-cursor.xvel+1;
-						else if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d1-floor.d1 < 0 && floor.flp && cursor.xvel > 0)
-							cursor.pos.fx = (floor.pos.x-cursor.xvel)-cursor.w-1;
-						cursor.xvel = 0;
-					}
-				}
-				if (cursor.cly) {
-					if (cursor.c2-floor.c1 < floor.w) {
-						cursor.yvel = 0;
-						newy = (int)floor.heightmap[(int)cursor.c2-(int)floor.c1];
-						/* Is the Floor, really a floor? */
-						if (cursor.d2 > (floor.d2-hmpeak)-cursor.yvel && floor.d2-cursor.d2 >= 0 && !floor.flp)
-							cursor.pos.fy = ((floor.d2-cursor.h)-newy)-cursor.yvel;
-						else if (cursor.d1 < floor.d2-cursor.yvel+1 && floor.d2-cursor.d1 <= 0 && !floor.flp)
-							cursor.pos.fy = (floor.d2)-cursor.yvel+1;
-						/* Is the Floor, actually a ceiling? */
-						if (cursor.d1 < (floor.d1+hmpeak)-cursor.yvel && cursor.d1-floor.d1 >= 0 && floor.flp)
-							cursor.pos.fy = (floor.pos.fy+newy)-cursor.yvel;
-						else if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.d2-floor.d1 < 0 && cursor.yvel > 0 && floor.flp)
-							cursor.pos.fy = (floor.pos.fy-cursor.yvel-1)-cursor.h;
-					}
-				}
-				cursor.gnded = (cursor.pos.fy == ((floor.d2-cursor.h)-newy)-cursor.yvel) ? 1 : 0;
-				printf("cursor.c2-floor.c1: %07.06f\n", cursor.c2-floor.c1);
-				printf("%u, %u\n%u\n%i\n%07.06f, %07.06f\n%07.06f, %07.06f\n", cursor.clx, cursor.cly, cursor.gnded, newy, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
-			}
-		}
-
-		/* Axis Aligned Bounding Box Collision. */
-		if (colltype == AABB && coll) {
-			if (!flt) {
-				cursor.a1 = cursor.pos.x;
-				cursor.a2 = cursor.pos.x+cursor.w;
-				cursor.b1 = cursor.pos.y;
-				cursor.b2 = cursor.pos.y+cursor.h;
-				floor.a1 = floor.pos.x;
-				floor.a2 = floor.pos.x+floor.w;
-				floor.b1 = floor.pos.y;
-				floor.b2 = floor.pos.y+floor.h;
-				/* Is the Cursor is on the ground? */
-				cursor.gnded = (cursor.b2 == floor.b1-(int)cursor.yvel-1) ? 1 : 0;
-
-				/* Check for collisions, on both axies. */
-				cursor.clx = ((cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.b2 > floor.b1) && (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.b1 < floor.b2)) ? 1 : 0;
-				cursor.cly = ((cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.a2 > floor.a1) && (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.a1 < floor.a2)) ? 1 : 0;
-
-				if (cursor.clx) {
-					/* Is the Cursor coming from the left? */
-					if (cursor.a2 > floor.a1-(int)cursor.xvel-1 && cursor.xvel > 0)
-						cursor.pos.x = (floor.pos.x-(int)cursor.xvel)-cursor.w-1;
-					/* Is the Cursor coming from the right? */
-					else if (cursor.a1 < floor.a2-(int)cursor.xvel+1 && cursor.xvel < 0)
-						cursor.pos.x = (floor.pos.x+floor.w)-(int)cursor.xvel+1;
-					cursor.xvel = 0;
-				}
-				if (cursor.cly) {
-					/* Is the Cursor coming from the top? */
-					if (cursor.b2 > floor.b1-(int)cursor.yvel-1 && cursor.yvel > 0)
-						cursor.pos.y = (floor.pos.y-(int)cursor.yvel)-cursor.h-1;
-					/* Is the Cursor coming from the bottom? */
-					else if (cursor.b1 < floor.b2-(int)cursor.yvel+1 && cursor.yvel < 0)
-						cursor.pos.y = (floor.pos.y+floor.h)-(int)cursor.yvel+1;
-					cursor.yvel = 0;
-				}
+		if (colltype == THM && coll)
+			thm(flt, hmpeak, cursor, floor);
 
-				if (verbose >= 1) {
-					printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
-					printf("x: %i, y: %i\n", cursor.pos.x, cursor.pos.y);
-					printf("floor.x: %i, floor.y: %i\n", floor.pos.x, floor.pos.y);
-					printf ("r: %i\n", (floor.pos.x+floor.w)-(int)cursor.xvel+1);
-				}
-				printf("%u, %u\n%u\n%i, %i\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.x, cursor.pos.y, cursor.xvel, cursor.yvel);
-			} else {
-				cursor.c1 = cursor.pos.fx;
-				cursor.c2 = cursor.pos.fx+cursor.w;
-				cursor.d1 = cursor.pos.fy;
-				cursor.d2 = cursor.pos.fy+cursor.h;
-				floor.c1 = floor.pos.fx;
-				floor.c2 = floor.pos.fx+floor.w;
-				floor.d1 = floor.pos.fy;
-				floor.d2 = floor.pos.fy+floor.h;
-
-				cursor.gnded = (cursor.d2 == floor.d1-cursor.yvel-1) ? 1 : 0;
-				cursor.clx = ((cursor.c2 > floor.c1-cursor.xvel-1 && cursor.d2 > floor.d1) && (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.d1 < floor.d2)) ? 1 : 0;
-				cursor.cly = ((cursor.d2 > floor.d1-cursor.yvel-1 && cursor.c2 > floor.c1) && (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.c1 < floor.c2)) ? 1 : 0;
-
-				if (cursor.clx) {
-					if (cursor.c2 > floor.c1-cursor.xvel-1 && cursor.xvel > 0)
-						cursor.pos.fx = (floor.pos.fx-cursor.xvel)-(double)cursor.w-1;
-					else if (cursor.c1 < floor.c2-cursor.xvel+1 && cursor.xvel < 0)
-						cursor.pos.fx = (floor.pos.fx+(double)floor.w)-cursor.xvel+1;
-					cursor.xvel = 0;
-				}
-				if (cursor.cly) {
-					if (cursor.d2 > floor.d1-cursor.yvel-1 && cursor.yvel > 0)
-						cursor.pos.fy = (floor.pos.fy-cursor.yvel)-(double)cursor.h-1;
-					else if (cursor.d1 < floor.d2-cursor.yvel+1 && cursor.yvel < 0)
-						cursor.pos.fy = (floor.pos.fy+(double)floor.h)-cursor.yvel+1;
-					cursor.yvel = 0;
-				}
-				if (verbose >= 1) {
-					printf("cursor.gnded: %u\nclx: %u, cly: %u\n", cursor.gnded, cursor.clx, cursor.cly);
-					printf("fx: %07.06f, fy: %07.06f\n", cursor.pos.fx, cursor.pos.fy);
-					printf("floor.fx: %07.06f, floor.fy: %07.06f\n", floor.pos.fx, floor.pos.fy);
-				}
-				printf("%u, %u\n%u\n%07.06f, %07.06f\n%07.06f, %07.06f\n\0", cursor.clx, cursor.cly, cursor.gnded, cursor.pos.fx, cursor.pos.fy, cursor.xvel, cursor.yvel);
-			}
-		}
+		if (colltype == AABB && coll)
+			aabb(flt, cursor, floor);
 	}
 	uint8_t a = 0;
 	unsigned int i = 0;