draw_light.c

Go to the documentation of this file.

#include "draw_light.h"
 
#include <stdlib.h>
 
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] = {
        {{1, 1}, {1, 0}},   // for up
        {{-1, -1}, {-1, 0}},// for down
        {{1, -1}, {0, -1}}, // for left
        {{-1, 1}, {0, 1}},  // for right
};
 

int need_loop_break(const int x, const int y, const vector2d_t dir, int j, int* prev_wall_at) {
    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;
}
 

int process_tile(int x, int y, int* prev_wall_at, const vector2d_t dir, int j) {
    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;
}
 

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) {
    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;
}
 

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) {
    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++;
    }
}
 
void draw_light_on_player(map_tile_t* arr1, map_tile_t* arr2, int height, int width, vector2d_t player,
                          const int light_radius) {
    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);
    }
}