 |
3D Maze Screenshot (Stefan Haubenthal)
#include <stdio.h>
#include <stdlib.h> // random
#define random(MAX) rand()%MAX
//#include <time.h> // randomize
#include <tgi.h>
#include <conio.h> // cgetc
#if 0
#include <dos.h> // sound, nosound, delay
#else
#define sound(FREQ)
#define nosound()
#define delay(TIME)
#endif
enum {UP,RIGHT,DOWN,LEFT}; // equally NORTH,EAST,SOUTH,WEST
#define RIGHT 1 // walls and borders
#define BOTTOM 2
typedef struct
{
unsigned char Walls;
unsigned char Border;
unsigned short Path;
} CELL;
struct
{
int Width, Height, NumCells;
int Dir[ 3 ];
CELL *Maze;
int Entry;
int CenterX;
int CenterY;
} g;
#define Cell( Row, Col ) ((Row) * g.Width + (Col))
#define IsConnected( C1, C2 ) (g.Maze[ (C1) ].Path == g.Maze[ (C2) ].Path)
#define GoodDir( Cell, Dir ) ((g.Maze[ (Cell) ].Border & (Dir)) == 0)
#define ROTATE_LEFT( Direction ) ((Direction + 3) & 0x3)
#define ROTATE_RIGHT( Direction ) ((Direction + 1) & 0x3)
enum { CENTER_WALL,LEFT_WALL,RIGHT_WALL,RIGHT_EDGE,LEFT_EDGE};
enum { UNMOVED, MOVED,BLOCKED,EXITED };
// Draws a wall shape
void DrawShape(int shape,int Size)
{
int OldSize=Size*2;
// vertical lines shared across all shapes (closes the shapes)
tgi_line( g.CenterX - Size, g.CenterY - Size,
g.CenterX - Size, g.CenterY + Size);
tgi_line( g.CenterX + Size, g.CenterY - Size,
g.CenterX + Size, g.CenterY + Size);
switch (shape)
{
case CENTER_WALL:
tgi_line( g.CenterX - Size, g.CenterY - Size,
g.CenterX + Size, g.CenterY - Size);
tgi_line( g.CenterX - Size, g.CenterY + Size,
g.CenterX + Size, g.CenterY + Size);
break;
case LEFT_WALL:
tgi_line( g.CenterX - OldSize, g.CenterY - OldSize,
g.CenterX - Size, g.CenterY - Size);
tgi_line( g.CenterX - OldSize, g.CenterY + OldSize,
g.CenterX - Size, g.CenterY + Size);
break;
case RIGHT_WALL:
tgi_line( g.CenterX + OldSize, g.CenterY - OldSize,
g.CenterX + Size, g.CenterY - Size);
tgi_line( g.CenterX + OldSize, g.CenterY + OldSize,
g.CenterX + Size, g.CenterY + Size);
break;
case RIGHT_EDGE:
tgi_line( g.CenterX + OldSize, g.CenterY - Size,
g.CenterX + Size, g.CenterY - Size);
tgi_line( g.CenterX + OldSize, g.CenterY + Size,
g.CenterX + Size, g.CenterY + Size);
break;
case LEFT_EDGE:
tgi_line( g.CenterX - OldSize, g.CenterY - Size,
g.CenterX - Size, g.CenterY - Size);
tgi_line( g.CenterX - OldSize, g.CenterY + Size,
g.CenterX - Size, g.CenterY + Size);
break;
}
}
// moves one cell in direction 'Direction' starting from cell *x,*y
// assumes *x,*y is within the maze and Direction is a valid direction.
int MoveXY(int Direction,int *x,int *y)
{
switch (Direction)
{
case (UP):
if( *y==0 ) return( BLOCKED );
if( g.Maze[ Cell( (*y)-1, *x ) ].Walls & BOTTOM ) return( BLOCKED );
(*y)--;
return( MOVED );
case (RIGHT):
if( g.Maze[ Cell( *y, *x ) ].Walls & RIGHT ) return( BLOCKED );
(*x)++;
return( MOVED );
case (DOWN):
if( g.Maze[ Cell( *y, *x ) ].Walls & BOTTOM )
{
if( *x != g.Entry) return( BLOCKED );
else return( EXITED );
}
(*y)++;
return( MOVED );
case (LEFT):
if( *x==0 ) return( BLOCKED );
if( g.Maze[ Cell( *y, (*x)-1 ) ].Walls & RIGHT ) return( BLOCKED );
(*x)--;
return( MOVED );
}
return( BLOCKED );
}
// Calculate which shapes are needed for a given cell
void DrawBlock(int Direction, int x, int y,int Size)
{
int tx, ty; // temporary position for movement tests
int movement; // result of movement tests
// Look to the left - draw nessary shapes
tx = x; ty = y;
movement = MoveXY( ROTATE_LEFT( Direction ), &tx, &ty );
if( movement == BLOCKED )
{
DrawShape( LEFT_WALL, Size );
}
else
{
if( movement == MOVED )
{
if( MoveXY( ROTATE_RIGHT( ROTATE_LEFT( Direction ) ), &tx, &ty) == BLOCKED )
{
DrawShape(LEFT_EDGE,Size);
}
else
{
} // Draw nothing - there is just empty space to the left.
}
else
{
} // Draw nothing - the Exit is to the left
}
// Look to the right - draw nessary shapes
tx = x; ty = y;
movement = MoveXY( ROTATE_RIGHT( Direction ), &tx, &ty );
if( movement == BLOCKED )
{
DrawShape( RIGHT_WALL, Size );
}
else
{
if( movement == MOVED )
{
if( MoveXY( ROTATE_LEFT( ROTATE_RIGHT( Direction ) ), &tx, &ty ) == BLOCKED )
{
DrawShape( RIGHT_EDGE, Size );
}
else
{
} // Draw nothing - there is just empty space to the right.
}
else
{
} // Draw nothing - the Exit is to the right
}
// Look straight ahead
if( MoveXY( Direction, &x, &y ) == BLOCKED )
{
DrawShape( CENTER_WALL, Size );
}
}
// Draws the maze as seen from cell x,y facing direction Direction
void Draw3d( int Direction, int x, int y )
{
int Size = g.CenterX / 2;
while( 1 )
{
DrawBlock( Direction, x, y, Size );
if( MoveXY( Direction, &x, &y ) != MOVED ) break;
// reduce shape size
Size /= 2;
}
}
// Interactive exploration of the maze in 3d
void Explore( void )
{
unsigned char GraphicsMode = TGI_MODE_320_200_2; // use VGA 640x480 16 color mode
int c; // character input
int x, y; // "position" of viewpoint in maze
int Direction; // direction of view (enumerated)
int Status; // results of attempted move.
tgi_load( GraphicsMode );
tgi_init( );
g.CenterX = tgi_getxres()/2;
g.CenterY = tgi_getyres()/2;
tgi_setcolor( COLOR_WHITE );
// random starting position and direction
x = random( g.Width );
y = random( g.Height );
Direction = random( 4 );
Draw3d( Direction, x, y );
c = 0;
while( 1 )
{
Status = UNMOVED;
c = cgetc();
if( c=='q' || c=='Q') break;
switch( c )
{
case 'J': // Rotate Left
case 'j':
case '4':
Direction = ROTATE_LEFT( Direction );
break;
case 'L': // Rotate Right
case 'l':
case '6':
Direction = ROTATE_RIGHT( Direction );
break;
case 'I': // Move Forward
case 'i':
case '8':
Status = MoveXY( Direction, &x, &y );
break;
case 'K':
case 'k':
case '2':
Status = MoveXY( (Direction + 2 ) % 4 ,&x, &y );
break;
default:
break;
}
if( Status==BLOCKED)
{
// beep the speaker
sound(550);
delay(10);
nosound();
}
else
{
if( Status == EXITED )
{
break;
}
else
{
tgi_clear();
Draw3d( Direction, x, y );
}
}
}
tgi_done();
if( Status == EXITED )
{
printf("Congratulations, you found your way out!\n");
}
}
// Joins two cells together into the same path.
void Join( int CellNum, int Dir )
{
int i, OldPath;
g.Maze[ CellNum ].Walls &= ~Dir; // clear the wall between them
// now merge the paths
OldPath = g.Maze[ CellNum + g.Dir[ Dir ] ].Path;
for( i = g.NumCells; i >= 0; i-- )
{
if( g.Maze[ i ].Path == OldPath )
{
g.Maze[ i ].Path = g.Maze[ CellNum ].Path;
}
}
}
// Randomly connects a cell with either its bottom or right neighbor.
int Connect( int CellNum )
{
int Neighbor, Offset, Dir;
Dir = random( 2 ) + 1; // random direction, 1 or 2
Neighbor = CellNum + g.Dir[ Dir ];
if( !GoodDir( CellNum, Dir ) || IsConnected( CellNum, Neighbor ) )
{
Dir = 3 - Dir; // get the OTHER neighbor
Neighbor = CellNum + g.Dir[ Dir ];
if( !GoodDir( CellNum, Dir ) || IsConnected( CellNum, Neighbor ) )
{
return( 0 );
}
}
Join( CellNum, Dir );
return( 1 );
}
// Generates the maze.
void Generate( void )
{
int ACell, Cnt;
// Connect a random cell in the maze to another path.
// Continue doing this until there is only one path in the maze.
do
{
for( ACell = random( g.NumCells ), Cnt = g.NumCells;
Cnt;
ACell++, Cnt-- )
{
if( ACell == g.NumCells ) ACell = 0;
if( Connect( ACell ) ) break;
}
}
while( Cnt );
}
// Initialization code.
void Init( void )
{
int i, Row, Col;
_randomize();
g.Dir[ 1 ] = 1; // right neighbor
g.Dir[ 2 ] = g.Width; // bottom neighbor
if( (g.Maze = calloc( g.NumCells, sizeof( CELL ) )) == NULL )
{
puts( "ERROR: Out of memory." );
exit( -1 );
}
for( Row = 0; Row < g.Height; Row++ )
{
g.Maze[ Cell( Row, g.Width - 1 ) ].Border |= RIGHT;
}
for( Col = 0; Col < g.Width; Col++ )
{
g.Maze[ Cell( g.Height - 1, Col ) ].Border |= BOTTOM;
}
for( i = 0; i < g.NumCells; i++ )
{
g.Maze[ i ].Path = i;
g.Maze[ i ].Walls = RIGHT + BOTTOM;
}
}
void main( int Argc, char *Argv[] )
{
if( Argc != 3 )
{
puts( "Needs dimensions, width and height." );
}
else
{
g.Width = atoi( Argv[ 1 ] );
g.Height = atoi( Argv[ 2 ] );
g.NumCells = g.Width * g.Height;
if( g.Width < 2 || g.Width > 50 || g.Height < 2 || g.Height > 50 )
{
puts( "Bad dimensions." );
}
else
{
Init();
// open up a random column on the bottom
g.Entry = random( g.Width );
Generate();
Explore();
}
}
}