122 lines
4.2 KiB
C
122 lines
4.2 KiB
C
#include <assert.h>
|
|
#include "sys/sys.h"
|
|
#include "game.h"
|
|
#include "map/game_map.h"
|
|
|
|
bool game_collision_is_occlusive(sys_maptile tile) {
|
|
if (tile >= 0 && tile < 30) { return true; }
|
|
if (tile >= 60 && tile < 90) { return true; }
|
|
return false;
|
|
}
|
|
|
|
bool game_collision_can_move(game_bbox body, sys_i32 dx, sys_i32 dy) {
|
|
sys_i32 x = body.x + dx;
|
|
sys_i32 y = body.y + dy;
|
|
|
|
// the player can never leave the map
|
|
if (x < 0) { return false; }
|
|
if (y < 0) { return false; }
|
|
if (x + body.w > map_game_map.width * TILE_SZ_MICROPIXEL) {
|
|
return false;
|
|
}
|
|
if (y + body.h > map_game_map.height * TILE_SZ_MICROPIXEL) {
|
|
return false;
|
|
}
|
|
|
|
// TODO: Collide with blocks
|
|
// If two collides with a block, check if one collides with it.
|
|
// The collision only matters if one doesn't.
|
|
return true;
|
|
}
|
|
|
|
#define round_down(x, incr) (x) - (x) % (incr)
|
|
#define round_up(x, incr) round_down((x) + (incr) - 1, incr)
|
|
|
|
game_collision game_collision_move_to_contact(
|
|
game_bbox* body, sys_i32 total_dx, sys_i32 total_dy
|
|
) {
|
|
sys_i32 src_x = body->x;
|
|
sys_i32 src_y = body->y;
|
|
game_collision collision = {
|
|
.collided_x=false,
|
|
.collided_y=false,
|
|
.distance_x=0,
|
|
.distance_y=0,
|
|
};
|
|
sys_i32 tar_x = body->x + total_dx;
|
|
sys_i32 tar_y = body->y + total_dy;
|
|
|
|
while (true) {
|
|
// calculate how much we still need to move
|
|
int32_t remaining_dx = tar_x - body->x;
|
|
int32_t remaining_dy = tar_y - body->y;
|
|
|
|
// if we don't need to move, stop
|
|
if (remaining_dx == 0 && remaining_dy == 0) {
|
|
collision.distance_x = body->x - src_x;
|
|
collision.distance_y = body->x - src_y;
|
|
return collision;
|
|
}
|
|
|
|
// figure out where we are
|
|
sys_i32 body_x0 = body->x;
|
|
sys_i32 body_y0 = body->y;
|
|
sys_i32 body_x1 = body->x + body->w;
|
|
sys_i32 body_y1 = body->y + body->h;
|
|
|
|
// figure out what tile we're still in
|
|
sys_i32 tile_x0 = round_down(body_x0, TILE_SZ_MICROPIXEL);
|
|
sys_i32 tile_y0 = round_down(body_y0, TILE_SZ_MICROPIXEL);
|
|
sys_i32 tile_x1 = round_up(body_x1, TILE_SZ_MICROPIXEL);
|
|
sys_i32 tile_y1 = round_up(body_y1, TILE_SZ_MICROPIXEL);
|
|
|
|
// but we want the _next_ tile
|
|
if (tile_x0 == body_x0) { tile_x0 -= TILE_SZ_MICROPIXEL; }
|
|
if (tile_y0 == body_y0) { tile_y0 -= TILE_SZ_MICROPIXEL; }
|
|
if (tile_x1 == body_x1) { tile_x1 += TILE_SZ_MICROPIXEL; }
|
|
if (tile_y1 == body_y1) { tile_y1 += TILE_SZ_MICROPIXEL; }
|
|
|
|
// length of an x axis move
|
|
int step_dx =
|
|
remaining_dx < 0 ?
|
|
// line up our left side with the tile to our left
|
|
// not exceeding dx
|
|
sys_max_i32(remaining_dx, tile_x0 - body_x0) :
|
|
remaining_dx > 0 ?
|
|
// line up our right side with the tile to our right
|
|
// not exceeding dx
|
|
sys_min_i32(remaining_dx, tile_x1 - body_x1) :
|
|
// dx == 0
|
|
INT32_MAX ;
|
|
|
|
int step_dy =
|
|
remaining_dy < 0 ?
|
|
// line up our top side with the tile above us
|
|
// not exceeding dy
|
|
sys_max_i32(remaining_dy, tile_y0 - body_y0) :
|
|
remaining_dy > 0 ?
|
|
// line up our bottom side with the tile below us
|
|
// not exceeding dy
|
|
sys_min_i32(remaining_dy, tile_y1 - body_y1) :
|
|
INT32_MAX;
|
|
|
|
// there must be a viable move in some direction
|
|
assert(step_dx != INT32_MAX || step_dy != INT32_MAX);
|
|
|
|
if (sys_abs_i32(step_dx) < sys_abs_i32(step_dy)) {
|
|
if (game_collision_can_move(*body, step_dx, 0)) {
|
|
body->x += step_dx; // take the tiny move
|
|
} else {
|
|
tar_x = body->x; // stop trying to move
|
|
collision.collided_x = true;
|
|
}
|
|
} else {
|
|
if (game_collision_can_move(*body, 0, step_dy)) {
|
|
body->y += step_dy; // take the tiny move
|
|
} else {
|
|
tar_y = body->y; // stop trying to move
|
|
collision.collided_y = true;
|
|
}
|
|
}
|
|
}
|
|
} |