libft strlen

Makefile

@@ -6,7 +6,7 @@
 #    By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2025/07/18 12:51:21 by lud-adam          #+#    #+#              #
-#    Updated: 2026/03/28 15:07:38 by lud-adam         ###   ########.fr        #
+#    Updated: 2026/03/29 14:43:31 by lud-adam         ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -22,13 +22,15 @@ P_OBJ = .obj/
 P_INC = inc/
 P_LIBFT = libft/
 
-SRC = main.c \
+SRC =  \
-      get_next_line.c \
+	main.c \
-      fill_array.c \
+	get_next_line.c \
-      check_input.c \
+	fill_vector.c \
-			print_board.c	\
+	check_input.c \
-			ai.c \
+	print_board.c	\
-			game.c
+	ai.c \
+	game.c \
+	vector.c
 
 SRCS = $(addprefix $(P_SRC), $(SRC))
 OBJS = $(patsubst $(P_SRC)%.c,$(P_OBJ)%.o,$(SRCS))
@@ -50,9 +52,11 @@ $(LIBFT):
 
 clean:
 	rm -rf $(P_OBJ)
+	$(MAKE) -C $(P_LIBFT) clean
 
 fclean: clean
 	rm -f $(NAME)
+	$(MAKE) -C $(P_LIBFT) fclean
 
 re: fclean all
 

alcu.map

@@ -1,10 +0,0 @@
-2
-9
-10
-5
-9
-8
-2
-1
-8
-10

compile_commands.json

@@ -1,53 +0,0 @@
-[
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/main.c",
-   "-o",
-   ".obj/main.o"
-  ],
-  "file": "src/main.c"
- },
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/fill_array.c",
-   "-o",
-   ".obj/fill_array.o"
-  ],
-  "file": "src/fill_array.c"
- },
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/check_input.c",
-   "-o",
-   ".obj/check_input.o"
-  ],
-  "file": "src/check_input.c"
- }
-]

inc/alcu.h

@@ -6,20 +6,24 @@
 /*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/03/28 13:27:29 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 21:41:55 by dgaillet         ###   ########lyon.fr   */
+/*   Updated: 2026/03/29 14:58:00 by lud-adam         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef ALCU_H
-# define ALCU_H
+#define ALCU_H
 
-# include <stddef.h>
+#include "vector.h"
 
-char	*read_file(int fd);
+#include <stdbool.h>
-int		check_input(int fd);
+#include <stddef.h>
-void	print_board(int *game_state, size_t nb_line);
+
-int		*fill_array(int fd, int size);
+char *read_file(int fd);
-int		ai(int *gamestate, int nb_line);
+bool check_input(t_vector *lines);
-void	game(int *lines, int size);
+void print_board(int *game_state, size_t nb_line);
+bool fill_vector(t_vector *lines, int fd);
+int ai(int *gamestate, int nb_line);
+bool game(int *lines, int size);
+int *fill_array(t_vector *lines, int *size);
 
 #endif

inc/compile_commands.json

@@ -0,0 +1 @@
+[]

inc/vector.h

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   vector.h                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/29 14:24:01 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 14:40:21 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <stdbool.h>
+#define VECTOR_INIT_CAPACITY 6
+#define UNDEFINE -1
+#define SUCCESS 0
+
+typedef struct s_vector_list {
+  void **items;
+  int capacity;
+  int total;
+} t_vector_list;
+
+typedef struct s_vector t_vector;
+
+struct s_vector {
+  t_vector_list vector_list; /**< List to store vector elements */
+  int (*pfVectorTotal)(
+      t_vector *); /**< Retrieves the total number of elements in the vector */
+  int (*pfVectorResize)(t_vector *,
+                        int); /**< Resizes the vector to a new capacity */
+  int (*pfVectorAdd)(t_vector *, void *); /**< Adds an element to the vector */
+  int (*pfVectorSet)(
+      t_vector *, int,
+      void *); /**< Sets an element at a specific index in the vector */
+  void *(*pfVectorGet)(t_vector *,
+                       int); /**< Retrieves an element from the vector */
+  int (*pfVectorDelete)(t_vector *,
+                        int); /**< Deletes an element from the vector */
+  int (*pfVectorFree)(
+      t_vector *); /**< Frees the memory allocated for the vector */
+};
+
+bool vector_init(t_vector *v);
+
+#endif

libft/ft_strlen.c

@@ -12,14 +12,11 @@
 
 #include "libft.h"
 
-size_t	ft_strlen(char *str, char c)
+size_t ft_strlen(const char *s) {
-{
+  size_t i;
-	size_t	i;
 
-	i = 0;
+  i = 0;
-	if (!str)
+  while (s[i])
-		return (0);
+    i++;
-	while (str[i] && str[i] != c)
+  return (i);
-		i++;
-	return (i);
 }

map_gen.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-if [ $# -lt 2 ]; then
-	echo "usage: bash map_gen.sh [size] [range]"
-	exit 1
-fi
-
-unset var
-for i in $( seq 1 $1 )
-do
-	var+="\n$(( RANDOM % $2 + 1))"
-done
-var="${var}\n";
-echo -e $var | tail -n +2
-

src/check_input.c

@@ -12,30 +12,31 @@
 
 #include "../libft/libft.h"
 #include "get_next_line.h"
+#include "vector.h"
+
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <stdbool.h>
 
-int	check_input(int fd)
+bool	check_input(t_vector* lines)
 {
 	int		i;
 	int		j;
-	char	*line;
+	char* line;
 
-	line = NULL;
-	line = get_next_line(fd);
 	j = 0;
-	while (line != NULL)
+	line = NULL;
+	while (j < lines->pfVectorTotal(lines))
 	{
+		line = (char*)lines->pfVectorGet(lines, j);
 		i = -1;
 		while (line[++i])
-			if (!(line[i] >= '0' && line[i] <= '9') && line[i] != '\n')
+			if ((!(line[i] >= '0' && line[i] <= '9') && line[i] != '\n') || i > 5)
-				return (free(line), -1);
+				return (false);
 		if (ft_atoi(line) < 1 || ft_atoi(line) > 10000)
-			return (free(line), -1);
+			return (false);
-		free(line);
 		j++;
-		line = get_next_line(fd);
 	}
-	return (j);
+	return (true);
 }

src/fill_array.c

@@ -1,35 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   fill_array.c                                       :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2026/03/28 13:21:46 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 20:53:02 by dgaillet         ###   ########lyon.fr   */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "../libft/libft.h"
-#include "get_next_line.h"
-
-int	*fill_array(int fd, int size)
-{
-	int		*res;
-	char	*line;
-	int		i;
-
-	res = malloc(sizeof(int) * size);
-	if (res == NULL)
-		return (NULL);
-	line = get_next_line(fd);
-	i = 0;
-	while (line != NULL)
-	{
-		res[i] = ft_atoi(line);
-		i++;
-		free(line);
-		line = get_next_line(fd);
-	}
-	return (res);
-}

src/fill_vector.c

@@ -0,0 +1,57 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   fill_vector.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/28 13:21:46 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 16:31:19 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../libft/libft.h"
+
+#include "get_next_line.h"
+
+#include "alcu.h"
+#include <stdbool.h>
+
+bool fill_vector(t_vector *lines, int fd) {
+  char *line;
+
+  line = get_next_line(fd);
+  if (!line)
+    return (false);
+  while (line != NULL) {
+    if (!ft_strncmp("\n", line, ft_strlen(line))) {
+      free(line);
+      return (true);
+    }
+    if (lines->pfVectorAdd(lines, line) == UNDEFINE) {
+      free(line);
+      return (false);
+    }
+    line = get_next_line(fd);
+  }
+  return (false);
+}
+
+int *fill_array(t_vector *lines, int *size) {
+  int *res;
+  int i;
+  char *line;
+
+  i = 0;
+  line = NULL;
+  *size = lines->pfVectorTotal(lines);
+  res = malloc(sizeof(int) * *size);
+  if (!res)
+    return (NULL);
+  while (i < *size) {
+    line = (char *)lines->pfVectorGet(lines, i);
+    res[i] = ft_atoi(line);
+    i++;
+  }
+  return (res);
+}

src/game.c

@@ -14,103 +14,94 @@
 #include "alcu.h"
 #include "get_next_line.h"
 
-static int	check_char_int(char *str)
+static int check_char_int(char *str) {
-{
+  int i;
-	int	i;
 
-	i = -1;
+  i = -1;
-	while (str[++i] && i < 100)
+  while (str[++i] && i < 100)
-		if (!(str[i] >= '0' && str[i] <= '9') && str[i] != '\n')
+    if (!(str[i] >= '0' && str[i] <= '9') && str[i] != '\n')
-			return (0);
+      return (0);
-	return (1);
+  return (1);
 }
 
-static int	play_choice(int *line, int choice)
+static int play_choice(int *line, int choice) {
-{
+  if (choice > 0 && choice < 4) {
-	if (choice > 0 && choice < 4)
+    if (choice > *line) {
-	{
+      ft_putstr_fd("-\nInvalid choice\n", 1);
-		if (choice > *line)
+      return (0);
-		{
+    }
-			ft_putstr_fd("-\nInvalid choice\n", 1);
+    *line -= choice;
-			return (0);
+    return (1);
-		}
+  } else {
-		*line -= choice;
+    ft_putstr_fd("-\nInvalid choice\n", 1);
-		return (1);
+    return (0);
-	}
+  }
-	else
-	{
-		ft_putstr_fd("-\nInvalid choice\n", 1);
-		return (0);
-	}
 }
 
-static void	player_turn(int *line)
+static bool player_turn(int *line) {
-{
+  char *temp;
-	char	*temp;
+  int choice;
-	int		choice;
 
-	while (1)
+  while (1) {
-	{
+    ft_putstr_fd("\nPlease choose between 1 and 3 items\n", 1);
-		ft_putstr_fd("\nPlease choose between 1 and 3 items\n", 1);
+    temp = get_next_line(0);
-		temp = get_next_line(0);
+    if (!temp)
-		if (temp && ft_strlen(temp) > 0)
+      return (false);
-		{
+    if (temp && ft_strlen(temp) > 0) {
-			if (!check_char_int(temp))
+      if (!check_char_int(temp)) {
-			{
+        free(temp);
-				free(temp);
+        continue;
-				continue ;
+      }
-			}
+      choice = ft_atoi(temp);
-			choice = ft_atoi(temp);
+      if (play_choice(line, choice))
-			if (play_choice(line, choice))
+        break;
-				break ;
+    } else
-		}
+      ft_putstr_fd("-\nInvalid choice\n", 1);
-		else
+    if (temp)
-			ft_putstr_fd("-\nInvalid choice\n", 1);
+      free(temp);
-		if (temp)
+  }
-			free(temp);
+  if (temp)
-	}
+    free(temp);
+  return (true);
 }
 
-static void	play_turns(int *lines, int i, int *ai_turn, int size)
+static bool play_turns(int *lines, int i, int *ai_turn, int size) {
-{
+  int choice;
-	int	choice;
 
-	while (lines[i] != 0)
+  while (lines[i] != 0) {
-	{
+    ft_putstr_fd("\n------------------------------\n", 1);
-		ft_putstr_fd("\n------------------------------\n", 1);
+    if (!*ai_turn) {
-		if (!*ai_turn)
+      print_board(lines, size);
-		{
+      if (player_turn(&lines[i]) == false)
-			print_board(lines, size);
+        return (false);
-			player_turn(&lines[i]);
+    } else {
-		}
+      print_board(lines, size);
-		else
+      ft_putstr_fd("\n", 1);
-		{
+      choice = ai(lines, size);
-			print_board(lines, size);
+      ft_putstr_fd("AI play ", 1);
-			ft_putstr_fd("\n", 1);
+      ft_putnbr_fd(choice, 1);
-			choice = ai(lines, size);
+      ft_putstr_fd("\n", 1);
-			ft_putstr_fd("AI play ", 1);
+      lines[i] -= choice;
-			ft_putnbr_fd(choice, 1);
+    }
-			ft_putstr_fd("\n", 1);
+    *ai_turn = *ai_turn == 0;
-			lines[i] -= choice;
+  }
-		}
+  return (true);
-		*ai_turn = *ai_turn == 0;
-	}
 }
 
-void	game(int *lines, int size)
+bool game(int *lines, int size) {
-{
+  int ai_turn;
-	int	ai_turn;
+  int i;
-	int	i;
 
-	ai_turn = 1;
+  ai_turn = 1;
-	i = size - 1;
+  i = size - 1;
-	while (i >= 0)
+  while (i >= 0) {
-	{
+    if (play_turns(lines, i, &ai_turn, size) == false)
-		play_turns(lines, i, &ai_turn, size);
+      return (false);
-		i--;
+    i--;
-	}
+  }
-	if (!ai_turn)
+  if (!ai_turn)
-		ft_putstr_fd("AI win ! It will replace you\n", 1);
+    ft_putstr_fd("AI win ! It will replace you\n", 1);
-	else
+  else
-		ft_putstr_fd("You win ! Well done\n", 1);
+    ft_putstr_fd("You win ! Well done\n", 1);
+  return (true);
 }

src/get_next_line.c

@@ -10,129 +10,116 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "../libft/libft.h"
 #include "get_next_line.h"
+#include "../libft/libft.h"
 
-size_t	ft_strlen_with_c(char *str, char c)
+size_t ft_strlen_with_c(char *str, char c) {
-{
+  size_t i;
-	size_t	i;
 
-	i = 0;
+  i = 0;
-	if (!str)
+  if (!str)
-		return (0);
+    return (0);
-	while (str[i] && str[i] != c)
+  while (str[i] && str[i] != c)
-		i++;
+    i++;
-	return (i);
+  return (i);
 }
 
-size_t	detect_newline(char *str)
+size_t detect_newline(char *str) {
-{
+  size_t i;
-	size_t	i;
 
-	i = 0;
+  i = 0;
-	if (!str)
+  if (!str)
-		return (0);
+    return (0);
-	while (str[i])
+  while (str[i]) {
-	{
+    if (str[i] == '\n')
-		if (str[i] == '\n')
+      return (1);
-			return (1);
+    i++;
-		i++;
+  }
-	}
+  return (0);
-	return (0);
 }
 
-static void	fill_line(char *line, char *c_remaining, char *src, size_t *index)
+static void fill_line(char *line, char *c_remaining, char *src, size_t *index) {
-{
+  size_t i;
-	size_t	i;
+  size_t j;
-	size_t	j;
 
-	i = 0;
+  i = 0;
-	j = 0;
+  j = 0;
-	while (c_remaining && c_remaining[i])
+  while (c_remaining && c_remaining[i]) {
-	{
+    line[i] = c_remaining[i];
-		line[i] = c_remaining[i];
+    i++;
-		i++;
+  }
-	}
+  while (src[j] && src[j] != '\n') {
-	while (src[j] && src[j] != '\n')
+    line[i + j] = src[j];
-	{
+    src[j] = 0;
-		line[i + j] = src[j];
+    j++;
-		src[j] = 0;
+  }
-		j++;
+  if (src[j] == '\n')
-	}
+    line[i + j] = '\n';
-	if (src[j] == '\n')
+  *index = j;
-		line[i + j] = '\n';
-	*index = j;
 }
 
-char	*build_line(char *src, char *c_remaining, size_t *index)
+char *build_line(char *src, char *c_remaining, size_t *index) {
-{
+  char *line;
-	char	*line;
+  size_t size;
-	size_t	size;
+  size_t is_jump;
-	size_t	is_jump;
 
-	is_jump = detect_newline(src);
+  is_jump = detect_newline(src);
-	size = ft_strlen_with_c(src, '\n') + ft_strlen_with_c(c_remaining, '\0')
+  size = ft_strlen_with_c(src, '\n') + ft_strlen_with_c(c_remaining, '\0') +
-		+ is_jump + 1;
+         is_jump + 1;
-	line = ft_calloc(size, sizeof(char));
+  line = ft_calloc(size, sizeof(char));
-	if (!line)
+  if (!line) {
-	{
+    free(c_remaining);
-		free(c_remaining);
+    return (NULL);
-		return (NULL);
+  }
-	}
+  if (!src)
-	if (!src)
+    return (NULL);
-		return (NULL);
+  fill_line(line, c_remaining, src, index);
-	fill_line(line, c_remaining, src, index);
+  if (c_remaining)
-	if (c_remaining)
+    free(c_remaining);
-		free(c_remaining);
+  return (line);
-	return (line);
 }
 
-static void	read_file(int fd, char *buffer, ssize_t *nb_read)
+static void read_file(int fd, char *buffer, ssize_t *nb_read) {
-{
+  *nb_read = read(fd, buffer, BUFFER_SIZE);
-	*nb_read = read(fd, buffer, BUFFER_SIZE);
+  if (*nb_read < 0)
-	if (*nb_read < 0)
+    return;
-		return ;
+  buffer[*nb_read] = '\0';
-	buffer[*nb_read] = '\0';
 }
 
-static char	*get_the_line(int fd, char *buffer)
+static char *get_the_line(int fd, char *buffer) {
-{
+  char *line;
-	char	*line;
+  size_t i;
-	size_t	i;
+  ssize_t nb_read;
-	ssize_t	nb_read;
 
-	i = 0;
+  i = 0;
-	nb_read = 0;
+  nb_read = 0;
-	line = NULL;
+  line = NULL;
-	if (buffer[0] != '\0')
+  if (buffer[0] != '\0') {
-	{
+    line = build_line(buffer, NULL, &i);
-		line = build_line(buffer, NULL, &i);
+    if (!line)
-		if (!line)
+      return (NULL);
-			return (NULL);
+    ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
-		ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
+  }
-	}
+  while (detect_newline(line) == 0) {
-	while (detect_newline(line) == 0)
+    read_file(fd, buffer, &nb_read);
-	{
+    if (nb_read < 0)
-		read_file(fd, buffer, &nb_read);
+      return (free(line), NULL);
-		if (nb_read < 0)
+    if (nb_read == 0)
-			return (free(line), NULL);
+      break;
-		if (nb_read == 0)
+    line = build_line(buffer, line, &i);
-			break ;
+    ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
-		line = build_line(buffer, line, &i);
+  }
-		ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
+  return (line);
-	}
-	return (line);
 }
 
-char	*get_next_line(int fd)
+char *get_next_line(int fd) {
-{
+  static char buffer[BUFFER_SIZE + 1] = "";
-	static char	buffer[BUFFER_SIZE + 1] = "";
+  char *line;
-	char		*line;
 
-	if (fd < 0 || BUFFER_SIZE <= 0)
+  if (fd < 0 || BUFFER_SIZE <= 0)
-		return (NULL);
+    return (NULL);
-	line = get_the_line(fd, buffer);
+  line = get_the_line(fd, buffer);
-	if (!line)
+  if (!line)
-		return (NULL);
+    return (NULL);
-	return (line);
+  return (line);
 }

src/main.c

@@ -6,53 +6,64 @@
 /*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/03/28 12:30:29 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 21:41:29 by dgaillet         ###   ########lyon.fr   */
+/*   Updated: 2026/03/29 16:31:17 by lud-adam         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../libft/libft.h"
 #include "alcu.h"
+
 #include <fcntl.h>
-#include <stdlib.h>
 #include <unistd.h>
 
-static int	get_fd(int argc, char **argv)
+static int get_fd(int argc, char **argv) {
-{
+  if (argc == 2) {
-	if (argc == 2)
+    return (open(argv[1], O_RDONLY));
-	{
+  } else if (argc == 1)
-		return (open(argv[1], O_RDONLY));
+    return (0);
-	}
+  else
-	else if (argc == 1)
+    return (-1);
-		return (0);
-	else
-		return (-1);
 }
 
-int	main(int argc, char *argv[])
+int main(int argc, char *argv[]) {
-{
-	int	fd;
-	int	size;
-	int	*lines;
 
-	fd = get_fd(argc, argv);
+  int fd;
-	if (fd < 0)
+  int size;
-	{
+  int *lines_int;
-		ft_putstr_fd("ERROR", 2);
+  t_vector lines;
-		return (1);
+
-	}
+  if (vector_init(&lines) == false) {
-	size = check_input(fd);
+    ft_putstr_fd("ERROR\n", 2);
-	if (size < 0)
+    return (1);
-	{
+  }
-		ft_putstr_fd("ERROR", 2);
+  fd = get_fd(argc, argv);
-		return (1);
+  lines_int = NULL;
-	}
+  size = 0;
-	close(fd);
+  if (fd < 0 || fill_vector(&lines, fd) == false) {
-	fd = open(argv[1], O_RDONLY);
+    lines.pfVectorFree(&lines);
-	lines = fill_array(fd, size);
+    ft_putstr_fd("ERROR\n", 2);
-	if (!lines)
+    return (1);
-		return (1);
+  }
-	game(lines, size);
+  if (check_input(&lines) == false) {
-	close(fd);
+    lines.pfVectorFree(&lines);
-	free(lines);
+    ft_putstr_fd("ERROR\n", 2);
-	return (0);
+    return (1);
+  }
+  lines_int = fill_array(&lines, &size);
+  lines.pfVectorFree(&lines);
+  if (!lines_int) {
+    lines.pfVectorFree(&lines);
+    ft_putstr_fd("ERROR\n", 2);
+    return (1);
+  }
+  close(fd);
+  if (open("/dev/tty", O_RDONLY) < 0 || game(lines_int, size) == false) {
+    free(lines_int);
+    ft_putstr_fd("ERROR\n", 2);
+    return (1);
+  }
+  if (fd != 0)
+    close(fd);
+  free(lines_int);
+  return (0);
 }

src/vector.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   vector.c                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/29 14:23:01 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 14:50:19 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "vector.h"
+#include "libft.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+int vector_resize(t_vector *v, int capacity);
+int vector_push_back(t_vector *v, void *item);
+int vector_set(t_vector *v, int index, void *item);
+void *vector_get(t_vector *v, int index);
+int vector_delete(t_vector *v, int index);
+int vector_free(t_vector *v);
+int vector_total(t_vector *v);
+
+bool vector_init(t_vector *v) {
+  v->pfVectorTotal = vector_total;
+  v->pfVectorResize = vector_resize;
+  v->pfVectorAdd = vector_push_back;
+  v->pfVectorSet = vector_set;
+  v->pfVectorGet = vector_get;
+  v->pfVectorFree = vector_free;
+  v->pfVectorDelete = vector_delete;
+  v->vector_list.capacity = VECTOR_INIT_CAPACITY;
+  v->vector_list.total = 0;
+  v->vector_list.items = malloc(sizeof(void *) * v->vector_list.capacity);
+  if (!v->vector_list.items) {
+    ft_putstr_fd("Memory allocation failed in vector_init\n", 2);
+    return (false);
+  }
+  return (true);
+}
+
+int vector_total(t_vector *v) {
+  int totalCount = UNDEFINE;
+  if (v) {
+    totalCount = v->vector_list.total;
+  }
+  return totalCount;
+}
+
+int vector_resize(t_vector *v, int capacity) {
+  int status = UNDEFINE;
+  if (v) {
+    void **items_copy = malloc(sizeof(void *) * capacity);
+    if (!items_copy)
+      return (status);
+    ft_memcpy(items_copy, v->vector_list.items,
+              sizeof(void *) * v->pfVectorTotal(v));
+    if (items_copy) {
+      free(v->vector_list.items);
+      v->vector_list.items = items_copy;
+      v->vector_list.capacity = capacity;
+      status = SUCCESS;
+    }
+  }
+  return (status);
+}
+
+int vector_push_back(t_vector *v, void *item) {
+  int status = UNDEFINE;
+  if (v) {
+    if (v->vector_list.capacity == v->vector_list.total) {
+      status = vector_resize(v, v->vector_list.capacity * 2);
+      if (status != UNDEFINE) {
+        v->vector_list.items[v->vector_list.total++] = item;
+      }
+    } else {
+      v->vector_list.items[v->vector_list.total++] = item;
+      status = SUCCESS;
+    }
+  }
+  return status;
+}
+
+int vector_set(t_vector *v, int index, void *item) {
+  int status = UNDEFINE;
+  if (v) {
+    if ((index >= 0) && (index < v->vector_list.total)) {
+      v->vector_list.items[index] = item;
+      status = SUCCESS;
+    }
+  }
+  return status;
+}
+
+void *vector_get(t_vector *v, int index) {
+  void *readData = NULL;
+  if (v) {
+    if ((index >= 0) && (index < v->vector_list.total)) {
+      readData = v->vector_list.items[index];
+    }
+  }
+  return readData;
+}
+
+int vector_delete(t_vector *v, int index) {
+  int status = UNDEFINE;
+  int i = 0;
+  if (v) {
+    if ((index < 0) || (index >= v->vector_list.total))
+      return status;
+    v->vector_list.items[index] = NULL;
+    for (i = index; (i < v->vector_list.total - 1); ++i) {
+      v->vector_list.items[i] = v->vector_list.items[i + 1];
+      v->vector_list.items[i + 1] = NULL;
+    }
+    v->vector_list.total--;
+    if ((v->vector_list.total > 0) &&
+        ((v->vector_list.total) == (v->vector_list.capacity / 4))) {
+      vector_resize(v, v->vector_list.capacity / 2);
+    }
+    status = SUCCESS;
+  }
+  return status;
+}
+
+int vector_free(t_vector *v) {
+  int status = UNDEFINE;
+  int total = v->pfVectorTotal(v);
+  if (v) {
+    for (int i = 0; i < total; i++) {
+      void *temp = v->pfVectorGet(v, i);
+      free(temp);
+    }
+    free(v->vector_list.items);
+  }
+  return status;
+}