@ -7,216 +7,221 @@
using std : : string ; using std : : string ;
using matrix : : Matrix ; using matrix : : Matrix ;
inline size_t rand ( size_t i , size_t j ) { namespace maze {
if ( i < j ) { inline size_t rand ( size_t i , size_t j ) {
return Random : : uniform ( i , j ) ; if ( i < j ) {
} else if ( j < i ) { return Random : : uniform ( i , j ) ;
return Random : : uniform ( j , i ) ; } else if ( j < i ) {
} else { return Random : : uniform ( j , i ) ;
return i ; } else {
return i ;
}
} }
}
inline bool complete ( Matrix & maze ) { inline bool complete ( Matrix & maze ) {
size_t width = matrix : : width ( maze ) ; size_t width = matrix : : width ( maze ) ;
size_t height = matrix : : height ( maze ) ; size_t height = matrix : : height ( maze ) ;
for ( size_t row = 1 ; row < height ; row + = 2 ) { for ( size_t row = 1 ; row < height ; row + = 2 ) {
for ( size_t col = 1 ; col < width ; col + = 2 ) { for ( size_t col = 1 ; col < width ; col + = 2 ) {
if ( maze [ row ] [ col ] ! = 0 ) return false ; if ( maze [ row ] [ col ] ! = 0 ) return false ;
}
} }
}
return true ; return true ;
} }
std : : vector < Point > neighborsAB ( Matrix & maze , Point on ) { std : : vector < Point > neighborsAB ( Matrix & maze , Point on ) {
std : : vector < Point > result ; std : : vector < Point > result ;
std : : array < Point , 4 > points { { std : : array < Point , 4 > points { {
{ on . x , on . y - 2 } , { on . x , on . y - 2 } ,
{ on . x , on . y + 2 } , { on . x , on . y + 2 } ,
{ on . x - 2 , on . y } , { on . x - 2 , on . y } ,
{ on . x + 2 , on . y } { on . x + 2 , on . y }
} } ; } } ;
for ( auto point : points ) { for ( auto point : points ) {
if ( matrix : : inbounds ( maze , point . x , point . y ) ) { if ( matrix : : inbounds ( maze , point . x , point . y ) ) {
result . push_back ( point ) ; result . push_back ( point ) ;
}
} }
}
return result ; return result ;
} }
std : : vector < Point > neighbors ( Matrix & maze , Point on ) { std : : vector < Point > neighbors ( Matrix & maze , Point on ) {
std : : vector < Point > result ; std : : vector < Point > result ;
std : : array < Point , 4 > points { { std : : array < Point , 4 > points { {
{ on . x , on . y - 2 } , { on . x , on . y - 2 } ,
{ on . x , on . y + 2 } , { on . x , on . y + 2 } ,
{ on . x - 2 , on . y } , { on . x - 2 , on . y } ,
{ on . x + 2 , on . y } { on . x + 2 , on . y }
} } ; } } ;
for ( auto point : points ) { for ( auto point : points ) {
if ( matrix : : inbounds ( maze , point . x , point . y ) ) { if ( matrix : : inbounds ( maze , point . x , point . y ) ) {
if ( maze [ point . y ] [ point . x ] = = WALL_VALUE ) { if ( maze [ point . y ] [ point . x ] = = WALL_VALUE ) {
result . push_back ( point ) ; result . push_back ( point ) ;
}
} }
} }
}
return result ; return result ;
} }
inline std : : pair < Point , Point > find_coord ( Matrix & maze ) { inline std : : pair < Point , Point > find_coord ( Matrix & maze ) {
size_t width = matrix : : width ( maze ) ; size_t width = matrix : : width ( maze ) ;
size_t height = matrix : : height ( maze ) ; size_t height = matrix : : height ( maze ) ;
for ( size_t y = 1 ; y < height ; y + = 2 ) { for ( size_t y = 1 ; y < height ; y + = 2 ) {
for ( size_t x = 1 ; x < width ; x + = 2 ) { for ( size_t x = 1 ; x < width ; x + = 2 ) {
if ( maze [ y ] [ x ] = = WALL_VALUE ) { if ( maze [ y ] [ x ] = = WALL_VALUE ) {
auto found = neighborsAB ( maze , { x , y } ) ; auto found = neighborsAB ( maze , { x , y } ) ;
for ( auto point : found ) { for ( auto point : found ) {
if ( maze [ point . y ] [ point . x ] = = 0 ) { if ( maze [ point . y ] [ point . x ] = = 0 ) {
return { { x , y } , point } ; return { { x , y } , point } ;
}
} }
} }
} }
} }
}
matrix : : dump ( " BAD MAZE " , maze ) ; matrix : : dump ( " BAD MAZE " , maze ) ;
dbc : : sentinel ( " failed to find coord? " ) ; dbc : : sentinel ( " failed to find coord? " ) ;
} }
void maze : : randomize_rooms ( std : : vector < Room > & rooms_out , std : : vector < Point > & maybe_here ) { void Builder : : randomize_rooms ( ) {
dbc : : check ( maybe_here . size ( ) > = 2 , " must have at least two possible points to place rooms " ) ; dbc : : check ( $ dead_ends . size ( ) > = 2 , " must have at least two possible points to place rooms " ) ;
while ( rooms_out . size ( ) < 2 ) { while ( $ rooms . size ( ) < 2 ) {
// use those dead ends to randomly place rooms
// use those dead ends to randomly place rooms
for ( auto at : maybe_here ) { for ( auto at : $ dead_ends ) {
if ( Random : : uniform ( 0 , 1 ) ) { if ( Random : : uniform ( 0 , 1 ) ) {
size_t offset = Random : : uniform ( 0 , 1 ) ; size_t offset = Random : : uniform ( 0 , 1 ) ;
Room cur { at . x + offset , at . y + offset , 1 , 1 } ; Room cur { at . x + offset , at . y + offset , 1 , 1 } ;
rooms_out . push_back ( cur ) ; $ rooms . push_back ( cur ) ;
}
} }
} }
} }
}
void maze : : init ( Matrix & maze ) { void Builder : : init ( ) {
matrix : : assign ( maze , WALL_VALUE ) ; matrix : : assign ( $ walls , WALL_VALUE ) ;
}
void maze : : divide ( Matrix & maze , Point start , Point end ) {
for ( matrix : : line it { start , end } ; it . next ( ) ; ) {
maze [ it . y ] [ it . x ] = 0 ;
maze [ it . y + 1 ] [ it . x ] = 0 ;
} }
}
void maze : : hunt_and_kill ( Matrix & maze , std : : vector < Room > & rooms , std : : vector < Point > & dead_ends ) { void Builder : : divide ( Point start , Point end ) {
for ( matrix : : line it { start , end } ; it . next ( ) ; ) {
for ( auto & room : rooms ) { $ walls [ it . y ] [ it . x ] = 0 ;
for ( matrix : : box it { maze , room . x , room . y , room . width } ; it . next ( ) ; ) { $ walls [ it . y + 1 ] [ it . x ] = 0 ;
maze [ it . y ] [ it . x ] = 0 ;
} }
} }
Point on { 1 , 1 } ; void Builder : : hunt_and_kill ( ) {
for ( auto & room : $ rooms ) {
while ( ! complete ( maze ) ) { for ( matrix : : box it { $ walls , room . x , room . y , room . width } ; it . next ( ) ; ) {
auto n = neighbors ( maze , on ) ; $ walls [ it . y ] [ it . x ] = 0 ;
if ( n . size ( ) = = 0 ) { }
dead_ends . push_back ( on ) ; }
auto t = find_coord ( maze ) ;
on = t . first ;
maze [ on . y ] [ on . x ] = 0 ;
size_t row = ( on . y + t . second . y ) / 2 ;
size_t col = ( on . x + t . second . x ) / 2 ;
maze [ row ] [ col ] = 0 ;
} else {
auto nb = n [ rand ( size_t ( 0 ) , n . size ( ) - 1 ) ] ;
maze [ nb . y ] [ nb . x ] = 0 ;
size_t row = ( nb . y + on . y ) / 2 ; Point on { 1 , 1 } ;
size_t col = ( nb . x + on . x ) / 2 ;
maze [ row ] [ col ] = 0 ; while ( ! complete ( $ walls ) ) {
on = nb ; auto n = neighbors ( $ walls , on ) ;
if ( n . size ( ) = = 0 ) {
$ dead_ends . push_back ( on ) ;
auto t = find_coord ( $ walls ) ;
on = t . first ;
$ walls [ on . y ] [ on . x ] = 0 ;
size_t row = ( on . y + t . second . y ) / 2 ;
size_t col = ( on . x + t . second . x ) / 2 ;
$ walls [ row ] [ col ] = 0 ;
} else {
auto nb = n [ rand ( size_t ( 0 ) , n . size ( ) - 1 ) ] ;
$ walls [ nb . y ] [ nb . x ] = 0 ;
size_t row = ( nb . y + on . y ) / 2 ;
size_t col = ( nb . x + on . x ) / 2 ;
$ walls [ row ] [ col ] = 0 ;
on = nb ;
}
} }
}
for ( auto at : dead_ends ) { for ( auto at : $ dead_ends ) {
for ( auto & room : rooms ) { for ( auto & room : $ rooms ) {
Point room_ul { room . x - room . width - 1 , room . y - room . height - 1 } ; Point room_ul { room . x - room . width - 1 , room . y - room . height - 1 } ;
Point room_lr { room . x + room . width - 1 , room . y + room . height - 1 } ; Point room_lr { room . x + room . width - 1 , room . y + room . height - 1 } ;
if ( at . x > = room_ul . x & & at . y > = room_ul . y & & if ( at . x > = room_ul . x & & at . y > = room_ul . y & &
at . x < = room_lr . x & & at . y < = room_lr . y ) at . x < = room_lr . x & & at . y < = room_lr . y )
{ {
for ( matrix : : compass it { maze , at . x , at . y } ; it . next ( ) ; ) { for ( matrix : : compass it { $ walls , at . x , at . y } ; it . next ( ) ; ) {
if ( maze [ it . y ] [ it . x ] = = 1 ) { if ( $ walls [ it . y ] [ it . x ] = = 1 ) {
maze [ it . y ] [ it . x ] = 0 ; $ walls [ it . y ] [ it . x ] = 0 ;
break ; break ;
}
} }
} }
} }
} }
} }
}
void maze : : inner_donut ( Matrix & maze , float outer_rad , float inner_rad ) { void Builder : : inner_donut ( float outer_rad , float inner_rad ) {
size_t x = matrix : : width ( maze ) / 2 ; size_t x = matrix : : width ( $ walls ) / 2 ;
size_t y = matrix : : height ( maze ) / 2 ; size_t y = matrix : : height ( $ walls ) / 2 ;
for ( matrix : : circle it { maze , { x , y } , outer_rad } ; for ( matrix : : circle it { $ walls , { x , y } , outer_rad } ;
it . next ( ) ; ) it . next ( ) ; )
{ {
for ( int x = it . left ; x < it . right ; x + + ) { for ( int x = it . left ; x < it . right ; x + + ) {
maze [ it . y ] [ x ] = 0 ; $ walls [ it . y ] [ x ] = 0 ;
}
} }
}
for ( matrix : : circle it { maze , { x , y } , inner_rad } ; for ( matrix : : circle it { $ walls , { x , y } , inner_rad } ;
it . next ( ) ; ) it . next ( ) ; )
{ {
for ( int x = it . left ; x < it . right ; x + + ) { for ( int x = it . left ; x < it . right ; x + + ) {
maze [ it . y ] [ x ] = 1 ; $ walls [ it . y ] [ x ] = 1 ;
}
} }
} }
}
void maze : : inner_box ( Matrix & maze , size_t outer_size , size_t inner_size ) { void Builder : : inner_box ( size_t outer_size , size_t inner_size ) {
size_t x = matrix : : width ( $ walls ) / 2 ;
size_t y = matrix : : height ( $ walls ) / 2 ;
size_t x = matrix : : width ( maze ) / 2 ; for ( matrix : : box it { $ walls , x , y , outer_size } ;
size_t y = matrix : : height ( maze ) / 2 ; it . next ( ) ; )
{
for ( matrix : : box it { maze , x , y , outer_size } ; $ walls [ it . y ] [ it . x ] = 0 ;
it . next ( ) ; ) }
{
maze [ it . y ] [ it . x ] = 0 ;
}
for ( matrix : : box it { maze , x , y , inner_size } ; for ( matrix : : box it { $ walls , x , y , inner_size } ;
it . next ( ) ; ) it . next ( ) ; )
{ {
maze [ it . y ] [ it . x ] = 1 ; $ walls [ it . y ] [ it . x ] = 1 ;
}
} }
}
void maze : : remove_dead_ends ( Matrix & maze , std : : vector < Point > & dead_ends ) { void Builder : : remove_dead_ends ( ) {
for ( auto at : dead_ends ) { dbc : : check ( $ dead_ends . size ( ) > 0 , " you have to run an algo first, no dead_ends to remove " ) ;
for ( matrix : : compass it { maze , at . x , at . y } ; it . next ( ) ; ) { for ( auto at : $ dead_ends ) {
if ( maze [ it . y ] [ it . x ] = = 0 ) { for ( matrix : : compass it { $ walls , at . x , at . y } ; it . next ( ) ; ) {
int diff_x = at . x - it . x ; if ( $ walls [ it . y ] [ it . x ] = = 0 ) {
int diff_y = at . y - it . y ; int diff_x = at . x - it . x ;
maze [ at . y + diff_y ] [ at . x + diff_x ] = 0 ; int diff_y = at . y - it . y ;
$ walls [ at . y + diff_y ] [ at . x + diff_x ] = 0 ;
}
} }
} }
} }
void Builder : : dump ( const std : : string & msg ) {
matrix : : dump ( msg , $ walls ) ;
}
} }
