Add map checks *

add:
- check if map is surronded by walls
- check file extension
dev:
- Makefile: now can include libraries
- add library libft
- add testmaps
- norm
This commit is contained in:
mcolonna 2024-10-10 13:34:24 +02:00
parent 5bad24dcee
commit 40d8462689
64 changed files with 1786 additions and 72 deletions

View file

@ -1,6 +1,9 @@
NAME = cub3D
CPP = gcc -Wall -Wextra -Werror -I include $(FLAGS)
C_FILES = $(wildcard **/*.c)
CPP = gcc -Wall -Wextra -Werror -I include -I libft $(FLAGS)
LIBRARIES_DIR = libft
LIBRARIES_A = libft/libft.a
CPP_2 = $(CPP) $(FLAGS_2)
C_FILES = $(wildcard src/**.c)
O_FILES = $(patsubst %.c,%.o,$(C_FILES))
ECHO = echoo(){ \
@ -13,6 +16,11 @@ ECHO = echoo(){ \
all : $(NAME)
$(LIBRARIES_DIR):
@$(ECHO)
@$(ECHO) "\e[30;47;1m $(NAME): making library $@... \e[0m"
$(MAKE) -C $@
clean :
@$(ECHO)
@$(ECHO) "\e[30;47;1m $(NAME): clean... \e[0m"
@ -25,10 +33,10 @@ fclean : clean
re : fclean all
$(NAME) : $(O_FILES)
$(NAME) : $(O_FILES) $(LIBRARIES_DIR)
@$(ECHO)
@$(ECHO) "\e[30;47;1m $(NAME): linking... \e[0m"
$(CPP) $(FLAGS_2) -o $(NAME) $(O_FILES)
$(CPP_2) -o $(NAME) $(O_FILES) $(LIBRARIES_A)
@$(ECHO)
@$(ECHO) "\t\t \e[0;92m\(^o^)/ \e[0;102;30;1m $(NAME) made! \e[0;92m \(^o^)/\e[0m"
@$(ECHO)
@ -58,4 +66,4 @@ check_headers :
2> /dev/null rm __tmp_check_header.out __tmp_check_header.c; \
if [ $$ERROR -eq 0 ]; then true; else false; fi;
.PHONY : all clean fclean re check_headers
.PHONY : all clean fclean re check_headers $(LIBRARIES_DIR)

View file

@ -6,7 +6,7 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/01 13:59:04 by mcolonna #+# #+# */
/* Updated: 2024/10/04 13:13:04 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 11:59:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -50,6 +50,9 @@ typedef struct s_object
/// @brief Represents a case of the map.
typedef struct s_map_case
{
/// @brief 'true' if the case is inside of the room (false with ' ' char)
bool inside;
/// @brief Is the case empty or a wall?
t_map_wall wall;
@ -103,4 +106,10 @@ bool map_from_file(t_map *dest, const char *file);
/// @brief Destroy the map to avoid leaks.
void map_destroy(t_map *map);
/// @brief Return true if the map is valid. Write an error message on stderr.
///
/// @param map The map to check.
/// @return true if the map is valid, false if not.
bool check_map(const t_map *map);
#endif

View file

@ -6,16 +6,13 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/03 14:19:03 by mc #+# #+# */
/* Updated: 2024/10/04 15:27:07 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 12:37:34 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef UTIL_H
# define UTIL_H
/// @brief Get the length of a string.
int getlen(const char *str);
/// @brief Write an error message on stderr.
///
/// @param str... All the strings to write. The last parameter MUST BE NULL.

47
libft/Makefile Normal file
View file

@ -0,0 +1,47 @@
# The interesting part
NAME = libft.a
SRCS = ./
INCLUDES = ./
FUNCTIONS = \
isalpha isdigit isalnum isascii isprint \
toupper tolower \
strncmp strlen strlcpy strlcat strchr strrchr strnstr strdup \
strmapi striteri substr strjoin strtrim split \
memset bzero memcpy memmove memchr memcmp calloc \
atoi itoa \
putchar_fd putstr_fd putendl_fd putnbr_fd
FUNCTIONS_BONUS = \
lstnew lstadd_front lstsize lstlast lstadd_back \
lstdelone lstclear lstiter lstmap
CODE = $(addprefix ft_, $(FUNCTIONS))
CODE_BONUS = $(addprefix ft_, $(FUNCTIONS_BONUS))
# It works and I probably won't change it for the rest of my life
C_FILES = $(addsuffix .c,$(addprefix $(SRCS),$(CODE)))
O_FILES = $(addsuffix .o,$(addprefix $(SRCS),$(CODE)))
C_FILES_BONUS = $(addsuffix .c,$(addprefix $(SRCS),$(CODE_BONUS)))
O_FILES_BONUS = $(addsuffix .o,$(addprefix $(SRCS),$(CODE_BONUS)))
CC = cc -Wall -Wextra -Werror
AR = ar rcs
MAKE = make
all : $(NAME)
$(NAME) : $(O_FILES)
$(AR) $(NAME) $(O_FILES)
%.o : %.c
$(CC) -I $(INCLUDES) -c $< -o $@
clean :
rm -f $(O_FILES) $(O_FILES_BONUS)
fclean : clean
rm -f $(NAME)
re : fclean all
bonus : $(O_FILES_BONUS)
$(AR) $(NAME) $(O_FILES_BONUS)
.PHONY : all clean fclean re bonus

50
libft/ft_atoi.c Normal file
View file

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/28 17:45:41 by mcolonna #+# #+# */
/* Updated: 2023/10/09 12:03:52 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
static int is_in(char c, char *chars)
{
int i;
i = 0;
while (chars[i])
{
if (c == chars[i])
return (1);
i++;
}
return (0);
}
int ft_atoi(const char *nptr)
{
int sign;
int i;
int r;
sign = 1;
i = 0;
r = 0;
while (is_in(nptr[i], " \f\n\r\t\v"))
i++;
if (is_in(nptr[i], "+-"))
{
if (nptr[i] == '-')
sign *= -1;
i++;
}
while (is_in(nptr[i], "0123456789"))
{
r = r * 10 + (nptr[i] - '0');
i++;
}
return (r * sign);
}

18
libft/ft_bzero.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:10:31 by mcolonna #+# #+# */
/* Updated: 2023/10/03 13:12:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
ft_memset(s, '\0', n);
}

29
libft/ft_calloc.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_calloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:41:02 by mcolonna #+# #+# */
/* Updated: 2023/10/09 15:58:33 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
void *ft_calloc(size_t nmemb, size_t size)
{
void *dest;
int len;
if ((long)nmemb * (long)size > (long)INT_MAX)
return (NULL);
len = size * nmemb;
dest = malloc(len);
if (!dest)
return (NULL);
ft_bzero(dest, len);
return (dest);
}

18
libft/ft_isalnum.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:02:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalnum(int c)
{
return (ft_isdigit(c) || ft_isalpha(c));
}

16
libft/ft_isalpha.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:46:27 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isalpha(int c)
{
return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
}

16
libft/ft_isascii.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:50:28 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isascii(int c)
{
return ((c >= 0 && c <= 127));
}

16
libft/ft_isdigit.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:47:07 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isdigit(int c)
{
return (c >= '0' && c <= '9');
}

16
libft/ft_isprint.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:51:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isprint(int c)
{
return (c >= 32 && c <= 126);
}

67
libft/ft_itoa.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:51:10 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:49:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static char get_digit_at(long pos_n, int i, int nb_len)
{
int w;
long ten_power;
w = nb_len - i - 1;
ten_power = 1;
while (w--)
ten_power *= 10;
return ('0' + pos_n / ten_power % 10);
}
static int get_nb_len(long pos_n)
{
int r;
long ten_powers;
r = 1;
ten_powers = 10;
while (pos_n >= ten_powers)
{
r++;
ten_powers *= 10;
}
return (r);
}
char *ft_itoa(int n)
{
long pos_n;
int sign;
int nb_len;
char *dest;
int i;
sign = (n >= 0) - (n < 0);
pos_n = (long)n * sign;
nb_len = get_nb_len(pos_n);
dest = malloc(((sign == -1) + nb_len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
if (sign == -1)
dest[i++] = '-';
while (i - (sign == -1) < nb_len)
{
dest[i] = get_digit_at(pos_n, i - (sign == -1), nb_len);
i++;
}
dest[i] = '\0';
return (dest);
}

24
libft/ft_lstadd_back.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_back.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:24:03 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:56:42 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_back(t_list **lst, t_list *new)
{
t_list *last;
last = ft_lstlast(*lst);
if (last)
last->next = new;
else
*lst = new;
}

19
libft/ft_lstadd_front.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_front.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:19:20 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:20:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_front(t_list **lst, t_list *new)
{
new->next = *lst;
*lst = new;
}

25
libft/ft_lstclear.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstclear.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:31:06 by mcolonna #+# #+# */
/* Updated: 2023/10/05 11:40:24 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstclear(t_list **lst, void (*del)(void *))
{
t_list *next;
while (*lst)
{
next = (*lst)->next;
ft_lstdelone(*lst, del);
*lst = next;
}
}

22
libft/ft_lstdelone.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:28:18 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:55:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
void ft_lstdelone(t_list *lst, void (*del)(void *))
{
if (!lst)
return ;
(*del)(lst->content);
free(lst);
}

22
libft/ft_lstiter.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstiter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:36:27 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:37:48 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstiter(t_list *lst, void (*f)(void *))
{
while (lst)
{
(*f)(lst->content);
lst = lst->next;
}
}

22
libft/ft_lstlast.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstlast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:22:57 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:53:31 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstlast(t_list *lst)
{
if (!lst)
return (NULL);
while (lst->next)
lst = lst->next;
return (lst);
}

38
libft/ft_lstmap.c Normal file
View file

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:37:57 by mcolonna #+# #+# */
/* Updated: 2023/10/12 13:17:57 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
t_list *dest;
t_list *new;
void *new_content;
dest = NULL;
if (!lst)
return (NULL);
while (lst)
{
new_content = (*f)(lst->content);
new = ft_lstnew(new_content);
if (!new)
{
(*del)(new_content);
ft_lstclear(&dest, del);
return (NULL);
}
ft_lstadd_back(&dest, new);
lst = lst->next;
}
return (dest);
}

26
libft/ft_lstnew.c Normal file
View file

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:14:54 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:51:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
t_list *ft_lstnew(void *content)
{
t_list *r;
r = malloc(sizeof(t_list));
if (!r)
return (NULL);
r->content = content;
r->next = NULL;
return (r);
}

26
libft/ft_lstsize.c Normal file
View file

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstsize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:21:29 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:44:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_lstsize(t_list *lst)
{
int i;
i = 0;
while (lst)
{
lst = lst->next;
i++;
}
return (i);
}

28
libft/ft_memchr.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:28:00 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:31:16 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
size_t i;
const char *s2 = s;
i = 0;
while (i < n)
{
if (s2[i] == (char) c)
return ((void *) s + i);
i++;
}
return (NULL);
}

25
libft/ft_memcmp.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:37:06 by mcolonna #+# #+# */
/* Updated: 2023/10/09 12:00:22 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
if (n == 0)
return (0);
i = 0;
while (i < n - 1 && ((unsigned char *)s1)[i] == ((unsigned char *)s2)[i])
i++;
return (((unsigned char *)s1)[i] - ((unsigned char *)s2)[i]);
}

30
libft/ft_memcpy.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:12:53 by mcolonna #+# #+# */
/* Updated: 2023/10/16 13:40:19 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memcpy(void *dest, const void *src, size_t n)
{
size_t i;
char *dest2;
char *src2;
dest2 = (char *)dest;
src2 = (char *)src;
i = 0;
while (i < n)
{
dest2[i] = src2[i];
i++;
}
return (dest);
}

31
libft/ft_memmove.c Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memmove.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:17:41 by mcolonna #+# #+# */
/* Updated: 2023/10/12 10:44:37 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memmove(void *dest, const void *src, size_t n)
{
size_t i;
if (!dest || !src)
return (NULL);
i = 0;
while (i < n)
{
if (dest < src)
((char *)dest)[i] = ((char *)src)[i];
else
((char *)dest)[n - i - 1] = ((char *)src)[n - i - 1];
i++;
}
return (dest);
}

28
libft/ft_memset.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:05:27 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:27:09 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memset(void *s, int c, size_t n)
{
size_t i;
char *dest;
dest = (char *)s;
i = 0;
while (i < n)
{
dest[i] = (char)c;
i++;
}
return (dest);
}

18
libft/ft_putchar_fd.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/03 14:29:09 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}

20
libft/ft_putendl_fd.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/04 14:17:01 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "libft.h"
void ft_putendl_fd(char *s, int fd)
{
write(fd, s, ft_strlen(s));
write(fd, "\n", 1);
}

40
libft/ft_putnbr_fd.c Normal file
View file

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:32:29 by mcolonna #+# #+# */
/* Updated: 2023/10/09 17:23:02 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include <limits.h>
#include "libft.h"
static void putunsigned(long nb, int fd)
{
if (nb == 0)
return ;
putunsigned(nb / 10, fd);
ft_putchar_fd((char)(nb % 10) + '0', fd);
}
void ft_putnbr_fd(int n, int fd)
{
long nb;
if (n < 0)
{
ft_putchar_fd('-', fd);
nb = -(long)n;
}
else
nb = n;
if (n == 0)
ft_putchar_fd('0', fd);
else
putunsigned(nb, fd);
}

19
libft/ft_putstr_fd.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/03 14:34:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "libft.h"
void ft_putstr_fd(char *s, int fd)
{
write(fd, s, ft_strlen(s));
}

98
libft/ft_split.c Normal file
View file

@ -0,0 +1,98 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:47:18 by mcolonna #+# #+# */
/* Updated: 2023/10/12 13:24:04 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static int count_until(char const *s, char const c)
{
int i;
i = 0;
while (s[i] && s[i] != c)
i++;
return (i);
}
static int count_words(char const *s, char c)
{
int i;
int r;
int in_a_word;
i = 0;
r = 0;
in_a_word = 0;
while (s[i])
{
if (s[i] == c)
{
in_a_word = 0;
}
else if (!in_a_word)
{
in_a_word = 1;
r++;
}
i++;
}
return (r);
}
static char **free_array(char ***array, int size)
{
int i;
i = 0;
while (i < size)
{
free((*array)[i]);
(*array)[i] = NULL;
i++;
}
free(*array);
*array = NULL;
return (NULL);
}
static void ignore_sep(char const *s, char c, int *i)
{
while (s[*i] == c)
(*i)++;
}
char **ft_split(char const *s, char c)
{
int size;
char **dest;
int i;
int str_i;
int len_until;
size = count_words(s, c);
dest = malloc((size + 1) * sizeof(char *));
if (!dest)
return (NULL);
i = -1;
str_i = 0;
while (++i < size)
{
ignore_sep(s, c, &str_i);
len_until = count_until(s + str_i, c);
dest[i] = ft_substr(s, str_i, len_until);
if (!dest[i])
return (free_array(&dest, i));
str_i += len_until;
}
dest[i] = NULL;
return (dest);
}

29
libft/ft_strchr.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:43:17 by mcolonna #+# #+# */
/* Updated: 2023/10/10 13:17:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strchr(const char *s, int c)
{
int i;
i = 0;
while (s[i])
{
if (s[i] == c)
return ((char *)s + i);
i++;
}
if (s[i] == c)
return ((char *)s + i);
return (NULL);
}

35
libft/ft_strdup.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdup.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/30 09:18:39 by mcolonna #+# #+# */
/* Updated: 2023/10/03 11:27:46 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strdup(const char *s)
{
int len;
int i;
char *dest;
len = 0;
while (s[len])
len++;
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s[i])
{
dest[i] = s[i];
i++;
}
dest[i] = '\0';
return (dest);
}

25
libft/ft_striteri.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striteri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:08:18 by mcolonna #+# #+# */
/* Updated: 2023/10/04 11:10:28 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
void ft_striteri(char *s, void (*f)(unsigned int, char *))
{
unsigned int i;
i = 0;
while (s[i])
{
(*f)(i, s + i);
i++;
}
}

42
libft/ft_strjoin.c Normal file
View file

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:31:45 by mcolonna #+# #+# */
/* Updated: 2023/10/04 11:25:38 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_strjoin(char const *s1, char const *s2)
{
int len;
char *dest;
int i;
int j;
len = ft_strlen(s1) + ft_strlen(s2);
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s1[i])
{
dest[i] = s1[i];
i++;
}
j = 0;
while (s2[j])
{
dest[i] = s2[j];
i++;
j++;
}
dest[i] = '\0';
return (dest);
}

44
libft/ft_strlcat.c Normal file
View file

@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/28 10:40:23 by mcolonna #+# #+# */
/* Updated: 2023/10/09 16:20:20 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t min(size_t a, size_t b)
{
if (a < b)
return (a);
else
return (b);
}
size_t ft_strlcat(char *dest, const char *src, size_t size)
{
size_t dest_len;
size_t dest_i;
size_t src_i;
dest_len = min(ft_strlen(dest), size);
if (dest_len < size - 1)
{
dest_i = dest_len;
src_i = 0;
while (src[src_i] && size > 0 && dest_i < size - 1)
{
dest[dest_i] = src[src_i];
src_i++;
dest_i++;
}
if (size > 0)
dest[dest_i] = '\0';
}
return (dest_len + ft_strlen(src));
}

30
libft/ft_strlcpy.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/25 20:39:39 by mcolonna #+# #+# */
/* Updated: 2023/10/09 11:44:13 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcpy(char *dest, const char *src, size_t size)
{
size_t i;
i = 0;
while (src[i] && size > 0 && i < size - 1)
{
dest[i] = src[i];
i++;
}
if (i < size)
dest[i] = '\0';
while (src[i])
i++;
return (i);
}

23
libft/ft_strlen.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/24 13:10:16 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:09:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
while (s[i])
i++;
return (i);
}

32
libft/ft_strmapi.c Normal file
View file

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmapi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:08:18 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:20:49 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
char *dest;
unsigned int i;
dest = malloc((ft_strlen(s) + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s[i])
{
dest[i] = (*f)(i, s[i]);
i++;
}
dest[i] = '\0';
return (dest);
}

25
libft/ft_strncmp.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/10 12:21:33 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:39:03 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
unsigned int i;
if (n == 0)
return (0);
i = 0;
while (i < n - 1 && s1[i] && s1[i] == s2[i])
i++;
return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}

47
libft/ft_strnstr.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:50:23 by mcolonna #+# #+# */
/* Updated: 2023/10/09 16:09:21 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
// Return 1 if there is 'little' at the pos 'i' of 'big', or else 0.
static int match(const char *big, const char *little, size_t len, size_t i)
{
int j;
j = 0;
while (little[j])
{
if (len <= i || big[i] != little[j])
return (0);
i++;
j++;
}
return (1);
}
char *ft_strnstr(const char *big, const char *little, size_t len)
{
size_t i;
i = 0;
if (!little[0])
return ((char *)big);
if (!big[i] || i >= len)
return (NULL);
while (!match(big, little, len, i))
{
i++;
if (!big[i] || i >= len)
return (NULL);
}
return ((char *)big + i);
}

31
libft/ft_strrchr.c Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strrchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:43:17 by mcolonna #+# #+# */
/* Updated: 2023/10/10 13:16:58 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strrchr(const char *s, int c)
{
char *r;
int i;
r = NULL;
i = 0;
while (s[i])
{
if (s[i] == c)
r = (char *)s + i;
i++;
}
if (s[i] == c)
r = (char *)s + i;
return (r);
}

80
libft/ft_strtrim.c Normal file
View file

@ -0,0 +1,80 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:39:33 by mcolonna #+# #+# */
/* Updated: 2023/10/04 13:07:54 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static int is_in(char const c, char const *set)
{
int i;
i = 0;
while (set[i])
{
if (set[i] == c)
return (1);
i++;
}
return (0);
}
static size_t get_length(char const *s1, char const *set)
{
size_t i;
size_t r;
size_t tmp;
i = 0;
while (is_in(s1[i], set))
i++;
r = 0;
tmp = 0;
while (s1[i])
{
if (is_in(s1[i], set))
{
tmp++;
}
else
{
r += tmp;
tmp = 0;
r++;
}
i++;
}
return (r);
}
char *ft_strtrim(char const *s1, char const *set)
{
size_t len;
char *dest;
size_t start;
size_t i;
len = get_length(s1, set);
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
start = 0;
while (is_in(s1[start], set))
start++;
i = 0;
while (i < len)
{
dest[i] = s1[start + i];
i++;
}
dest[i] = '\0';
return (dest);
}

41
libft/ft_substr.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_substr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:17:12 by mcolonna #+# #+# */
/* Updated: 2023/10/09 13:27:30 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
char *dest;
size_t s_len;
size_t dest_len;
size_t i;
s_len = ft_strlen(s);
if (s_len < start)
dest_len = 0;
else if (s_len < start + len)
dest_len = s_len - start;
else
dest_len = len;
dest = malloc((dest_len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (i < dest_len)
{
dest[i] = s[start + i];
i++;
}
dest[i] = '\0';
return (dest);
}

18
libft/ft_tolower.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:53:06 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:58:02 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_tolower(int c)
{
if (c >= 'A' && c <= 'Z')
return (c - 'A' + 'a');
return (c);
}

18
libft/ft_toupper.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:53:06 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:56:52 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
return (c - 'a' + 'A');
return (c);
}

196
libft/libft.h Normal file
View file

@ -0,0 +1,196 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 11:46:15 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:11:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <stddef.h>
# include <limits.h>
///// CHAR /////
// (In libc) Return 1 if the char 'c' is a specific type of char, or else 0.
int ft_isalpha(int c); // A-Za-z
int ft_isdigit(int c); // 0-9
int ft_isalnum(int c); // A-Za-z0-9
int ft_isascii(int c); // (0)-(127)
int ft_isprint(int c); // (32)-(126)
// (In libc) Return the uppercase/lowercase version of the letter,
// or the char itself if it's not a letter.
int ft_toupper(int c);
int ft_tolower(int c);
///// STR /////
// (In libc) Compare 2 strings until n
int ft_strncmp(const char *s1, const char *s2, size_t n);
// (In libc) Return the length of the string 's'.
size_t ft_strlen(const char *s);
// (In libc) Copy/Append src on dst.
// 'dst' will be 'size' chars max, including \0,
// except if 'dst' is already longer for strlcat().
// 1. Never do more than size.
// 2. Always end by \0, except if it doesn't respect 1.
size_t ft_strlcpy(char *dst, const char *src, size_t size);
size_t ft_strlcat(char *dst, const char *src, size_t size);
// (In libc) Return a pointer to the first of last char 'c' in 's',
// or return NULL if there aren't any.
char *ft_strchr(const char *s, int c); // First char.
char *ft_strrchr(const char *s, int c); // Last char.
// (In libc) Return a pointer to the first occurence
// of string 'little' in string 'big'.
// Don't look chars after 'size'.
char *ft_strnstr(const char *big, const char *little, size_t len);
// (In libc) Return an malloced duplicate of 's'.
// Uses: malloc
// Error: return NULL
char *ft_strdup(const char *s);
// (Perso) Apply 'f' on each char of the string 's' and returns the result.
// Uses: malloc
// Error: return NULL
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
// (Perso) Call 'f' for each char of 's'.
void ft_striteri(char *s, void (*f)(unsigned int, char *));
// (Perso) Return the substring of 's' which starts at 'start'
// and is of length 'len'.
// Don't take chars after the end of the string.
// Uses: malloc
// Error: return NULL
char *ft_substr(char const *s, unsigned int start, size_t len);
// (Perso) Concatenate the two strings.
// Uses: malloc
// Error: return NULL
char *ft_strjoin(char const *s1, char const *s2);
// (Perso) Remove the characters 'set' from the beginning
// and the end of the string.
// Uses: malloc
// Error: return NULL
char *ft_strtrim(char const *s1, char const *set);
// (Perso) Split 's' by the chars 'c'.
// Return an array ended by NULL.
// Uses: malloc
// Error: return NULL
char **ft_split(char const *s, char c);
///// MEM /////
// (In libc) Fills 's' with 'n' times the char 'c'.
// Return 'c'.
void *ft_memset(void *s, int c, size_t n);
// (In libc) Just ft_memset(s, '\0', n) lol.
void ft_bzero(void *s, size_t n);
// (In libc) Copy 'n' bytes from 'src' to 'dest'.
// The 'src' and 'dest' areas mustn't overlap.
// Return 'dest'.
void *ft_memcpy(void *dest, const void *src, size_t n);
// (In libc) Same, but the areas can overlap.
// Return 'dest'.
void *ft_memmove(void *dest, const void *src, size_t n);
// (In libc) Find the character 'c' in 's', 's' being of length 'n'.
// NULL if none.
void *ft_memchr(const void *s, int c, size_t n);
// (In libc) Compare 'n' bytes of 's1' and 's2'.
int ft_memcmp(const void *s1, const void *s2, size_t n);
// (In libc) Alloc an array of 'size' elements with each element
// being of size 'size'.
// Uses: malloc
// Error: return NULL
void *ft_calloc(size_t nmemb, size_t size);
///// CAST /////
// (In libc) Cast a string to an int.
// /[ \f\n\r\t\v]*[-+]?[0-9]*.*/
int ft_atoi(const char *nptr);
// (Perso) Cast an int to a string.
// Uses: malloc
// Error: return NULL
char *ft_itoa(int n);
///// WRITE /////
// (Perso) Write the char/string on the file descriptor 'fd'.
// Uses: write
void ft_putchar_fd(char c, int fd);
void ft_putstr_fd(char *s, int fd);
// (Perso) Write the string 's' followed by a newline.
// Uses: write
void ft_putendl_fd(char *s, int fd);
// (Perso) Write the number 'n'.
// Uses: write
void ft_putnbr_fd(int n, int fd);
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
///// BONUS /////
// Create an malloced list of size = 1: {content}
// Uses: malloc
// Error: return NULL
t_list *ft_lstnew(void *content);
// Add 'new' at the beginning of the list.
void ft_lstadd_front(t_list **lst, t_list *new);
// Get the length of the list.
int ft_lstsize(t_list *lst);
// Return the last node of the list.
t_list *ft_lstlast(t_list *lst);
// Add 'new' at the end of the list.
void ft_lstadd_back(t_list **lst, t_list *new);
// Apply 'del' on the element's content, then free lst.
// Uses: free
void ft_lstdelone(t_list *lst, void (*del)(void *));
// Free every element's content with del and free the elements.
// *lst will be set to NULL.
// Uses: free
void ft_lstclear(t_list **lst, void (*del)(void *));
// Apply f on the content of each node.
void ft_lstiter(t_list *lst, void (*f)(void *));
// Apply f on the content of each node
// and create a new list with the resulting contents.
// Uses: free, malloc
// Error: return NULL
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
#endif

View file

@ -6,7 +6,7 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/02 15:45:49 by mcolonna #+# #+# */
/* Updated: 2024/10/04 15:10:50 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 12:44:12 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -26,9 +26,11 @@ int main(int argc, char *argv[])
success = map_from_file(&map, argv[1]);
printf("--> Success: %i <--\n", success);
if (success)
{
printf("C 0x%08x\nF 0x%08x\nEA %s\nWE %s\nNO %s\nSO %s\n",
map.color_ceiling, map.color_floor,
map.texture_east, map.texture_west,
map.texture_north, map.texture_south);
map_destroy(&map);
map_destroy(&map);
}
}

View file

@ -6,7 +6,7 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/01 17:12:58 by mcolonna #+# #+# */
/* Updated: 2024/10/04 15:25:32 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 13:11:43 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,18 +14,41 @@
#include "map_utils.h"
#include "stream.h"
#include "read_all_text.h"
#include "libft.h"
#include <util.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
static bool map_from_file2(t_map *dest, t_stream *stream, int fd)
{
bool success;
stream->i = 0;
success = read_map(dest, stream);
if (success)
{
success = check_map(dest);
if (!success)
map_destroy(dest);
}
close(fd);
free((void *)stream->str);
return (success);
}
bool map_from_file(t_map *dest, const char *file)
{
int fd;
t_stream stream;
bool err;
if (ft_strncmp(file + ft_strlen(file) - 4, ".cub", 5))
{
write_err("File extension must be .cub\n", NULL);
return (false);
}
fd = open(file, O_RDONLY);
if (fd < 0)
{
@ -37,12 +60,10 @@ bool map_from_file(t_map *dest, const char *file)
if (!stream.str)
{
write_err("Can't read file.\n", NULL);
close(fd);
return (false);
}
stream.i = 0;
err = read_map(dest, &stream);
free((void *)stream.str);
return (err);
return (map_from_file2(dest, &stream, fd));
}
void map_destroy(t_map *map)
@ -53,3 +74,50 @@ void map_destroy(t_map *map)
free((void *)map->texture_south);
free(map->cases);
}
static bool check_map2(const t_map *map, unsigned int x, unsigned int y)
{
unsigned int x2;
unsigned int y2;
const t_map_case *c;
c = &map->cases[y * map->width + x];
if (c->inside && c->wall != WALL)
{
if (x == 0 || x == map->width - 1
|| y == 0 || y == map->height - 1)
return (write_err("Map is not surrounded by walls\n", NULL), false);
x2 = x - 2;
while (++x2 < x + 2)
{
y2 = y - 2;
while (++y2 < y + 2)
{
if (x < map->width && y < map->height
&& !map->cases[y2 * map->width + x2].inside)
return (write_err("Map is not surrounded by walls\n", NULL),
false);
}
}
}
return (true);
}
// TODO check player
bool check_map(const t_map *map)
{
unsigned int x;
unsigned int y;
x = -1;
while (++x < map->width)
{
y = -1;
while (++y < map->height)
{
if (!check_map2(map, x, y))
return (false);
}
}
return (true);
}

View file

@ -6,7 +6,7 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/04 12:05:21 by mcolonna #+# #+# */
/* Updated: 2024/10/04 15:23:28 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 11:59:02 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,11 +14,11 @@
#include <stdlib.h>
const t_map_mapping_element g_map_mapping[] = {
{' ', {EMPTY, {NULL, NULL, NULL, NULL}}},
{'0', {EMPTY, {NULL, NULL, NULL, NULL}}},
{'1', {WALL, {NULL, NULL, NULL, NULL}}},
{'N', {EMPTY, {NULL, NULL, NULL, NULL}}}, // TODO add player object
{'S', {EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'E', {EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'W', {EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'\0', {EMPTY, {NULL, NULL, NULL, NULL}}}};
{' ', {false, EMPTY, {NULL, NULL, NULL, NULL}}},
{'0', {true, EMPTY, {NULL, NULL, NULL, NULL}}},
{'1', {true, WALL, {NULL, NULL, NULL, NULL}}},
{'N', {true, EMPTY, {NULL, NULL, NULL, NULL}}}, // TODO add player object
{'S', {true, EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'E', {true, EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'W', {true, EMPTY, {NULL, NULL, NULL, NULL}}}, // --
{'\0', {true, EMPTY, {NULL, NULL, NULL, NULL}}}};

View file

@ -6,7 +6,7 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/03 15:02:09 by mc #+# #+# */
/* Updated: 2024/10/04 15:28:06 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 13:32:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -62,10 +62,9 @@ bool read_string_parameter(const char *name, const char **dest,
if (!err && *dest)
{
*redefined = true;
write_err("Parameter '", name, "' was defined several times\n",
NULL);
write_err("Parameter '", name, "' was defined several times\n", NULL);
}
if (err || (!err && *dest))
if (*redefined || err)
{
*stream = old;
free(r);
@ -96,8 +95,7 @@ bool read_map(t_map *dest, t_stream *stream)
rdf = false;
while (!rdf && !err && stream->str[stream->i])
{
if (true
&& (read_expected_string("\n", stream, &err), err)
if ((read_expected_string("\n", stream, &err), err)
&& !read_string_parameter("NO", &dest->texture_north, stream, &rdf)
&& !read_string_parameter("SO", &dest->texture_south, stream, &rdf)
&& !read_string_parameter("WE", &dest->texture_west, stream, &rdf)
@ -106,11 +104,12 @@ bool read_map(t_map *dest, t_stream *stream)
&& !read_color_parameter("C", &dest->color_ceiling, stream, &rdf))
{
err = !read_map_description(dest, stream);
return (!err);
break ;
}
err = false;
}
if (!rdf && !dest->cases)
write_err("Map description missing\n", NULL);
err = (write_err("Map description missing\n", NULL), true);
(rdf || err) && (map_destroy(dest), false);
return (!err && !rdf && dest->cases);
}

View file

@ -3,15 +3,16 @@
/* ::: :::::::: */
/* read_all_text.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mc <mc@student.42.fr> +#+ +:+ +#+ */
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/02 16:18:35 by mcolonna #+# #+# */
/* Updated: 2024/10/03 14:20:37 by mc ### ########.fr */
/* Updated: 2024/10/10 12:38:19 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "read_all_text.h"
#include "util.h"
#include "libft.h"
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
@ -27,7 +28,7 @@
/// @return true if success, false if error.
static bool strconcat(char **dest, char *src, int n)
{
const int len_dest = getlen(*dest);
const int len_dest = ft_strlen(*dest);
char *old_dest;
int i;
@ -59,7 +60,7 @@ static char *add_endline_if_necessary(char *str)
{
char *endline;
if (str[0] == '\0' || str[getlen(str) - 1] == '\n')
if (str[0] == '\0' || str[ft_strlen(str) - 1] == '\n')
return (str);
endline = malloc(1 * sizeof(char));
if (!endline)

View file

@ -6,24 +6,15 @@
/* By: mcolonna <mcolonna@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/03 14:19:38 by mc #+# #+# */
/* Updated: 2024/10/04 15:26:32 by mcolonna ### ########.fr */
/* Updated: 2024/10/10 12:38:42 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "util.h"
#include "libft.h"
#include <stdarg.h>
#include <unistd.h>
int getlen(const char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}
void write_err(const char *str, ...)
{
va_list args;
@ -32,7 +23,7 @@ void write_err(const char *str, ...)
write(2, "Error\n", 6);
while (str)
{
write(2, str, getlen(str));
write(2, str, ft_strlen(str));
str = va_arg(args, const char *);
}
}

View file

@ -1,19 +1,12 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
SO jde:
WE weeeee
SO south2
11111
10N01
10001
11111

View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
1111111
1000001
10W0001
1000001
1111111

View file

@ -1,15 +1,6 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee

View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
1101111
1000001
10W0001
1000001
1111111

View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
0111111
1000001
10W0001
1000001
1111111

View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
111111
1000001
10W0001
1000001
1111111

View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
1111111
1000001
10W0 01
1000001
1111111

11
testmaps/good.cub Normal file
View file

@ -0,0 +1,11 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
1111111
1000001
10W0001
1000001
1111111

View file

@ -0,0 +1,19 @@
F 255,127,0
EA eastimage
NO theimageforthenorthwall
C 0,2,67
SO SOUTH!!!!!!1
WE weeeee
111
111 101
111 101111101
101111101100001
100001101101111
1111111111101100101
1000000000101110101
11011111110W00010101
1001 10000010101
1111 111111100000001111111
110000000000100000001
111111111111111111111