willem/cub3d
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/quinten' into willem

Browse Source
This commit is contained in:
Willem Haffmans 2025-06-10 16:21:13 +02:00
commit 9f40ab82ad
41 changed files with 475 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -6,12 +6,11 @@
# By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2024/10/15 11:48:46 by whaffman #+# #+# #
# Updated: 2025/06/04 20:10:47 by qmennen ### ########.fr #
# Updated: 2025/06/05 17:28:32 by qmennen ### ########.fr #
# #
# **************************************************************************** #
NAME = cub3D
FLAGS = ""
DIST_PATH = dist
SRC_PATH = src
@ -47,7 +46,7 @@ SOURCES = $(shell basename -a $(shell find $(SRC_PATH) -type f -name "*.c"))
# Build configurations
BUILD_CONFIGS = release debug asan tsan
release_CFLAGS = -Wall -Werror -Werror -flto -Ofast -march=native -mtune=native -ffast-math -DFULLSCREEN=1
release_CFLAGS = -Wall -Wextra -Werror -flto -Ofast -march=native -mtune=native -ffast-math -DFULLSCREEN=0
unity_CFLAGS = -Wall -Werror -Werror -Ofast -march=native -mtune=native -ffast-math
debug_CFLAGS = -Wall -Werror -Werror -g3 -DDEBUG -DDBG='fprintf(stderr, RED "DEBUG: " RESET "%s:%d (%s)\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);'
asan_CFLAGS = -Wall -Werror -Werror -flto -fsanitize=address,leak,undefined -g3 -DFULLSCREEN=0

3
inc/collision.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 14:40:47 by qmennen #+# #+# */
/* Updated: 2025/06/03 21:24:43 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:49:10 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -18,6 +18,5 @@
int collision_horizontal(t_map *map, t_player *player, double xa);
int collision_vertical(t_map *map, t_player *player, double ya);
int collision_sprite(t_game *game, double xa, double ya);
void collect(t_player *player);
#endif

4
inc/cub3d.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 12:22:29 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:54:18 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:48:20 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -71,7 +71,7 @@
# include "monster.h"
int initialize_cub3d(t_game **game, const char *mapfile);
int shader_init(t_game **game);
int shader_init(void);
void set_uniforms(t_game *game);
int load_uniforms(t_game **game);
void count_scores(t_game *game);

11
inc/game_menu.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/27 15:07:48 by qmennen #+# #+# */
/* Updated: 2025/06/03 19:15:44 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:20:30 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,12 +19,19 @@ void menu_display(t_menu *menu, t_screen *screen);
void draw_end_screen(t_game_manager *manager, t_menu *menu);
t_menu *create_end_screen(t_game_manager *manager);
mlx_image_t *menu_load_background(mlx_t *mlx, char *background_path);
void menu_set_background(t_menu *menu, mlx_t *mlx, char *b_path);
t_menu *create_main_menu(t_game_manager *manager);
t_menu *menu_create(t_game_manager *manager, char *b_path,
const t_menu_item *options[]);
t_menu_item *menu_item_create(t_screen *screen, const char *text,
void (*act)(struct s_menu_item *item, t_game_manager *manager));
void menu_free(t_menu *menu, t_screen *screen);
void menu_toggle(t_menu *menu, t_screen *screen);
void menu_toggle(t_menu *menu);
char *get_score_prefix(int index);
char *get_score_suffix(int index);
void draw_score_line(
mlx_t *mlx, mlx_image_t **img, char *text, t_vec2_int pos
);
char *get_score_text(char *prefix, char *suffix, int score);
#endif

4
inc/parser.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/19 14:41:55 by whaffman #+# #+# */
/* Updated: 2025/06/03 15:49:59 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:49:46 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -48,5 +48,7 @@ t_tile **create_grid(int width, int height);
int find_player_or_empty(t_map *map, int *x, int *y);
int floodfill(t_map *map, int x, int y);
t_sprite make_sprite(t_sprite_lib *def, double x, double y);
int parse_map_line_sprites(char *line, t_game *game, int y);
int count_sprites(char *line);
#endif

4
inc/render.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 16:28:16 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:15:26 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:30:30 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -28,7 +28,7 @@ unsigned int get_texture_color(mlx_texture_t *texture,
void sort_sprites(t_game *game);
void calculate_sprite_dist(t_game *game);
void cam_fraction(t_game *game, t_sprite *sprite);
unsigned int calculate_alpha(int x, int y, double dist);
unsigned int calculate_alpha(double dist);
unsigned int sample_texture_color(t_sprite *sprite,
t_vec2_int tex, int n);

8
inc/types.h
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 15:52:44 by qmennen #+# #+# */
/* Updated: 2025/06/05 17:08:34 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:06:16 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -170,11 +170,7 @@ typedef struct s_scoreboard
int enemies;
int start_time;
int end_time;
mlx_image_t *tiles_text;
mlx_image_t *collectibles_text;
mlx_image_t *battery_text;
mlx_image_t *enemies_text;
mlx_image_t *time_text;
mlx_image_t *texts[5];
} t_scoreboard;
typedef struct s_game

36
src/game/collision.c
View File

@ -6,25 +6,38 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 14:40:59 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:35:34 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:41:31 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "collision.h"
void collect(t_player *player)
static void collect(t_game *game, t_sprite *sprite)
{
t_player *player;
player = game->player;
player->battery += 0.5f;
if (player->battery > 1.f)
player->battery = 1.f;
sprite->type = SPRITE_TYPE_COLLECTED;
game->scoreboard->collectibles++;
}
static void damage_player(t_player *player, float amount)
{
player->battery -= amount;
if (player->battery < 0.f)
player->battery = 0.f;
player->hit_timer = 0.65f;
}
int collision_sprite(t_game *game, double xa, double ya)
{
t_player *player;
t_map *map;
t_sprite *sprites;
int i;
t_player *player;
t_map *map;
t_sprite *sprites;
unsigned int i;
player = game->player;
map = game->map;
@ -38,16 +51,9 @@ int collision_sprite(t_game *game, double xa, double ya)
&& fabs(player->pos.y + ya - sprites[i].pos.y) < 0.5))
{
if (sprites[i].type == SPRITE_TYPE_ENEMY)
{
player->battery -= 0.001;
player->hit_timer = .65f;
}
damage_player(player, 0.05f);
else
{
sprites[i].type = SPRITE_TYPE_COLLECTED;
collect(player);
game->scoreboard->collectibles++;
}
collect(game, &sprites[i]);
return (1);
}
i++;

5
src/game/flash.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/06/03 15:53:32 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:42:45 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:41:33 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,5 +22,4 @@ void handle_flash(t_sprite *sprite, t_game *game)
sprite->type = SPRITE_TYPE_DISABLED;
game->scoreboard->enemies++;
}
}
}

42
src/game/game.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 15:46:08 by qmennen #+# #+# */
/* Updated: 2025/06/05 17:09:48 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:25:17 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -24,7 +24,7 @@ int game_create(t_game **game)
{
return (free(*game), FAILURE);
}
return (SUCCESS);
return (SUCCESS);
}
void game_over(t_game_manager *manager)
@ -62,7 +62,25 @@ void game_run(t_game *game)
collision_sprite(game, 0, 0);
if (game->player->battery <= 0 || count_tiles(game->map, TILE_EMPTY) == 0)
game_over(game->manager);
}
static void free_scoreboard(mlx_t *mlx, t_scoreboard *scoreboard)
{
int i;
if (!scoreboard)
return ;
i = 0;
while (i < 5)
{
if (scoreboard->texts[i])
{
mlx_delete_image(mlx, scoreboard->texts[i]);
scoreboard->texts[i] = NULL;
}
i++;
}
free(scoreboard);
}
void game_free(t_game *game)
@ -83,22 +101,6 @@ void game_free(t_game *game)
if (game->keyboard)
free(game->keyboard);
if (game->scoreboard)
{
if (game->scoreboard->tiles_text)
mlx_delete_image(game->screen->mlx, game->scoreboard->tiles_text);
if (game->scoreboard->collectibles_text)
mlx_delete_image(game->screen->mlx, game->scoreboard->collectibles_text);
if (game->scoreboard->battery_text)
mlx_delete_image(game->screen->mlx, game->scoreboard->battery_text);
if (game->scoreboard->enemies_text)
mlx_delete_image(game->screen->mlx, game->scoreboard->enemies_text);
free(game->scoreboard);
}
}
void game_terminate(t_game *game)
{
print_scores(game);
game_free(game);
exit(EXIT_SUCCESS);
free_scoreboard(game->screen->mlx, game->scoreboard);
game->scoreboard = NULL;
}

3
src/game/game_hud.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/28 14:26:29 by qmennen #+# #+# */
/* Updated: 2025/06/03 19:22:47 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:41:43 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -58,7 +58,6 @@ void handle_battery(t_game *game)
{
game->player->battery = 0;
game->manager->state = GAME_STATE_MENU;
// game_terminate(game);
}
draw_battery(game->screen->minimap, game->player->battery);
}

6
src/game/player.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 18:53:19 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:49:17 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:44:18 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -32,11 +32,11 @@ int player_create(t_game **game)
void interact_door(t_game *game)
{
t_vec2_int pos;
pos = vec2_to_int(add(game->player->pos, game->player->dir));
if (game->map->grid[pos.y][pos.x] == TILE_DOOR)
{
game->map->grid[pos.y][pos.x] = TILE_EMPTY;
game->scoreboard->tiles_visited++;
}
}
}

2
src/manager/game_manager.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/27 13:48:18 by qmennen #+# #+# */
/* Updated: 2025/06/04 18:52:53 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:19:59 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */

17
src/manager/game_manager_utils.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* game_manager_utils.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/05/27 15:22:15 by qmennen #+# #+# */
/* Updated: 2025/06/04 17:51:00 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* game_manager_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/27 15:22:15 by qmennen #+# #+# */
/* Updated: 2025/06/05 18:44:32 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -39,6 +39,7 @@ void game_manager_handle_input(t_game_manager *manager)
{
(*manager->active_menu)->selected_option--;
if ((*manager->active_menu)->selected_option < 0)
(*manager->active_menu)->selected_option = (*manager->active_menu)->num_options - 1;
(*manager->active_menu)->selected_option = (
*manager->active_menu)->num_options - 1;
}
}

90
src/menu/end_screen.c
View File

@ -3,10 +3,10 @@
/* :::::::: */
/* end_screen.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/06/03 16:20:35 by qmennen #+# #+# */
/* Updated: 2025/06/05 17:41:28 by whaffman ######## odam.nl */
/* Updated: 2025/06/10 16:20:56 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -21,49 +21,47 @@ static void slideshow(t_game *game)
game->screenshots[frame_idx]->instances[0].enabled = true;
if (last_frame_time == 0)
last_frame_time = mlx_get_time();
if (mlx_get_time() - last_frame_time > 5 && frame_idx < game->screenshot_idx && frame_idx < MAX_SCREENSHOTS) {
if (mlx_get_time() - last_frame_time > 5 && frame_idx < game->screenshot_idx
&& frame_idx < MAX_SCREENSHOTS)
{
game->screenshots[frame_idx++]->instances[0].enabled = true;
game->screenshots[frame_idx - 1]->instances[0].enabled = false;
last_frame_time = mlx_get_time();
frame_idx %= (MAX_SCREENSHOTS < game->screenshot_idx) * MAX_SCREENSHOTS + (MAX_SCREENSHOTS >= game->screenshot_idx) * game->screenshot_idx;
frame_idx %= (MAX_SCREENSHOTS < game->screenshot_idx) * MAX_SCREENSHOTS
+ (MAX_SCREENSHOTS >= game->screenshot_idx) * game->screenshot_idx;
}
}
char *get_score_text(char *prefix, char *suffix, int score)
static void draw_scoreboard(t_game_manager *manager)
{
char *score_text;
char *score_complete;
char *score_value;
const int s_val[] = {
(int)(manager->game->scoreboard->tiles_visited
/ (double)manager->game->scoreboard->total_tiles * 100),
(int)(manager->game->player->battery * 100),
manager->game->scoreboard->collectibles,
manager->game->scoreboard->enemies,
manager->game->scoreboard->end_time
- manager->game->scoreboard->start_time
};
t_game *game;
int i;
char *s_text;
score_text = ft_itoa(score);
if (!score_text)
return (NULL);
score_value = ft_strjoin(prefix, score_text);
free(score_text);
if (!score_value)
return (NULL);
if (!suffix)
return (score_value);
score_complete = ft_strjoin(score_value, suffix);
free(score_value);
return (score_complete);
}
static void draw_score_line(mlx_t *mlx, mlx_image_t **img, char *text, t_vec2_int pos)
{
if (!text || *img != NULL)
return ;
*img = mlx_put_string(mlx, text, pos.x, pos.y);
free(text);
i = -1;
game = manager->game;
while (++i < 5)
{
s_text = get_score_text(get_score_prefix(i), get_score_suffix(i),
s_val[i]);
if (s_text)
draw_score_line(game->screen->mlx, &game->scoreboard->texts[i],
s_text, (t_vec2_int){350,
game->screen->height / 2 - 150 + i * 50});
}
}
void draw_end_screen(t_game_manager *manager, t_menu *menu)
{
char *tiles_score;
char *battery_percentage;
char *collectibles_score;
char *enemies_score;
char *time_text;
t_game *game;
if (!manager || !manager->game)
@ -72,31 +70,11 @@ void draw_end_screen(t_game_manager *manager, t_menu *menu)
slideshow(game);
if (menu->hidden)
{
menu_toggle(menu, game->screen);
menu_toggle(menu);
count_scores(game);
}
menu->selector->instances[0].y = manager->game->screen->height / 2
+ menu->selected_option * 50;
tiles_score = get_score_text("Discovered area: ", "%",
(double) game->scoreboard->tiles_visited / game->scoreboard->total_tiles * 100);
draw_score_line(game->screen->mlx, &game->scoreboard->tiles_text,
tiles_score, (t_vec2_int){350, game->screen->height / 2 - 100});
battery_percentage = get_score_text("Battery percentage: ",
"%", (double) game->player->battery * 100);
draw_score_line(game->screen->mlx, &game->scoreboard->battery_text,
battery_percentage, (t_vec2_int){350, game->screen->height / 2 - 75});
collectibles_score = get_score_text("Batteries found: ", NULL,
game->scoreboard->collectibles);
draw_score_line(game->screen->mlx, &game->scoreboard->collectibles_text,
collectibles_score, (t_vec2_int){350, game->screen->height / 2 - 50});
enemies_score = get_score_text("Enemies defeated: ", NULL,
game->scoreboard->enemies);
draw_score_line(game->screen->mlx, &game->scoreboard->enemies_text,
enemies_score, (t_vec2_int){350, game->screen->height / 2 - 25});
time_text = get_score_text("Play time: ", " seconds",
game->scoreboard->end_time - game->scoreboard->start_time);
draw_score_line(game->screen->mlx, &game->scoreboard->time_text,
time_text, (t_vec2_int){350, game->screen->height / 2 });
menu->selector->instances[0].enabled = false;
draw_scoreboard(manager);
}
static void game_exit(struct s_menu_item *item, t_game_manager *manager)

79
src/menu/end_screen_utils.c Normal file
View File

@ -0,0 +1,79 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* end_screen_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/06/10 14:54:49 by qmennen #+# #+# */
/* Updated: 2025/06/10 15:30:18 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "game_menu.h"
char *get_score_prefix(int index)
{
const char *score_prefix[] = {
"Discovered area: ",
"Battery percentage: ",
"Batteries found: ",
"Enemies defeated: ",
"Play time: "
};
if (index < 0 || index >= 5)
return (NULL);
return ((char *)score_prefix[index]);
}
char *get_score_suffix(int index)
{
const char *score_suffix[] = {
"%",
"%",
NULL,
NULL,
" seconds"
};
if (index < 0 || index >= 5)
return (NULL);
return ((char *)score_suffix[index]);
}
void draw_score_line(
mlx_t *mlx, mlx_image_t **img, char *text, t_vec2_int pos
)
{
if (!text)
return ;
if (*img != NULL)
{
free(text);
return ;
}
printf("Drawing score line: %s at (%d, %d)\n", text, pos.x, pos.y);
*img = mlx_put_string(mlx, text, pos.x, pos.y);
free(text);
}
char *get_score_text(char *prefix, char *suffix, int score)
{
char *score_text;
char *score_complete;
char *score_value;
score_text = ft_itoa(score);
if (!score_text)
return (NULL);
score_value = ft_strjoin(prefix, score_text);
free(score_text);
if (!score_value)
return (NULL);
if (!suffix)
return (score_value);
score_complete = ft_strjoin(score_value, suffix);
free(score_value);
return (score_complete);
}

9
src/menu/main_menu.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/28 14:14:11 by qmennen #+# #+# */
/* Updated: 2025/06/05 17:09:25 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:28:51 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,15 +21,13 @@ static void game_exit(struct s_menu_item *item, t_game_manager *manager)
static void game_start(struct s_menu_item *item, t_game_manager *manager)
{
t_game *game;
t_screen *screen;
(void)item;
game = manager->game;
screen = game->screen;
game->screen->minimap->instances[0].enabled = true;
game->screen->hud->instances[0].enabled = true;
game->scoreboard->start_time = mlx_get_time();
menu_toggle(*(manager->active_menu), screen);
menu_toggle(*(manager->active_menu));
manager->state = GAME_STATE_PLAYING;
}
@ -43,7 +41,8 @@ t_menu *create_main_menu(t_game_manager *manager)
};
t_menu *menu;
menu = menu_create(manager, "./assets/menu/surveillor_background.png", menu_items);
menu = menu_create(manager, "./assets/menu/surveillor_background.png",
menu_items);
if (!menu)
return (NULL);
return (menu);

20
src/menu/menu.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/27 14:31:53 by qmennen #+# #+# */
/* Updated: 2025/06/03 20:16:52 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:28:28 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,17 +22,7 @@ t_menu *menu_create(t_game_manager *manager, char *b_path,
if (!menu)
return (NULL);
ft_memset(menu, 0, sizeof(t_menu));
if (b_path)
menu->background = menu_load_background(
manager->game->screen->mlx, b_path);
if (b_path && mlx_image_to_window(
manager->game->screen->mlx, menu->background, 0, 0) < 0)
{
mlx_delete_image(manager->game->screen->mlx, menu->background);
return (free(menu), NULL);
}
if (menu->background)
menu->background->instances[0].enabled = false;
menu_set_background(menu, manager->game->screen->mlx, b_path);
menu->hidden = 1;
i = -1;
while (options[++i])
@ -46,13 +36,11 @@ t_menu *menu_create(t_game_manager *manager, char *b_path,
void menu_display(t_menu *menu, t_screen *screen)
{
int i;
int half_w;
int half_h;
half_w = screen->width / 2;
half_h = screen->height / 2;
if (menu->hidden)
menu_toggle(menu, screen);
menu_toggle(menu);
menu->selector->instances[0].x = 150;
menu->selector->instances[0].y = half_h + menu->selected_option * 50;
i = 0;
@ -64,7 +52,7 @@ void menu_display(t_menu *menu, t_screen *screen)
}
}
void menu_toggle(t_menu *menu, t_screen *screen)
void menu_toggle(t_menu *menu)
{
int i;

3
src/menu/menu_item.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/28 13:50:14 by qmennen #+# #+# */
/* Updated: 2025/06/03 16:23:36 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:50:10 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -24,7 +24,6 @@ t_menu_item *menu_item_create(t_screen *screen, const char *text,
item->text = (char *)text;
item->act = act;
item->image = mlx_put_string(screen->mlx, text, 0, 0);
// mlx_resize_image(item->image, 200, 50);
item->image->instances[0].enabled = false;
return (item);
}

15
src/menu/menu_util.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/28 14:45:59 by qmennen #+# #+# */
/* Updated: 2025/05/28 14:46:31 by qmennen ### ########.fr */
/* Updated: 2025/06/05 18:47:58 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -28,3 +28,16 @@ mlx_image_t *menu_load_background(mlx_t *mlx, char *background_path)
background_image = mlx_texture_to_image(mlx, background_texture);
return (mlx_delete_texture(background_texture), background_image);
}
void menu_set_background(t_menu *menu, mlx_t *mlx, char *b_path)
{
if (!menu || !b_path)
return ;
menu->background = menu_load_background(mlx, b_path);
if (mlx_image_to_window(mlx, menu->background, 0, 0) < 0)
{
mlx_delete_image(mlx, menu->background);
return ;
}
menu->background->instances[0].enabled = false;
}

28
src/monster/monster.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* monster.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/05/28 17:15:52 by qmennen #+# #+# */
/* Updated: 2025/06/03 14:51:23 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* monster.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/28 17:15:52 by qmennen #+# #+# */
/* Updated: 2025/06/10 14:45:44 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,14 +14,14 @@
void update_monsters(t_game *game)
{
int i;
t_vec2 d;
t_sprite *sprite;
double dist_squared;
double inv_dist;
unsigned int i;
t_vec2 d;
t_sprite *sprite;
double dist_squared;
double inv_dist;
i = -1;
while (++i < game->map->n_sprites)
i = 0;
while (i++ < game->map->n_sprites)
{
sprite = &game->map->sprites[i];
if (sprite->type != SPRITE_TYPE_ENEMY)

16
src/parser/find_player_or_empty.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* find_player_or_empty.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/23 12:13:50 by whaffman #+# #+# */
/* Updated: 2025/04/24 11:55:22 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* find_player_or_empty.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/23 12:13:50 by whaffman #+# #+# */
/* Updated: 2025/06/10 14:39:59 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,7 +14,7 @@
int find_player_or_empty(t_map *map, int *x, int *y)
{
int i;
unsigned int i;
if (!map || !x || !y)
return (FAILURE);

17
src/parser/floodfill.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* floodfill.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/23 12:14:58 by whaffman #+# #+# */
/* Updated: 2025/04/23 12:20:18 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* floodfill.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/23 12:14:58 by whaffman #+# #+# */
/* Updated: 2025/06/10 15:42:03 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,7 +14,8 @@
int floodfill(t_map *map, int x, int y)
{
if (!map || x < 0 || y < 0 || x >= map->width || y >= map->height)
if (!map || x < 0 || y < 0
|| x >= (int) map->width || y >= (int) map->height)
return (FAILURE);
if (map->grid[y][x] == TILE_VOID)
return (FAILURE);

16
src/parser/get_tile.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* get_tile.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/23 12:23:05 by whaffman #+# #+# */
/* Updated: 2025/05/07 11:51:33 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* get_tile.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/23 12:23:05 by whaffman #+# #+# */
/* Updated: 2025/06/10 14:37:58 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,7 +14,7 @@
t_tile get_tile(t_map *map, int x, int y)
{
if (x < 0 || y < 0 || x >= map->width || y >= map->height)
if (x < 0 || y < 0 || x >= (int) map->width || y >= (int) map->height)
return (TILE_WALL);
return (map->grid[y][x]);
}

16
src/parser/map_width.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* map_width.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/22 13:13:07 by whaffman #+# #+# */
/* Updated: 2025/05/07 11:48:00 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* map_width.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 13:13:07 by whaffman #+# #+# */
/* Updated: 2025/06/10 14:38:27 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,7 +21,7 @@ int map_width(char **lines)
width = 0;
while (lines[i])
{
if (ft_strlen(lines[i]) > width)
if ((int) ft_strlen(lines[i]) > width)
width = ft_strlen(lines[i]);
i++;
}

8
src/parser/parse_config_line.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 13:10:06 by whaffman #+# #+# */
/* Updated: 2025/06/04 17:57:29 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:47:23 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,7 +16,6 @@ mlx_texture_t *load_texture(const char *path)
{
mlx_texture_t *texture;
// printf("Loading texture: |%s|\n", path);
texture = mlx_load_png(path);
if (texture == NULL)
{
@ -29,7 +28,8 @@ mlx_texture_t *load_texture(const char *path)
t_token_handler handle_config_token(const char *token, t_map *map)
{
const char *config_tokens[] = {
"NO", "SO", "WE", "EA", "D", "F", "C", "FT", "CT", "-c", "-s", "-e", NULL
"NO", "SO", "WE", "EA", "D", "F", "C", "FT", "CT", "-c", "-s", "-e",
NULL
};
const t_token_handler handlers[] = {
handle_wall, handle_wall, handle_wall, handle_wall, handle_wall,
@ -38,8 +38,8 @@ t_token_handler handle_config_token(const char *token, t_map *map)
};
int i;
(void)map;
i = 0;
// printf("Token: %s\n", token);
while (config_tokens[i] != NULL)
{
if (ft_strcmp(token, config_tokens[i]) == 0)

71
src/parser/parse_map.c
View File

@ -6,22 +6,13 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 13:12:04 by whaffman #+# #+# */
/* Updated: 2025/05/28 17:07:32 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:45:35 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include <math.h>
t_vec2 parse_dir(int x, int y)
{
t_vec2 dir;
dir.x = (double)x;
dir.y = (double)y;
return (dir);
}
int parse_player(t_game *game, int y, int x, char c)
{
t_player *player;
@ -35,21 +26,21 @@ int parse_player(t_game *game, int y, int x, char c)
player->pos.x = ((double)x + 0.5f);
player->pos.y = ((double)y + 0.5f);
if (c == 'N')
player->dir = parse_dir(0, -1);
player->dir = (t_vec2){0.0, -1.0};
else if (c == 'E')
player->dir = parse_dir(1, 0);
player->dir = (t_vec2){1.0, 0.0};
else if (c == 'S')
player->dir = parse_dir(0, 1);
player->dir = (t_vec2){0.0, 1.0};
else if (c == 'W')
player->dir = parse_dir(-1, 0);
player->dir = (t_vec2){-1.0, 0.0};
player->camera = rot(player->dir, 0.5f * M_PI);
return (SUCCESS);
}
int parse_map_line(char **lines, t_game *game, int y)
{
int x;
t_map *map;
unsigned int x;
t_map *map;
map = game->map;
map->grid[y] = malloc(sizeof(t_tile) * (map->width + 1));
@ -74,22 +65,6 @@ int parse_map_line(char **lines, t_game *game, int y)
return (SUCCESS);
}
int count_sprites(char *line)
{
int count;
int i;
count = 0;
i = 0;
while (line[i])
{
if (line[i] >= 'a' && line[i] <= 'z')
count++;
i++;
}
return (count);
}
int prepare_map(char **lines, t_game *game)
{
int y;
@ -118,38 +93,10 @@ int prepare_map(char **lines, t_game *game)
return (SUCCESS);
}
int parse_map_line_sprites(char *line, t_game *game, int y)
{
int x;
t_map *map;
t_sprite_lib *sprite_lib;
map = game->map;
sprite_lib = map->sprite_lib;
x = 0;
while (line[x])
{
if (line[x] >= 'a' && line[x] <= 'z')
{
if (sprite_lib[line[x] - 'a'].texture == NULL)
{
ft_putstr_fd("Error: Undefined sprite symbol\n", 2);
return (FAILURE);
}
map->sprites[map->n_sprites] = make_sprite(
&sprite_lib[line[x] - 'a'],
(double)x + 0.5f, (double)y + 0.5f);
map->n_sprites++;
}
x++;
}
return (SUCCESS);
}
int parse_map(char **lines, t_game *game)
{
int y;
t_map *map;
unsigned int y;
t_map *map;
map = game->map;
if (!prepare_map(lines, game))

57
src/parser/parse_map_sprites.c Normal file
View File

@ -0,0 +1,57 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse_map_sprites.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/06/10 15:45:12 by qmennen #+# #+# */
/* Updated: 2025/06/10 15:47:07 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
int count_sprites(char *line)
{
int count;
int i;
count = 0;
i = 0;
while (line[i])
{
if (line[i] >= 'a' && line[i] <= 'z')
count++;
i++;
}
return (count);
}
int parse_map_line_sprites(char *line, t_game *game, int y)
{
int x;
t_map *map;
t_sprite_lib *sprite_lib;
map = game->map;
sprite_lib = map->sprite_lib;
x = 0;
while (line[x])
{
if (line[x] >= 'a' && line[x] <= 'z')
{
if (sprite_lib[line[x] - 'a'].texture == NULL)
{
ft_putstr_fd("Error: Undefined sprite symbol\n", 2);
return (FAILURE);
}
map->sprites[map->n_sprites] = make_sprite(
&sprite_lib[line[x] - 'a'],
(double)x + 0.5f, (double)y + 0.5f);
map->n_sprites++;
}
x++;
}
return (SUCCESS);
}

20
src/parser/print_map.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* print_map.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/23 12:11:12 by whaffman #+# #+# */
/* Updated: 2025/04/23 12:20:12 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* print_map.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/23 12:11:12 by whaffman #+# #+# */
/* Updated: 2025/06/10 15:47:33 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,9 +14,9 @@
void print_map(t_map *map)
{
const int chars[] = {'X', ' ', '.', '#', 'P'};
int i;
int j;
const int chars[] = {'X', ' ', '.', '#', 'P'};
unsigned int i;
unsigned int j;
if (!map)
return ;

17
src/render/dda.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/02 11:58:09 by whaffman #+# #+# */
/* Updated: 2025/06/04 18:32:57 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:40:24 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -67,14 +67,13 @@ int dda_main(t_vec2 ray_dir, t_vec2_int map_pos, t_vec2 *side_dist, t_map *map)
side_dist->y += delta_dist.y * side;
map_pos.x += step.x * (1 - side);
map_pos.y += step.y * side;
if (map_pos.x < 0
|| map_pos.x >= map->width
|| map_pos.y < 0
|| map_pos.y >= map->height)
printf("Out of bounds: %d %d\n", map_pos.x, map_pos.y);
if (map_pos.x < 0 || map_pos.x >= (int) map->width
|| map_pos.y < 0 || map_pos.y >= (int) map->height)
break ;
if (map->grid[map_pos.y][map_pos.x] == TILE_EMPTY)
map->grid[map_pos.y][map_pos.x] = TILE_VISITED;
hit = (map->grid[map_pos.y][map_pos.x] == TILE_WALL) - (map->grid[map_pos.y][map_pos.x] == TILE_DOOR);
hit = (map->grid[map_pos.y][map_pos.x] == TILE_WALL)
- (map->grid[map_pos.y][map_pos.x] == TILE_DOOR);
}
side = -1 * (1 - side) + side;
if (hit == -1)
@ -99,9 +98,9 @@ double dda(t_render *render, t_vec2 ray_dir, t_vec2 pos, t_map *map)
if (abs(side) == 2)
{
render->door = 1;
side /= 2;
side /= 2;
}
side = (side + 1)/2;
side = (side + 1) / 2;
return ((1 - side) * (side_dist.x - delta_dist.x)
- side * (side_dist.y - delta_dist.y));
}

68
src/render/render.c
View File

@ -6,54 +6,64 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 16:28:10 by qmennen #+# #+# */
/* Updated: 2025/06/03 22:17:23 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:36:55 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
void create_screenshot(t_game *game)
static void cut_image(t_screen *screen, mlx_image_t **canvas)
{
int i;
int j;
int idx1;
int idx2;
mlx_image_t *screenshot;
if (!game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS])
{
game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS] = mlx_new_image(game->screen->mlx, game->screen->width / 3, game->screen->height / 3);
mlx_image_to_window(game->screen->mlx, game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS], 1000, 250);
game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS]->instances[0].enabled = false;
}
screenshot = game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS];
if (!screenshot)
return ;
unsigned int i;
unsigned int j;
unsigned int idx1;
unsigned int idx2;
i = 0;
while (i < game->screen->height / 3)
while (i < screen->height / 3)
{
j = 0;
while (j < game->screen->width / 3)
while (j < screen->width / 3)
{
idx1 = (i * game->screen->width / 3 + j) * 4;
idx2 = (i * game->screen->img->width + j) * 12;
screenshot->pixels[idx1] = game->screen->img->pixels[idx2];
screenshot->pixels[idx1 + 1] = game->screen->img->pixels[idx2 + 1];
screenshot->pixels[idx1 + 2] = game->screen->img->pixels[idx2 + 2];
screenshot->pixels[idx1 + 3] = game->screen->img->pixels[idx2 + 3];
idx1 = (i * screen->width / 3 + j) * 4;
idx2 = (i * screen->img->width + j) * 12;
(*canvas)->pixels[idx1] = screen->img->pixels[idx2];
(*canvas)->pixels[idx1 + 1] = screen->img->pixels[idx2 + 1];
(*canvas)->pixels[idx1 + 2] = screen->img->pixels[idx2 + 2];
(*canvas)->pixels[idx1 + 3] = screen->img->pixels[idx2 + 3];
j++;
}
i++;
}
printf("Screenshot %d taken\n", game->screenshot_idx);
}
void create_screenshot(t_game *game)
{
mlx_image_t *screenshot;
if (!game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS])
{
game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS]
= mlx_new_image(game->screen->mlx, game->screen->width / 3,
game->screen->height / 3);
mlx_image_to_window(game->screen->mlx, game->screenshots[
game->screenshot_idx % MAX_SCREENSHOTS], 1000, 250);
game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS]
->instances[0].enabled = false;
}
screenshot = game->screenshots[game->screenshot_idx % MAX_SCREENSHOTS];
if (!screenshot)
return ;
cut_image(game->screen, &screenshot);
game->screenshot_idx++;
return ;
}
void flash(t_game *game)
{
mlx_image_t *img;
int x;
int y;
unsigned int x;
unsigned int y;
if (game->screen->flash == 0)
return ;
@ -76,8 +86,8 @@ void flash(t_game *game)
void cast_rays(t_game *game)
{
int x;
t_render render[WIDTH];
unsigned int x;
t_render render[WIDTH];
x = 0;
draw_floor(game);

15
src/render/render_floor.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/14 13:06:39 by whaffman #+# #+# */
/* Updated: 2025/06/04 20:07:21 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:41:41 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -26,21 +26,24 @@ static t_vec2 calc_floor_step(t_game *game,
static void draw_floor_ceiling_pixel(t_game *game,
t_vec2_int coord, double row_dist, t_vec2 floor_pos)
{
const t_vec2_int tex = vec2_to_int(mul(get_fraction(floor_pos), game->map->texture_floor->width));
const t_vec2_int tex = vec2_to_int(
mul(get_fraction(floor_pos), game->map->texture_floor->width));
int color;
if (game->map->texture_floor == NULL)
color = game->map->floor_color << 8 | (int)(1.0 / row_dist * 255);
else
color = get_texture_color(game->map->texture_floor,
(t_render){row_dist, 0, 0}, tex);
(t_render){.perp_dist = row_dist, .sign = 0, .door = 0,
.side = SIDE_DOOR, .wall_x = 0}, tex);
mlx_put_pixel(game->screen->img,
coord.x, coord.y, color);
if (game->map->texture_ceiling == NULL)
color = game->map->ceiling_color << 8 | (int)(1.0 / row_dist * 255);
else
color = get_texture_color(game->map->texture_ceiling,
(t_render){row_dist, 0, 0}, tex);
(t_render){.perp_dist = row_dist, .sign = 0, .door = 0,
.side = SIDE_DOOR, .wall_x = 0}, tex);
mlx_put_pixel(game->screen->img,
coord.x, game->screen->height - coord.y - 1, color);
}
@ -58,7 +61,7 @@ static void draw_floor_row(t_game *game,
floor_pos = add(game->player->pos, mul(left_ray, row_dist));
if (isinf(floor_pos.x) || isinf(floor_pos.y))
return ;
while (coord.x < game->screen->width)
while (coord.x < (int) game->screen->width)
{
draw_floor_ceiling_pixel(game, coord, row_dist, floor_pos);
floor_pos = add(floor_pos, floor_step);
@ -74,7 +77,7 @@ void draw_floor(t_game *game)
coord.y = game->screen->height / 2;
coord.x = 0;
while (coord.y < game->screen->height)
while (coord.y < (int) game->screen->height)
{
draw_floor_row(game, coord, left_ray, right_ray);
coord.y++;

16
src/render/render_sprite.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/08 12:23:17 by qmennen #+# #+# */
/* Updated: 2025/06/03 22:15:19 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:34:01 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -34,13 +34,12 @@ static int sprite_visible(t_game *game,
return (!isnan(sprite->cam_frac)
&& sprite->dist > MIN_SPRITE_DIST
&& x > 0
&& x < game->screen->width
&& x < (int) game->screen->width
&& sprite->dist <= render[x].perp_dist);
}
static void draw_sprite_column(
t_game *game, t_sprite *sprite, t_render *render,
t_sprite_column column)
t_game *game, t_sprite *sprite, t_sprite_column column)
{
t_vec2_int tex;
t_vec2 inv_range;
@ -52,8 +51,7 @@ static void draw_sprite_column(
frame %= sprite->n_frames;
inv_range.y = 1.0 / (column.end.y - column.start.y);
inv_range.x = 1.0 / (column.end.x - column.start.x);
sprite->alpha = calculate_alpha(column.start.x,
column.start.y, sprite->dist);
sprite->alpha = calculate_alpha(sprite->dist);
tex.x = column.x - column.start.x;
tex.x *= sprite->texture->width / sprite->n_frames;
tex.x *= inv_range.x;
@ -63,7 +61,7 @@ static void draw_sprite_column(
tex.y = (y - column.start.y) * sprite->texture->height;
tex.y *= inv_range.y;
color = sample_texture_color(sprite, tex, frame);
if (y > 0 && y < game->screen->height && (color & 0xFF) != 0)
if (y > 0 && y < (int) game->screen->height && (color & 0xFF) != 0)
mlx_put_pixel(game->screen->img, column.x, y, color);
y++;
}
@ -88,7 +86,7 @@ void draw_sprite(t_game *game, t_sprite *sprite, t_render *render)
column.start = start;
column.end = end;
column.x = x;
draw_sprite_column(game, sprite, render, column);
draw_sprite_column(game, sprite, column);
}
x++;
}
@ -96,7 +94,7 @@ void draw_sprite(t_game *game, t_sprite *sprite, t_render *render)
void render_sprites(t_render *render, t_game *game)
{
int i;
unsigned int i;
calculate_sprite_dist(game);
sort_sprites(game);

26
src/render/render_sprite_utils.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* render_sprite_utils.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/05/14 21:21:57 by whaffman #+# #+# */
/* Updated: 2025/05/18 12:51:23 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* render_sprite_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/14 21:21:57 by whaffman #+# #+# */
/* Updated: 2025/06/10 14:30:19 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,9 +14,9 @@
void sort_sprites(t_game *game)
{
int i;
int j;
t_sprite key;
unsigned int i;
int j;
t_sprite key;
i = 1;
while (i < game->map->n_sprites)
@ -35,8 +35,8 @@ void sort_sprites(t_game *game)
void calculate_sprite_dist(t_game *game)
{
t_vec2 player_pos;
int i;
t_vec2 player_pos;
unsigned int i;
i = 0;
player_pos = game->player->pos;
@ -70,7 +70,7 @@ void cam_fraction(t_game *game, t_sprite *sprite)
return ;
}
unsigned int calculate_alpha(int x, int y, double dist)
unsigned int calculate_alpha(double dist)
{
int alpha;

9
src/render/render_walls.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/14 13:05:28 by whaffman #+# #+# */
/* Updated: 2025/06/04 18:17:33 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:45:19 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -40,6 +40,7 @@ t_render cast_ray(t_game *game, int x)
double perp_dist;
render.door = 0;
render.sign = 1;
ray_dir = add(game->player->dir,
mul(game->player->camera,
(2.0f * x / (double)game->screen->width - 1)));
@ -84,7 +85,7 @@ static int set_range(t_game *game, t_render render, t_range *range, int height)
tex_start = range->start;
range->start = (range->start > 0) * range->start;
range->end = height / 2 + game->screen->height / 2;
if (range->end >= game->screen->height)
if (range->end >= (int) game->screen->height)
range->end = game->screen->height - 1;
return (tex_start);
}
@ -109,9 +110,9 @@ void draw_line(t_game *game, t_render render, int x)
color = get_texture_color(game->map->textures[render.side],
render, tex);
if (x < 0
|| x >= game->screen->width
|| x >= (int) game->screen->width
|| range.start < 0
|| range.start >= game->screen->height)
|| range.start >= (int) game->screen->height)
break ;
mlx_put_pixel(game->screen->img, x, range.start, color);
range.start++;

21
src/screen.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 15:30:27 by qmennen #+# #+# */
/* Updated: 2025/06/03 20:20:36 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:41:07 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -43,8 +43,8 @@ int screen_create(t_game **game)
void fill_background(mlx_image_t *image, int color)
{
int i;
int j;
unsigned int i;
unsigned int j;
i = 0;
while (i < image->width)
@ -77,14 +77,17 @@ int center_window(t_screen *screen)
int screen_display(t_screen *screen)
{
int display_error;
fill_background(screen->background, 0x000000FF);
display_error = 0;
display_error |= mlx_image_to_window(screen->mlx, screen->background, 0, 0) < 0;
display_error |= mlx_image_to_window(screen->mlx, screen->img, 0, 0) < 0;
display_error |= mlx_image_to_window(screen->mlx, screen->minimap, 175, 575) < 0;
display_error |= mlx_image_to_window(screen->mlx, screen->hud, 0, 0) < 0;
display_error |= mlx_image_to_window(screen->mlx,
screen->background, 0, 0) < 0;
display_error |= mlx_image_to_window(screen->mlx,
screen->img, 0, 0) < 0;
display_error |= mlx_image_to_window(screen->mlx,
screen->minimap, 175, 575) < 0;
display_error |= mlx_image_to_window(screen->mlx,
screen->hud, 0, 0) < 0;
if (display_error || !center_window(screen))
{
printf(RED "Display failed to initialize\n" RESET);

36
src/shader/shaders.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/08 18:27:59 by qmennen #+# #+# */
/* Updated: 2025/06/03 19:34:08 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:48:16 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,9 +16,6 @@
void set_uniforms(t_game *game)
{
mlx_ctx_t *ctx;
ctx = (mlx_ctx_t *)game->screen->mlx->context;
glUniform1f(game->screen->u_time_location, (float)mlx_get_time());
glUniform1f(game->screen->u_battery_location, game->player->battery);
glUniform2f(game->screen->u_resolution_location,
@ -33,16 +30,21 @@ int load_uniforms(t_game **game)
mlx_ctx_t *ctx;
ctx = (mlx_ctx_t *)(*game)->screen->mlx->context;
(*game)->screen->u_time_location = glGetUniformLocation(ctx->shaderprogram, "u_time");
(*game)->screen->u_battery_location = glGetUniformLocation(ctx->shaderprogram, "u_battery");
(*game)->screen->u_hit_timer_location = glGetUniformLocation(ctx->shaderprogram, "u_hit_timer");
(*game)->screen->u_enabled_location = glGetUniformLocation(ctx->shaderprogram, "u_enabled");
(*game)->screen->u_resolution_location = glGetUniformLocation(ctx->shaderprogram, "u_resolution");
if ((*game)->screen->u_time_location < 0 ||
(*game)->screen->u_battery_location < 0 ||
(*game)->screen->u_hit_timer_location < 0 ||
(*game)->screen->u_enabled_location < 0 ||
(*game)->screen->u_resolution_location < 0)
(*game)->screen->u_time_location = glGetUniformLocation(
ctx->shaderprogram, "u_time");
(*game)->screen->u_battery_location = glGetUniformLocation(
ctx->shaderprogram, "u_battery");
(*game)->screen->u_hit_timer_location = glGetUniformLocation(
ctx->shaderprogram, "u_hit_timer");
(*game)->screen->u_enabled_location = glGetUniformLocation(
ctx->shaderprogram, "u_enabled");
(*game)->screen->u_resolution_location = glGetUniformLocation(
ctx->shaderprogram, "u_resolution");
if ((*game)->screen->u_time_location < 0
|| (*game)->screen->u_battery_location < 0
|| (*game)->screen->u_hit_timer_location < 0
|| (*game)->screen->u_enabled_location < 0
|| (*game)->screen->u_resolution_location < 0)
return (FAILURE);
return (SUCCESS);
}
@ -53,7 +55,7 @@ static const char *read_vertex_shader(void)
char *shader;
int fd;
int file_size;
size_t bytes_read;
ssize_t bytes_read;
file_size = get_file_size(target);
fd = open(target, O_RDONLY);
@ -80,7 +82,7 @@ static const char *read_fragment_shader(void)
char *shader;
int fd;
int file_size;
size_t bytes_read;
ssize_t bytes_read;
file_size = get_file_size(target);
fd = open(target, O_RDONLY);
@ -103,7 +105,7 @@ static const char *read_fragment_shader(void)
return (close(fd), shader);
}
int shader_init(t_game **game)
int shader_init(void)
{
vert_shader = read_vertex_shader();
if (!vert_shader)

35
src/util/errors.c
View File

@ -1,35 +0,0 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* errors.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/15 15:40:14 by qmennen #+# #+# */
/* Updated: 2025/05/07 11:34:57 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "MLX42.h"
#include "cub3d.h"
const char *last_error(void)
{
if (mlx_errno > 0)
return (mlx_strerror(mlx_errno));
else if (errno > 0)
return (strerror(errno));
else
return (NULL);
}
void game_error(t_game *game, const char *msg)
{
const char *last_err = last_error();
if (msg == NULL && last_err)
printf(RED"%s\n"RESET, last_err);
else
printf(RED"%s\n"RESET, msg);
game_terminate(game);
}

18
src/util/hooks.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* hooks.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/04/15 17:51:26 by qmennen #+# #+# */
/* Updated: 2025/06/04 16:48:57 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* hooks.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/15 17:51:26 by qmennen #+# #+# */
/* Updated: 2025/06/10 15:48:10 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,7 +21,7 @@ void keyhandle(mlx_key_data_t keydata, void *param)
game_manager_destroy(manager);
}
void handle_mouse(t_game *game)
void handle_mouse(t_game *game)
{
t_vec2_int mouse_pos;
mlx_t *mlx;
@ -31,4 +31,4 @@ void handle_mouse(t_game *game)
mlx_get_mouse_pos(mlx, &mouse_pos.x, &mouse_pos.y);
rotate(game->player, 0.1 * (mouse_pos.x - mlx->width / 2), mlx->delta_time);
mlx_set_mouse_pos(mlx, mlx->width / 2, mlx->height / 2);
}
}

4
src/util/initialize.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/04/22 17:08:26 by qmennen #+# #+# */
/* Updated: 2025/06/04 19:51:13 by qmennen ### ########.fr */
/* Updated: 2025/06/10 14:42:24 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -47,7 +47,7 @@ int initialize_cub3d(t_game **game, const char *mapfile)
return (FAILURE);
if (!texture_load(*game))
return (FAILURE);
if (!shader_init(game))
if (!shader_init())
return (FAILURE);
if (!screen_create(game))
return (FAILURE);

17
src/util/score.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/05/25 20:54:23 by whaffman #+# #+# */
/* Updated: 2025/06/03 21:42:54 by qmennen ### ########.fr */
/* Updated: 2025/06/10 15:47:55 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,9 +14,9 @@
int count_tiles(t_map *map, t_tile tile_type)
{
int count;
int x;
int y;
int count;
unsigned int x;
unsigned int y;
count = 0;
y = 0;
@ -36,8 +36,8 @@ int count_tiles(t_map *map, t_tile tile_type)
int count_collected(t_game *game)
{
int collected;
int i;
int collected;
unsigned int i;
i = 0;
collected = 0;
@ -67,9 +67,10 @@ void print_scores(t_game *game)
void count_scores(t_game *game)
{
t_scoreboard *scoreboard;
scoreboard = game->scoreboard;
scoreboard->tiles_visited = count_tiles(game->map, TILE_VISITED);
scoreboard->total_tiles = count_tiles(game->map, TILE_EMPTY) + scoreboard->tiles_visited;
scoreboard->total_tiles = count_tiles(game->map, TILE_EMPTY)
+ scoreboard->tiles_visited;
scoreboard->collectibles = count_collected(game);
}