Contributing

Code Style Guidelines

Cub3D follows the 42 school norm, a strict coding standard that ensures consistency and readability.

The 42 Norm

Function Length

Maximum 25 lines per function (excluding opening/closing braces)

Line Length

Maximum 80 columns per line

Functions per File

Maximum 5 functions per .c file (flexible for complex modules)

Variables

Maximum 4 variables per function, aligned declarations

Function Header Format

All functions must have the 42 header comment:

Example Header

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   filename.c                                         :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: username <username@student.42.fr>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: YYYY/MM/DD HH:MM:SS by username          #+#    #+#             */
/*   Updated: YYYY/MM/DD HH:MM:SS by username         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

Formatting Rules

Indentation
Braces
Naming
Forbidden

Use tabs for indentation, not spaces.

void	function_name(t_map *mapa)
{
	int		i;
	int		count;

	i = 0;
	while (i < 10)
	{
		count++;
		i++;
	}
}

One tab per indentation level
Align variable declarations with tabs
Use tabs between type and variable name

K&R style bracing:

// Functions: opening brace on new line
void	my_function(int param)
{
	// function body
}

// Control structures: opening brace on same line
if (condition)
{
	// body
}
else
{
	// body
}

while (condition)
{
	// body
}

Naming conventions:

// Functions: snake_case
void	init_dda(t_map *mapa);
int		perform_dda(t_map *mapa);

// Variables: snake_case
int		player_x;
double	ray_dir_x;

// Structures: prefix with s_, typedef with t_
typedef struct s_map
{
	int		width;
	int		height;
}			t_map;

// Macros: UPPER_CASE
# define WIDTH 1732
# define HEIGHT 1000

Not allowed in 42 norm:

for loops (use while instead)
switch statements
goto
Ternary operators ? :
Multiple assignments on one line
Variable declarations mixed with code
Comments using // (use /* */ only)
More than one statement per line

This codebase uses some non-norm features like // comments. These should be converted to /* */ style for strict compliance.

Example: Norm-Compliant Function

Good Example

void	calculate_wall_data(t_map *mapa, double *dist)
{
	if (mapa->side == 0)
		*dist = (mapa->map_x - mapa->xx + (1 - mapa->step_x) / 2)
			/ mapa->ray_dir_x / SIZE;
	else
		*dist = (mapa->map_y - mapa->yy + (1 - mapa->step_y) / 2)
			/ mapa->ray_dir_y / SIZE;
	mapa->line_height = (int)(HEIGHT / *dist);
	if (mapa->side == 0)
		mapa->wall_x = mapa->yy / SIZE + *dist * mapa->ray_dir_y;
	else
		mapa->wall_x = mapa->xx / SIZE + *dist * mapa->ray_dir_x;
	mapa->wall_x -= floor(mapa->wall_x);
}

Adding New Features

General Workflow

Plan the feature

Identify which module(s) need changes
Determine if new files are needed
Check if t_map structure needs new fields
Consider performance impact

Update header file

Add function declarations to cub3.h:

cub3.h

// Add new function declaration
void	new_feature_function(t_map *mapa);

// Add new structure fields if needed
typedef struct s_map
{
	// ... existing fields ...
	int		new_field;
}			t_map;

Implement the feature

Create or modify source files following the norm:

new_feature.c

#include "cub3.h"

void	new_feature_function(t_map *mapa)
{
	int		i;
	
	i = 0;
	/* Implementation */
}

Update Makefile

Add new source files to SRC variable:

Makefile

SRC = main.c utils.c ... new_feature.c

Initialize new fields

If you added fields to t_map, initialize them:

main.c:init_values()

mapa->new_field = 0;

Clean up resources

If your feature allocates memory, add cleanup:

freemem.c:freeall()

ft_memdel(map->new_allocated_field);

Example: Adding Minimap Feature

Here’s how to add a minimap display:

/* In structure definition */
typedef struct s_map
{
	/* ... existing fields ... */
	int		minimap_enabled;
	int		minimap_scale;
}			t_map;

/* Add function declaration */
void	draw_minimap(t_map *mapa);

Testing Changes

Build and Test Workflow

Clean build

make fclean
make

Ensure no compilation warnings or errors.

Test with valid maps

./cub3d maps/valid_map.cub

Test movement (W, A, S, D)
Test rotation (arrow keys)
Test window closing (ESC or X button)

Test with invalid maps

./cub3d maps/invalid_unclosed.cub
./cub3d maps/missing_texture.cub
./cub3d maps/invalid_rgb.cub

Verify appropriate error messages appear.

Memory check

valgrind --leak-check=full ./cub3d maps/valid_map.cub

Verify no memory leaks in your new code.

Edge cases

Test boundary conditions:

Empty maps
Very large maps
Player at map edges
Unusual texture sizes

Test Map Collection

Create a comprehensive test suite:

Test Script

#!/bin/bash

echo "Testing valid maps..."
for map in maps/valid/*.cub; do
    echo "Testing $map"
    timeout 5 ./cub3d "$map" || echo "FAILED: $map"
done

echo "\nTesting invalid maps (should error)..."
for map in maps/invalid/*.cub; do
    echo "Testing $map"
    ./cub3d "$map" 2>&1 | grep -q "Error" && echo "OK" || echo "FAILED: $map"
done

Common Test Cases

Valid Map Tests

Simple rectangular room
Complex maze
Large open area
Multiple rooms connected
Player facing each direction (N, S, E, W)
Different texture combinations
Various RGB color values

Invalid Map Tests

Map not closed by walls
Multiple players
No player
Invalid characters in map
Missing texture files
Invalid RGB values (greater than 255 or less than 0)
Duplicate attributes (two NO declarations)
Missing required attributes
Wrong file extension

Edge Cases

Player starting position at edge
1x1 room (minimum valid map)
Very long corridors
Texture file permissions issues
Extremely large maps (performance test)
Map with only player and walls (no spaces)

Build System

Makefile Targets

Available Commands

make          # Build cub3d executable
make all      # Same as make
make clean    # Remove object files
make fclean   # Remove objects and executable
make re       # Rebuild from scratch (fclean + all)

Makefile Structure

The Makefile automatically handles dependencies:

Makefile:27-36

all: $(MINILIBX) $(LIBFT) $(NAME)
$(NAME): $(MINILIBX) $(OBJS)
	$(CC) $(CFLAGS) -o $(NAME) $(OBJS) -L$(MINILIBX_DIR) -lmlx -L$(LIBFT_DIR) -lft -lm -lX11 -lXext

$(LIBFT):
	make -C $(LIBFT_DIR)

$(MINILIBX):
	make -C $(MINILIBX_DIR)

The Makefile rebuilds libft and minilibx as needed. If you make changes to libft functions, run make re in the libft directory, then make in the main directory.

Adding Compilation Flags

To add custom flags temporarily:

# Debug build without optimization
make CFLAGS="-Wall -Wextra -Werror -g -O0"

# Profile build
make CFLAGS="-Wall -Wextra -Werror -pg"

# Sanitizer build (detect memory errors)
make CFLAGS="-Wall -Wextra -Werror -g -fsanitize=address"

Common Development Tasks

Adding a New Utility Function

Choose appropriate utils file

utils.c - Map validation
utils2.c - String/map copying
utils3.c - Flood fill/map checking
utils4.c - Color validation
utils5.c - Window/input handling
utils6.c - Movement/rendering
utils7.c - Key events/drawing

Or create utils8.c for new category.

Declare in header

cub3.h

/* Add to appropriate section */
int		my_new_function(t_map *mapa, int param);

Implement function

utils8.c

#include "cub3.h"

int	my_new_function(t_map *mapa, int param)
{
	int		result;
	
	result = param * 2;
	return (result);
}

Update Makefile if new file

SRC = main.c ... utils7.c utils8.c freemem.c ...

Modifying the t_map Structure

Changing t_map requires updating multiple locations:

Structure definition in cub3.h
Initialization in init_values() (main.c)
Cleanup in freeall() if pointer (freemem.c)

Adding a Field

/* 1. In cub3.h:79-162 */
typedef struct s_map
{
	/* ... existing fields ... */
	int		my_new_field;  /* Add new field */
}			t_map;

/* 2. In main.c:init_values() */
void	init_values(t_map *mapa)
{
	/* ... existing initialization ... */
	mapa->my_new_field = 0;  /* Initialize */
}

/* 3. In freemem.c:freeall() - only if pointer */
void	freeall(t_map *map)
{
	freetextures(map);
	freeme(map->toflood_map);
	freeme(map->final_map);
	ft_memdel(map->my_new_field);  /* Free if allocated */
}

Adding New Map Attributes

To add support for new .cub file attributes (e.g., FLOOR_TEXTURE):

Add to t_map structure

cub3.h

typedef struct s_map
{
	/* ... */
	char	*floor_texture_path;
}			t_map;

Parse in parselineutils.c

parselineutils.c:check_array_for_atributes()

if (!ft_strcmp(arr[0], "FT"))  /* FT = Floor Texture */
{
	if (map->floor_texture_path)
		return (msg(2, MAP_ARG_DUP), 1);
	map->floor_texture_path = ft_strdup(arr[1]);
}

Validate in all_atributes_asigned()

parselineutils.c:55-62

if (map->northtexture && map->southtexture && map->easttexture
    && map->westtexture && map->floorcolor && map->ceilingcolor
    && map->floor_texture_path)  /* Add check */
    return (1);

Add cleanup

freemem.c:freetextures()

ft_memdel(map->floor_texture_path);

Where to Find Help

Documentation

MiniLibX

Check the MiniLibX documentation in minilibx-linux/ directory

Raycasting Tutorial

Lode’s Raycasting Tutorial

42 Norm

Official 42 norm PDF (available in your 42 cluster)

libft Functions

Reference your own libft implementation in libft/ directory

Code References

Use grep to find usage examples:

Finding Examples

# Find all uses of a function
grep -rn "mlx_new_window" .

# Find all map validation code
grep -rn "flood_fill" .

# Find error handling patterns
grep -rn "freeall" .

# Find structure field usage
grep -rn "mapa->ray_dir_x" .

Key Source Files for Reference

Task	Reference File	Key Functions
Initialization	`main.c:15-72`	`init_values()`, `cubed_init()`
Raycasting	`raycasting.c`	`raycasting()`, `perform_dda()`
Rendering	`drawing.c`	`draw_3d_dda()`, `draw_wall()`
Movement	`utils6.c:29-91`	`move_cubed()`, `cubed_render()`
Parsing	`parselineutils.c`	`parsefloorceilingdirections()`
Memory	`freemem.c`	`freeall()`, `freeme()`
Validation	`utils3.c`	`flood_fill()`, `checkclosemap()`

Debugging Resources

See the Debugging page for:

GDB usage with raycasting
Valgrind memory checking
Common error solutions
Performance profiling

Pre-submission Checklist

Always run make fclean && make before final submission to ensure a clean build from scratch.

Get Started

Core Concepts

User Guide

Technical Reference

Development

Contributing

Code Style Guidelines

The 42 Norm

Function Length

Line Length

Functions per File

Variables

Function Header Format

Formatting Rules

Example: Norm-Compliant Function

Adding New Features

General Workflow

Example: Adding Minimap Feature

Testing Changes

Build and Test Workflow

Test Map Collection

Common Test Cases

Build System

Makefile Targets

Makefile Structure

Adding Compilation Flags

Common Development Tasks

Adding a New Utility Function

Modifying the t_map Structure

Adding New Map Attributes

Where to Find Help

Documentation

MiniLibX

Raycasting Tutorial

42 Norm

libft Functions

Code References

Key Source Files for Reference

Debugging Resources

Pre-submission Checklist

Get Started

Core Concepts

User Guide

Technical Reference

Development

​Code Style Guidelines

​The 42 Norm

Function Length

Line Length

Functions per File

Variables

​Function Header Format

​Formatting Rules

​Example: Norm-Compliant Function

​Adding New Features

​General Workflow

​Example: Adding Minimap Feature

​Testing Changes

​Build and Test Workflow

​Test Map Collection

​Common Test Cases

​Build System

​Makefile Targets

​Makefile Structure

​Adding Compilation Flags

​Common Development Tasks

​Adding a New Utility Function

​Modifying the t_map Structure

​Adding New Map Attributes

​Where to Find Help

​Documentation

MiniLibX

Raycasting Tutorial

42 Norm

libft Functions

​Code References

​Key Source Files for Reference

​Debugging Resources

​Pre-submission Checklist

Code Style Guidelines

The 42 Norm

Function Header Format

Formatting Rules

Example: Norm-Compliant Function

Adding New Features

General Workflow

Example: Adding Minimap Feature

Testing Changes

Build and Test Workflow

Test Map Collection

Common Test Cases

Build System

Makefile Targets

Makefile Structure

Adding Compilation Flags

Common Development Tasks

Adding a New Utility Function

Modifying the t_map Structure

Adding New Map Attributes

Where to Find Help

Documentation

Code References

Key Source Files for Reference

Debugging Resources

Pre-submission Checklist