draw_light.c File Reference

Implements functionality fro drawing light on player. More...

#include "draw_light.h"
#include <stdlib.h>

Go to the source code of this file.

Functions
int	need_loop_break (const int x, const int y, const vector2d_t dir, int j, int *prev_wall_at)
	This is a helper function to check if the loop needs to break with this specific edge case.
int	process_tile (int x, int y, int *prev_wall_at, const vector2d_t dir, int j)
	This function processes the tile at the given coordinates and updates the revealed_map_arr array.
int	check_and_process_tile (int x, int y, int *prev_wall_at, const vector2d_t dir, int j, const vector2d_t diagonal_check, const vector2d_t reverse_check)
	This function checks if the tile at the given coordinates is valid and processes it.
void	process_light_in_direction (const vector2d_t player, const vector2d_t dir, const vector2d_t diagonal_check, const vector2d_t reverse_check, const int light_radius)
	Processes light in a specific direction and updates the revealed map_arr.
void	draw_light_on_player (map_tile_t *arr1, map_tile_t *arr2, int height, int width, vector2d_t player, const int light_radius)
	Draws light around the player.

Variables
map_tile_t *	map_arr
map_tile_t *	revealed_map_arr
int	map_height
int	map_width
vector2d_t	player_position
int	radius
const vector2d_t	checks_vector [4][2]
	Each array row corresponds to the vector in the directions array.

Detailed Description

Implements functionality fro drawing light on player.

Definition in file draw_light.c.

Function Documentation

check_and_process_tile()

int check_and_process_tile	(	int	x,
		int	y,
		int *	prev_wall_at,
		const vector2d_t	dir,
		int	j,
		const vector2d_t	diagonal_check,
		const vector2d_t	reverse_check )

This function checks if the tile at the given coordinates is valid and processes it.

Parameters

x	current tile x-coordinates
y	current tile y-coordinates
prev_wall_at	index of the previous wall tile
dir	the direction to check
j	loop counter
diagonal_check	the diagonal check vector
reverse_check	the reverse check vector

Returns

1 if loops must break, 0 when not

Definition at line 88 of file draw_light.c.

                                                                                            {
    int quit = 0;
    //calculated access index
    const int access_idx = x * map_height + y;
 
    if (x < 0 || x >= map_width || y < 0 || y >= map_height) {
        //calculated x or y is out of bounds
        quit = 1;
    } else {
        if (revealed_map_arr[access_idx] == HIDDEN) {
            //initialize the relative diagonal and reverse tiles based on the y and x values
            const int rel_diagonal = map_arr[(x + diagonal_check.dx) * map_height + y + diagonal_check.dy];
            const int rel_reverse = map_arr[(x + reverse_check.dx) * map_height + y + reverse_check.dy];
 
            if (rel_diagonal == WALL && rel_reverse == WALL && j > 1) {
                //if the diagonal and reverse tiles are walls and the distance from the player is greater than 1
                // then the tile must be hidden because reverse tile is blocking the view
                quit = 1;
            } else {
                quit = process_tile(x, y, prev_wall_at, dir, j);
            }
        } else if (revealed_map_arr[access_idx] == WALL && need_loop_break(x, y, dir, j, prev_wall_at)) {
            quit = 1;
        }
    }
    return quit;
}

draw_light_on_player()

void draw_light_on_player	(	map_tile_t *	arr1,
		map_tile_t *	arr2,
		int	height,
		int	width,
		vector2d_t	player,
		int	light_radius )

Draws light around the player.

Parameters

arr1	The pointer to the 2D array containing all the map tiles (no Hidden tiles)
arr2	The pointer to the 2D array to reveal the arr1, based on the player's position and light radius
height	The height of the map
width	The width of the map
player	The player's position on the map
light_radius	The radius of the light around the player

Definition at line 156 of file draw_light.c.

                                                  {
    map_arr = arr1;
    revealed_map_arr = arr2;
    map_height = height;
    map_width = width;
    player_position = player;
    radius = light_radius;
 
    if (light_radius <= 0) {
        //light radius is negative or 0, do nothing
        return;
    }
 
    for (int i = 0; i < 4; i++) {
        const vector2d_t dir = directions[i];
        const vector2d_t diagonal_check = checks_vector[i][0];
        const vector2d_t reverse_check = checks_vector[i][1];
 
        process_light_in_direction(player, dir, diagonal_check, reverse_check, light_radius);
    }
}

need_loop_break()

int need_loop_break	(	const int	x,
		const int	y,
		const vector2d_t	dir,
		int	j,
		int *	prev_wall_at )

This is a helper function to check if the loop needs to break with this specific edge case.

Parameters

x	current tile x-coordinates
y	current tile y-coordinates
dir	the direction to check
j	loop counter
prev_wall_at	pointer to variable, which should be written

Returns

1 if loops must break, 0 when not

Definition at line 39 of file draw_light.c.

                                                                                              {
    if (j == 0) {
        //gets the x or y value of the calculated coordinates
        *prev_wall_at = abs(y * dir.dy + x * dir.dx);
        return 1;
    }
    if (*prev_wall_at == abs(y * dir.dy + x * dir.dx)) {
        //if the previous j-loop had a wall at x or y coordinate, the loop must break
        //or else diagonals tiles (behind a wall and not visible by the player) are revealed
        return 1;
    }
    return 0;
}

process_light_in_direction()

void process_light_in_direction	(	const vector2d_t	player,
		const vector2d_t	dir,
		const vector2d_t	diagonal_check,
		const vector2d_t	reverse_check,
		const int	light_radius )

Processes light in a specific direction and updates the revealed map_arr.

Parameters

player	the player's position on the map_arr
dir	the direction vector
diagonal_check	the diagonal check vector
reverse_check	the reverse check vector
light_radius	the radius of the light around the player

Definition at line 126 of file draw_light.c.

                                                                                        {
    int correction = 0;
    int prev_wall_at = -1;
 
    for (int j = 0; j <= light_radius; j++) {
        const int start_x = player.dx + j * dir.dy;
        int start_y = player.dy + j * dir.dx;
 
        if (dir.dx != 0) {
            //if the direction is vertical negate the subtrahend
            start_y = player.dy - j * dir.dx;
        }
 
        if (start_x < 0 || start_x >= map_width || start_y < 0 || start_y >= map_height) {
            //start position is out of bounds, skip to the next direction
            break;
        }
        for (int k = 1; k <= light_radius - correction; k++) {
            const int x = start_x + k * dir.dx;
            const int y = start_y + k * dir.dy;
 
            if (check_and_process_tile(x, y, &prev_wall_at, dir, j, diagonal_check, reverse_check)) {
                break;
            }
        }
        correction++;
    }
}

process_tile()

int process_tile	(	int	x,
		int	y,
		int *	prev_wall_at,
		const vector2d_t	dir,
		int	j )

This function processes the tile at the given coordinates and updates the revealed_map_arr array.

Parameters

x	current tile x-coordinates
y	current tile y-coordinates
prev_wall_at	index of the previous wall tile
dir	the direction to check
j	loop counter

Returns

Definition at line 63 of file draw_light.c.

                                                                               {
    int break_loop = 0;
    //calculated access index
    const int access_idx = x * map_height + y;
 
    revealed_map_arr[access_idx] = map_arr[access_idx];
 
    if (map_arr[access_idx] == WALL) {
        break_loop = need_loop_break(x, y, dir, j, prev_wall_at);
    }
    return break_loop;
}

Variable Documentation

checks_vector

const vector2d_t checks_vector[4][2]

Initial value:

= {
        {{1, 1}, {1, 0}},   
        {{-1, -1}, {-1, 0}},
        {{1, -1}, {0, -1}}, 
        {{-1, 1}, {0, 1}},  
}

Each array row corresponds to the vector in the directions array.

A row contains:

• the diagonal check vector
• the reverse check vector

Definition at line 22 of file draw_light.c.

                                       {
        {{1, 1}, {1, 0}},   // for up
        {{-1, -1}, {-1, 0}},// for down
        {{1, -1}, {0, -1}}, // for left
        {{-1, 1}, {0, 1}},  // for right
};

map_arr

map_tile_t* map_arr

Definition at line 9 of file draw_light.c.

map_height

int map_height

Definition at line 11 of file draw_light.c.

map_width

int map_width

Definition at line 12 of file draw_light.c.

player_position

vector2d_t player_position

Definition at line 13 of file draw_light.c.

radius

int radius

Definition at line 14 of file draw_light.c.

revealed_map_arr

map_tile_t* revealed_map_arr

Definition at line 10 of file draw_light.c.