//updated file builder.c
//cell structure
//each cell has 4 walls
//each wall is divided into 3 for 3 model sections
//p.s check for doubled walls
typedef struct
{
VECTOR right_walls;//right wall start vector
VECTOR right_walle;//right wall end vector
VECTOR left_walls;//left wall start vector
VECTOR left_walle;//left wall end vector
VECTOR lower_walls;//lower wall start vector
VECTOR lower_walle;//lower wall end vector
VECTOR upper_walls;//upper wall start vector
VECTOR upper_walle;//upper wall end vector
VECTOR pos;//center of cell
int index;//cell index
}cell;
int totcells=0;//total cells
var spc=0;//space between cell centers
cell *cells;//cell array
var w;//width of grid
var h;//height of grid
/*
typedef struct
{
ENTITY* section_ent;
}section;
section* T_sections;//T shaped intersections
section* cross_sections;//+ shaped intersections;
section* corner_sections;//corner shaped intersections
section* hallway_section;//hallway sections
*/
void on_t_intersection_topleft(int cell_index,VECTOR *pos);
void on_t_intersection_bottomleft(int cell_index,VECTOR* pos);
void on_t_intersection_topleftside(int cell_index,VECTOR* pos);
void on_t_intersection_toprightside(int cell_index,VECTOR* pos);
void on_cross_intersection(int cell_index,VECTOR* pos);
void on_corner_topleft(int cell_index,VECTOR* pos);
void on_corner_topright(int cell_index,VECTOR* pos);
void on_corner_bottomleft(int cell_index,VECTOR* pos);
void on_corner_bottomright(int cell_index,VECTOR* pos);
void on_upward_straight_leftmiddle(int cell_index,VECTOR* pos);
void on_upward_straight_lefttop(int cell_index,VECTOR* pos);
void on_upward_straight_leftbottom(int cell_index,VECTOR* pos);
void on_sideways_straight_topmiddle(int cell_index,VECTOR* pos);
void on_sideways_straight_topright(int cell_index,VECTOR* pos);
void on_sideways_straight_bottomleft(int cell_index,VECTOR* pos);
////////////////////////////////////////////////////////check walls
//cur_cell has upper wall?
int has_upper_wall(int cur_cell)
{
if((cells[cur_cell].upper_walls.x!=0 && cells[cur_cell].upper_walle.x!=0)&&(cells[cur_cell].upper_walls.y!=0 && cells[cur_cell].upper_walle.y!=0))
return 1;
else return 0;
}
//cur_cell has lower wall?
int has_lower_wall(int cur_cell)
{
if((cells[cur_cell].lower_walls.x!=0 && cells[cur_cell].lower_walle.x!=0)&&(cells[cur_cell].lower_walls.y!=0 && cells[cur_cell].lower_walle.y!=0))
return 1;
else return 0;
}
//cur_cell has right wall?
int has_right_wall(int cur_cell)
{
if((cells[cur_cell].right_walls.x!=0 && cells[cur_cell].right_walle.x!=0)&&(cells[cur_cell].right_walls.y!=0 && cells[cur_cell].right_walle.y!=0))
return 1;
else return 0;
}
//cur_cell has left wall?
int has_left_wall(int cur_cell)
{
if((cells[cur_cell].left_walls.x!=0 && cells[cur_cell].left_walle.x!=0)&&(cells[cur_cell].left_walls.y!=0 && cells[cur_cell].left_walle.y!=0))
return 1;
else return 0;
}
////////////////////////////////////////////////////////neigbours
//cur_cell is on right of targetcell?
int is_on_right(int targetcell,int cur_cell)
{
if(cells[targetcell].pos.y<cells[cur_cell].pos.y)// &&(cells[targetcell].pos.x==cells[curcell].pos.x))//right of curcell
return 1;
else return 0;
}
//cur_cell is on left of targetcell?
int is_on_left(int targetcell,int cur_cell)
{
if(cells[targetcell].pos.y>cells[cur_cell].pos.y)//&& (cells[targetcell].pos.x==cells[curcell].pos.x))//left of curcell
return 1;
else return 0;
}
//cur_cell is on top of targetcell?
int is_on_top(int targetcell,int cur_cell)
{
if(cells[targetcell].pos.x>cells[cur_cell].pos.x)//&& (cells[targetcell].pos.y==cells[curcell].pos.y))//top of curcell
return 1;
else return 0;
}
//cur_cell is on bottom of targetcell?
int is_on_bottom(int targetcell,int cur_cell)
{
if(cells[targetcell].pos.x<cells[cur_cell].pos.x)//&& (cells[targetcell].pos.y==cells[curcell].pos.y))//bottom of curcell
return 1;
else return 0;
}
//return the index of the cell ontop of curcell
int get_upper_cell(int cur_cell)
{
int i;
for(i=0;i<totcells;i++)
{
if(vec_dist(cells[cur_cell].pos,cells[i].pos)==spc)//in neighbour range?
{
if(is_on_top(i,cur_cell))return i;//cells[i].index;//cell index ontop of current cell
}
}
return -1;//no cell found
}
//return the index of the cell below curcell
int get_lower_cell(int cur_cell)
{
int i;
for(i=0;i<totcells;i++)
{
if(vec_dist(cells[cur_cell].pos,cells[i].pos)==spc)//in neighbour range?
{
if(is_on_bottom(i,cur_cell))return i;//cells[i].index;//cell index bellow of current cell
}
}
return -1;//no cell found
}
//return the index of the cell left of curcell
int get_left_cell(int cur_cell)
{
int i;
for(i=0;i<totcells;i++)
{
if(vec_dist(cells[cur_cell].pos,cells[i].pos)==spc)//in neighbour range?
{
if(is_on_left(i,cur_cell))return i;//cells[i].index;//cell index left of current cell
}
}
return -1;//no cell found
}
//return the index of the cell right of curcell
int get_right_cell(int cur_cell)
{
int i;
for(i=0;i<totcells;i++)
{
if(vec_dist(cells[cur_cell].pos,cells[i].pos)==spc)//in neighbour range?
{
if(is_on_right(i,cur_cell))return i;//cells[i].index;//cell index right of current cell
}
}
return -1;//no cell found
}
////////////////////////////////////////////////////////remove walls
//remove curcell left wall
void remove_left_wall(int cur_cell)
{
vec_set(cells[cur_cell].left_walls,nullvector);
vec_set(cells[cur_cell].left_walle,nullvector);
}
//remove curcell right wall
void remove_right_wall(int cur_cell)
{
vec_set(cells[cur_cell].right_walls,nullvector);
vec_set(cells[cur_cell].right_walle,nullvector);
}
//remove curcell upper wall
void remove_upper_wall(int cur_cell)
{
vec_set(cells[cur_cell].upper_walls,nullvector);
vec_set(cells[cur_cell].upper_walle,nullvector);
}
//remove curcell lower wall
void remove_lower_wall(int cur_cell)
{
vec_set(cells[cur_cell].lower_walls,nullvector);
vec_set(cells[cur_cell].lower_walle,nullvector);
}
////////////////////////////////////////////////////////add walls
var d=2;
void add_left_wall(int cur_cell)
{
if(!has_left_wall(cur_cell))
{
vec_set(cells[cur_cell].left_walls,vector(cells[cur_cell].pos.x-spc/d,cells[cur_cell].pos.y+spc/d,0));
vec_set(cells[cur_cell].left_walle,vector(cells[cur_cell].pos.x+spc/d,cells[cur_cell].pos.y+spc/d,0));
}
}
void add_right_wall(int cur_cell)
{
if(!has_right_wall(cur_cell))
{
vec_set(cells[cur_cell].right_walls,vector(cells[cur_cell].pos.x-spc/d,cells[cur_cell].pos.y-spc/d,0));
vec_set(cells[cur_cell].right_walle,vector(cells[cur_cell].pos.x+spc/d,cells[cur_cell].pos.y-spc/d,0));
}
}
void add_upper_wall(int cur_cell)
{
if(!has_upper_wall(cur_cell))
{
vec_set(cells[cur_cell].upper_walls,vector(cells[cur_cell].pos.x+spc/d,cells[cur_cell].pos.y-spc/d,0));
vec_set(cells[cur_cell].upper_walle,vector(cells[cur_cell].pos.x+spc/d,cells[cur_cell].pos.y+spc/d,0));
}
}
void add_lower_wall(int cur_cell)
{
if(!has_lower_wall(cur_cell))
{
vec_set(cells[cur_cell].lower_walls,vector(cells[cur_cell].pos.x-spc/d,cells[cur_cell].pos.y-spc/d,0));
vec_set(cells[cur_cell].lower_walle,vector(cells[cur_cell].pos.x-spc/d,cells[cur_cell].pos.y+spc/d,0));
}
}
////////////////////////////////////////////////////////make grid
//void generate_grid(length of a straight section,amount of cells eg. 10x10 3x3)
//creates a grid of cells of value NxN
void generate_grid(var l,int tot)
{
var segment_length=l; //segment length of a straight segment model
int amount=tot;//amount of cells =amount x amount eg.3x3 grid
w=(segment_length*3)*amount;//width
h=(segment_length*3)*amount;//height
spc=segment_length*3;//space between cells centers
totcells=(int)(amount*amount);
cells=malloc(sizeof(cell)*totcells);
//create cells in grid
int i=0;
var d=2;
var xx=0,yy=0;
for(xx=0;xx<w;xx+=spc)
{
for(yy=0;yy<h;yy+=spc)
{
vec_set(cells[i].pos,vector(xx,yy,0));//cell pos
vec_set(cells[i].right_walls,vector(xx-spc/d,yy-spc/d,0));//r wall start
vec_set(cells[i].right_walle,vector(xx+spc/d,yy-spc/d,0));//r wall end
vec_set(cells[i].left_walls,vector(xx-spc/d,yy+spc/d,0));//l wall start
vec_set(cells[i].left_walle,vector(xx+spc/d,yy+spc/d,0));//l wall end
vec_set(cells[i].lower_walls,vector(xx-spc/d,yy-spc/d,0));//lower wall start
vec_set(cells[i].lower_walle,vector(xx-spc/d,yy+spc/d,0));//lower wall end
vec_set(cells[i].upper_walls,vector(xx+spc/d,yy-spc/d,0));//upper wall start
vec_set(cells[i].upper_walle,vector(xx+spc/d,yy+spc/d,0));//upper wall end
cells[i].index=i;
i+=1;
}
}
}
////////////////////////////////////////////////////////make maze
///////////////////////////
//create non-solvable maze
//by removing random cell walls
void do_maze()
{
int curcell=0;
for(curcell=0;curcell<totcells;curcell++)
{
int pick=random(4);//to remove a wall at random position(left/right/up/down walls)
if(pick==0)
{
//if not on border
//if has cell left of it
int neigbour=get_left_cell(curcell);
if(neigbour!=-1)
{
//if unvisited
if(has_right_wall(curcell) && has_upper_wall(curcell) && has_lower_wall(curcell))
{
//remove wall between
if(has_left_wall(curcell))remove_left_wall(curcell);
if(has_right_wall(neigbour))remove_right_wall(neigbour);
}
}
}
//picked neigbour right of curcell
if(pick==1)
{
//if not on border
//if has cell right of it
int neigbour=get_right_cell(curcell);
if(neigbour!=-1)
{
//if unvisited
if(has_left_wall(curcell) && has_upper_wall(curcell) && has_lower_wall(curcell))
{
//remove wall between
if(has_right_wall(curcell))remove_right_wall(curcell);
if(has_left_wall(neigbour))remove_left_wall(neigbour);
}
}
}
//picked neigbour ontop of curcell
if(pick==2)
{
//if not on border
//if has cell ontop of it
int neigbour=get_upper_cell(curcell);
if(neigbour!=-1)
{
//if unvisited
if(has_left_wall(curcell) && has_right_wall(curcell) && has_lower_wall(curcell))
{
//remove wall between
if(has_upper_wall(curcell))remove_upper_wall(curcell);
if(has_lower_wall(neigbour))remove_lower_wall(neigbour);
}
}
}
//picked neigbour below of curcell
if(pick==3)
{
//if not on border
//if has cell below it
int neigbour=get_lower_cell(curcell);
if(neigbour!=-1)
{
//if unvisited
if(has_left_wall(curcell) && has_right_wall(curcell) && has_upper_wall(curcell))
{
//remove wall between
if(has_lower_wall(curcell))remove_lower_wall(curcell);
if(has_upper_wall(neigbour))remove_upper_wall(neigbour);
}
}
}
}
////////////////////////////////////////////////////////make solvable
//if theres cells with less than min_walls add walls to it
//to prevent non-solvable mazes
for(curcell=0;curcell<totcells;curcell++)
{
int min_walls=2;
int total_cell_walls=0;
if(has_left_wall(curcell)) total_cell_walls+=1;
if(has_right_wall(curcell)) total_cell_walls+=1;
if(has_upper_wall(curcell)) total_cell_walls+=1;
if(has_lower_wall(curcell)) total_cell_walls+=1;
if(total_cell_walls<=min_walls)
{
if(total_cell_walls<=min_walls && !has_left_wall(curcell))
{
int neighbour=get_left_cell(curcell);
if(neighbour!=-1)
{
add_left_wall(curcell);
add_right_wall(neighbour);
total_cell_walls+=1;
}
}
if(total_cell_walls<=min_walls && !has_right_wall(curcell))
{
int neighbour=get_right_cell(curcell);
if(neighbour!=-1)
{
add_right_wall(curcell);
add_left_wall(neighbour);
total_cell_walls+=1;
}
}
if(total_cell_walls<=min_walls && !has_upper_wall(curcell))
{
int neighbour=get_upper_cell(curcell);
if(neighbour!=-1)
{
add_upper_wall(curcell);
add_lower_wall(neighbour);
total_cell_walls+=1;
}
}
if(total_cell_walls<=min_walls && !has_lower_wall(curcell))
{
int neighbour=get_lower_cell(curcell);
if(neighbour!=-1)
{
add_lower_wall(curcell);
add_upper_wall(neighbour);
total_cell_walls+=1;
}
}
}
}
}
////////////////////////
//create intersections and corners entities
void find_sections()
{
int curcell;
int pick=0;
for(curcell=0;curcell<totcells;curcell++)
{
//upperwallend -leftt top of cell
//upperwallstart -right top of cell
//lowerwallend -left bottom of cell
//lowerwallstart -right bottom of cell
//leftwallstart - bottom left of cell
//leftwallend - top left of cell
//rightwallstart - bottom right of cell
//rightwallend - top right of cell
//all shapes to build the maze-like structure are ceated and placed inside these functions
//iterate through neigbours
pick=get_left_cell(curcell);
if(pick!=-1)
{
//check for intersection T shaped at top left of cell
if(has_left_wall(curcell))
{
if(has_upper_wall(curcell)&& has_upper_wall(pick))
{
int a=get_upper_cell(curcell);
if(a!=-1)
{
if(!has_left_wall(a))//topleft T intersection
{
on_t_intersection_topleft(curcell,cells[curcell].upper_walle);
}
if(has_left_wall(a))//+ intersection
{
on_cross_intersection(curcell,cells[curcell].upper_walle);
}
}
}
}
//check for intersection T shaped at bottom left of cell
if(has_left_wall(curcell))
{
if(has_lower_wall(curcell)&& has_lower_wall(pick))
{
int a=get_lower_cell(curcell);
if(a!=-1)
{
if(!has_left_wall(a))//bottomleft inverted T _|_ intersection
{
on_t_intersection_bottomleft(curcell,cells[curcell].lower_walle);
}
}
}
}
}
pick=get_upper_cell(curcell);
if(pick!=-1)
{
//check for intersection T |-- shaped at top left of cell
if(has_left_wall(curcell)&& has_left_wall(pick))
{
if(has_upper_wall(curcell))
{
int a=get_left_cell(curcell);
if(a!=-1)
{
if(!has_upper_wall(a))//topleft on side |-- intersection
{
on_t_intersection_topleftside(curcell,cells[curcell].upper_walle);
}
}
}
}
//check for intersection T --| shaped at top right of cell
if(has_right_wall(curcell)&& has_right_wall(pick))
{
if(has_upper_wall(curcell))
{
int a=get_right_cell(curcell);
if(a!=-1)
{
if(!has_upper_wall(a))//topright on side --| intersection
{
on_t_intersection_toprightside(curcell,cells[curcell].right_walle);
}
}
}
}
}
//find corners
pick=get_left_cell(curcell);
if(pick!=-1)
{
if(has_left_wall(curcell))
{
if(has_upper_wall(curcell)&& !has_upper_wall(pick))
{
int a=get_upper_cell(curcell);
if(a!=-1)
{
if(!has_left_wall(a))//topleft corner
{
on_corner_topleft(curcell,cells[curcell].upper_walle);
}
}
}
}
}
pick=get_right_cell(curcell);
if(pick!=-1)
{
if(has_right_wall(curcell))
{
if(has_upper_wall(curcell)&& !has_upper_wall(pick))
{
int a=get_upper_cell(curcell);
if(a!=-1)
{
if(!has_right_wall(a))//topright corner intersection
{
on_corner_topright(curcell,cells[curcell].right_walle);
}
}
}
}
}
pick=get_left_cell(curcell);
if(pick!=-1)
{
if(has_left_wall(curcell))
{
if(has_lower_wall(curcell)&& !has_lower_wall(pick))
{
int a=get_lower_cell(curcell);
if(a!=-1)
{
if(!has_left_wall(a))//bottomleft corner intersection
{
on_corner_bottomleft(curcell,cells[curcell].left_walls);
}
}
}
}
}
pick=get_right_cell(curcell);
if(pick!=-1)
{
if(has_right_wall(curcell))
{
if(has_lower_wall(curcell)&& !has_lower_wall(pick))
{
int a=get_lower_cell(curcell);
if(a!=-1)
{
if(!has_right_wall(a))//bottomright corner intersection
{
on_corner_bottomright(curcell,cells[curcell].right_walls);
}
}
}
}
}
//x axis hallway sections
pick=get_left_cell(curcell);
if(pick!=-1)
{
if(has_left_wall(curcell)&& has_right_wall(pick))
{
on_upward_straight_leftmiddle(curcell,vector(cells[curcell].pos.x,cells[curcell].pos.y+spc/2,cells[curcell].pos.z));
if(!has_upper_wall(curcell) && !has_upper_wall(pick))
{
on_upward_straight_lefttop(curcell,vector(cells[curcell].pos.x+spc/3,cells[curcell].pos.y+spc/2,cells[curcell].pos.z));
}
if(!has_lower_wall(curcell) && !has_lower_wall(pick))
{
on_upward_straight_leftbottom(curcell,vector(cells[curcell].pos.x-spc/3,cells[curcell].pos.y+spc/2,cells[curcell].pos.z));
}
}
}
//y axis hallway sections
pick=get_upper_cell(curcell);
if(pick!=-1)
{
if(has_upper_wall(curcell)&& has_lower_wall(pick))
{
on_sideways_straight_topmiddle(curcell,vector(cells[curcell].pos.x+spc/2,cells[curcell].pos.y,cells[curcell].pos.z));
if(!has_right_wall(curcell) && !has_right_wall(pick))
{
on_sideways_straight_topright(curcell,vector(cells[curcell].pos.x+spc/2,cells[curcell].pos.y-spc/3,cells[curcell].pos.z));
}
if(!has_left_wall(curcell) && !has_left_wall(pick))
{
on_sideways_straight_bottomleft(curcell,vector(cells[curcell].pos.x+spc/2,cells[curcell].pos.y+spc/3,cells[curcell].pos.z));
}
}
}
}
}
