fish/sunmaze/sunmaze.c

   1 /*
   2  *  DWR:  This file has been changed to implement shadow in the
   3  *  3d presentation of the maze.
   4  *  This is the original file from Fish 171:  Maze/3DDemo.c
   5  *  All modifications are marked with "DWR:".
   6  */
   7
   8 #include <aros/oldprograms.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <libraries/dosextens.h>
  13 #include <intuition/intuition.h>
  14 #include <exec/memory.h>
  15 #include <graphics/gfxmacros.h>
  16
  17 #define BITMAP
  18
  19 #include "maze.h"         /* This is our maze generator */
  20
  21 #define MENUITEMS 6
  22
  23 struct IntuiText item[MENUITEMS*2]=
  24 { {6,0,JAM2,0,0,NULL,NULL,NULL} };
  25
  26 struct IntuiText abouttxt5=   /* Yes, this game needs lots of credits */
  27 { 7,0,JAM2,32,60,NULL,"keys to move",NULL};  /* DWR: changed */
  28 struct IntuiText abouttxt4=
  29 { 7,0,JAM2,12,50,NULL,"Use keypad cursor",&abouttxt5};  /* DWR: changed */
  30 struct IntuiText abouttxt3=
  31 { 4,0,JAM2,0,40,NULL,"Freely distributable",&abouttxt4};  /* DWR: changed */
  32
  33 struct IntuiText abouttxt3b=
  34 { 2,0,JAM2,36,30,NULL,"Dirk Reisig",&abouttxt3};  /* DWR: inserted */
  35 struct IntuiText abouttxt3a=
  36 { 1,0,JAM2,40,20,NULL,"Shadows by",&abouttxt3b};  /* DWR: inserted */
  37
  38 struct IntuiText abouttxt2=
  39 { 6,0,JAM2,24,10,NULL,"Werner Gunther",&abouttxt3a};  /* DWR: changed */
  40 struct IntuiText abouttxt1=
  41 { 6,0,JAM2,40,0,NULL,"Written by",&abouttxt2};
  42
  43
  44 struct MenuItem mi[MENUITEMS] =          /* main menu structures */
  45 {
  46  {
  47  NULL,0,0,70,11,
  48  ITEMTEXT|ITEMENABLED|HIGHCOMP,
  49  0, 0, 0, 0, 0, 0
  50  }
  51 };
  52 struct MenuItem sizemenu[MENUITEMS] =    /* sub menu for sizes */
  53 {
  54  {
  55  NULL,60,0,90,11,
  56  ITEMTEXT|ITEMENABLED|HIGHCOMP|CHECKIT,
  57  0, 0, 0, 0, 0, 0
  58  }
  59 };
  60 struct MenuItem about =                  /* about, credits & help */
  61 {
  62  NULL,60,0,160,70,
  63  ITEMTEXT|ITEMENABLED,
  64  0,(APTR)&abouttxt1,0,0,0,0
  65 };
  66
  67 struct Menu menu=
  68 {
  69  NULL,0,0,70,11,
  70  MENUENABLED,
  71  "Options",
  72  mi
  73 };
  74
  75 struct NewScreen ns=                     /* screen low-rez, 8 colors */
  76 {
  77  0,0,320,200,3,
  78  1,0,
  79  0,
  80  CUSTOMSCREEN,
  81  0, 0, 0, 0,
  82 };
  83
  84 struct NewWindow nw=                     /* window for menus & gadgets */
  85 {
  86  0,1,286,199,
  87  1,0,
  88  CLOSEWINDOW|GADGETUP|MENUPICK|MENUVERIFY|VANILLAKEY,
  89  BORDERLESS|NOCAREREFRESH|WINDOWCLOSE|ACTIVATE,
  90  0, 0,
  91  "Maze 3D Demo",
  92  0, 0, 0, 0, 0, 0,
  93  CUSTOMSCREEN
  94 };
  95
  96 struct Image mazeimage={0,0,0,0,1,0,4,4,0}; /* Image to display the maze */
  97
  98 char mtxt[MENUITEMS][9]=                    /* menu text */
  99 {
 100  "Map","New Maze","Size","Demo","Quit","About"
 101 };
 102 char sizetxt[MENUITEMS][11]=                /* text for size menu */
 103 {
 104  "Trivial","Simple","Normal","Advanced","Difficult","Impossible"
 105 };
 106
 107 struct GfxBase *GfxBase = NULL;
 108 struct IntuitionBase *IntuitionBase = NULL;
 109 struct Screen *screen = NULL;
 110 struct Window *window = NULL;
 111 struct BitMap *bm;
 112 struct IntuiMessage *msg;
 113 struct AreaInfo  areainfo;
 114 struct TmpRas tmpras;
 115 struct RastPort *rp;
 116
 117 ULONG  class,code;
 118 BOOL   WorkBench=FALSE,demomode=FALSE,forward();
 119 void   right(),left(),demo(),newmaze(),leave(),show3d(),showmaze();
 120 void   statusline();
 121 short  i,j,xsize,ysize,mazesize=2,x,y,wayout,moves;
 122 char   *mymaze=NULL,areapts[7*5],*raster=NULL,buffer[20];
 123 short  dirincs[4][2]={{0,-1},{1,0},{0,1},{-1,0}};
 124 char   heading[][7]={"North"," East ","South"," West "};
 125
 126 int IsPassage(short, short);
 127
 128 int main(argc,argv)
 129 int argc;
 130 char argv[];
 131 {
 132  if (!argc) WorkBench=TRUE;      /* open stuff */
 133  if (!(IntuitionBase = (struct IntuitionBase*)
 134   OpenLibrary("intuition.library",0L)))
 135     leave("No Intuition Library");
 136  if (!(GfxBase = (struct GfxBase*) OpenLibrary("graphics.library",0L)))
 137     leave("No Graphics Library");
 138
 139  for(i=0;i<MENUITEMS;i++)        /* set menu-strip */
 140  {                               /* could have be done on declaration */
 141   sizemenu[i]=sizemenu[0];
 142   sizemenu[i].NextItem=&sizemenu[i+1];
 143   sizemenu[i].ItemFill=(APTR)&item[i+MENUITEMS];
 144   sizemenu[i].TopEdge=i*11;
 145   item[i]=item[0];
 146   item[i+MENUITEMS]=item[0];
 147   item[i+MENUITEMS].IText=sizetxt[i];
 148   item[i+MENUITEMS].LeftEdge=11;
 149   item[i].IText=mtxt[i];
 150   mi[i]=mi[0];
 151   mi[i].NextItem=&mi[i+1];
 152   mi[i].ItemFill=(APTR)&item[i];
 153   mi[i].TopEdge=i*11;
 154  }
 155  mi[MENUITEMS-1].NextItem=NULL;
 156  sizemenu[MENUITEMS-1].NextItem=NULL;
 157  mi[2].SubItem=&sizemenu[0];
 158  mi[5].SubItem=&about;
 159  sizemenu[mazesize].Flags|=CHECKED;
 160
 161  if (!(screen = (struct Screen*) OpenScreen(&ns))) /* open screen & window */
 162     leave ("Can't open Screen");
 163  bm = screen->ViewPort.RasInfo->BitMap;
 164  rp = &screen->RastPort;
 165
 166  nw.Screen=screen;
 167  if (!(window = (struct Window*) OpenWindow(&nw))) leave("Can't open Window");
 168  SetMenuStrip(window,&menu);
 169
 170 /*
 171 *  DWR: Following eight statements replace the original color setting.
 172 */
 173
 174  SetRGB4(&screen->ViewPort,0, 0, 0, 0); /* Background, black */
 175  SetRGB4(&screen->ViewPort,1, 1, 5, 2); /* Floor, in shadow, dark green */
 176  SetRGB4(&screen->ViewPort,2, 2, 7, 1); /* Floor, in sun, light green */
 177  SetRGB4(&screen->ViewPort,3, 8, 8, 8); /* Side wall, in shadow, dark grey */
 178  SetRGB4(&screen->ViewPort,4,12,12,12); /* Side wall, in sun, light grey */
 179  SetRGB4(&screen->ViewPort,5,10,10,10); /* Front wall, in shadow, dark white */
 180  SetRGB4(&screen->ViewPort,6,14,14,14); /* Front wall, in sun, light white */
 181  SetRGB4(&screen->ViewPort,7, 8, 8,15); /* Sky, blue  */
 182
 183  /* stuff needed by FloodFill, AreaFill */
 184  if(!(raster=(char *)AllocRaster(192,188))) leave("Can't allocate TmpRaster");
 185  InitTmpRas(&tmpras,raster,4512);
 186  rp->TmpRas=&tmpras;
 187  InitArea(&areainfo,areapts,7);
 188  rp->AreaInfo=&areainfo;
 189  BNDRYOFF(rp);
 190
 191  for(i=0;i<3;i++) /* Draw status-display box */
 192  {
 193   SetAPen(rp,i+3);
 194   AreaMove(rp,190+5*i,12+5*i);
 195   AreaDraw(rp,319-5*i,12+5*i);
 196   AreaDraw(rp,319-5*i,125-5*i);
 197   AreaDraw(rp,319-5*i-5,125-5*i-5);
 198   AreaDraw(rp,319-5*i-5,12+i*5+5);
 199   AreaDraw(rp,190+5*i+5,12+i*5+5);
 200   AreaEnd(rp);
 201   SetAPen(rp,i+2);
 202   AreaMove(rp,190+5*i,12+5*i);
 203   AreaDraw(rp,190+5*i,125-5*i);
 204   AreaDraw(rp,319-5*i,125-5*i);
 205   AreaDraw(rp,319-5*i-5,125-5*i-5);
 206   AreaDraw(rp,319-5*i-5,12+i*5+5);
 207   AreaDraw(rp,190+5*i+5,12+i*5+5);
 208   AreaEnd(rp);
 209  }
 210
 211  newmaze();
 212
 213  for(;;)           /* main loop, wait for a message if not in demo-mode */
 214  {
 215   if (!demomode) WaitPort(window->UserPort);
 216   else demo();
 217   if(NULL != (msg=(struct IntuiMessage*)GetMsg(window->UserPort)))
 218   {
 219    demomode=FALSE;
 220    class=msg->Class;
 221    code=msg->Code;
 222    ReplyMsg((struct Message *)msg);
 223    switch(class)
 224    {
 225     case CLOSEWINDOW:
 226      leave("");
 227     case VANILLAKEY:
 228      if(y!=wayout || x!=xsize-3)
 229       switch(code) /* we check numbers 6/4/8, these are arrows on the */
 230       {            /* num pad keys, so we don't need RawKeyConvert */
 231        case '8':
 232         forward();
 233         break;
 234        case '4':
 235         left();
 236         break;
 237        case '6':
 238         right();
 239         break;
 240       }
 241      break;
 242     case MENUPICK:
 243       switch(ITEMNUM(code))
 244       {
 245        case 0:         /* map */
 246         showmaze();
 247         moves+=30;
 248         break;         /* New Maze */
 249        case 1:
 250         newmaze();
 251         break;
 252        case 2:
 253         if(SUBNUM(code)==mazesize) break;
 254         sizemenu[mazesize].Flags&=~CHECKED;
 255         mazesize=SUBNUM(code);
 256         sizemenu[mazesize].Flags|=CHECKED;
 257         newmaze();
 258         break;
 259        case 3:         /* Demo  */
 260         demomode=TRUE;
 261         break;
 262        case 4:         /* Quit  */
 263         leave("");
 264        case 5:         /* About */
 265                 ; /* Inserted ; to make Aztec happy -- PDS(1) -- 31-jul-88 */
 266       }
 267    }
 268   }
 269  }
 270 }
 271
 272 void leave(error)
 273 char *error;
 274 {
 275  BPTR file;
 276                    /* Free Resouces & Exit */
 277  if(window)        CloseWindow(window);
 278  if(screen)        CloseScreen(screen);
 279  if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
 280  if(GfxBase)       CloseLibrary((struct Library *)GfxBase);
 281  if (mymaze)       FreeMem(mymaze,(xsize>>3)*ysize);
 282  if (raster)       FreeRaster(raster,192,188);
 283
 284  if (*error && WorkBench &&
 285      (file=Open("con:20/70/400/60/Maze 3D Demo",MODE_OLDFILE)))
 286  {
 287   Write(file,error,strlen(error));
 288   Delay(200L);
 289   Close(file);
 290  }
 291  else if (*error) printf("%s\n",error);
 292  exit(0);
 293 }
 294
 295 void newmaze()
 296 {
 297  if (mymaze) FreeMem(mymaze,(xsize>>3)*ysize); /* Free old maze */
 298  xsize=32+mazesize*16;                         /* get new dimension */
 299  ysize=12+mazesize*12;
 300  if (!(mymaze=(char*) AllocMem((xsize>>3)*ysize,MEMF_CHIP|MEMF_CLEAR)))
 301      leave("Out of chip memory");              /* allocate new one */
 302  SetAPen(rp,6);                                /* clear status display */
 303  RectFill(rp,205,27,304,110);
 304  SetAPen(rp,1);
 305  statusline(10,"Moves:");
 306  statusline(30,"Looking");
 307  statusline(60,"Size:");
 308  sprintf(buffer,"%ld*%ld",(long)xsize,(long)ysize);
 309  statusline(70,buffer);
 310
 311  maze(xsize,ysize,mymaze);                     /* genarate a new maze */
 312  seed = FastRand(seed);
 313  y= ((seed & 0x7ffe) % (ysize-4)+2) & 0x7ffe;  /* random start point */
 314  x= 2;
 315
 316  seed = FastRand(seed);
 317  wayout = ((seed & 0x7ffe) % (ysize-4)+2) & 0x7ffe;  /* random exit */
 318  MAZESET(xsize-3,wayout,xsize,mymaze);               /* open exit */
 319  direction=1;                                    /* heading right (east) */
 320  statusline(40,heading[direction]);
 321  moves=0;
 322  show3d();
 323  showmaze();
 324 }
 325
 326 void statusline(y,text)
 327 short y;
 328 char *text;
 329 {                                  /* Write text, centered, into */
 330  Move(rp,255-strlen(text)*4,27+y); /* status-display */
 331  SetAPen(rp,1);
 332  SetBPen(rp,6);
 333  Text(rp,text,strlen(text));
 334 }
 335
 336 void showmaze()                   /* show the maze */
 337 {
 338  mazeimage.Width=xsize;           /* we define a Image-structure on our */
 339  mazeimage.Height=ysize;          /* bitmapped maze */
 340  mazeimage.ImageData=(short*)mymaze;
 341  DrawImage(rp,&mazeimage,255-(xsize/2),127);
 342                                                /* wait for a message */
 343  while(! window->UserPort->mp_MsgList.lh_Head->ln_Succ)
 344  {
 345   SetAPen(rp,++i&7);                        /* exit and current position */
 346   WritePixel(rp,255-(xsize/2)+x,127+y);     /* are blinking */
 347   WritePixel(rp,253-(xsize/2)+xsize,127+wayout);
 348   Delay(6L);
 349  }
 350  SetAPen(rp,0);
 351  RectFill(rp,191,127,319,199);
 352 }
 353
 354
 355 /*
 356 *  DWR: The original 3d function is replaced by the one
 357 *  at the end of this file..
 358 */
 359
 360
 361 void demo()    /* demo mode: follow the left-hand wall until we get to */
 362 {              /* the exit */
 363  long delay;
 364                /* be fast if the exit is far away, slow if it gets nearer */
 365  delay=19-18*(xsize-3-x+((wayout-y)<0?-(wayout-y):(wayout-y)))/
 366           ((wayout<ysize/2? ysize-wayout:wayout)+xsize-3);
 367
 368  if(y==wayout && x==xsize-3) /* did we reach the exit ?*/
 369  {
 370   demomode=FALSE;            /* stop if we did */
 371   return;
 372  }                           /* is it possible to turn left ? */
 373  if(MAZETEST(x+dirincs[(direction-1)&3][0],y+dirincs[(direction-1)&3][1],
 374              xsize,mymaze))
 375  {
 376   left();                    /* yes, turn left */
 377   Delay(delay);
 378   forward();                 /* and one step forward */
 379  }
 380  else if(!forward()) right(); /* if not try to move forward, if everything */
 381                               /* fails, turn right */
 382  Delay(delay);
 383 }
 384
 385 BOOL forward()                /* move one step forward if possible */
 386 {
 387  if(!(MAZETEST(x+dirincs[direction][0],
 388              y+dirincs[direction][1],xsize,mymaze))) return(FALSE);
 389
 390  x+=dirincs[direction][0];
 391  y+=dirincs[direction][1];
 392  moves++;
 393  sprintf(buffer," %ld/%ld ",
 394          (long)moves,(long)(xsize-3-x+((wayout-y)<0?-(wayout-y):(wayout-y))));
 395  statusline(20,buffer);
 396  show3d();
 397
 398  if(y==wayout && x==xsize-3)  /* has the exit been reached ?*/
 399  {
 400   SetAPen(rp,1);              /* yes, write some stupid text */
 401   SetBPen(rp,7);
 402   Move(rp,58,102);  /*  DWR: changed  */
 403   Text(rp,"Solved in",9);
 404   SetAPen(rp,6);
 405   SetBPen(rp,2);  /*  DWR: changed  */
 406   sprintf(buffer,"%ld moves.",(long)moves);
 407   Move(rp,94-strlen(buffer)*4,116);
 408   Text(rp,buffer,strlen(buffer));
 409  }
 410  return(TRUE);
 411 }
 412
 413 void left()                 /* turn left */
 414 {
 415  direction--;
 416  direction=direction & 3;
 417  show3d();
 418  statusline(40,heading[direction]);
 419 }
 420
 421 void right()                /* turn right */
 422 {
 423   direction++;
 424  direction=direction & 3;
 425  show3d();
 426  statusline(40,heading[direction]);
 427 }
 428
 429
 430 /*
 431  *  DWR: The new 3d fucntion and its support.
 432  *  The basic form of the display is a number of (not drawn) paralel
 433  *  squares.
 434  *  Starting at the middle of the display (roughly 200*200) the
 435  *  smallest square has a side of one dot. The next square two dots.
 436  *  This increments via 4, 8, 16, 32, 64 to 128 dots.  This way
 437  *  we can see 8 squares deep.
 438  *  By drawing diagonals we separate walls from the floor and the
 439  *  sky.  When there is a cross-passage, we donot draw these
 440  *  diagonals but extent the square in the direction of the cross
 441  *  path until we reach the nearer square.
 442  *  The shadows are based on a sun at 60 degrees above the horizon
 443  *  and in the south-west (3 o'clock).  This way we have shadow-patterns
 444  *  which can be expressed in the number system of the squares. (You
 445  *  remember the 30-60-90 triangle?)
 446  *  The order of drawing is chosen to mask away some bad drawn shadows
 447  *  and irregularities in conjunction with edges.
 448  */
 449
 450
 451 #define MAXDEPTH 8      /* 8 squares deep                               */
 452
 453 #define SHADOW 1        /* The value you must subtract from a           */
 454                         /* wall or floor to get it shaded               */
 455 #define SKY   7
 456 #define FLOOR 2         /* 2 -> light green, 1 -> dark green            */
 457 #define SIDE  4         /* 4 -> light grey,  3-> dark grey              */
 458 #define FRONT 6         /* 6 -> light white, 5-> dark white (grey of course) */
 459
 460 #define HMID 94         /* The horizontal middle of the display         */
 461 #define VMID 105        /* The vertical middle                          */
 462                         /* This was 106, which was wrong                */
 463
 464 #define LEFT -1         /* Factors which define the direction           */
 465 #define RIGHT 1         /* from the horizontal middle                   */
 466
 467
 468 short Shadow[]={ 0,0,SHADOW,SHADOW }; /* Change this to reposition the sun */
 469
 470
 471 void show3d()
 472 {
 473
 474   short Side;           /* Can be "LEFT" or "RIGHT"                     */
 475   short Wall;           /* Actual distance we can see                   */
 476   short Depth;          /* Level we are drawing in                      */
 477   short Inner;          /* Size of the wall in the square we are        */
 478   short Outer;          /* Size of the wall one level nearer            */
 479   short Middle;         /* Size of the wall between those two           */
 480   short InMid;          /* Size of shadow far from us                   */
 481   short OutMid;         /* Size of shadow near to us                    */
 482   short Minim;          /* The minimal size we use with drawing shadows */
 483   short MazeExit;       /* Flag set if we are looking at the exit       */
 484
 485 /*
 486   WaitBOVP(rp);
 487 */
 488
 489  /*
 490   *  First we draw the pampas.  It consists of floor and
 491   *  the sky, separated by the horizon.
 492   *  All floor under the horizon is light green (in the sun),
 493   *  and all above is blue sky.
 494   */
 495
 496   SetAPen(rp,SKY);
 497   RectFill(rp,0,VMID-HMID,2*HMID,VMID);
 498   SetAPen(rp,FLOOR);
 499   RectFill(rp,0,VMID+1,2*HMID,VMID+HMID);
 500
 501
 502  /*
 503   *  Find out how far we can see in the maze.
 504   *  That is howmuch squares is the opposite wall
 505   *  from us away.  If further than we can draw, this
 506   *  value represents the deepest square we can draw (8).
 507   */
 508
 509   for (Depth=1; Depth<MAXDEPTH; Depth++){
 510     if (!(MAZETEST(x+Depth*dirincs[direction][0],
 511                    y+Depth*dirincs[direction][1],
 512                    xsize,mymaze)))
 513     break;
 514   }
 515
 516  /*
 517   *  Keep this value for later when we draw the opposite wall.
 518   *  Determine the smallest value we use with drawing shades.
 519   *  And perhaps we are looking at the exit.
 520   */
 521
 522   Wall=Depth-1;
 523   Minim=1<<((MAXDEPTH-1)-Depth);
 524   MazeExit= ((y==wayout)&&((x+Wall*dirincs[direction][0])==xsize-2));
 525
 526  /*
 527   *  Draw first the left side of the view, followed
 528   *  by the right side.
 529   */
 530
 531   for (Side=LEFT; Side<=RIGHT; Side+=2){
 532
 533    /*
 534     *  Loop for drawing in all squares, beginning at
 535     *  the farrest level, ending at our present position.
 536     */
 537
 538     for (Depth=Wall; Depth>=0; Depth--){
 539
 540      /*
 541       *  Detemine some values we use in this square.
 542       */
 543
 544       Inner=1<<((MAXDEPTH-2)-Depth);  /* Half size of this square          */
 545       Outer=Inner<<1;                 /* Half size on one square nearer    */
 546       Middle=(Outer+Inner)/2;         /* The same size of a square between */
 547       if (Outer>HMID) Outer=HMID;     /* If too near (larger than display  */
 548       if (Middle>HMID) Middle=HMID;   /* clip it to a useful size          */
 549
 550      /*
 551       *  Are we dealing with a wall or a cross-passage?
 552       */
 553
 554       if (!IsPassage(Side,Depth)){
 555
 556        /*
 557         *  We draw a wall and its shadow if visable.
 558         *  The shadow is visable if the surface of the
 559         *  wall is in the shadow.
 560         */
 561
 562         if (Shadow[(direction+Side)&3]){
 563
 564          /*  The shadow is on our path, now is
 565           *  it directed toward us or from us away?
 566           */
 567
 568           if (Shadow[direction]){          /*  To us    */
 569             InMid=Middle;
 570             OutMid=Middle<<1;
 571             if (OutMid>HMID) OutMid=HMID;
 572           } else{                          /*  From us  */
 573             InMid=Middle/2+1;
 574             if (InMid<Minim) InMid=Minim;
 575             OutMid=Middle;
 576           }
 577
 578          /*
 579           *  Draw this shadow of the side wall on out path
 580           */
 581
 582           SetAPen(rp,FLOOR-SHADOW);
 583           AreaMove(rp,HMID,VMID+InMid);
 584           AreaDraw(rp,HMID,VMID+OutMid);
 585           AreaDraw(rp,HMID+Side*Outer,VMID+Outer);
 586           AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
 587           AreaEnd(rp);
 588         }
 589         /*  End of drawing shadow on our path  */
 590
 591        /*
 592         *  Draw the side wall itself using the color of
 593         *  a side wall, but modify it by a possible
 594         *  shade correction.
 595         */
 596
 597         SetAPen(rp,SIDE-Shadow[(direction+Side)&3]);
 598         AreaMove(rp,HMID+Side*Inner,VMID-Inner);
 599         AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
 600         AreaDraw(rp,HMID+Side*Outer,VMID+Outer);
 601         AreaDraw(rp,HMID+Side*Outer,VMID-Outer);
 602         AreaEnd(rp);
 603
 604        /*
 605         *  If we are the first time in this loop,
 606         *  and the opposite wall is in the shadow,
 607         *  and the just drawn side wall is in the sun,
 608         *  draw the shadow from the opposite wall on it.
 609         */
 610
 611         if ((Depth==Wall)&& Shadow[direction]&& !Shadow[(direction+Side)&3]){
 612           SetAPen(rp,SIDE-SHADOW);
 613           AreaMove(rp,HMID+Side*Inner,VMID-Inner);
 614           AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
 615           AreaDraw(rp,HMID+Side*Middle,VMID+Middle);
 616           AreaEnd(rp);
 617         }
 618       }
 619       /*  End of dealing with a side wall */
 620
 621       else{
 622
 623        /*
 624         *  Here we are dealing with a cross passage,
 625         *  We first draw some shadows on the floor,
 626         *  as well on our path, as on the cross passage.
 627         */
 628
 629         SetAPen(rp,FLOOR-SHADOW);
 630
 631        /*
 632         *  Is the shadow in the direction of our path?
 633         */
 634
 635         if (Shadow[(direction+Side)&3]){
 636
 637          /*
 638           *  The shadow is in the direction of our path,
 639           *  now is it directed from us away?
 640           */
 641
 642           if (Shadow[direction]){
 643
 644            /*
 645             *  The crosswall is in the shade.
 646             *  Draw the shadow on the coss path.
 647             *  The distiction between the sides is to meet
 648             *  the RectFill() form.
 649             */
 650
 651             if (Side==LEFT)
 652               RectFill(rp,HMID-Outer,VMID+Inner,HMID,VMID+Middle);
 653             else
 654               RectFill(rp,HMID,VMID+Inner,HMID+Outer,VMID+Middle);
 655           }
 656           else{
 657
 658            /*
 659             *  The cross wall is in the sun.
 660             *  Draw the shadow of the other side.
 661             */
 662
 663             if (Side==LEFT)
 664               RectFill(rp,HMID-Outer,VMID+Middle,HMID,VMID+Outer);
 665             else
 666               RectFill(rp,HMID,VMID+Middle,HMID+Outer,VMID+Outer);
 667           }
 668         }
 669         /*  End of shadow directed to our path  */
 670
 671         else{
 672
 673          /*
 674           *  The shadow is directed from our path away.
 675           *  Now draw the shadow on the cross path if
 676           *  the cross wall is in the shade.
 677           */
 678
 679           if (Shadow[direction]){
 680             AreaMove(rp,HMID+Side*Inner,VMID+Inner);
 681             AreaDraw(rp,HMID+Side*Outer,VMID+Inner);
 682             AreaDraw(rp,HMID+Side*Outer,VMID+(Inner+Outer)/2);
 683             AreaEnd(rp);
 684           }
 685         }
 686
 687        /*
 688         *  If we are here for the first time,
 689         *  and the opposite wall is visable,
 690         *  and it is in the shade,
 691         *  extent the shadow of the opposite wall to
 692         *  the one from the cross wall. (A tiny triangle)
 693         */
 694
 695         if ((Depth==Wall)&&(Depth<MAXDEPTH)&&(Shadow[direction])){
 696           AreaMove(rp,HMID+Side*Inner,VMID+Inner);
 697           AreaDraw(rp,HMID+Side*Middle,VMID+Middle);
 698           AreaDraw(rp,HMID+Side*Outer,VMID+Middle);
 699           AreaDraw(rp,HMID+Side*Outer,VMID+Inner);
 700           AreaEnd(rp);
 701         }
 702
 703        /*
 704         *  If we are not dealing with the exit's cross path
 705         *  draw the cross wall itself.
 706         */
 707
 708         if (!(MazeExit&&(Depth>(Wall-1)))){
 709            SetAPen(rp,FRONT-Shadow[direction]);
 710           if (Side==RIGHT)
 711             RectFill(rp,HMID+Inner,VMID-Inner,HMID+Outer,VMID+Inner);
 712           else
 713             RectFill(rp,HMID-Outer,VMID-Inner,HMID-Inner,VMID+Inner);
 714         }
 715
 716       }
 717       /*  End of drawing a cross passage (or side wall)  */
 718     }
 719     /*  End of drawing in subsequent squares  */
 720   }
 721   /*  End of drawing the left and right side ot the picture  */
 722
 723  /*
 724   *  Now we have to draw the opposite wall
 725   *  or the exit if not too far away
 726   */
 727
 728   Depth=Wall;
 729
 730   if (Depth<MAXDEPTH-1){
 731
 732    /*
 733     *  It is not too far away.
 734     *  Fill in again those sizes.
 735     */
 736
 737     Inner=1<<((MAXDEPTH-2)-Depth);
 738     Outer=Inner<<1;
 739     Middle=(Outer+Inner)/2;
 740     if (Outer>HMID) Outer=HMID;
 741     if (Middle>HMID) Middle=HMID;
 742
 743    /*
 744     *  Are we not looking at the exit?
 745     */
 746
 747     if (!MazeExit){
 748
 749      /*
 750       *  We are looking at an opposite wall.
 751       *  Draw its shadow on the floor if it is in the shade.
 752       */
 753
 754       if (Shadow[direction]){
 755         SetAPen(rp,FLOOR-SHADOW);
 756         AreaMove(rp,HMID+1-Inner,VMID+Inner);
 757         AreaDraw(rp,HMID+1-Middle,VMID+Middle);
 758         AreaDraw(rp,HMID-1+Middle,VMID+Middle);
 759         AreaDraw(rp,HMID-1+Inner,VMID+Inner);
 760         AreaEnd(rp);
 761       }
 762
 763      /*
 764       *  Draw the opposite wall itself.
 765       */
 766
 767       SetAPen(rp,FRONT-Shadow[direction]);
 768       RectFill(rp,HMID-Inner,VMID-Inner,HMID+Inner,VMID+Inner);
 769
 770      /*
 771       *  If the opposite wall is bounded to a side wall,
 772       *  and this side wall is in the shadow,
 773       *  and the opposite wall is in the sun,
 774       *  draw the shadow of the side wall on the opposite wall.
 775       */
 776
 777       for (Side=LEFT; Side<=RIGHT; Side+=2){
 778         if (
 779             (!IsPassage(Side,Depth))&&
 780             (Shadow[(direction+Side)&3])&&
 781             (!Shadow[direction])
 782            ){
 783           SetAPen(rp,FRONT-SHADOW);
 784           AreaMove(rp,HMID+Side*Inner,VMID-Inner);
 785           AreaDraw(rp,HMID+Side*Inner,VMID+Inner);
 786           AreaDraw(rp,HMID,VMID+Inner);
 787           AreaEnd(rp);
 788         }
 789       }
 790     }
 791   }
 792 }
 793
 794
 795
 796 /*
 797  *  This was original in line, but it disturbed the view over the
 798  *  code.  Placing it in a function made the clearity of the show3d()
 799  *  function better.
 800  *  This function returns the presence of a cross passage at <Side>'s
 801  *  side and <Depth> from us away.
 802  */
 803
 804 int IsPassage(Side,Depth)
 805 short Side,Depth;
 806 {
 807   register int xx,yy;
 808   xx=x+dirincs[(direction+Side)&3][0]+Depth*dirincs[direction][0];
 809   yy=y+dirincs[(direction+Side)&3][1]+Depth*dirincs[direction][1];
 810   return(MAZETEST(xx,yy, xsize,mymaze));
 811 }
 812