Ladebeze66/cub3D
1
0
Fork 0
mirror of https://github.com/Ladebeze66/cub3D.git synced 2025-12-13 04:36:59 +01:00
Code Issues Packages Projects Releases Wiki Activity

manqueunefonctionnorme

Browse Source
This commit is contained in:
Ladebeze66 2024-01-29 20:26:06 +01:00
parent fcbbe51d52
commit 7d67dfd452
121 changed files with 998 additions and 2860 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Makefile
View File

@ -6,7 +6,7 @@
# By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2024/01/14 16:54:48 by fgras-ca #+# #+# #
# Updated: 2024/01/23 19:56:56 by fgras-ca ### ########.fr #
# Updated: 2024/01/29 20:12:12 by fgras-ca ### ########.fr #
# #
# **************************************************************************** #
@ -24,7 +24,6 @@ WHITE = \033[0;97m
ORANGE = \033[38;5;214m
NAME = cub3d
LIBFT = libft.a
SRC = main.c \
./utils/ft_utils_gnl.c \
@ -32,7 +31,6 @@ SRC = main.c \
./utils/ft_utils_convert.c \
./utils/ft_utils_str_1.c \
./parsing/ft_map_check.c \
./parsing/ft_read_map.c \
./parsing/ft_map_dimensions.c \
./parsing/ft_parsing.c \
./move/ft_collision.c \
@ -43,6 +41,7 @@ SRC = main.c \
./draw/ft_2d_view.c \
./draw/ft_textures.c \
./draw/ft_3d_view.c \
./draw/ft_3d_view_utils.c \
./draw/ft_horizontal_ray.c \
./draw/ft_vertical_ray.c \
./draw/ft_pixel.c \
@ -56,10 +55,9 @@ SRC = main.c \
./parsing/ft_find_map_start.c \
./parsing/ft_textures_and_colors.c \
./parsing/ft_find_player_position.c \
SRC_DIR_LIBFT = libft/
SRC_LIBFT = $(addprefix $(SRC_DIR_LIBFT), $(LIBFT))
./parsing/ft_find_player_utils.c \
./parsing/ft_map_check_utils.c \
./parsing/ft_text_and_col_utils.c \
OBJ = $(SRC:.c=.o)

275
cub3d.h
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/14 16:56:52 by fgras-ca #+# #+# */
/* Updated: 2024/01/28 22:03:37 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 20:09:43 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -24,29 +24,30 @@
# include "include/mlx.h"
# ifndef BUFFER_SIZE
# define BUFFER_SIZE 100000
# define BUFFER_SIZE 100000
# endif
# define PI 3.14159265359
# define P2 PI/2
# define P3 3*PI/2
# define P2 1.57079632679
# define P3 4.71238898038
# define COLBUF 1
# define NUMRAY 1280
# define FOVIEW 60
# define DISRAY 1000000
# define DOF 120
# define WIDTH 1780
# define WIDTH 1680
# define HEIGHT 720
# define BOV 500
# define BOV 400
# define MAX_LINE_LENGTH 100000
# define DX_LENGTH 8
typedef enum {
typedef enum s_WallDirection {
NORTH,
SOUTH,
WEST,
EAST,
NONE // Utilisé lorsqu'aucun mur n'est touché
} WallDirection;
NONE
} t_WallDirection;
typedef struct s_img
{
@ -108,15 +109,15 @@ typedef struct s_struture_windows
typedef struct s_texture
{
char *north;
char *south;
char *west;
char *east;
char *north;
char *south;
char *west;
char *east;
char *door;
char *door_open;
unsigned int floor_color;
unsigned int ceil_color;
} t_texture;
unsigned int floor_color;
unsigned int ceil_color;
} t_texture;
typedef struct s_struture_map
{
@ -126,9 +127,9 @@ typedef struct s_struture_map
int i;
int j;
int temp;
int mapX;
int mapY;
int mapS;
int map_x;
int map_y;
int map_s;
float player_x;
float player_y;
char player_direction;
@ -136,10 +137,14 @@ typedef struct s_struture_map
} t_structure_map;
typedef struct s_sprite {
void *frames[3]; // Tableau pour stocker les frames du sprite
int width, height; // Dimensions du sprite
int current_frame; // Index de la frame actuelle
} t_sprite;
void *frames[3];
int width;
int height;
int current_frame;
float world_x;
float world_y;
float distance;
} t_sprite;
typedef struct s_structure_main
{
@ -166,7 +171,7 @@ typedef struct s_res_params {
int original_y;
int pixel_pos_rescaled;
int pixel_pos_original;
} t_res_params;
} t_res_params;
typedef struct s_rescale_params {
void *original_img;
@ -177,30 +182,29 @@ typedef struct s_rescale_params {
int px;
int py;
t_res_params *res;
} t_rescale_params;
} t_rescale_params;
typedef struct s_position_params {
int *future_px;
int *future_py;
int pdx;
int pdy;
int collisionBuffer;
int collision_buffer;
int px;
int py;
double pa;
char direction;
} t_position_params;
} t_position_params;
typedef struct s_map_params {
t_structure_map *map_info;
const char *buffer;
int length;
int *maxWidth;
int *max_width;
int *height;
int *currentWidth;
int *isNewLine;
} t_map_params;
int *current_width;
int *is_new_line;
} t_map_params;
typedef struct s_square_params {
t_structure_main *w;
@ -209,15 +213,15 @@ typedef struct s_square_params {
int xo;
int yo;
int color;
} t_square_params;
} t_square_params;
typedef struct s_sky_ground_params {
t_structure_main *w;
int startHeight;
int endHeight;
int start_height;
int end_height;
int color;
int backgroundOffsetX;
} t_sky_ground_params;
int background_off_setx;
} t_sky_ground_params;
typedef struct s_line_params {
t_structure_main *w;
@ -226,7 +230,7 @@ typedef struct s_line_params {
int x1;
int y1;
int color;
} t_line_params;
} t_line_params;
typedef struct s_line_deltas {
int dx;
@ -235,53 +239,51 @@ typedef struct s_line_deltas {
int sy;
int err;
t_line_params *params;
} t_line_deltas;
} t_line_deltas;
typedef struct s_texture_params {
t_structure_main *w;
int startX;
int endX;
float lineOff;
float lineH;
WallDirection wallDir;
int start_x;
int end_x;
float line_off;
float line_h;
t_WallDirection wall_dir;
float rx;
float ry;
float disT;
} t_texture_params;
float dis_t;
} t_texture_params;
typedef struct s_ray_params {
t_structure_main *w;
t_square_params sq;
t_texture_params texture;
int r;
int tileSize;
int tile_size;
float rx;
float ry;
float disT;
WallDirection wallDir;
int numRays;
float dis_t;
t_WallDirection wall_dir;
int num_rays;
int color;
int start3DHeight;
int max3DHeight;
float lineH;
float lineOff;
int backgroundOffsetX;
int start3d_height;
int max3d_height;
float line_h;
float line_off;
int background_off_setx;
int raywidth;
} t_ray_params;
} t_ray_params;
typedef struct s_ray_calc_params {
t_structure_main *w;
float ra;
float *disRay;
float *dis_ray;
float *rx;
float *ry;
WallDirection *wallDir;
t_WallDirection *wall_dir;
float xo;
float yo;
int dof;
} t_ray_calc_params;
} t_ray_calc_params;
typedef struct s_texture_data
{
@ -295,71 +297,109 @@ typedef struct s_init_params {
t_structure_main *w;
int tilesize;
int numrays;
float FOV;
float DR;
} t_init_params;
float fo_v;
float d_r;
} t_init_params;
typedef struct s_ray_properties {
float disH;
float disV;
WallDirection hwalldir;
WallDirection vwalldir;
float dis_h;
float dis_v;
t_WallDirection hwalldir;
t_WallDirection vwalldir;
float hx;
float hy;
float vx;
float vy;
} t_ray_properties;
} t_ray_properties;
typedef struct {
typedef struct s_base_params {
int tilesize;
int numrays;
float FOV;
float DR;
float fo_v;
float d_r;
float ra;
} t_base_params;
} t_base_params;
typedef struct {
float disH;
float disV;
float disT;
typedef struct s_ray_state {
float dis_h;
float dis_v;
float dis_t;
float hx;
float hy;
float vx;
float vy;
WallDirection hwalldir;
WallDirection vwalldir;
} t_ray_state;
t_WallDirection hwalldir;
t_WallDirection vwalldir;
} t_ray_state;
typedef struct {
typedef struct s_ray_calc {
t_structure_main *w;
int r;
int color;
} t_ray_calc;
} t_ray_calc;
typedef struct {
typedef struct s_drawrays2d_params {
t_base_params base_params;
t_ray_state ray_state;
t_ray_calc ray_calc;
t_ray_params rayparams;
t_ray_calc_params hrayparams;
t_ray_calc_params vrayparams;
} t_drawrays2d_params;
} t_drawrays2d_params;
typedef struct {
int jkl;
int yui;
} t_state;
typedef struct s_state {
int jkl;
int yui;
} t_state;
typedef struct {
t_structure_main *w;
t_state state;
} t_global_struct;
typedef struct s_global_struct {
t_structure_main *w;
t_state state;
} t_global_struct;
typedef struct s_draw_params
{
int texturewidth;
int textureheight;
int texturex;
int textureY;
int a;
int b;
int c;
double step;
int x;
int i;
} t_draw_params;
typedef struct s_collision_params
{
int dx[DX_LENGTH];
int dy[DX_LENGTH];
} t_collision_params;
typedef struct s_player_info
{
bool *found_player;
t_structure_map *map;
int line_number;
int column_number;
} t_player_info;
typedef struct s_point
{
int x;
int y;
} t_point;
typedef struct s_map_check
{
char *map;
int maxWidth;
int height;
} t_map_check;
//ft_utils_split.c 5 / 5
char **ft_split(char const *s, char c);
//ft_utils_gnl.c 4 / 5
char *get_next_line(int fd);
/*ft_key.c 3/5*/
int *kill_prog(t_structure_main *w);
void move(int key, t_structure_main *w);
int deal_key(int key, t_structure_main *w);
@ -371,13 +411,12 @@ int ft_strncmp(const char *s1, const char *s2, size_t n);
int ft_strcmp(const char *s1, const char *s2);
void *ft_memcpy(void *dest, const void *src, size_t n);
void *ft_memset(void *s, int c, size_t n);
/*collision*/
int can_move_to(t_structure_main *w, double future_x, double future_y);
int can_move_to(t_structure_main *w, double future_x, double future_y);
char *ft_itoa(int nb);
void draw_black_ground(t_ray_params *params, t_texture_params tparams);
/*parsing*/
int is_map_closed(char* map, int width, int height);
bool parse_map(const char *map_content, int length, t_structure_map *map_info);
int is_map_closed(char *map, int width, int height);
bool parse_map(const char *map_content,
int length, t_structure_map *map_info);
int check_borders(char *map, int maxWidth, int height);
int check_interior(char *map, int maxWidth, int height);
void exit_error(t_structure_main *w);
@ -386,24 +425,25 @@ void process_character(t_map_params *params, int *i);
void get_map_dimensions(t_map_params *params);
void fill_map_space(t_structure_map *map_info, int maxWidth, int height);
void copy_map_data(t_map_params *params);
bool load_cub_file(const char *filename, t_texture *textures, t_structure_map *map_info);
bool load_cub_file(const char *filename,
t_texture *textures, t_structure_map *map_info);
bool parse_texture_line(const char *line, t_texture *textures);
bool handle_map(int fd, char **map_buffer, int *map_length);
bool parse_color_line(const char *line, unsigned int *color);
bool parse_number_from_str(const char **str, int *number);
bool is_valid_texture(const char *line);
bool handle_textures(int fd, t_texture *textures);
bool find_player_position_and_direction(const char *map_content, int length, t_structure_map *map_info);
bool find_player(const char *map_content,
int length, t_structure_map *map);
void calculate_map(t_structure_map *map_info);
/*textures*/
void load_wall_textures(t_structure_main *w);
void draw_texture(t_texture_params *tex_params);
int get_texture_color(t_structure_main *w, WallDirection wallDir, int textureX, int textureY);
void draw_yolo(t_ray_params *rparams, t_texture_params *tparams, int deca);
/*3D view*/
int get_texture_color(t_structure_main *w,
t_WallDirection wallDir, int textureX, int textureY);
void draw_yolo(t_ray_params *rparams, t_texture_params *tparams, int deca);
void drawray(t_ray_params *ray_params);
void draw_background(t_structure_main *w);
float correctFisheye(float distance, float ra, float playerAngle);
//2D map
void rescale_image(t_rescale_params *params, t_structure_main *w);
void draw_square(t_structure_main *w, int x, int y, int color);
void draw_map(t_structure_main *w);
@ -411,20 +451,27 @@ void put_pixel_img(t_structure_main *w, int x, int y, int color);
void draw_square_raw(t_square_params *params);
void draw_line(t_line_params *params);
void drawrays2d(t_structure_main *w);
//Ray
void calculateverticalray(t_ray_calc_params *params);
void handle_ra_vertical(t_ray_calc_params *params, float nTan, int tileSize);
void calculatehorizontalray(t_ray_calc_params *params);
void handle_ra_not_equal_pi(t_ray_calc_params *params, float atan, int tilesize);
void handle_ra_not_equal_pi(t_ray_calc_params *params,
float atan, int tilesize);
float dist(float ax, float ay, float bx, float by);
//window
void init_windows(t_structure_main *w);
void init_player(t_structure_main *w);
void init_mlx_and_window(t_structure_main *w);
void sleep_mouse(t_global_struct *global_struct);
//sprite
void load_sprite_frames(t_sprite *sprite, void *mlx_ptr);
void update_sprite_frame(t_sprite *sprite);
void draw_sprite(t_sprite *sprite, void *mlx_ptr, void *win_ptr, int win_width, int win_height);
void init_line_params(t_line_params *lineparams, t_ray_params *rayParams);
void init_texture_params(t_texture_params *textureparams,
t_ray_params *rayParams);
void initialize_variables(int *i, int *line_number,
int *column_number, bool *found_player);
bool check_for_player(char current_char, bool *found_player);
void update_player_info(t_structure_map *map_info,
int line_number, int column_number, char player_direction);
void update_position(char current_char, int *line_number, int *column_number);
bool check_for_multiple_players(bool found_player);
int check_boundaries(t_point p, t_map_check *map_check);
int is_space_surrounded_by_walls(t_map_check *map_check, t_point p);
#endif

32
draw/ft_2d_view.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 17:49:42 by fgras-ca #+# #+# */
/* Updated: 2024/01/23 17:43:56 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 16:20:39 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -26,39 +26,39 @@ float correctfisheye(float distance, float ra, float playerAngle)
void init_base_params(t_base_params *params, t_structure_main *w)
{
params->tilesize = w->s_map.mapS;
params->tilesize = w->s_map.map_s;
params->numrays = NUMRAY;
params->FOV = FOVIEW * (PI / 180);
params->DR = params->FOV / params->numrays;
params->ra = w->s_player.pa - (params->FOV / 2);
params->fo_v = FOVIEW * (PI / 180);
params->d_r = params->fo_v / params->numrays;
params->ra = w->s_player.pa - (params->fo_v / 2);
draw_background(w);
}
void calculate_ray(t_base_params *base, t_ray_state *state,
t_ray_calc *calc, t_ray_params *rayparams)
{
if (state->disH < state->disV)
if (state->dis_h < state->dis_v)
{
rayparams->disT = state->disH;
rayparams->dis_t = state->dis_h;
calc->color = 0xFF0000;
rayparams->wallDir = state->hwalldir;
rayparams->wall_dir = state->hwalldir;
rayparams->rx = state->hx;
rayparams->ry = state->hy;
}
else
{
rayparams->disT = state->disV;
rayparams->dis_t = state->dis_v;
calc->color = 0x00FF00;
rayparams->wallDir = state->vwalldir;
rayparams->wall_dir = state->vwalldir;
rayparams->rx = state->vx;
rayparams->ry = state->vy;
}
rayparams->disT = correctfisheye(rayparams->disT,
rayparams->dis_t = correctfisheye(rayparams->dis_t,
base->ra, calc->w->s_player.pa);
rayparams->w = calc->w;
rayparams->tileSize = base->tilesize;
rayparams->tile_size = base->tilesize;
rayparams->r = calc->r;
rayparams->numRays = base->numrays;
rayparams->num_rays = base->numrays;
rayparams->color = calc->color;
}
@ -73,16 +73,16 @@ void drawrays2d(t_structure_main *w)
{
params.base_params.ra = fmod(params.base_params.ra + 2 * PI, 2 * PI);
params.hrayparams = (t_ray_calc_params){w, params.base_params.ra,
&params.ray_state.disH, &params.ray_state.hx,
&params.ray_state.dis_h, &params.ray_state.hx,
&params.ray_state.hy, &params.ray_state.hwalldir};
params.vrayparams = (t_ray_calc_params){w, params.base_params.ra,
&params.ray_state.disV, &params.ray_state.vx,
&params.ray_state.dis_v, &params.ray_state.vx,
&params.ray_state.vy, &params.ray_state.vwalldir};
calculatehorizontalray(&params.hrayparams);
calculateverticalray(&params.vrayparams);
calculate_ray(&params.base_params, &params.ray_state,
&params.ray_calc, &params.rayparams);
drawray(&params.rayparams);
params.base_params.ra += params.base_params.DR;
params.base_params.ra += params.base_params.d_r;
}
}

143
draw/ft_3d_view.c
View File

@ -6,32 +6,50 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 17:35:53 by fgras-ca #+# #+# */
/* Updated: 2024/01/26 17:25:05 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:05:58 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "../cub3d.h"
void init_line_params(t_line_params *lineparams, t_ray_params *rayParams)
static void calculate_line_height(t_ray_params *rayparams)
{
lineparams->w = rayParams->w;
lineparams->x0 = (int)rayParams->w->s_player.px;
lineparams->y0 = (int)rayParams->w->s_player.py;
lineparams->x1 = (int)rayParams->rx;
lineparams->y1 = (int)rayParams->ry;
lineparams->color = rayParams->color;
rayparams->line_h = (rayparams->tile_size * rayparams->max3d_height)
/ rayparams->dis_t;
if (rayparams->line_h > rayparams->max3d_height)
{
rayparams->line_h = rayparams->max3d_height;
}
rayparams->line_off = ((rayparams->max3d_height - rayparams->line_h) / 2);
}
void init_texture_params(t_texture_params *textureparams,
t_ray_params *rayParams)
static void calculate_deca(t_ray_params *rayparams, float *olineh, int *deca)
{
textureparams->w = rayParams->w;
textureparams->lineOff = rayParams->lineOff;
textureparams->lineH = rayParams->lineH;
textureparams->wallDir = rayParams->wallDir;
textureparams->rx = rayParams->rx + rayParams->backgroundOffsetX;
textureparams->ry = rayParams->ry;
textureparams->disT = rayParams->disT;
*olineh = (rayparams->w->s_map.map_s * rayparams->w->s_win.height)
/ rayparams->dis_t;
if (*olineh > rayparams->w->s_win.height)
{
*deca = *olineh - rayparams->w->s_win.height;
}
else
{
*deca = 0;
}
}
static void set_rayparams(t_ray_params *rayparams)
{
rayparams->start3d_height = 0;
rayparams->max3d_height = rayparams->w->s_win.height
+ rayparams->start3d_height;
}
static void set_texture_params(t_ray_params *rayparams,
t_texture_params *textureparams)
{
textureparams->start_x = rayparams->r * rayparams->raywidth
+ rayparams->background_off_setx;
textureparams->end_x = textureparams->start_x + rayparams->raywidth;
}
void drawray(t_ray_params *rayparams)
@ -40,96 +58,23 @@ void drawray(t_ray_params *rayparams)
t_texture_params textureparams;
float olineh;
int deca;
int color;
rayparams->start3DHeight = 0;
rayparams->max3DHeight = rayparams->w->s_win.height
+ rayparams->start3DHeight;
rayparams->lineH = (rayparams->tileSize * rayparams->max3DHeight)
/ rayparams->disT;
if (rayparams->lineH > rayparams->max3DHeight)
{
rayparams->lineH = rayparams->max3DHeight;
}
rayparams->lineOff = ((rayparams->max3DHeight - rayparams->lineH) / 2);
olineh = (rayparams->w->s_map.mapS * rayparams->w->s_win.height) / rayparams->disT;
rayparams->backgroundOffsetX = BOV;
rayparams->raywidth = rayparams->w->s_win.width / rayparams->numRays;
textureparams.startX = rayparams->r * rayparams->raywidth
+ rayparams->backgroundOffsetX;
textureparams.endX = textureparams.startX + rayparams->raywidth;
set_rayparams(rayparams);
calculate_line_height(rayparams);
rayparams->raywidth = rayparams->w->s_win.width / rayparams->num_rays;
rayparams->background_off_setx = BOV;
calculate_deca(rayparams, &olineh, &deca);
set_texture_params(rayparams, &textureparams);
init_texture_params(&textureparams, rayparams);
init_line_params(&lineparams, rayparams);
draw_line(&lineparams);
if (olineh > rayparams->w->s_win.height)
deca = olineh - rayparams->w->s_win.height;
else
deca = 0;
draw_black_ground(rayparams, textureparams);
if (deca != 0)
{
draw_yolo(rayparams, &textureparams, deca);
}
else
{
draw_texture(&textureparams);
}
void draw_yolo(t_ray_params *rparams, t_texture_params *tparams, int deca)
{
int texturewidth;
int textureheight;
int i;
int y;
int x;
float perspectivefactor;
int texturex;
int color;
texturewidth = tparams->w->s_img.texture_width;
textureheight = tparams->w->s_img.texture_height;
i = 0;
for (y = rparams->lineOff; y < rparams->lineOff + rparams->lineH; y++) {
// La variable perspectiveFactor permet de mapper la texture en tenant compte de la perspective
perspectivefactor = (float)(y - rparams->lineOff) / rparams->lineH;
int textureY = perspectivefactor * (textureheight );
if (textureY >= textureheight) {
textureY = textureheight - 1;
}
//for (int x = startX; x < endX; x++) {
x = tparams->startX;
switch (tparams->wallDir) {
case NORTH:
case SOUTH:
// Assurez-vous que rx est normalisé correctement pour le mappage de texture
texturex = (int)(tparams->rx * texturewidth / tparams->w->s_map.mapS) % texturewidth;
break;
case WEST:
case EAST:
// Assurez-vous que ry est normalisé correctement pour le mappage de texture
texturex = (int)(tparams->ry * texturewidth / tparams->w->s_map.mapS) % texturewidth;
break;
}
if (texturex >= texturewidth) {
texturex = texturewidth - 1;
}
//printf("%f %f\n",lineOff, lineOff/lineH);
color = get_texture_color(tparams->w, tparams->wallDir, texturex, y);
// BLOCK OK MEH
// float ww = ((720+merde)/lineH);
// //printf("%d %d %d\n", t ,td, merde);
// put_pixel_img(w, x, (int)(iii*ww)-merde/2, color);
// iii++;
int a = tparams->lineOff - deca / 2;
int b = tparams->lineH + (deca /2);
int c = tparams->lineH;
double step = (b - a)/(double)(c - 1);
//printf("%d %d %d\n", t ,td, merde);
put_pixel_img(tparams->w, x, (int)(a + i * step), color);
i++;
//}
}
}

93
draw/ft_3d_view_utils.c Normal file
View File

@ -0,0 +1,93 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_3d_view_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/29 17:00:21 by fgras-ca #+# #+# */
/* Updated: 2024/01/29 17:05:55 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "../cub3d.h"
static void set_texture_coords(t_texture_params *tparams,
t_draw_params *dparams)
{
if (tparams->wall_dir == NORTH || tparams->wall_dir == SOUTH)
{
dparams->texturex = (int)(tparams->rx * dparams->texturewidth
/ tparams->w->s_map.map_s) % dparams->texturewidth;
}
else if (tparams->wall_dir == WEST || tparams->wall_dir == EAST)
{
dparams->texturex = (int)(tparams->ry * dparams->texturewidth
/ tparams->w->s_map.map_s) % dparams->texturewidth;
}
if (dparams->texturex >= dparams->texturewidth)
{
dparams->texturex = dparams->texturewidth - 1;
}
}
static void draw_texture_line(t_ray_params *rparams,
t_texture_params *tparams, t_draw_params *dparams, int deca)
{
int y;
int color;
float perspectivefactor;
y = rparams->line_off;
dparams->i = 0;
dparams->x = tparams->start_x;
while (y < rparams->line_off + rparams->line_h)
{
perspectivefactor = (float)(y - rparams->line_off) / rparams->line_h;
dparams->textureY = perspectivefactor * dparams->textureheight;
if (dparams->textureY >= dparams->textureheight)
dparams->textureY = dparams->textureheight - 1;
set_texture_coords(tparams, dparams);
color = get_texture_color(tparams->w,
tparams->wall_dir, dparams->texturex, y);
dparams->a = tparams->line_off - deca / 2;
dparams->b = tparams->line_h + (deca / 2);
dparams->c = tparams->line_h;
dparams->step = (dparams->b - dparams->a) / (double)(dparams->c - 1);
put_pixel_img(tparams->w, dparams->x,
(int)(dparams->a + dparams->i * dparams->step), color);
dparams->i++;
y++;
}
}
void draw_yolo(t_ray_params *rparams, t_texture_params *tparams, int deca)
{
t_draw_params dparams;
dparams.texturewidth = tparams->w->s_img.texture_width;
dparams.textureheight = tparams->w->s_img.texture_height;
draw_texture_line(rparams, tparams, &dparams, deca);
}
void init_line_params(t_line_params *lineparams, t_ray_params *rayParams)
{
lineparams->w = rayParams->w;
lineparams->x0 = (int)rayParams->w->s_player.px;
lineparams->y0 = (int)rayParams->w->s_player.py;
lineparams->x1 = (int)rayParams->rx;
lineparams->y1 = (int)rayParams->ry;
lineparams->color = rayParams->color;
}
void init_texture_params(t_texture_params *textureparams,
t_ray_params *rayParams)
{
textureparams->w = rayParams->w;
textureparams->line_off = rayParams->line_off;
textureparams->line_h = rayParams->line_h;
textureparams->wall_dir = rayParams->wall_dir;
textureparams->rx = rayParams->rx + rayParams->background_off_setx;
textureparams->ry = rayParams->ry;
textureparams->dis_t = rayParams->dis_t;
}

30
draw/ft_background.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 23:19:39 by fgras-ca #+# #+# */
/* Updated: 2024/01/26 17:40:14 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:08:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,10 +17,10 @@ void draw_sky_ground(t_sky_ground_params *params)
t_square_params square_params;
square_params.w = params->w;
square_params.x = params->backgroundOffsetX;
square_params.y = params->startHeight;
square_params.xo = params->w->s_win.width + params->backgroundOffsetX;
square_params.yo = params->endHeight;
square_params.x = params->background_off_setx;
square_params.y = params->start_height;
square_params.xo = params->w->s_win.width + params->background_off_setx;
square_params.yo = params->end_height;
square_params.color = params->color;
draw_square_raw(&square_params);
}
@ -33,16 +33,16 @@ void draw_background(t_structure_main *w)
backgroundoffsetx = BOV;
sky_params.w = w;
sky_params.startHeight = 0;
sky_params.endHeight = w->s_win.height / 2;
sky_params.start_height = 0;
sky_params.end_height = w->s_win.height / 2;
sky_params.color = w->t->ceil_color;
sky_params.backgroundOffsetX = backgroundoffsetx;
sky_params.background_off_setx = backgroundoffsetx;
draw_sky_ground(&sky_params);
ground_params.w = w;
ground_params.startHeight = w->s_win.height / 2;
ground_params.endHeight = w->s_win.height;
ground_params.start_height = w->s_win.height / 2;
ground_params.end_height = w->s_win.height;
ground_params.color = w->t->floor_color;
ground_params.backgroundOffsetX = backgroundoffsetx;
ground_params.background_off_setx = backgroundoffsetx;
draw_sky_ground(&ground_params);
}
@ -51,10 +51,10 @@ void draw_black_ground(t_ray_params *params, t_texture_params tparams)
t_square_params square_params;
square_params.w = params->w;
square_params.x = tparams.startX;
square_params.y = params->lineOff;
square_params.x = tparams.start_x;
square_params.y = params->line_off;
square_params.xo = square_params.x + 1;
square_params.yo = params->lineOff + params->lineH ;
square_params.yo = params->line_off + params->line_h ;
square_params.color = 0x000000;
draw_square_raw(&square_params);
}
}

8
draw/ft_draw.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 22:38:28 by fgras-ca #+# #+# */
/* Updated: 2024/01/14 17:54:44 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 15:47:48 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -20,9 +20,9 @@ void draw_square(t_structure_main *w, int x, int y, int color)
int i;
int j;
xo = x * w->s_map.mapS;
yo = y * w->s_map.mapS;
size = w->s_map.mapS;
xo = x * w->s_map.map_s;
yo = y * w->s_map.map_s;
size = w->s_map.map_s;
i = 0;
while (i < size)
{

55
draw/ft_horizontal_ray.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 19:53:47 by fgras-ca #+# #+# */
/* Updated: 2024/01/25 20:37:32 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:12:54 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -25,38 +25,37 @@ void inithorizontalray(t_ray_calc_params *params)
int tilesize;
atan = -1 / tan(params->ra);
tilesize = params->w->s_map.mapS;
tilesize = params->w->s_map.map_s;
if (params->ra != PI)
handle_ra_not_equal_pi(params, atan, tilesize);
else
handle_ra_equal_pi(params);
}
void update_ray_params(t_ray_calc_params *params, int mx, int my) {
int mp = my * params->w->s_map.mapX + mx;
void update_ray_params(t_ray_calc_params *params, int mx, int my)
{
int mp;
char map_pos;
if (mp >= 0 && mp < params->w->s_map.mapX * params->w->s_map.mapY) {
char map_pos = params->w->s_map.map[mp];
if (map_pos == '1' || map_pos == '2') {
params->dof = DOF;
*params->disRay = dist(params->w->s_player.px, params->w->s_player.py,
*params->rx, *params->ry);
if (params->ra > PI)
*params->wallDir = NORTH;
else
*params->wallDir = SOUTH;
// Définir le type de mur actuel
if (map_pos == '2') {
params->w->current_wall_type = map_pos;
} else {
// Assurez-vous de réinitialiser pour les murs normaux
params->w->current_wall_type = '1';
}
}
}
mp = my * params->w->s_map.map_x + mx;
if (mp >= 0 && mp < params->w->s_map.map_x * params->w->s_map.map_y)
{
map_pos = params->w->s_map.map[mp];
if (map_pos == '1' || map_pos == '2')
{
params->dof = DOF;
*params->dis_ray = dist(params->w->s_player.px,
params->w->s_player.py, *params->rx, *params->ry);
if (params->ra > PI)
*params->wall_dir = NORTH;
else
*params->wall_dir = SOUTH;
if (map_pos == '2')
params->w->current_wall_type = map_pos;
else
params->w->current_wall_type = '1';
}
}
}
void processhorizontalray(t_ray_calc_params *params)
@ -65,8 +64,8 @@ void processhorizontalray(t_ray_calc_params *params)
int my;
int tilesize;
tilesize = params->w->s_map.mapS;
*params->disRay = DISRAY;
tilesize = params->w->s_map.map_s;
*params->dis_ray = DISRAY;
while (params->dof < DOF)
{
mx = (int)(*params->rx) / tilesize;

3
draw/ft_load_textures.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/14 20:30:59 by fgras-ca #+# #+# */
/* Updated: 2024/01/25 20:34:50 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:13:50 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -37,7 +37,6 @@ void load_wall_textures(t_structure_main *w)
load_texture(w, w->t->west, (void **)&w->s_img.west_texture);
load_texture(w, w->t->east, (void **)&w->s_img.east_texture);
load_texture(w, "textures/door_close.xpm", (void **)&w->s_img.door_texture);
//load_texture(w, "textures/open_door.xpm", (void **)&w->s_img.open_door_texture);
}
void exit_error(t_structure_main *w)

44
draw/ft_textures.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 17:39:11 by fgras-ca #+# #+# */
/* Updated: 2024/01/25 20:34:32 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:17:21 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -20,19 +20,19 @@ void draw_texture_line(t_texture_params *params, float y, int textureY)
int color;
texturewidth = params->w->s_img.texture_width;
x = params->startX;
while (x < params->endX)
x = params->start_x;
while (x < params->end_x)
{
if (params->wallDir == NORTH || params->wallDir == SOUTH)
if (params->wall_dir == NORTH || params->wall_dir == SOUTH)
texturex = (int)(params->rx * texturewidth
/ params->w->s_map.mapS) % texturewidth;
/ params->w->s_map.map_s) % texturewidth;
else
texturex = (int)(params->ry * texturewidth
/ params->w->s_map.mapS) % texturewidth;
/ params->w->s_map.map_s) % texturewidth;
if (texturex >= texturewidth)
texturex = texturewidth - 1;
color = get_texture_color(params->w,
params->wallDir, texturex, textureY);
params->wall_dir, texturex, textureY);
put_pixel_img(params->w, x, y, color);
x++;
}
@ -46,10 +46,10 @@ void draw_texture(t_texture_params *params)
int texturey;
textureheight = params->w->s_img.texture_height;
y = params->lineOff;
while (y < params->lineOff + params->lineH)
y = params->line_off;
while (y < params->line_off + params->line_h)
{
perspectivefactor = (y - params->lineOff) / params->lineH;
perspectivefactor = (y - params->line_off) / params->line_h;
texturey = perspectivefactor * textureheight;
if (texturey >= textureheight)
texturey = textureheight - 1;
@ -58,14 +58,15 @@ void draw_texture(t_texture_params *params)
}
}
void *get_selected_texture(t_structure_main *w, WallDirection wallDir)
void *get_selected_texture(t_structure_main *w, t_WallDirection wallDir)
{
void *texture = NULL;
if (w->current_wall_type == '2') {
return w->s_img.door_texture; // Texture pour porte fermée
} /*else if (w->current_wall_type == '3') {
return w->s_img.open_door_texture; // Texture pour porte ouverte
}*/
void *texture;
texture = NULL;
if (w->current_wall_type == '2')
{
return (w->s_img.door_texture);
}
else if (wallDir == NORTH)
return (w->s_img.north_texture);
else if (wallDir == SOUTH)
@ -76,12 +77,12 @@ void *get_selected_texture(t_structure_main *w, WallDirection wallDir)
return (w->s_img.east_texture);
else
{
fprintf(stderr, "Invalid wall direction.\n");
printf("Invalid wall direction.\n");
exit_error(w);
return (NULL);
}
if (texture == NULL)
fprintf(stderr, "get_selected_texture: selected texture is NULL\n");
if (texture == NULL)
printf("get_selected_texture: selected texture is NULL\n");
else
printf("get_selected_texture: selected texture = %p\n", texture);
}
@ -95,7 +96,7 @@ t_texture_data get_texture_data(void *texture)
return (texture_data);
}
int get_texture_color(t_structure_main *w, WallDirection wallDir,
int get_texture_color(t_structure_main *w, t_WallDirection wallDir,
int textureX, int textureY)
{
void *selected_texture;
@ -108,7 +109,6 @@ int get_texture_color(t_structure_main *w, WallDirection wallDir,
fprintf(stderr, "No texture selected for color retrieval\n");
return (0);
}
texture_data = get_texture_data(selected_texture);
pixel_pos = (textureX + textureY * w->s_img.texture_width)
* (texture_data.bpp / 8);

56
draw/ft_vertical_ray.c
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 20:03:21 by fgras-ca #+# #+# */
/* Updated: 2024/01/25 20:37:08 by fgras-ca ### ########.fr */
/* Updated: 2024/01/29 17:22:00 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -18,35 +18,35 @@ void initverticalray(t_ray_calc_params *params)
int tilesize;
ntan = -tan(params->ra);
tilesize = params->w->s_map.mapS;
tilesize = params->w->s_map.map_s;
handle_ra_vertical(params, ntan, tilesize);
}
void update_vertical_ray_params(t_ray_calc_params *params, int mx, int my) {
int mp = my * params->w->s_map.mapX + mx;
void update_vertical_ray_params(t_ray_calc_params *params, int mx, int my)
{
int mp;
char map_pos;
if (mp >= 0 && mp < params->w->s_map.mapX * params->w->s_map.mapY) {
char map_pos = params->w->s_map.map[mp];
if (map_pos == '1' || map_pos == '2') {
params->dof = DOF;
*params->disRay = dist(params->w->s_player.px, params->w->s_player.py,
*params->rx, *params->ry);
if (params->ra > P2 && params->ra < P3)
*params->wallDir = WEST;
else
*params->wallDir = EAST;
// Définir le type de mur actuel
if (map_pos == '2') {
params->w->current_wall_type = map_pos;
} else {
// Assurez-vous de réinitialiser pour les murs normaux
params->w->current_wall_type = '1';
}
}
}
mp = my * params->w->s_map.map_x + mx;
if (mp >= 0 && mp < params->w->s_map.map_x * params->w->s_map.map_y)
{
map_pos = params->w->s_map.map[mp];
if (map_pos == '1' || map_pos == '2')
{
params->dof = DOF;
*params->dis_ray = dist(params->w->s_player.px,
params->w->s_player.py,
*params->rx, *params->ry);
if (params->ra > P2 && params->ra < P3)
*params->wall_dir = WEST;
else
*params->wall_dir = EAST;
if (map_pos == '2')
params->w->current_wall_type = map_pos;
else
params->w->current_wall_type = '1';
}
}
}
void processverticalray(t_ray_calc_params *params)
@ -55,8 +55,8 @@ void processverticalray(t_ray_calc_params *params)
int my;
int tilesize;
tilesize = params->w->s_map.mapS;
*params->disRay = DISRAY;
tilesize = params->w->s_map.map_s;
*params->dis_ray = DISRAY;
while (params->dof < DOF)
{
mx = (int)(*params->rx) / tilesize;

168
include/mlx.h
View File

@ -1,139 +1,53 @@
/*
** mlx.h for MinilibX in
**
** Made by Charlie Root
** Login <ol@epitech.net>
**
** Started on Mon Jul 31 16:37:50 2000 Charlie Root
** Last update Tue May 15 16:23:28 2007 Olivier Crouzet
*/
/*
** MinilibX - Please report bugs
*/
/*
** FR msg - FR msg - FR msg
**
** La MinilibX utilise 2 librairies supplementaires qu'il
** est necessaire de rajouter a la compilation :
** -lmlx -lXext -lX11
**
** La MinilibX permet le chargement des images de type Xpm.
** Notez que cette implementation est incomplete.
** Merci de communiquer tout probleme de chargement d'image
** de ce type.
*/
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mlx.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/29 17:22:58 by fgras-ca #+# #+# */
/* Updated: 2024/01/29 17:28:02 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MLX_H
#define MLX_H
# define MLX_H
void *mlx_init();
/*
** needed before everything else.
** return (void *)0 if failed
*/
/*
** Basic actions
*/
void *mlx_new_window(void *mlx_ptr, int size_x, int size_y, char *title);
/*
** return void *0 if failed
*/
int mlx_clear_window(void *mlx_ptr, void *win_ptr);
int mlx_pixel_put(void *mlx_ptr, void *win_ptr, int x, int y, int color);
/*
** origin for x & y is top left corner of the window
** y down is positive
** color is 0x00RRGGBB
*/
/*
** Image stuff
*/
int mlx_clear_window(void *mlx_ptr, void *win_ptr);
int mlx_pixel_put(void *mlx_ptr, void *win_ptr, int x, int y, int color);
void *mlx_new_image(void *mlx_ptr,int width,int height);
/*
** return void *0 if failed
** obsolete : image2 data is stored using bit planes
** void *mlx_new_image2(void *mlx_ptr,int width,int height);
*/
char *mlx_get_data_addr(void *img_ptr, int *bits_per_pixel,
int *size_line, int *endian);
/*
** endian : 0 = sever X is little endian, 1 = big endian
** for mlx_new_image2, 2nd arg of mlx_get_data_addr is number_of_planes
*/
int mlx_put_image_to_window(void *mlx_ptr, void *win_ptr, void *img_ptr,
int *size_line, int *endian);
int mlx_put_image_to_window(void *mlx_ptr, void *win_ptr, void *img_ptr,
int x, int y);
int mlx_get_color_value(void *mlx_ptr, int color);
/*
** dealing with Events
*/
int mlx_mouse_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_key_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_expose_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_loop_hook (void *mlx_ptr, int (*funct_ptr)(), void *param);
int mlx_loop (void *mlx_ptr);
int mlx_loop_end (void *mlx_ptr);
/*
** hook funct are called as follow :
**
** expose_hook(void *param);
** key_hook(int keycode, void *param);
** mouse_hook(int button, int x,int y, void *param);
** loop_hook(void *param);
**
*/
/*
** Usually asked...
*/
int mlx_string_put(void *mlx_ptr, void *win_ptr, int x, int y, int color,
char *string);
int mlx_get_color_value(void *mlx_ptr, int color);
int mlx_mouse_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_key_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_expose_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int mlx_loop_hook (void *mlx_ptr, int (*funct_ptr)(), void *param);
int mlx_loop (void *mlx_ptr);
int mlx_loop_end (void *mlx_ptr);
int mlx_string_put(void *mlx_ptr, void *win_ptr, int x, int y, int color,
char *string);
void mlx_set_font(void *mlx_ptr, void *win_ptr, char *name);
void *mlx_xpm_to_image(void *mlx_ptr, char **xpm_data,
int *width, int *height);
int *width, int *height);
void *mlx_xpm_file_to_image(void *mlx_ptr, char *filename,
int *width, int *height);
int mlx_destroy_window(void *mlx_ptr, void *win_ptr);
int *width, int *height);
int mlx_destroy_window(void *mlx_ptr, void *win_ptr);
int mlx_destroy_image(void *mlx_ptr, void *img_ptr);
int mlx_destroy_display(void *mlx_ptr);
int mlx_hook(void *win_ptr, int x_event, int x_mask,
int (*funct)(), void *param);
int mlx_do_key_autorepeatoff(void *mlx_ptr);
int mlx_do_key_autorepeaton(void *mlx_ptr);
int mlx_do_sync(void *mlx_ptr);
int mlx_mouse_get_pos(void *mlx_ptr, void *win_ptr, int *x, int *y);
int mlx_mouse_move(void *mlx_ptr, void *win_ptr, int x, int y);
int mlx_mouse_hide(void *mlx_ptr, void *win_ptr);
int mlx_mouse_show(void *mlx_ptr, void *win_ptr);
int mlx_get_screen_size(void *mlx_ptr, int *sizex, int *sizey);
int mlx_destroy_image(void *mlx_ptr, void *img_ptr);
int mlx_destroy_display(void *mlx_ptr);
/*
** generic hook system for all events, and minilibX functions that
** can be hooked. Some macro and defines from X11/X.h are needed here.
*/
int mlx_hook(void *win_ptr, int x_event, int x_mask,
int (*funct)(), void *param);
int mlx_do_key_autorepeatoff(void *mlx_ptr);
int mlx_do_key_autorepeaton(void *mlx_ptr);
int mlx_do_sync(void *mlx_ptr);
int mlx_mouse_get_pos(void *mlx_ptr, void *win_ptr, int *x, int *y);
int mlx_mouse_move(void *mlx_ptr, void *win_ptr, int x, int y);
int mlx_mouse_hide(void *mlx_ptr, void *win_ptr);
int mlx_mouse_show(void *mlx_ptr, void *win_ptr);
int mlx_get_screen_size(void *mlx_ptr, int *sizex, int *sizey);
#endif /* MLX_H */
#endif

102
libft/Makefile
View File

@ -1,102 +0,0 @@
# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2023/02/06 12:19:21 by fgras-ca #+# #+# #
# Updated: 2024/01/15 22:06:15 by fgras-ca ### ########.fr #
# #
# **************************************************************************** #
RST = \033[0m
GRAY = \033[0;90m
RED = \033[0;91m
GREEN = \033[0;92m
YELLOW = \033[0;93m
BLUE = \033[0;94m
MAGENTA = \033[0;95m
CYAN = \033[0;96m
WHITE = \033[0;97m
ORANGE = \033[38;5;214m
NAME = libft.a
SOURCES = ft_atoi.c \
ft_isalpha.c \
ft_memchr.c \
ft_memset.c \
ft_strlcat.c \
ft_strnstr.c \
ft_toupper.c \
ft_bzero.c \
ft_isascii.c \
ft_memcmp.c \
ft_strchr.c \
ft_strlcpy.c \
ft_strrchr.c \
ft_calloc.c \
ft_isdigit.c \
ft_memcpy.c \
ft_substr.c \
ft_isalnum.c \
ft_isprint.c \
ft_memmove.c \
ft_strncmp.c \
ft_tolower.c\
ft_strtrim.c \
ft_putchar_fd.c \
ft_putstr_fd.c \
ft_putendl_fd.c \
ft_putnbr_fd.c \
ft_strmapi.c \
ft_striteri.c \
ft_itoa.c \
ft_strcmp.c \
ft_strstr.c \
ft_reallocarray.c \
ft_strcat.c \
ft_strcpy.c \
ft_realloc.c \
ft_strncpy.c \
ft_strtol.c \
ft_strtok.c \
SRCBONUS = ft_lstnew.c \
ft_lstadd_front.c \
ft_lstsize.c \
ft_lstlast.c \
ft_lstadd_back.c \
ft_lstdelone.c \
ft_lstclear.c \
ft_lstiter.c \
ft_lstiter.c \
ft_lstmap.c \
OBJECTS = $(SOURCES:.c=.o)
BONUS_OBJ = $(SRCBONUS:.c=.o)
CC = gcc
RM = rm -f
CFLAGS = -Wall -Werror -Wextra
all: $(NAME)
$(NAME): $(OBJECTS)
@echo $(CC) (CFLAGS) $(OBJECTS) -o $(NAME)
bonus: $(OBJECTS) $(BONUS_OBJ)
$(CC) (CFLAGS) $(OBJECTS) $(BONUS_OBJ) -o $(NAME)
clean:
@echo $(RM) $(OBJECTS) $(BONUS_OBJ)
fclean: clean
@echo $(RM) $(NAME) $(BONUS_OBJ)
re: fclean all

38
libft/ft_atoi.c
View File

@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/11 16:16:54 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 09:57:55 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_atoi(const char *nptr)
{
int i;
int sign;
int res;
i = 0;
sign = 1;
res = 0;
while (nptr[i] == 32 || (nptr[i] >= 9 && nptr[i] <= 13))
i++;
if (nptr[i] == '-' || nptr[i] == '+')
{
if (nptr[i] == '-')
sign = - (1);
i++;
}
while (nptr[i] >= 48 && nptr[i] <= 57)
{
res = res * 10 + nptr[i] - 48;
i++;
}
return (res * sign);
}

BIN
libft/ft_atoi.o
View File

Binary file not shown.

25
libft/ft_bzero.c
View File

@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/04 11:37:30 by fgras-ca #+# #+# */
/* Updated: 2023/02/20 16:07:19 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_bzero(void *ptr, size_t len)
{
size_t i;
i = 0;
while (i < len)
{
*(char *)(ptr + i) = 0;
i++;
}
}

BIN
libft/ft_bzero.o
View File

Binary file not shown.

28
libft/ft_calloc.c
View File

@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_calloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/11 17:47:38 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 10:45:58 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_calloc(size_t nmemb, size_t size)
{
void *ptr;
if (!nmemb || !size)
return (malloc(0));
if ((nmemb * size) / size != nmemb)
return (NULL);
ptr = malloc(size * nmemb);
if (!ptr)
return (0);
ft_bzero(ptr, size * nmemb);
return (ptr);
}

BIN
libft/ft_calloc.o
View File

Binary file not shown.

21
libft/ft_isalnum.c
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/01 16:21:11 by fgras-ca #+# #+# */
/* Updated: 2023/02/01 16:24:23 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalnum(int c)
{
if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57))
return (1);
else
return (0);
}

BIN
libft/ft_isalnum.o
View File

Binary file not shown.

21
libft/ft_isalpha.c
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/01 13:36:34 by fgras-ca #+# #+# */
/* Updated: 2023/02/01 13:58:21 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalpha(int c)
{
if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122))
return (1);
else
return (0);
}

BIN
libft/ft_isalpha.o
View File

Binary file not shown.

20
libft/ft_isascii.c
View File

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/01 16:40:31 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:07:04 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
return (0);
}

BIN
libft/ft_isascii.o
View File

Binary file not shown.

21
libft/ft_isdigit.c
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/01 14:46:59 by fgras-ca #+# #+# */
/* Updated: 2023/02/01 15:55:00 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isdigit(int c)
{
if (c >= 48 && c <= 57)
return (1);
else
return (0);
}

BIN
libft/ft_isdigit.o
View File

Binary file not shown.

20
libft/ft_isprint.c
View File

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/03 12:43:03 by fgras-ca #+# #+# */
/* Updated: 2023/02/03 13:25:31 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isprint(int c)
{
if (c >= 32 && c <= 126)
return (1);
return (0);
}

BIN
libft/ft_isprint.o
View File

Binary file not shown.

56
libft/ft_itoa.c
View File

@ -1,56 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 15:53:35 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 10:21:07 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t ft_len_nb(int nb)
{
int len;
len = 0;
if (nb <= 0)
len++;
while (nb)
{
len++;
nb = nb / 10;
}
return (len);
}
char *ft_itoa(int n)
{
int len;
char *str;
long nb;
len = ft_len_nb(n);
nb = n;
str = malloc(sizeof(char) * len +1);
if (!str)
return (0);
if (nb < 0)
{
str[0] = '-';
nb = -nb;
}
if (nb == 0)
str[0] = '0';
str[len--] = '\0';
while (nb)
{
str[len] = nb % 10 + '0';
len--;
nb = nb / 10;
}
return (str);
}

BIN
libft/ft_itoa.o
View File

Binary file not shown.

29
libft/ft_lstadd_back.c
View File

@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_back.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 18:08:00 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:15:14 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_back(t_list **lst, t_list *new)
{
t_list *temp;
if (new && lst)
{
if (*lst)
{
temp = ft_lstlast(*lst);
temp->next = new;
}
else
*lst = new;
}
}

22
libft/ft_lstadd_front.c
View File

@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_front.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/22 18:06:54 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:06:52 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_front(t_list **lst, t_list *new)
{
if (new)
{
new->next = *lst;
*lst = new;
}
}

25
libft/ft_lstclear.c
View File

@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstclear.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 18:19:42 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:22:17 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstclear(t_list **lst, void (*del)(void*))
{
t_list *temp;
while (*lst && lst)
{
temp = (*lst)->next;
ft_lstdelone(*lst, (*del));
*lst = temp;
}
}

21
libft/ft_lstdelone.c
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 18:17:06 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:33:01 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstdelone(t_list *lst, void (*del)(void*))
{
if (!lst || !del)
return ;
del(lst->content);
free(lst);
}

24
libft/ft_lstiter.c
View File

@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstiter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 18:22:52 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:24:51 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstiter(t_list *lst, void (*f)(void *))
{
if (!lst || !f)
return ;
while (lst)
{
f(lst->content);
lst = lst->next;
}
}

24
libft/ft_lstlast.c
View File

@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstlast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 17:48:29 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:02:44 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstlast(t_list *lst)
{
while (lst)
{
if (lst->next == NULL)
return (lst);
lst = lst->next;
}
return (lst);
}

35
libft/ft_lstmap.c
View File

@ -1,35 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 18:25:24 by fgras-ca #+# #+# */
/* Updated: 2023/02/23 18:29:44 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
t_list *tmp;
t_list *res;
if (!lst || !f)
return (NULL);
res = 0;
while (lst)
{
tmp = ft_lstnew((*f)(lst->content));
if (!tmp)
{
ft_lstclear(&res, del);
return (NULL);
}
ft_lstadd_back(&res, tmp);
lst = lst->next;
}
return (res);
}

25
libft/ft_lstnew.c
View File

@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/22 17:09:25 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:06:38 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstnew(void *content)
{
t_list *new;
new = malloc(sizeof(t_list));
if (!new)
return (0);
new->content = content;
new->next = 0;
return (new);
}

28
libft/ft_lstsize.c
View File

@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstsize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/23 17:17:36 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:06:24 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_lstsize(t_list *lst)
{
int i;
t_list *tmp;
tmp = lst;
i = 0;
while (tmp)
{
tmp = tmp->next;
i++;
}
return (i);
}

27
libft/ft_memchr.c
View File

@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/10 13:42:10 by fgras-ca #+# #+# */
/* Updated: 2023/02/14 13:03:28 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
size_t i;
i = 0;
while (i < n)
{
if (((unsigned char *)s)[i] == (unsigned char)c)
return ((void *)(s + i));
i++;
}
return (0);
}

BIN
libft/ft_memchr.o
View File

Binary file not shown.

27
libft/ft_memcmp.c
View File

@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/10 14:45:56 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:18:05 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
i = 0;
while (i < n)
{
if (((unsigned char *)s1)[i] != ((unsigned char *)s2)[i])
return (((unsigned char *)s1)[i] - ((unsigned char *)s2)[i]);
i++;
}
return (0);
}

BIN
libft/ft_memcmp.o
View File

Binary file not shown.

32
libft/ft_memcpy.c
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/04 14:43:15 by fgras-ca #+# #+# */
/* Updated: 2023/02/20 16:13:43 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memcpy(void *dest, const void *src, size_t n)
{
char *destmov;
char *srcmov;
size_t i;
destmov = (char *)dest;
srcmov = (char *)src;
if (!dest && !src)
return (0);
i = 0;
while (i < n)
{
destmov[i] = srcmov[i];
i++;
}
return (dest);
}

BIN
libft/ft_memcpy.o
View File

Binary file not shown.

42
libft/ft_memmove.c
View File

@ -1,42 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memmove.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/07 11:11:49 by fgras-ca #+# #+# */
/* Updated: 2023/02/07 16:04:25 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memmove(void *dest, const void *src, size_t n)
{
char *destmov;
char *srcmov;
size_t i;
if (!dest && !src)
return (0);
destmov = (char *)dest;
srcmov = (char *)src;
i = 0;
if (destmov > srcmov)
{
while (n--)
{
destmov[n] = srcmov[n];
}
}
else
{
while (n--)
{
destmov[i] = srcmov[i];
i++;
}
}
return (destmov);
}

BIN
libft/ft_memmove.o
View File

Binary file not shown.

26
libft/ft_memset.c
View File

@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/03 15:49:51 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:07:29 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memset(void *s, int c, size_t n)
{
size_t i;
i = 0;
while (i < n)
{
*(unsigned char *)(s + i) = (unsigned char)c;
i++;
}
return (s);
}

BIN
libft/ft_memset.o
View File

Binary file not shown.

18
libft/ft_putchar_fd.c
View File

@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 11:23:07 by fgras-ca #+# #+# */
/* Updated: 2023/02/15 11:30:37 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}

BIN
libft/ft_putchar_fd.o
View File

Binary file not shown.

28
libft/ft_putendl_fd.c
View File

@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 13:33:49 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 10:19:05 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putendl_fd(char *s, int fd)
{
int i;
i = 0;
if (!s)
return ;
while (s[i])
{
write(fd, &s[i], 1);
i++;
}
write(fd, "\n", 1);
}

BIN
libft/ft_putendl_fd.o
View File

Binary file not shown.

36
libft/ft_putnbr_fd.c
View File

@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 13:53:25 by fgras-ca #+# #+# */
/* Updated: 2023/02/15 14:00:06 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putnbr_fd(int n, int fd)
{
if (n == -2147483648)
{
write(fd, "-2147483648", 11);
}
else if (n >= 0 && n < 10)
{
n += 48;
ft_putchar_fd(n, fd);
}
else if (n < 0)
{
ft_putchar_fd('-', fd);
ft_putnbr_fd((n * (-1)), fd);
}
else
{
ft_putnbr_fd(n / 10, fd);
ft_putnbr_fd(n % 10, fd);
}
}

BIN
libft/ft_putnbr_fd.o
View File

Binary file not shown.

27
libft/ft_putstr_fd.c
View File

@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 12:29:14 by fgras-ca #+# #+# */
/* Updated: 2023/02/15 19:02:37 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putstr_fd(char *s, int fd)
{
int i;
i = 0;
if (!s || !fd)
return ;
while (s[i])
{
write(fd, &s[i], 1);
i++;
}
}

BIN
libft/ft_putstr_fd.o
View File

Binary file not shown.

35
libft/ft_realloc.c
View File

@ -1,35 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_realloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/15 16:31:35 by fgras-ca #+# #+# */
/* Updated: 2023/12/10 13:59:12 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_realloc(void *ptr, size_t newsize, size_t oldsize)
{
char *newptr;
if (ptr == NULL)
{
return (malloc(newsize));
}
if (newsize <= oldsize)
{
return (ptr);
}
newptr = malloc(newsize);
if (newptr == NULL)
{
return (NULL);
}
ft_memcpy(newptr, ptr, oldsize);
free(ptr);
return (newptr);
}

BIN
libft/ft_realloc.o
View File

Binary file not shown.

32
libft/ft_reallocarray.c
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_reallocarray.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/15 15:52:29 by fgras-ca #+# #+# */
/* Updated: 2023/12/07 11:46:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t get_mul_no_overflow(void)
{
return ((size_t)1 << (sizeof(size_t) * 4));
}
void *ft_reallocarray(void *optr, size_t nmemb, size_t size, size_t oldsize)
{
size_t mul_no_overflow;
mul_no_overflow = get_mul_no_overflow();
if ((nmemb >= mul_no_overflow || size >= mul_no_overflow)
&& nmemb > 0 && SIZE_MAX / nmemb < size)
{
errno = ENOMEM;
return (NULL);
}
return (ft_realloc(optr, nmemb * size, oldsize));
}

BIN
libft/ft_reallocarray.o
View File

Binary file not shown.

32
libft/ft_strcat.c
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/21 19:20:36 by fgras-ca #+# #+# */
/* Updated: 2023/11/21 19:28:29 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strcat(char *dest, const char *src)
{
char *save;
save = dest;
while (*dest)
{
dest++;
}
while (*src)
{
*dest = *src;
dest++;
src++;
}
*dest = '\0';
return (save);
}

BIN
libft/ft_strcat.o
View File

Binary file not shown.

32
libft/ft_strchr.c
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/09 14:27:10 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 10:54:39 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strchr(const char *s, int c)
{
int i;
char *str;
str = (char *)s;
i = 0;
while (str[i])
{
if (str[i] == (char)c)
return (&str[i]);
i++;
}
if (str[i] == (char)c)
return (&str[i]);
return (0);
}

BIN
libft/ft_strchr.o
View File

Binary file not shown.

23
libft/ft_strcmp.c
View File

@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/14 16:57:42 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:10:27 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strcmp(const char *s1, const char *s2)
{
while (*s1 && (*s1 == *s2))
{
s1++;
s2++;
}
return (*(const unsigned char *)s1 - *(const unsigned char *)s2);
}

BIN
libft/ft_strcmp.o
View File

Binary file not shown.

28
libft/ft_strcpy.c
View File

@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/21 19:23:08 by fgras-ca #+# #+# */
/* Updated: 2023/11/21 19:26:36 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strcpy(char *dest, const char *src)
{
char *save;
save = dest;
while (*src)
{
*dest = *src;
dest++;
src++;
}
*dest = '\0';
return (save);
}

BIN
libft/ft_strcpy.o
View File

Binary file not shown.

25
libft/ft_striteri.c
View File

@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striteri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/16 14:25:00 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:08:02 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_striteri(char *s, void (*f)(unsigned int, char*))
{
unsigned int i;
if (!s)
return ;
i = 0;
while (s[i])
{
f(i, &s[i]);
i++;
}
}

BIN
libft/ft_striteri.o
View File

Binary file not shown.

33
libft/ft_strlcat.c
View File

@ -1,33 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/08 14:10:58 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:09:41 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcat(char *dst, const char *src, size_t size)
{
size_t i;
size_t dst_len;
i = 0;
if (!dst && !size)
return (0);
dst_len = ft_strlen(dst);
if (size <= dst_len)
return (size + ft_strlen(src));
while (src[i] && i < size - dst_len -1)
{
dst[dst_len + i] = src[i];
i++;
}
dst[dst_len + i] = 0;
return (dst_len + ft_strlen(src));
}

BIN
libft/ft_strlcat.o
View File

Binary file not shown.

32
libft/ft_strlcpy.c
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/08 13:24:31 by fgras-ca #+# #+# */
/* Updated: 2023/02/08 13:33:32 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcpy(char *dst, const char *src, size_t size)
{
size_t i;
i = 0;
if (size > 0)
{
while (src[i] && i < (size - 1))
{
dst[i] = src[i];
i++;
}
dst[i] = 0;
}
while (src[i])
i++;
return (i);
}

BIN
libft/ft_strlcpy.o
View File

Binary file not shown.

33
libft/ft_strmapi.c
View File

@ -1,33 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmapi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/16 13:38:52 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:04:43 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strmapi(const char *s, char (*f)(unsigned int, char))
{
char *result;
unsigned int i;
if (!s)
return (0);
result = malloc(sizeof(char) * (ft_strlen(s) + 1));
if (!result)
return (0);
i = 0;
while (s[i])
{
result[i] = f(i, s[i]);
i++;
}
result[i] = 0;
return (result);
}

BIN
libft/ft_strmapi.o
View File

Binary file not shown.

29
libft/ft_strncmp.c
View File

@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/09 17:12:38 by fgras-ca #+# #+# */
/* Updated: 2023/02/14 13:26:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
size_t i;
i = 0;
if (n == 0)
{
return (0);
}
while (s1[i] == s2[i] && (s1[i] != '\0' || s2[i] != '\0') && i < (n - 1))
{
i++;
}
return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}

BIN
libft/ft_strncmp.o
View File

Binary file not shown.

31
libft/ft_strncpy.c
View File

@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/27 20:03:19 by fgras-ca #+# #+# */
/* Updated: 2023/12/07 11:56:51 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strncpy(char *dest, char *src, unsigned int n)
{
unsigned int i;
i = 0;
while (src[i] != '\0' && i < n)
{
dest[i] = src[i];
++i;
}
while (i < n)
{
dest[i] = '\0';
i++;
}
return (dest);
}

BIN
libft/ft_strncpy.o
View File

Binary file not shown.

41
libft/ft_strnstr.c
View File

@ -1,41 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/11 14:31:40 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 10:08:36 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strnstr(const char *haystack, const char *needle, size_t len)
{
size_t i;
size_t j;
i = 0;
if (needle == haystack)
return ((char *)haystack);
if (!len && !haystack)
return (0);
while (haystack[i] != '\0')
{
j = 0;
while (haystack[i + j] == needle[j] && (i + j) < len)
{
if (haystack[i + j] == '\0' && needle[j] == '\0')
{
return ((char *)&haystack[j]);
}
j++;
}
if (needle[j] == '\0')
return ((char *)(haystack + i));
i++;
}
return (NULL);
}

BIN
libft/ft_strnstr.o
View File

Binary file not shown.

29
libft/ft_strrchr.c
View File

@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strrchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/09 16:10:11 by fgras-ca #+# #+# */
/* Updated: 2023/02/14 15:36:23 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strrchr(const char *s, int c)
{
int i;
i = 0;
while (s[i])
i++;
while (i >= 0)
{
if (s[i] == (char)c)
return ((char *)(s + i));
i--;
}
return (0);
}

BIN
libft/ft_strrchr.o
View File

Binary file not shown.

42
libft/ft_strstr.c
View File

@ -1,42 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/14 20:54:44 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 21:08:57 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strstr(const char *haystack, const char *needle)
{
const char *p;
const char *beginning;
const char *n;
p = haystack;
if (*needle == '\0')
return ((char *)haystack);
while (*p != '\0')
{
if (*p == *needle)
{
beginning = p;
n = needle;
while (*p == *n && *n != '\0' && *p != '\0')
{
p++;
n++;
}
if (*n == '\0')
return ((char *)beginning);
p = beginning;
}
p++;
}
return (NULL);
}

BIN
libft/ft_strstr.o
View File

Binary file not shown.

83
libft/ft_strtok.c
View File

@ -1,83 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtok.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/14 17:14:45 by fgras-ca #+# #+# */
/* Updated: 2023/12/07 11:41:34 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static char *init_str_and_lasts(char **lasts, char *str)
{
if (str == NULL)
{
str = *lasts;
if (str == NULL)
return (NULL);
}
else
{
*lasts = str;
}
return (str);
}
static char *find_token_start(char **lasts, const char *delim)
{
int ch;
ch = **lasts;
while (ch != '\0' && ft_strchr(delim, ch) != NULL)
{
(*lasts)++;
ch = **lasts;
}
if (**lasts == '\0')
{
*lasts = NULL;
return (NULL);
}
return (*lasts);
}
static char *find_token_end(char **lasts, const char *delim)
{
int ch;
char *str;
str = *lasts;
ch = **lasts;
while (ch != '\0' && ft_strchr(delim, ch) == NULL)
{
(*lasts)++;
ch = **lasts;
}
if (**lasts != '\0')
{
**lasts = '\0';
(*lasts)++;
}
else
{
*lasts = NULL;
}
return (str);
}
char *ft_strtok(char *str, const char *delim)
{
static char *lasts;
str = init_str_and_lasts(&lasts, str);
if (str == NULL)
return (NULL);
str = find_token_start(&lasts, delim);
if (str == NULL)
return (NULL);
return (find_token_end(&lasts, delim));
}

BIN
libft/ft_strtok.o
View File

Binary file not shown.

115
libft/ft_strtol.c
View File

@ -1,115 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtol.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/01 14:00:32 by fgras-ca #+# #+# */
/* Updated: 2023/12/07 11:56:12 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static int skip_whitespaces_and_sign(const char *str, int *sign)
{
int i;
i = 0;
while (str[i] == ' ' || (str[i] >= '\t' && str[i] <= '\r'))
i++;
if (str[i] == '+' || str[i] == '-')
{
if (str[i] == '-')
*sign = -1;
i++;
}
return (i);
}
static int determine_base(const char *str, int *base, int index)
{
if ((*base == 0 || *base == 16) && str[index] == '0'
&& (str[index + 1] == 'x' || str[index + 1] == 'X'))
{
*base = 16;
index += 2;
}
else if (*base == 0)
{
if (str[index] == '0')
*base = 8;
else
*base = 10;
}
return (index);
}
static int check_base(const char *str, int *base, int *sign)
{
int i;
*sign = 1;
i = skip_whitespaces_and_sign(str, sign);
i = determine_base(str, base, i);
return (i);
}
static long convert_strtol(const char *str, int base, int sign)
{
long result;
int digit;
result = 0;
while (*str)
{
digit = 0;
if (*str >= '0' && *str <= '9')
digit = *str - '0';
else if (*str >= 'A' && *str <= 'Z')
digit = *str - 'A' + 10;
else if (*str >= 'a' && *str <= 'z')
digit = *str - 'a' + 10;
else
break ;
if (digit >= base)
break ;
if (sign > 0 && result > (LONG_MAX - digit) / base)
return (errno = ERANGE, LONG_MAX);
if (sign < 0 && result < (LONG_MIN + digit) / base)
return (errno = ERANGE, LONG_MIN);
result = result * base + digit;
str++;
}
return (result * sign);
}
long ft_strtol(const char *str, char **endptr, int base)
{
int sign;
int i;
long result;
if (base < 0 || base == 1 || base > 36)
{
if (endptr)
*endptr = (char *)str;
return (0);
}
i = check_base(str, &base, &sign);
result = convert_strtol(str + i, base, sign);
if (endptr)
*endptr = (char *)(str + i);
while (*str)
{
if ((*str >= '0' && *str <= '9' && *str - '0' < base)
|| (*str >= 'A' && *str <= 'Z' && *str - 'A' + 10 < base)
|| (*str >= 'a' && *str <= 'z' && *str - 'a' + 10 < base))
*endptr = (char *)(str + 1);
else
break ;
str++;
}
return (result);
}

BIN
libft/ft_strtol.o
View File

Binary file not shown.

52
libft/ft_strtrim.c
View File

@ -1,52 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 16:30:26 by fgras-ca #+# #+# */
/* Updated: 2023/03/13 14:12:41 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static int char_in_set(char c, char const *set)
{
size_t i;
i = 0;
while (set[i])
{
if (set[i] == c)
return (1);
i++;
}
return (0);
}
char *ft_strtrim(char const *s1, char const *set)
{
char *str;
size_t i;
size_t start;
size_t end;
if (!s1)
return (0);
start = 0;
while (s1[start] && char_in_set(s1[start], set))
start++;
end = ft_strlen(s1);
while (end > start && char_in_set(s1[end - 1], set))
end--;
str = (char *)malloc(sizeof(*s1) * (end - start + 1));
if (!str)
return (0);
i = 0;
while (start < end)
str[i++] = s1[start++];
str[i] = 0;
return (str);
}

BIN
libft/ft_strtrim.o
View File

Binary file not shown.

37
libft/ft_substr.c
View File

@ -1,37 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_substr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/13 15:40:49 by fgras-ca #+# #+# */
/* Updated: 2023/11/14 17:07:20 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
char *new_s;
size_t i;
size_t j;
new_s = (char *)malloc(sizeof(char) * (len + 1));
if (!s || !new_s)
return (NULL);
i = 0;
j = 0;
while (s[i])
{
if (i >= start && j < len)
{
new_s[j] = s[i];
j++;
}
i++;
}
new_s[j] = '\0';
return (new_s);
}

BIN
libft/ft_substr.o
View File

Binary file not shown.

20
libft/ft_tolower.c
View File

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/09 14:09:59 by fgras-ca #+# #+# */
/* Updated: 2023/02/14 13:36:02 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_tolower(int c)
{
if (c >= 65 && c <= 90)
c += 32;
return (c);
}

BIN
libft/ft_tolower.o
View File

Binary file not shown.

20
libft/ft_toupper.c
View File

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/08 16:02:00 by fgras-ca #+# #+# */
/* Updated: 2023/02/14 13:36:40 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_toupper(int c)
{
if (c >= 97 && c <= 122)
c -= 32;
return (c);
}

BIN
libft/ft_toupper.o
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More