Change collision function input to t_collider

diff --git a/include/so_long.h b/include/so_long.h
index 41181664c084b0bf95e81647802d306d190d8bf1..585527e58f84cad2dac519cb6fb50148d60fd664 100644 (file)
--- a/include/so_long.h
+++ b/include/so_long.h
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/08 14:14:02 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/05/15 14:48:10 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/05/15 14:58:14 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -50,6 +50,12 @@ typedef struct s_ivector
        int                     y;
 }                              t_ivector;
 
+typedef struct s_collider
+{
+       t_vector position;
+       t_ivector size;
+} t_collider;
+
 typedef struct s_actor
 {
        t_vector        position;
@@ -88,12 +94,11 @@ void                        on_key_input(mlx_key_data_t event, void *params);
 t_vector               grid_to_screen_pos(t_ivector grid_pos, t_ivector tile_size);
 t_ivector              screen_to_grid_pos(t_vector screen_pos, t_ivector tile_size);
 enum e_tile            get_tile(t_tilemap *map, int x, int y);
-int                            check_collision(t_vector a_pos, t_ivector a_size,
-                                       t_vector b_pos, t_ivector b_size);
-int                            check_wall_collision(t_vector a_pos, t_ivector a_size,
+int                            check_collision(t_collider a, t_collider b);
+int                            check_wall_collision(t_collider collider,
                                        t_tilemap *map);
 void                   move_and_slide(t_actor *actor, t_tilemap *map,
                                        double delta_time);
-int                            is_on_floor(t_vector pos, t_ivector size, t_tilemap *map);
+int                            is_on_floor(t_collider collider, t_tilemap *map);
 
 #endif // SO_LONG_H

diff --git a/src/collision.c b/src/collision.c
index 4458d606fe7c88313cebb98f47b4cbfe0114180e..f7ab7ecbafa227c24b316f1077a6e6a54acfe2ed 100644 (file)
--- a/src/collision.c
+++ b/src/collision.c
@@ -6,61 +6,60 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/14 11:48:59 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/05/15 14:47:26 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/05/15 15:02:47 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "so_long.h"
 
-static int     check_wall_collision_with_cell(t_vector a_pos, t_ivector a_size,
-                                                                                  t_tilemap *map, t_ivector tile);
+static int     check_wall_collision_with_cell(t_collider collider, t_tilemap *map,
+                               t_ivector tile);
 
 /*
  * Checks if a and b are colliding and returns the direction relative to a.
  * Example: The top left edge of a and the bottom right of b overlap.
  * In this case, check_collision() will return (UP | LEFT).
  */
-int    check_collision(t_vector a_pos, t_ivector a_size, t_vector b_pos,
-               t_ivector b_size)
+int    check_collision(t_collider a, t_collider b)
 {
        int     result;
 
        result = 0;
-       if (a_pos.x < b_size.x + b_pos.x && a_pos.x + a_size.x > b_pos.x
-               && a_pos.y < b_size.y + b_pos.y && a_pos.y + a_size.y > b_pos.y)
+       if (a.position.x < b.size.x + b.position.x && a.position.x
+               + a.size.x > b.position.x && a.position.y < b.size.y + b.position.y
+               && a.position.y + a.size.y > b.position.y)
        {
-               if (a_pos.x < b_pos.x)
+               if (a.position.x < b.position.x)
                        result |= RIGHT;
-               if (a_pos.x > b_pos.x)
+               if (a.position.x > b.position.x)
                        result |= LEFT;
-               if (a_pos.y < b_pos.y)
+               if (a.position.y < b.position.y)
                        result |= DOWN;
-               if (a_pos.y > b_pos.y)
+               if (a.position.y > b.position.y)
                        result |= UP;
        }
        return (result);
 }
 
-int    check_wall_collision(t_vector a_pos, t_ivector a_size, t_tilemap *map)
+int    check_wall_collision(t_collider collider, t_tilemap *map)
 {
        int                     result;
-       t_ivector       a_tile;
+       t_ivector       local_tile;
        t_ivector       check_tile;
        int                     x;
        int                     y;
 
-    result = 0;
-       a_tile = screen_to_grid_pos(a_pos, map->tile_size);
+       result = 0;
+       local_tile = screen_to_grid_pos(collider.position, map->tile_size);
        x = -1;
        while (x <= 1)
        {
                y = -1;
                while (y <= 1)
                {
-            check_tile.x = a_tile.x + x;
-            check_tile.y = a_tile.y + y;
-                       result |= check_wall_collision_with_cell(a_pos, a_size, map,
-                                       check_tile);
+                       check_tile.x = local_tile.x + x;
+                       check_tile.y = local_tile.y + y;
+                       result |= check_wall_collision_with_cell(collider, map, check_tile);
                        y++;
                }
                x++;
@@ -68,46 +67,44 @@ int check_wall_collision(t_vector a_pos, t_ivector a_size, t_tilemap *map)
        return (result);
 }
 
-static int     check_wall_collision_with_cell(t_vector a_pos, t_ivector a_size,
-               t_tilemap *map, t_ivector tile)
+static int     check_wall_collision_with_cell(t_collider collider, t_tilemap *map,
+               t_ivector tile)
 {
-       t_vector        wall_pos;
-       t_ivector       wall_size;
+       t_collider      wall;
 
        if (get_tile(map, tile.x, tile.y) == WALL)
        {
-               wall_pos = grid_to_screen_pos(tile, map->tile_size);
-               wall_size.x = map->tile_size.x;
-               wall_size.y = map->tile_size.y;
-               return (check_collision(a_pos, a_size, wall_pos, wall_size));
+               wall.position = grid_to_screen_pos(tile, map->tile_size);
+               wall.size.x = map->tile_size.x;
+               wall.size.y = map->tile_size.y;
+               return (check_collision(collider, wall));
        }
        return (0);
 }
 
-void move_and_slide(t_actor *actor, t_tilemap *map, double delta_time)
+void   move_and_slide(t_actor *actor, t_tilemap *map, double delta_time)
 {
-       t_vector move_pos;
-
-       move_pos.x = actor->position.x + (actor->velocity.x * delta_time);
-       move_pos.y = actor->position.y;
+       t_collider      c;
 
-       if ((check_wall_collision(move_pos, actor->size, map) & (RIGHT | LEFT)) == 0)
-               actor->position.x = move_pos.x;
+       c.size = actor->size;
+       c.position.x = actor->position.x + (actor->velocity.x * delta_time);
+       c.position.y = actor->position.y;
+       if ((check_wall_collision(c, map) & (RIGHT | LEFT)) == 0)
+               actor->position.x = c.position.x;
        else
                actor->velocity.x = 0;
-
-       move_pos.x = actor->position.x;
-       move_pos.y = actor->position.y + (actor->velocity.y * delta_time);
-       if ((check_wall_collision(move_pos, actor->size, map) & (UP | DOWN)) == 0)
-               actor->position.y = move_pos.y;
+       c.position.x = actor->position.x;
+       c.position.y = actor->position.y + (actor->velocity.y * delta_time);
+       if ((check_wall_collision(c, map) & (UP | DOWN)) == 0)
+               actor->position.y = c.position.y;
        else
                actor->velocity.y = 0;
 }
 
-int is_on_floor(t_vector pos, t_ivector size, t_tilemap *map)
+int    is_on_floor(t_collider collider, t_tilemap *map)
 {
-       pos.y += 5;
-       if (check_wall_collision(pos, size, map))
+       collider.position.y += 5;
+       if (check_wall_collision(collider, map))
                return (1);
        return (0);
 }

diff --git a/src/player_process.c b/src/player_process.c
index c66d13d052c898282ce8d3092e1b1d485fa7988e..0194d5990eaa96a104c6bf862ed6b698a8f6f993 100644 (file)
--- a/src/player_process.c
+++ b/src/player_process.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/14 12:40:05 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/05/15 14:46:26 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/05/15 15:04:25 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,14 +17,16 @@ static t_vector     get_direction_from_input(t_game *game);
 
 void   player_process(t_game *game)
 {
-       t_actor *player;
+       t_actor         *player;
+       t_collider      c;
 
        player = &game->player;
        player->direction = get_direction_from_input(game);
        player->velocity.x = player->direction.x * PLAYER_MOVE_SPEED;
        player->velocity.y += 50;
-       if (player->direction.y == -1 && is_on_floor(player->position, player->size,
-                       &game->map))
+       c.position = player->position;
+       c.size = player->size;
+       if (player->direction.y == -1 && is_on_floor(c, &game->map))
                player->velocity.y = -1000;
        move_and_slide(player, &game->map, game->mlx->delta_time);
 }