CMakeLists.txt

@@ -27,26 +27,19 @@ set(ASSETS_cg
   assets-cg/img/player.png
   assets-cg/img/wall.png
   assets-cg/img/spike.png
-  assets-cg/img/end.png
-  assets-cg/img/door.png
-  assets-cg/img/key.png
-  assets-cg/img/conveyor_u.png
-  assets-cg/img/conveyor_r.png
-  assets-cg/img/conveyor_d.png
-  assets-cg/img/conveyor_l.png
   # ...
 )
 
 fxconv_declare_assets(${ASSETS} ${ASSETS_fx} ${ASSETS_cg} WITH_METADATA)
 
 add_executable(myaddin ${SOURCES} ${ASSETS} ${ASSETS_${FXSDK_PLATFORM}})
-target_compile_options(myaddin PRIVATE -Wall -Wextra -Os -Wno-missing-braces)
+target_compile_options(myaddin PRIVATE -Wall -Wextra -Os)
 target_link_libraries(myaddin Gint::Gint)
 
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G)
-  generate_g1a(TARGET myaddin OUTPUT "ZkwuL.g1a"
-    NAME "ZkwuL" ICON assets-fx/icon.png)
+  generate_g1a(TARGET myaddin OUTPUT "ZkuwL.g1a"
+    NAME "ZkuwL" ICON assets-fx/icon.png)
 elseif("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
-  generate_g3a(TARGET myaddin OUTPUT "ZkwuL.g3a"
-    NAME "ZkwuL" ICONS assets-cg/icon-uns.png assets-cg/icon-sel.png)
+  generate_g3a(TARGET myaddin OUTPUT "ZkuwL.g3a"
+    NAME "ZkuwL" ICONS assets-cg/icon-uns.png assets-cg/icon-sel.png)
 endif()

README.md

@@ -5,7 +5,3 @@
 ZkwuL is a game made with [gint](https://gitea.planet-casio.com/Lephenixnoir/gint)
 
 It's a remake of my [first game](https://massena.itch.io/zkwul-the-game) made with GameMaker Studio 2
-
-# Softwares used
-
-I use [SLE](https://sr.ht/~kikoodx/sle/) and [kble2lua](https://gitea.planet-casio.com/KikooDX/kble2lua)

assets-cg/img/fxconv-metadata.txt

@@ -8,32 +8,4 @@ wall.png:
 
 spike.png:
   type: bopti-image
-  name: img_spike
-
-end.png:
-  type: bopti-image
-  name: img_end
-
-door.png:
-  type: bopti-image
-  name: img_door
-
-key.png:
-  type: bopti-image
-  name: img_key
-
-conveyor_u.png:
-  type: bopti-image
-  name: img_conveyor_u
-
-conveyor_r.png:
-  type: bopti-image
-  name: img_conveyor_r
-
-conveyor_d.png:
-  type: bopti-image
-  name: img_conveyor_d
-
-conveyor_l.png:
-  type: bopti-image
-  name: img_conveyor_l
+  name: img_spike

include/main.h

@@ -1,32 +1,34 @@
 #pragma once
 
-#define LEVEL_NB 3
 #define LEVEL_SIZE 16
 #define TILE_SIZE 12
-#define PLAYER_SIZE 10
 
-/* struct for a pair of int values */
+/* see we use a typedef like bellow
+ * its lazy and allow you to type
+ * Vec2 instead of struct TwoValues */
 typedef struct Vec2 {
 	int x, y;
 } Vec2;
 
-/* struct for a pair of float values */
-typedef struct FVec2 {
-	float x, y;
-} FVec2;
-
-/* struct for player's data */
+/* we do da same with player cause laziness never killed nobody
+ * wait */
 typedef struct Player {
 	Vec2 pos;
 	Vec2 spawn;
-	FVec2 frac;
 } Player;
 
-/* used for tiles */
+/* using a typedef is what cool kids do at least i think
+ * you might no remember what `int x` is :(
+ * if x is declared with `tile_t x` you know x is some tile :)
+ * knowledge is power and cool
+ * as bonus it looks cool in function declaration
+ * cool stuff told u :D */
 typedef int tile_t;
 
-Vec2 search(tile_t x, tile_t level[LEVEL_SIZE][LEVEL_SIZE]);
-int collide_pixel(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]);
-int collide(Vec2 pos, int h, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]);
-int object_delete(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]);
-Player player_reset(Player player, tile_t level[LEVEL_SIZE][LEVEL_SIZE]);
+Vec2 search(tile_t x, tile_t level[16][16]);
+/* here u can see i replaced x and y arguments with your twovalues struct
+ * u made smthing use it
+ * it will be handy in the future and makes better looking code */
+int collide_pixel(Vec2 pos, tile_t obj, tile_t level[16][16]);
+int collide(Vec2 pos, int h, tile_t obj, tile_t level[16][16]);
+Player level_reset(Player player);

open_kble.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-sle -tileset levels/tileset.png \
--tile-width 8 -tile-height 8 -level-width 16 -level-height 16 \
--editor-width 128 -editor-height 128 $@

src/levels.c

@@ -1,60 +1,22 @@
 #include "main.h"
 
-const tile_t level[LEVEL_NB][LEVEL_SIZE][LEVEL_SIZE] = {
-    {
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 4, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 2, 2, 0, 0, 0, 0, 2, 0, 0, 3, 0, 0, 2,
-        2, 0, 0, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 2, 2, 2, 2,
-        2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 2,
-        2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 0, 0, 2,
-        2, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 2, 2, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 4, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
-    },
-
-    {
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2,
-        2, 0, 6, 0, 0, 4, 0, 0, 0, 0, 4, 0, 0, 6, 0, 2,
-        2, 0, 0, 0, 4, 2, 0, 0, 0, 0, 2, 4, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 2, 2, 2, 2,
-        2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 5, 0, 3, 2,
-        2, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 5, 0, 0, 2,
-        2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 2, 2, 2, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
-        2, 0, 0, 0, 4, 2, 0, 0, 0, 0, 2, 4, 0, 0, 0, 2,
-        2, 0, 6, 0, 0, 4, 0, 0, 0, 0, 4, 0, 0, 6, 0, 2,
-        2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
-  },
-
-    {
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 8, 8, 8, 8, 4, 6, 8, 8, 8, 8, 8, 8, 2, 2,
-        2, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 2,
-        2, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 2,
-        2, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 8, 9, 9, 9, 2,
-        2, 4, 7, 4, 2, 2, 2, 2, 2, 2, 2, 2, 9, 9, 9, 2,
-        2, 6, 7, 6, 2, 2, 2, 2, 2, 2, 2, 2, 9, 9, 9, 2,
-        2, 7, 7, 7, 0, 0, 1, 2, 2, 2, 2, 2, 9, 9, 9, 2,
-        2, 7, 7, 7, 2, 2, 2, 2, 2, 3, 0, 5, 9, 9, 9, 2,
-        2, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 6, 9, 6, 2,
-        2, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 4, 9, 4, 2,
-        2, 7, 7, 7, 10, 2, 2, 2, 2, 2, 2, 9, 9, 9, 9, 2,
-        2, 7, 7, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 2,
-        2, 7, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 2,
-        2, 2, 10, 10, 10, 10, 10, 10, 6, 4, 10, 10, 10, 10, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
-    }
-};
+/* see use tile_t cause these stuff are tiles
+ * would you believe it? */
+const tile_t level[16][16] = {
+	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+	{1, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 3, 1},
+	{1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1},
+	{1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1},
+	{1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 1},
+	{1, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
+	{1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+	{1, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 1},
+	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+};

src/main.c

@@ -1,19 +1,15 @@
-/* ZkwuL by Massena */
-/* Optimisation and rewrite thanks to KikooDX */
-
 #include <gint/display.h>
 #include <gint/keyboard.h>
-#include <gint/std/string.h>
 #include "main.h"
 
 Vec2 search(tile_t x, tile_t level[16][16]) {
-	/* Search for x in a given matrix. */
-	/* If x is found, return it coordinates */
+	// Search for x in a given matrix.
+	// If x is found, return it coordinates
 	Vec2 coordinates = {0, 0};
 	for(int m = 0; m < LEVEL_SIZE; ++m) {
 			for(int n = 0; n < LEVEL_SIZE; ++n) {
 				if(level[m][n] == x) {
-					/* idk why m and n are inversed but it works kek */
+					// idk why m and n are inversed but it works kek
 					coordinates.x = n * 12;
 					coordinates.y = m * 12;
 					return coordinates;
@@ -24,8 +20,8 @@ Vec2 search(tile_t x, tile_t level[16][16]) {
 }
 
 int collide_pixel(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
-	/* Check if there's something in (x, y) */
-	if(obj == level[pos.y / TILE_SIZE][pos.x / TILE_SIZE]) {
+	// Check if there's something in (x, y)
+	if(obj == level[pos.x / TILE_SIZE][pos.y / TILE_SIZE]) {
 		return 1;
 	}
 	else {
@@ -34,13 +30,14 @@ int collide_pixel(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
 }
 
 int collide(Vec2 pos, int h, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
-	/* tl = top left */
-	/* br = bottom right */
+	/* tl = top left
+	 * br = bottom right
+	 * avoid repetition later on ezier to work on */
 	const Vec2 pos_tl = (Vec2){pos.x + h, pos.y + h};
-	const Vec2 pos_br = (Vec2){pos.x + PLAYER_SIZE - h - 1, pos.y + PLAYER_SIZE - h - 1};
-	/* Check if there's something in */
-	/* the square (x + 1, y + 1, x + 11, y + 11) */
-	/* The size of the hitbox changes with h */
+	const Vec2 pos_br = (Vec2){pos.x + TILE_SIZE - h - 1, pos.y + TILE_SIZE - h - 1};
+	// Check if there's something in
+	// the square (x + 1, y + 1, x + 11, y + 11)
+	// The size of the hitbox changes with h
 	if(collide_pixel(pos_tl, obj, level) ||
 	   collide_pixel(pos_br, obj, level) ||
 	   collide_pixel((Vec2){pos_tl.x, pos_br.y}, obj, level) ||
@@ -51,29 +48,7 @@ int collide(Vec2 pos, int h, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
 	return 0;
 }
 
-int object_delete(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
-	/* delete the object if it touches the player */
-	const Vec2 pos_tl = (Vec2){pos.x, pos.y};
-	const Vec2 pos_br = (Vec2){pos.x + PLAYER_SIZE - 1, pos.y + PLAYER_SIZE - 1};
-
-	if(collide_pixel(pos_tl, obj, level)) { 
-		level[pos_tl.y / TILE_SIZE][pos_tl.x / TILE_SIZE] = 0;
-	}
-	if(collide_pixel(pos_br, obj, level)) { 
-		level[pos_br.y / TILE_SIZE][pos_br.x / TILE_SIZE] = 0;
-	}
-	if(collide_pixel((Vec2){pos_tl.x, pos_br.y}, obj, level)) { 
-		level[pos_br.y / TILE_SIZE][pos_tl.x / TILE_SIZE] = 0;
-	}
-	if(collide_pixel((Vec2){pos_br.x, pos_tl.y}, obj, level)) { 
-		level[pos_tl.y / TILE_SIZE][pos_br.x / TILE_SIZE] = 0;
-	}
-	return 1;
-}
-
-Player player_reset(Player player, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
-	/* reset the level */
-	player.spawn = search(1, level);
+Player level_reset(Player player) {
 	player.pos = player.spawn;
 	return player;
 }
@@ -82,170 +57,67 @@ int main(void) {
 	extern bopti_image_t img_player;
 	extern bopti_image_t img_wall;
 	extern bopti_image_t img_spike;
-	extern bopti_image_t img_end;
-	extern bopti_image_t img_door;
-	extern bopti_image_t img_key;
-	extern bopti_image_t img_conveyor_u;
-	extern bopti_image_t img_conveyor_r;
-	extern bopti_image_t img_conveyor_d;
-	extern bopti_image_t img_conveyor_l;
 
-	extern tile_t level[LEVEL_NB][LEVEL_SIZE][LEVEL_SIZE];
+	extern tile_t level[LEVEL_SIZE][LEVEL_SIZE];
 
 	int running = 1;
-	int timer = 0; /* lol */
-	int lvl = 0;
-	tile_t curr_level[LEVEL_SIZE][LEVEL_SIZE];
 
-	/* player */
+	// player
 	Player player = {
 		.pos = {0, 0},
-		.spawn = {0, 0},
-		.frac = {0, 0}
+		.spawn = {0, 0}
 	};
-	
-	memcpy(curr_level, level[lvl], sizeof(level[lvl]));
-	player = player_reset(player, curr_level);
+	player.spawn = search(2, level);
+	player = level_reset(player);
 
-	/* main loop */
+	// main loop
 	while(running) {
 
 		dclear(C_BLACK);
 
-		/* drawing the level */
+		// drawing the level
 		for(int m = 0; m < LEVEL_SIZE; ++m) {
 			for(int n = 0; n < LEVEL_SIZE; ++n) {
-				switch(curr_level[n][m]) {
-					case 2:
-						/* walls */
+				switch(level[n][m]) {
+					case 1:
+						// walls
 						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_wall);
 						break;
 					case 3:
-						/* end ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_end,
-							((timer / 30) % 4) * 12, 0, 12, 12, 0);
-						break;
-					case 4:
-						/* spikes */
+						// spikes
 						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_spike);
 						break;
-					case 5:
-						/* door */
-						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_door);
-						break;
-					case 6:
-						/* key ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_key,
-							((timer / 30) % 4) * 12, 0, 12, 12, 0);
-						break;
-
-					case 7:
-						/* key ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_u,
-							((timer / 15) % 6) * 12, 0, 12, 12, 0);
-						break;
-					case 8:
-						/* key ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_r,
-							((timer / 15) % 6) * 12, 0, 12, 12, 0);
-						break;
-					case 9:
-						/* key ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_d,
-							((timer / 15) % 6) * 12, 0, 12, 12, 0);
-						break;
-					case 10:
-						/* key ring */
-						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_l,
-							((timer / 15) % 6) * 12, 0, 12, 12, 0);
-						break;
 				}
 			}
 		}
 
-		dprint(0, 0, C_BLACK, "%d", lvl);
-		/* drawing the player */
+		// drawing the player
 		dimage(player.pos.x, player.pos.y, &img_player);
 
 		dupdate();
 
+		/* if something has x and y, you probably want to use your Vec2 struct */
 		Vec2 mov = {
 			.x = keydown(KEY_RIGHT) - keydown(KEY_LEFT),
 			.y = keydown(KEY_DOWN) - keydown(KEY_UP)
 		};
 		clearevents();
 
-		/* conveyors */
-		if(collide(player.pos, 0, 7, curr_level)) { player.frac.y -= 0.5; }
-		if(collide(player.pos, 0, 8, curr_level)) { player.frac.x += 0.5; }
-		if(collide(player.pos, 0, 9, curr_level)) { player.frac.y += 0.5; }
-		if(collide(player.pos, 0, 10, curr_level)) { player.frac.x -= 0.5; }
-
-		/* little accelerations (like conveyors) */
-		const int ifrac_x = player.frac.x;
-		player.frac.x -= ifrac_x;
-		mov.x += ifrac_x;
-
-		const int ifrac_y = player.frac.y;
-		player.frac.y -= ifrac_y;
-		mov.y += ifrac_y;
-
-		/* trying to move the player >w< */
-		if(!collide((Vec2){player.pos.x + mov.x, player.pos.y}, 0, 2, curr_level) &&
-			!collide((Vec2){player.pos.x + mov.x, player.pos.y}, 1, 5, curr_level)) {
+		// trying to move the player >w<
+		if(!collide((Vec2){player.pos.x + mov.x, player.pos.y}, 0, 1, level)) {
 			player.pos.x += mov.x;
 		}
-		else {
-			player.frac = (FVec2){ 0, 0 };
-		}
 
-		if(!collide((Vec2){player.pos.x, player.pos.y + mov.y}, 0, 2, curr_level) &&
-			!collide((Vec2){player.pos.x, player.pos.y + mov.y}, 1, 5, curr_level)) {
+		if(!collide((Vec2){player.pos.x, player.pos.y + mov.y}, 0, 1, level)) {
 			player.pos.y += mov.y;
 		}
-		else {
-			player.frac = (FVec2){ 0, 0 };
+
+		// d i e
+		if(collide(player.pos, 2, 3, level)) {
+			player = level_reset(player);
 		}
 
-		/* d i e */
-		if(collide(player.pos, 2, 4, curr_level)) {
-			memcpy(curr_level, level[lvl], sizeof(level[lvl]));
-			player = player_reset(player, curr_level);
-		}
-
-		/* keys */
-		if(collide(player.pos, 0, 6, curr_level)) {
-			object_delete(player.pos, 6, curr_level);
-			/* check if there is any key */
-			Vec2 key_pos = search(6, curr_level);
-			if(key_pos.x == 0 && key_pos.y == 0) {
-				for(int m = 0; m < LEVEL_SIZE; ++m) {
-					for(int n = 0; n < LEVEL_SIZE; ++n) {
-						if(curr_level[m][n] == 5) {
-							curr_level[m][n] = 0;
-						}
-					}
-				}
-			}
-		}
-
-		/* end */
-		if(keydown(KEY_EXIT)) {
-			running = 0;
-		}
-
-		if(collide(player.pos, 0, 3, curr_level)) {
-			if(lvl != LEVEL_NB - 1) { 
-				++lvl;
-				memcpy(curr_level, level[lvl], sizeof(level[lvl]));
-				player = player_reset(player, curr_level);
-			}
-			else {
-				running = 0;
-			}
-		}
-
-		++timer; /* lol^2 */
+		if(keydown(KEY_EXIT)) running = 0;
 	}
 
 	return 1;