home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 2: PC
/
frozenfish_august_1995.bin
/
bbs
/
d02xx
/
d0255.lha
/
SunMaze
/
sunmaze.c
< prev
Wrap
C/C++ Source or Header
|
1989-10-19
|
23KB
|
802 lines
/*
* DWR: This file has been changed to implement shadow in the
* 3d presentation of the maze.
* This is the original file from Fish 171: Maze/3DDemo.c
* All modifications are marked with "DWR:".
*/
#include <proto/all.h>
#include <libraries/dosextens.h>
#include <intuition/intuition.h>
#include <exec/memory.h>
#include <graphics/gfxmacros.h>
#define BITMAP
#include "maze.h" /* This is our maze generator */
#define MENUITEMS 6
struct IntuiText item[MENUITEMS*2]=
{ 6,0,JAM2,0,0,NULL,NULL,NULL };
struct IntuiText abouttxt5= /* Yes, this game needs lots of credits */
{ 7,0,JAM2,32,60,NULL,"keys to move",NULL}; /* DWR: changed */
struct IntuiText abouttxt4=
{ 7,0,JAM2,12,50,NULL,"Use keypad cursor",&abouttxt5}; /* DWR: changed */
struct IntuiText abouttxt3=
{ 4,0,JAM2,0,40,NULL,"Freely distributable",&abouttxt4}; /* DWR: changed */
struct IntuiText abouttxt3b=
{ 2,0,JAM2,36,30,NULL,"Dirk Reisig",&abouttxt3}; /* DWR: inserted */
struct IntuiText abouttxt3a=
{ 1,0,JAM2,40,20,NULL,"Shadows by",&abouttxt3b}; /* DWR: inserted */
struct IntuiText abouttxt2=
{ 6,0,JAM2,24,10,NULL,"Werner Gunther",&abouttxt3a}; /* DWR: changed */
struct IntuiText abouttxt1=
{ 6,0,JAM2,40,0,NULL,"Written by",&abouttxt2};
struct MenuItem mi[MENUITEMS] = /* main menu structures */
{
NULL,0,0,70,11,
ITEMTEXT|ITEMENABLED|HIGHCOMP,
NULL,NULL,NULL,NULL,NULL,NULL
};
struct MenuItem sizemenu[MENUITEMS] = /* sub menu for sizes */
{
NULL,60,0,90,11,
ITEMTEXT|ITEMENABLED|HIGHCOMP|CHECKIT,
NULL,NULL,NULL,NULL,NULL,NULL
};
struct MenuItem about = /* about, credits & help */
{
NULL,60,0,160,70,
ITEMTEXT|ITEMENABLED,
NULL,(APTR)&abouttxt1,NULL,NULL,NULL,NULL
};
struct Menu menu=
{
NULL,0,0,70,11,
MENUENABLED,
"Options",
mi
};
struct NewScreen ns= /* screen low-rez, 8 colors */
{
0,0,320,200,3,
1,0,
NULL,
CUSTOMSCREEN,
NULL,NULL,NULL,NULL
};
struct NewWindow nw= /* window for menus & gadgets */
{
0,1,286,199,
1,0,
CLOSEWINDOW|GADGETUP|MENUPICK|MENUVERIFY|VANILLAKEY,
BORDERLESS|NOCAREREFRESH|WINDOWCLOSE|ACTIVATE,
NULL, NULL,
"Maze 3D Demo",
NULL, NULL, NULL,NULL,NULL,NULL,
CUSTOMSCREEN
};
struct Image mazeimage={0,0,0,0,1,0,4,4,0}; /* Image to display the maze */
char mtxt[MENUITEMS][9]= /* menu text */
{
"Map","New Maze","Size","Demo","Quit","About"
};
char sizetxt[MENUITEMS][11]= /* text for size menu */
{
"Trivial","Simple","Normal","Advanced","Difficult","Impossible"
};
struct GfxBase *GfxBase = NULL;
struct IntuitionBase *IntuitionBase = NULL;
struct Screen *screen = NULL;
struct Window *window = NULL;
struct BitMap *bm;
struct IntuiMessage *msg;
struct AreaInfo areainfo;
struct TmpRas tmpras;
struct RastPort *rp;
ULONG class,code;
BOOL WorkBench=FALSE,demomode=FALSE,forward();
void right(),left(),demo(),newmaze(),leave(),main(),show3d(),showmaze();
void statusline();
short i,j,xsize,ysize,mazesize=2,x,y,wayout,moves;
char *mymaze=NULL,areapts[7*5],*raster=NULL,buffer[20];
short dirincs[4][2]={{0,-1},{1,0},{0,1},{-1,0}};
char heading[][7]={"North"," East ","South"," West "};
void main(argc,argv)
short argc;
char argv[];
{
if (!argc) WorkBench=TRUE; /* open stuff */
if (!(IntuitionBase = (struct IntuitonBase*)
OpenLibrary("intuition.library",0L)))
leave("No Intuition Library");
if (!(GfxBase = (struct GfxBase*) OpenLibrary("graphics.library",0L)))
leave("No Graphics Library");
for(i=0;i<MENUITEMS;i++) /* set menu-strip */
{ /* could have be done on declaration */
sizemenu[i]=sizemenu[0];
sizemenu[i].NextItem=&sizemenu[i+1];
sizemenu[i].ItemFill=(APTR)&item[i+MENUITEMS];
sizemenu[i].TopEdge=i*11;
item[i]=item[0];
item[i+MENUITEMS]=item[0];
item[i+MENUITEMS].IText=sizetxt[i];
item[i+MENUITEMS].LeftEdge=11;
item[i].IText=mtxt[i];
mi[i]=mi[0];
mi[i].NextItem=&mi[i+1];
mi[i].ItemFill=(APTR)&item[i];
mi[i].TopEdge=i*11;
}
mi[MENUITEMS-1].NextItem=NULL;
sizemenu[MENUITEMS-1].NextItem=NULL;
mi[2].SubItem=&sizemenu[0];
mi[5].SubItem=&about;
sizemenu[mazesize].Flags|=CHECKED;
if (!(screen = (struct Screen*) OpenScreen(&ns))) /* open screen & window */
leave ("Can't open Screen");
bm = screen->ViewPort.RasInfo->BitMap;
rp = &screen->RastPort;
nw.Screen=screen;
if (!(window = (struct Window*) OpenWindow(&nw))) leave("Can't open Window");
SetMenuStrip(window,&menu);
/*
* DWR: Following eight statements replace the original color setting.
*/
SetRGB4(&screen->ViewPort,0, 0, 0, 0); /* Background, black */
SetRGB4(&screen->ViewPort,1, 1, 5, 2); /* Floor, in shadow, dark green */
SetRGB4(&screen->ViewPort,2, 2, 7, 1); /* Floor, in sun, light green */
SetRGB4(&screen->ViewPort,3, 8, 8, 8); /* Side wall, in shadow, dark grey */
SetRGB4(&screen->ViewPort,4,12,12,12); /* Side wall, in sun, light grey */
SetRGB4(&screen->ViewPort,5,10,10,10); /* Front wall, in shadow, dark white */
SetRGB4(&screen->ViewPort,6,14,14,14); /* Front wall, in sun, light white */
SetRGB4(&screen->ViewPort,7, 8, 8,15); /* Sky, blue */
/* stuff needed by FloodFill, AreaFill */
if(!(raster=(char *)AllocRaster(192,188))) leave("Can't allocate TmpRaster");
InitTmpRas(&tmpras,raster,4512);
rp->TmpRas=&tmpras;
InitArea(&areainfo,areapts,7);
rp->AreaInfo=&areainfo;
BNDRYOFF(rp);
for(i=0;i<3;i++) /* Draw status-display box */
{
SetAPen(rp,i+3);
AreaMove(rp,190+5*i,12+5*i);
AreaDraw(rp,319-5*i,12+5*i);
AreaDraw(rp,319-5*i,125-5*i);
AreaDraw(rp,319-5*i-5,125-5*i-5);
AreaDraw(rp,319-5*i-5,12+i*5+5);
AreaDraw(rp,190+5*i+5,12+i*5+5);
AreaEnd(rp);
SetAPen(rp,i+2);
AreaMove(rp,190+5*i,12+5*i);
AreaDraw(rp,190+5*i,125-5*i);
AreaDraw(rp,319-5*i,125-5*i);
AreaDraw(rp,319-5*i-5,125-5*i-5);
AreaDraw(rp,319-5*i-5,12+i*5+5);
AreaDraw(rp,190+5*i+5,12+i*5+5);
AreaEnd(rp);
}
newmaze();
for(;;) /* main loop, wait for a message if not in demo-mode */
{
if (!demomode) WaitPort(window->UserPort);
else demo();
if(msg=(struct IntuiMessage*)GetMsg(window->UserPort))
{
demomode=FALSE;
class=msg->Class;
code=msg->Code;
ReplyMsg(msg);
switch(class)
{
case CLOSEWINDOW:
leave("");
case VANILLAKEY:
if(y!=wayout || x!=xsize-3)
switch(code) /* we check numbers 6/4/8, these are arrows on the */
{ /* num pad keys, so we don't need RawKeyConvert */
case '8':
forward();
break;
case '4':
left();
break;
case '6':
right();
break;
}
break;
case MENUPICK:
switch(ITEMNUM(code))
{
case 0: /* map */
showmaze();
moves+=30;
break; /* New Maze */
case 1:
newmaze();
break;
case 2:
if(SUBNUM(code)==mazesize) break;
sizemenu[mazesize].Flags&=~CHECKED;
mazesize=SUBNUM(code);
sizemenu[mazesize].Flags|=CHECKED;
newmaze();
break;
case 3: /* Demo */
demomode=TRUE;
break;
case 4: /* Quit */
leave("");
case 5: /* About */
; /* Inserted ; to make Aztec happy -- PDS(1) -- 31-jul-88 */
}
}
}
}
}
void leave(error)
char *error;
{
BPTR file;
/* Free Resouces & Exit */
if(window) CloseWindow(window);
if(screen) CloseScreen(screen);
if(IntuitionBase) CloseLibrary(IntuitionBase);
if(GfxBase) CloseLibrary(GfxBase);
if (mymaze) FreeMem(mymaze,(xsize>>3)*ysize);
if (raster) FreeRaster(raster,192,188);
if (*error && WorkBench &&
(file=Open("con:20/70/400/60/Maze 3D Demo",MODE_OLDFILE)))
{
Write(file,error,strlen(error));
Delay(200L);
Close(file);
}
else if (*error) printf("%s\n",error);
exit(0);
}
void newmaze()
{
if (mymaze) FreeMem(mymaze,(xsize>>3)*ysize); /* Free old maze */
xsize=32+mazesize*16; /* get new dimension */
ysize=12+mazesize*12;
if (!(mymaze=(char*) AllocMem((xsize>>3)*ysize,MEMF_CHIP|MEMF_CLEAR)))
leave("Out of chip memory"); /* allocate new one */
SetAPen(rp,6); /* clear status display */
RectFill(rp,205,27,304,110);
SetAPen(rp,1);
statusline(10,"Moves:");
statusline(30,"Looking");
statusline(60,"Size:");
sprintf(buffer,"%ld*%ld",xsize,ysize);
statusline(70,buffer);
maze(xsize,ysize,mymaze); /* genarate a new maze */
seed = FastRand(seed);
y= ((seed & 0x7ffe) % (ysize-4)+2) & 0x7ffe; /* random start point */
x= 2;
seed = FastRand(seed);
wayout = ((seed & 0x7ffe) % (ysize-4)+2) & 0x7ffe; /* random exit */
MAZESET(xsize-3,wayout,xsize,mymaze); /* open exit */
direction=1; /* heading right (east) */
statusline(40,heading[direction]);
moves=0;
show3d();
showmaze();
}
void statusline(y,text)
short y;
char *text;
{ /* Write text, centered, into */
Move(rp,255-strlen(text)*4,27+y); /* status-display */
SetAPen(rp,1);
SetBPen(rp,6);
Text(rp,text,strlen(text));
}
void showmaze() /* show the maze */
{
mazeimage.Width=xsize; /* we define a Image-structure on our */
mazeimage.Height=ysize; /* bitmapped maze */
mazeimage.ImageData=(short*)mymaze;
DrawImage(rp,&mazeimage,255-(xsize/2),127);
/* wait for a message */
while(! window->UserPort->mp_MsgList.lh_Head->ln_Succ)
{
SetAPen(rp,++i&7); /* exit and current position */
WritePixel(rp,255-(xsize/2)+x,127+y); /* are blinking */
WritePixel(rp,253-(xsize/2)+xsize,127+wayout);
Delay(6L);
}
SetAPen(rp,0);
RectFill(rp,191,127,319,199);
}
/*
* DWR: The original 3d function is replaced by the one
* at the end of this file..
*/
void demo() /* demo mode: follow the left-hand wall until we get to */
{ /* the exit */
long delay;
/* be fast if the exit is far away, slow if it gets nearer */
delay=19-18*(xsize-3-x+((wayout-y)<0?-(wayout-y):(wayout-y)))/
((wayout<ysize/2? ysize-wayout:wayout)+xsize-3);
if(y==wayout && x==xsize-3) /* did we reach the exit ?*/
{
demomode=FALSE; /* stop if we did */
return;
} /* is it possible to turn left ? */
if(MAZETEST(x+dirincs[(direction-1)&3][0],y+dirincs[(direction-1)&3][1],
xsize,mymaze))
{
left(); /* yes, turn left */
Delay(delay);
forward(); /* and one step forward */
}
else if(!forward()) right(); /* if not try to move forward, if everything */
/* fails, turn right */
Delay(delay);
}
BOOL forward() /* move one step forward if possible */
{
if(!(MAZETEST(x+dirincs[direction][0],
y+dirincs[direction][1],xsize,mymaze))) return(FALSE);
x+=dirincs[direction][0];
y+=dirincs[direction][1];
moves++;
sprintf(buffer," %ld/%ld ",
moves,xsize-3-x+((wayout-y)<0?-(wayout-y):(wayout-y)));
statusline(20,buffer);
show3d();
if(y==wayout && x==xsize-3) /* has the exit been reached ?*/
{
SetAPen(rp,1); /* yes, write some stupid text */
SetBPen(rp,7);
Move(rp,58,102); /* DWR: changed */
Text(rp,"Solved in",9);
SetAPen(rp,6);
SetBPen(rp,2); /* DWR: changed */
sprintf(buffer,"%ld moves.",moves);
Move(rp,94-strlen(buffer)*4,116);
Text(rp,buffer,strlen(buffer));
}
return(TRUE);
}
void left() /* turn left */
{
direction=(--direction) & 3;
show3d();
statusline(40,heading[direction]);
}
void right() /* turn right */
{
direction=(++direction) & 3;
show3d();
statusline(40,heading[direction]);
}
/*
* DWR: The new 3d fucntion and its support.
* The basic form of the display is a number of (not drawn) paralel
* squares.
* Starting at the middle of the display (roughly 200*200) the
* smallest square has a side of one dot. The next square two dots.
* This increments via 4, 8, 16, 32, 64 to 128 dots. This way
* we can see 8 squares deep.
* By drawing diagonals we separate walls from the floor and the
* sky. When there is a cross-passage, we donot draw these
* diagonals but extent the square in the direction of the cross
* path until we reach the nearer square.
* The shadows are based on a sun at 60 degrees above the horizon
* and in the south-west (3 o'clock). This way we have shadow-patterns
* which can be expressed in the number system of the squares. (You
* remember the 30-60-90 triangle?)
* The order of drawing is chosen to mask away some bad drawn shadows
* and irregularities in conjunction with edges.
*/
#define MAXDEPTH 8 /* 8 squares deep */
#define SHADOW 1 /* The value you must subtract from a */
/* wall or floor to get it shaded */
#define SKY 7
#define FLOOR 2 /* 2 -> light green, 1 -> dark green */
#define SIDE 4 /* 4 -> light grey, 3-> dark grey */
#define FRONT 6 /* 6 -> light white, 5-> dark white (grey of course) */
#define HMID 94 /* The horizontal middle of the display */
#define VMID 105 /* The vertical middle */
/* This was 106, which was wrong */
#define LEFT -1 /* Factors which define the direction */
#define RIGHT 1 /* from the horizontal middle */
short Shadow[]={ 0,0,SHADOW,SHADOW }; /* Change this to reposition the sun */
void show3d()
{
short Side; /* Can be "LEFT" or "RIGHT" */
short Wall; /* Actual distance we can see */
short Depth; /* Level we are drawing in */
short Inner; /* Size of the wall in the square we are */
short Outer; /* Size of the wall one level nearer */
short Middle; /* Size of the wall between those two */
short InMid; /* Size of shadow far from us */
short OutMid; /* Size of shadow near to us */
short Minim; /* The minimal size we use with drawing shadows */
short MazeExit; /* Flag set if we are looking at the exit */
/*
WaitBOVP(rp);
*/
/*
* First we draw the pampas. It consists of floor and
* the sky, separated by the horizon.
* All floor under the horizon is light green (in the sun),
* and all above is blue sky.
*/
SetAPen(rp,SKY);
RectFill(rp,0,VMID-HMID,2*HMID,VMID);
SetAPen(rp,FLOOR);
RectFill(rp,0,VMID+1,2*HMID,VMID+HMID);
/*
* Find out how far we can see in the maze.
* That is howmuch squares is the opposite wall
* from us away. If further than we can draw, this
* value represents the deepest square we can draw (8).
*/
for (Depth=1; Depth<MAXDEPTH; Depth++){
if (!(MAZETEST(x+Depth*dirincs[direction][0],
y+Depth*dirincs[direction][1],
xsize,mymaze)))
break;
}
/*
* Keep this value for later when we draw the opposite wall.
* Determine the smallest value we use with drawing shades.
* And perhaps we are looking at the exit.
*/
Wall=Depth-1;
Minim=1<<((MAXDEPTH-1)-Depth);
MazeExit= ((y==wayout)&&((x+Wall*dirincs[direction][0])==xsize-2));
/*
* Draw first the left side of the view, followed
* by the right side.
*/
for (Side=LEFT; Side<=RIGHT; Side+=2){
/*
* Loop for drawing in all squares, beginning at
* the farrest level, ending at our present position.
*/
for (Depth=Wall; Depth>=0; Depth--){
/*
* Detemine some values we use in this square.
*/
Inner=1<<((MAXDEPTH-2)-Depth); /* Half size of this square */
Outer=Inner<<1; /* Half size on one square nearer */
Middle=(Outer+Inner)/2; /* The same size of a square between */
if (Outer>HMID) Outer=HMID; /* If too near (larger than display */
if (Middle>HMID) Middle=HMID; /* clip it to a useful size */
/*
* Are we dealing with a wall or a cross-passage?
*/
if (!IsPassage(Side,Depth)){
/*
* We draw a wall and its shadow if visable.
* The shadow is visable if the surface of the
* wall is in the shadow.
*/
if (Shadow[(direction+Side)&3]){
/* The shadow is on our path, now is
* it directed toward us or from us away?
*/
if (Shadow[direction]){ /* To us */
InMid=Middle;
OutMid=Middle<<1;
if (OutMid>HMID) OutMid=HMID;
} else{ /* From us */
InMid=Middle/2+1;
if (InMid<Minim) InMid=Minim;
OutMid=Middle;
}
/*
* Draw this shadow of the side wall on out path
*/
SetAPen(rp,FLOOR-SHADOW);
AreaMove(rp,HMID,VMID+InMid);
AreaDraw(rp,HMID,VMID+OutMid);
AreaDraw(rp,HMID+Side*Outer,VMID+Outer);
AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
AreaEnd(rp);
}
/* End of drawing shadow on our path */
/*
* Draw the side wall itself using the color of
* a side wall, but modify it by a possible
* shade correction.
*/
SetAPen(rp,SIDE-Shadow[(direction+Side)&3]);
AreaMove(rp,HMID+Side*Inner,VMID-Inner);
AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
AreaDraw(rp,HMID+Side*Outer,VMID+Outer);
AreaDraw(rp,HMID+Side*Outer,VMID-Outer);
AreaEnd(rp);
/*
* If we are the first time in this loop,
* and the opposite wall is in the shadow,
* and the just drawn side wall is in the sun,
* draw the shadow from the opposite wall on it.
*/
if ((Depth==Wall)&& Shadow[direction]&& !Shadow[(direction+Side)&3]){
SetAPen(rp,SIDE-SHADOW);
AreaMove(rp,HMID+Side*Inner,VMID-Inner);
AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
AreaDraw(rp,HMID+Side*Middle,VMID+Middle);
AreaEnd(rp);
}
}
/* End of dealing with a side wall */
else{
/*
* Here we are dealing with a cross passage,
* We first draw some shadows on the floor,
* as well on our path, as on the cross passage.
*/
SetAPen(rp,FLOOR-SHADOW);
/*
* Is the shadow in the direction of our path?
*/
if (Shadow[(direction+Side)&3]){
/*
* The shadow is in the direction of our path,
* now is it directed from us away?
*/
if (Shadow[direction]){
/*
* The crosswall is in the shade.
* Draw the shadow on the coss path.
* The distiction between the sides is to meet
* the RectFill() form.
*/
if (Side==LEFT)
RectFill(rp,HMID-Outer,VMID+Inner,HMID,VMID+Middle);
else
RectFill(rp,HMID,VMID+Inner,HMID+Outer,VMID+Middle);
}
else{
/*
* The cross wall is in the sun.
* Draw the shadow of the other side.
*/
if (Side==LEFT)
RectFill(rp,HMID-Outer,VMID+Middle,HMID,VMID+Outer);
else
RectFill(rp,HMID,VMID+Middle,HMID+Outer,VMID+Outer);
}
}
/* End of shadow directed to our path */
else{
/*
* The shadow is directed from our path away.
* Now draw the shadow on the cross path if
* the cross wall is in the shade.
*/
if (Shadow[direction]){
AreaMove(rp,HMID+Side*Inner,VMID+Inner);
AreaDraw(rp,HMID+Side*Outer,VMID+Inner);
AreaDraw(rp,HMID+Side*Outer,VMID+(Inner+Outer)/2);
AreaEnd(rp);
}
}
/*
* If we are here for the first time,
* and the opposite wall is visable,
* and it is in the shade,
* extent the shadow of the opposite wall to
* the one from the cross wall. (A tiny triangle)
*/
if ((Depth==Wall)&&(Depth<MAXDEPTH)&&(Shadow[direction])){
AreaMove(rp,HMID+Side*Inner,VMID+Inner);
AreaDraw(rp,HMID+Side*Middle,VMID+Middle);
AreaDraw(rp,HMID+Side*Outer,VMID+Middle);
AreaDraw(rp,HMID+Side*Outer,VMID+Inner);
AreaEnd(rp);
}
/*
* If we are not dealing with the exit's cross path
* draw the cross wall itself.
*/
if (!(MazeExit&&(Depth>(Wall-1)))){
SetAPen(rp,FRONT-Shadow[direction]);
if (Side==RIGHT)
RectFill(rp,HMID+Inner,VMID-Inner,HMID+Outer,VMID+Inner);
else
RectFill(rp,HMID-Outer,VMID-Inner,HMID-Inner,VMID+Inner);
}
}
/* End of drawing a cross passage (or side wall) */
}
/* End of drawing in subsequent squares */
}
/* End of drawing the left and right side ot the picture */
/*
* Now we have to draw the opposite wall
* or the exit if not too far away
*/
Depth=Wall;
if (Depth<MAXDEPTH-1){
/*
* It is not too far away.
* Fill in again those sizes.
*/
Inner=1<<((MAXDEPTH-2)-Depth);
Outer=Inner<<1;
Middle=(Outer+Inner)/2;
if (Outer>HMID) Outer=HMID;
if (Middle>HMID) Middle=HMID;
/*
* Are we not looking at the exit?
*/
if (!MazeExit){
/*
* We are looking at an opposite wall.
* Draw its shadow on the floor if it is in the shade.
*/
if (Shadow[direction]){
SetAPen(rp,FLOOR-SHADOW);
AreaMove(rp,HMID+1-Inner,VMID+Inner);
AreaDraw(rp,HMID+1-Middle,VMID+Middle);
AreaDraw(rp,HMID-1+Middle,VMID+Middle);
AreaDraw(rp,HMID-1+Inner,VMID+Inner);
AreaEnd(rp);
}
/*
* Draw the opposite wall itself.
*/
SetAPen(rp,FRONT-Shadow[direction]);
RectFill(rp,HMID-Inner,VMID-Inner,HMID+Inner,VMID+Inner);
/*
* If the opposite wall is bounded to a side wall,
* and this side wall is in the shadow,
* and the opposite wall is in the sun,
* draw the shadow of the side wall on the opposite wall.
*/
for (Side=LEFT; Side<=RIGHT; Side+=2){
if (
(!IsPassage(Side,Depth))&&
(Shadow[(direction+Side)&3])&&
(!Shadow[direction])
){
SetAPen(rp,FRONT-SHADOW);
AreaMove(rp,HMID+Side*Inner,VMID-Inner);
AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
AreaDraw(rp,HMID,VMID+Inner);
AreaEnd(rp);
}
}
}
}
}
/*
* This was original in line, but it disturbed the view over the
* code. Placing it in a function made the clearity of the show3d()
* function better.
* This function returns the presence of a cross passage at <Side>'s
* side and <Depth> from us away.
*/
IsPassage(Side,Depth)
short Side,Depth;
{
register int xx,yy;
xx=x+dirincs[(direction+Side)&3][0]+Depth*dirincs[direction][0];
yy=y+dirincs[(direction+Side)&3][1]+Depth*dirincs[direction][1];
return(MAZETEST(xx,yy, xsize,mymaze));
}