253 lines
6.5 KiB
C
253 lines
6.5 KiB
C
/* 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 */
|
|
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 */
|
|
coordinates.x = n * 12;
|
|
coordinates.y = m * 12;
|
|
return coordinates;
|
|
}
|
|
}
|
|
}
|
|
return coordinates;
|
|
}
|
|
|
|
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]) {
|
|
return 1;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int collide(Vec2 pos, int h, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
|
|
/* tl = top left */
|
|
/* br = bottom right */
|
|
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 */
|
|
if(collide_pixel(pos_tl, obj, level) ||
|
|
collide_pixel(pos_br, obj, level) ||
|
|
collide_pixel((Vec2){pos_tl.x, pos_br.y}, obj, level) ||
|
|
collide_pixel((Vec2){pos_br.x, pos_tl.y}, obj, level))
|
|
{
|
|
return 1;
|
|
}
|
|
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.pos = player.spawn;
|
|
return player;
|
|
}
|
|
|
|
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];
|
|
|
|
int running = 1;
|
|
int timer = 0; /* lol */
|
|
int lvl = 0;
|
|
tile_t curr_level[LEVEL_SIZE][LEVEL_SIZE];
|
|
|
|
/* player */
|
|
Player player = {
|
|
.pos = {0, 0},
|
|
.spawn = {0, 0},
|
|
.frac = {0, 0}
|
|
};
|
|
|
|
memcpy(curr_level, level[lvl], sizeof(level[lvl]));
|
|
player = player_reset(player, curr_level);
|
|
|
|
/* main loop */
|
|
while(running) {
|
|
|
|
dclear(C_BLACK);
|
|
|
|
/* 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 */
|
|
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 */
|
|
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 */
|
|
dimage(player.pos.x, player.pos.y, &img_player);
|
|
|
|
dupdate();
|
|
|
|
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)) {
|
|
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)) {
|
|
player.pos.y += mov.y;
|
|
}
|
|
else {
|
|
player.frac = (FVec2){ 0, 0 };
|
|
}
|
|
|
|
/* 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 */
|
|
}
|
|
|
|
return 1;
|
|
}
|