main/automap.c

   1 /* $Id: automap.c,v 1.11 2003-10-10 09:36:34 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Routines for displaying the auto-map.
  18  *
  19  * Old Log:
  20  * Revision 1.8  1995/10/31  10:24:54  allender
  21  * shareware stuff
  22  *
  23  * Revision 1.7  1995/10/21  16:18:20  allender
  24  * blit pcx background directly to Page canvas instead of creating
  25  * seperate bitmap for it -- hope to solve VM bug on some macs
  26  *
  27  * Revision 1.6  1995/10/20  00:49:16  allender
  28  * added redbook check during automap
  29  *
  30  * Revision 1.5  1995/09/13  08:44:07  allender
  31  * Dave Denhart's changes to speed up the automap
  32  *
  33  * Revision 1.4  1995/08/18  15:46:00  allender
  34  * put text all on upper bar -- and fixed background since
  35  * changing xparency color
  36  *
  37  * Revision 1.3  1995/08/03  15:15:18  allender
  38  * fixed edge hashing problem causing automap to crash
  39  *
  40  * Revision 1.2  1995/07/12  12:49:27  allender
  41  * works in 640x480 mode
  42  *
  43  * Revision 1.1  1995/05/16  15:22:59  allender
  44  * Initial revision
  45  *
  46  * Revision 2.2  1995/03/21  14:41:26  john
  47  * Ifdef'd out the NETWORK code.
  48  *
  49  * Revision 2.1  1995/03/20  18:16:06  john
  50  * Added code to not store the normals in the segment structure.
  51  *
  52  * Revision 2.0  1995/02/27  11:32:55  john
  53  * New version 2.0, which has no anonymous unions, builds with
  54  * Watcom 10.0, and doesn't require parsing BITMAPS.TBL.
  55  *
  56  * Revision 1.117  1995/02/22  14:11:31  allender
  57  * remove anonymous unions from object structure
  58  *
  59  * Revision 1.116  1995/02/22  13:24:39  john
  60  * Removed the vecmat anonymous unions.
  61  *
  62  * Revision 1.115  1995/02/09  14:57:02  john
  63  * Reduced mem usage. Made automap slide farther.
  64  *
  65  * Revision 1.114  1995/02/07  20:40:44  rob
  66  * Allow for anarchy automap of player pos by option.
  67  *
  68  * Revision 1.113  1995/02/07  15:45:33  john
  69  * Made automap memory be static.
  70  *
  71  * Revision 1.112  1995/02/02  12:24:00  adam
  72  * played with automap labels
  73  *
  74  * Revision 1.111  1995/02/02  01:52:52  john
  75  * Made the automap use small font.
  76  *
  77  * Revision 1.110  1995/02/02  01:34:34  john
  78  * Made Reset in automap not change segmentlimit.
  79  *
  80  * Revision 1.109  1995/02/02  01:23:11  john
  81  * Finalized the new automap partial viewer.
  82  *
  83  * Revision 1.108  1995/02/02  00:49:45  mike
  84  * new automap segment-depth functionality.
  85  *
  86  * Revision 1.107  1995/02/02  00:23:04  john
  87  * Half of the code for new connected distance stuff in automap.
  88  *
  89  * Revision 1.106  1995/02/01  22:54:00  john
  90  * Made colored doors not fade in automap. Made default
  91  * viewing area be maxxed.
  92  *
  93  * Revision 1.105  1995/02/01  13:16:13  john
  94  * Added great grates.
  95  *
  96  * Revision 1.104  1995/01/31  12:47:06  john
  97  * Made Alt+F only work with cheats enabled.
  98  *
  99  * Revision 1.103  1995/01/31  12:41:23  john
 100  * Working with new controls.
 101  *
 102  * Revision 1.102  1995/01/31  12:04:19  john
 103  * Version 2 of new key control.
 104  *
 105  * Revision 1.101  1995/01/31  11:32:00  john
 106  * First version of new automap system.
 107  *
 108  * Revision 1.100  1995/01/28  16:55:48  john
 109  * Made keys draw in automap in the segments that you have
 110  * visited.
 111  *
 112  * Revision 1.99  1995/01/28  14:44:51  john
 113  * Made hostage doors show up on automap.
 114  *
 115  * Revision 1.98  1995/01/22  17:03:49  rob
 116  * Fixed problem drawing playerships in automap coop/team mode
 117  *
 118  * Revision 1.97  1995/01/21  17:23:11  john
 119  * Limited S movement in map. Made map bitmap load from disk
 120  * and then freed it.
 121  *
 122  * Revision 1.96  1995/01/19  18:55:38  john
 123  * Don't draw players in automap if not obj_player.
 124  *
 125  * Revision 1.95  1995/01/19  18:48:13  john
 126  * Made player colors better in automap.
 127  *
 128  * Revision 1.94  1995/01/19  17:34:52  rob
 129  * Added team colorizations in automap.
 130  *
 131  * Revision 1.93  1995/01/19  17:15:36  rob
 132  * Trying to add player ships into map for coop and team mode.
 133  *
 134  * Revision 1.92  1995/01/19  17:11:09  john
 135  * Added code for Rob to draw Multiplayer ships in automap.
 136  *
 137  * Revision 1.91  1995/01/12  13:35:20  john
 138  * Fixed bug with Segment 0 not getting displayed
 139  * in automap if you have EDITOR compiled in.
 140  *
 141  * Revision 1.90  1995/01/08  16:17:14  john
 142  * Added code to draw player's up vector while in automap.
 143  *
 144  * Revision 1.89  1995/01/08  16:09:41  john
 145  * Fixed problems with grate.
 146  *
 147  * Revision 1.88  1994/12/14  22:54:17  john
 148  * Fixed bug that didn't show hostages in automap.
 149  *
 150  * Revision 1.87  1994/12/09  00:41:03  mike
 151  * fix hang in automap print screen
 152  *
 153  * Revision 1.86  1994/12/05  23:37:15  matt
 154  * Took out calls to warning() function
 155  *
 156  * Revision 1.85  1994/12/03  22:35:28  yuan
 157  * Localization 412
 158  *
 159  * Revision 1.84  1994/12/02  15:05:45  matt
 160  * Added new "official" cheats
 161  *
 162  * Revision 1.83  1994/11/30  12:10:49  adam
 163  * added support for PCX titles/brief screens
 164  *
 165  * Revision 1.82  1994/11/27  23:15:12  matt
 166  * Made changes for new mprintf calling convention
 167  *
 168  * Revision 1.81  1994/11/27  15:35:52  matt
 169  * Enable screen shots even when debugging is turned off
 170  *
 171  * Revision 1.80  1994/11/26  22:51:43  matt
 172  * Removed editor-only fields from segment structure when editor is compiled
 173  * out, and padded segment structure to even multiple of 4 bytes.
 174  *
 175  * Revision 1.79  1994/11/26  16:22:48  matt
 176  * Reduced leave_time
 177  *
 178  * Revision 1.78  1994/11/23  22:00:10  mike
 179  * show level number.
 180  *
 181  * Revision 1.77  1994/11/21  11:40:33  rob
 182  * Tweaked the game-loop for automap in multiplayer games.
 183  *
 184  * Revision 1.76  1994/11/18  16:42:06  adam
 185  * removed a font
 186  *
 187  * Revision 1.75  1994/11/17  13:06:48  adam
 188  * changed font
 189  *
 190  * Revision 1.74  1994/11/14  20:47:17  john
 191  * Attempted to strip out all the code in the game
 192  * directory that uses any ui code.
 193  *
 194  */
 195
 196 #ifdef HAVE_CONFIG_H
 197 #include <conf.h>
 198 #endif
 199
 200 #include <stdio.h>
 201 #include <stdlib.h>
 202 #include <string.h>
 203
 204 #ifdef OGL
 205 #include "ogl_init.h"
 206 #endif
 207
 208 #include "pa_enabl.h"                   //$$POLY_ACC
 209 #include "error.h"
 210 #include "3d.h"
 211 #include "inferno.h"
 212 #include "u_mem.h"
 213 #include "render.h"
 214 #include "object.h"
 215 #include "vclip.h"
 216 #include "game.h"
 217 #include "mono.h"
 218 #include "polyobj.h"
 219 #include "sounds.h"
 220 #include "player.h"
 221 #include "bm.h"
 222 #include "key.h"
 223 #include "newmenu.h"
 224 #include "menu.h"
 225 #include "screens.h"
 226 #include "textures.h"
 227 #include "mouse.h"
 228 #include "timer.h"
 229 #include "segpoint.h"
 230 #include "joy.h"
 231 #include "iff.h"
 232 #include "pcx.h"
 233 #include "palette.h"
 234 #include "wall.h"
 235 #include "gameseq.h"
 236 #include "gamefont.h"
 237 #ifdef NETWORK
 238 #include "network.h"
 239 #endif
 240 #include "kconfig.h"
 241 #ifdef NETWORK
 242 #include "multi.h"
 243 #endif
 244 #include "endlevel.h"
 245 #include "text.h"
 246 #include "gauges.h"
 247 #include "songs.h"
 248 #include "powerup.h"
 249 #include "switch.h"
 250 #include "automap.h"
 251 #include "cntrlcen.h"
 252
 253 #if defined(POLY_ACC)
 254 #include "poly_acc.h"
 255 #endif
 256
 257 #ifdef OGL
 258 #define AUTOMAP_DIRECT_RENDER
 259 #endif
 260
 261 #define EF_USED     1   // This edge is used
 262 #define EF_DEFINING 2   // A structure defining edge that should always draw.
 263 #define EF_FRONTIER 4   // An edge between the known and the unknown.
 264 #define EF_SECRET   8   // An edge that is part of a secret wall.
 265 #define EF_GRATE    16  // A grate... draw it all the time.
 266 #define EF_NO_FADE  32  // An edge that doesn't fade with distance
 267 #define EF_TOO_FAR  64  // An edge that is too far away
 268
 269 void modex_printf(int x,int y,char *s,grs_font *font,int color);
 270
 271 typedef struct Edge_info {
 272         short verts[2];     // 4 bytes
 273         ubyte sides[4];     // 4 bytes
 274         short segnum[4];    // 8 bytes  // This might not need to be stored... If you can access the normals of a side.
 275         ubyte flags;        // 1 bytes  // See the EF_??? defines above.
 276         ubyte color;        // 1 bytes
 277         ubyte num_faces;    // 1 bytes  // 19 bytes...
 278 } Edge_info;
 279
 280 // OLD BUT GOOD -- #define MAX_EDGES_FROM_VERTS(v)   ((v*5)/2)
 281 // THE following was determined by John by loading levels 1-14 and recording
 282 // numbers on 10/26/94.
 283 //#define MAX_EDGES_FROM_VERTS(v)   (((v)*21)/10)
 284 #define MAX_EDGES_FROM_VERTS(v)     ((v)*4)
 285 //#define MAX_EDGES (MAX_EDGES_FROM_VERTS(MAX_VERTICES))
 286
 287 #define MAX_EDGES 6000  // Determined by loading all the levels by John & Mike, Feb 9, 1995
 288
 289 #define K_WALL_NORMAL_COLOR     BM_XRGB(29, 29, 29 )
 290 #define K_WALL_DOOR_COLOR       BM_XRGB(5, 27, 5 )
 291 #define K_WALL_DOOR_BLUE        BM_XRGB(0, 0, 31)
 292 #define K_WALL_DOOR_GOLD        BM_XRGB(31, 31, 0)
 293 #define K_WALL_DOOR_RED         BM_XRGB(31, 0, 0)
 294 #define K_WALL_REVEALED_COLOR   BM_XRGB(0, 0, 25 ) //what you see when you have the full map powerup
 295 #define K_HOSTAGE_COLOR         BM_XRGB(0, 31, 0 )
 296 #define K_FONT_COLOR_20         BM_XRGB(20, 20, 20 )
 297 #define K_GREEN_31              BM_XRGB(0, 31, 0)
 298
 299 int Wall_normal_color;
 300 int Wall_door_color;
 301 int Wall_door_blue;
 302 int Wall_door_gold;
 303 int Wall_door_red;
 304 int Wall_revealed_color;
 305 int Hostage_color;
 306 int Font_color_20;
 307 int Green_31;
 308 int White_63;
 309 int Blue_48;
 310 int Red_48;
 311
 312 void init_automap_colors(void)
 313 {
 314         Wall_normal_color = K_WALL_NORMAL_COLOR;
 315         Wall_door_color = K_WALL_DOOR_COLOR;
 316         Wall_door_blue = K_WALL_DOOR_BLUE;
 317         Wall_door_gold = K_WALL_DOOR_GOLD;
 318         Wall_door_red = K_WALL_DOOR_RED;
 319         Wall_revealed_color = K_WALL_REVEALED_COLOR;
 320         Hostage_color = K_HOSTAGE_COLOR;
 321         Font_color_20 = K_FONT_COLOR_20;
 322         Green_31 = K_GREEN_31;
 323
 324         White_63 = gr_find_closest_color_current(63,63,63);
 325         Blue_48 = gr_find_closest_color_current(0,0,48);
 326         Red_48 = gr_find_closest_color_current(48,0,0);
 327 }
 328
 329 // Segment visited list
 330 ubyte Automap_visited[MAX_SEGMENTS];
 331
 332 // Edge list variables
 333 static int Num_edges=0;
 334 static int Max_edges;           //set each frame
 335 static int Highest_edge_index = -1;
 336 static Edge_info Edges[MAX_EDGES];
 337 static short DrawingListBright[MAX_EDGES];
 338
 339 //static short DrawingListBright[MAX_EDGES];
 340 //static short Edge_used_list[MAX_EDGES];                               //which entries in edge_list have been used
 341
 342 // Map movement defines
 343 #define PITCH_DEFAULT 9000
 344 #define ZOOM_DEFAULT i2f(20*10)
 345 #define ZOOM_MIN_VALUE i2f(20*5)
 346 #define ZOOM_MAX_VALUE i2f(20*100)
 347
 348 #define SLIDE_SPEED                             (350)
 349 #define ZOOM_SPEED_FACTOR               500     //(1500)
 350 #define ROT_SPEED_DIVISOR               (115000)
 351
 352 #ifndef AUTOMAP_DIRECT_RENDER
 353 // Screen anvas variables
 354 static int current_page=0;
 355 #ifdef WINDOWS
 356 static dd_grs_canvas ddPages[2];
 357 static dd_grs_canvas ddDrawingPages[2];
 358
 359 #define ddPage ddPages[0]
 360 #define ddDrawingPage ddDrawingPages[0]
 361
 362 #endif
 363
 364 #if defined(MACINTOSH) && defined(POLY_ACC)
 365         grs_canvas Pages[2];                    // non static under rave so the backbuffer callback function can get at them
 366         grs_canvas DrawingPages[2];             // non static under rave so the backbuffer callback function can get at them
 367 #else
 368         static grs_canvas Pages[2];
 369         static grs_canvas DrawingPages[2];
 370 #endif
 371 #endif /* AUTOMAP_DIRECT_RENDER */
 372
 373 #define Page Pages[0]
 374 #define DrawingPage DrawingPages[0]
 375
 376 // Flags
 377 static int Automap_cheat = 0;           // If set, show everything
 378
 379 // Rendering variables
 380 static fix Automap_zoom = 0x9000;
 381 static vms_vector view_target;
 382 static fix Automap_farthest_dist = (F1_0 * 20 * 50);            // 50 segments away
 383 static vms_matrix       ViewMatrix;
 384 static fix ViewDist=0;
 385
 386 //      Function Prototypes
 387 void adjust_segment_limit(int SegmentLimit);
 388 void draw_all_edges(void);
 389 void automap_build_edge_list(void);
 390
 391 #define MAX_DROP_MULTI          2
 392 #define MAX_DROP_SINGLE 9
 393
 394 vms_vector MarkerPoint[NUM_MARKERS];            //these are only used in multi.c, and I'd get rid of them there, but when I tried to do that once, I caused some horrible bug. -MT
 395 int HighlightMarker=-1;
 396 char MarkerMessage[NUM_MARKERS][MARKER_MESSAGE_LEN];
 397 char MarkerOwner[NUM_MARKERS][CALLSIGN_LEN+1];
 398 float MarkerScale=2.0;
 399 int     MarkerObject[NUM_MARKERS];
 400
 401 extern vms_vector Matrix_scale;         //how the matrix is currently scaled
 402
 403 // -------------------------------------------------------------
 404
 405 void DrawMarkerNumber (int num)
 406  {
 407   int i;
 408   g3s_point BasePoint,FromPoint,ToPoint;
 409
 410   float ArrayX[10][20]={ {-.25, 0.0, 0.0, 0.0, -1.0, 1.0},
 411                          {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
 412                          {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0},
 413                          {-1.0, -1.0, -1.0, 1.0, 1.0, 1.0},
 414                          {-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
 415                          {-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
 416                          {-1.0, 1.0, 1.0, 1.0},
 417                          {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
 418                          {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0}
 419
 420                        };
 421   float ArrayY[10][20]={ {.75, 1.0, 1.0, -1.0, -1.0, -1.0},
 422                          {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
 423                          {1.0, 1.0, 1.0, -1.0, -1.0, -1.0, 0.0, 0.0},
 424                          {1.0, 0.0, 0.0, 0.0, 1.0, -1.0},
 425                          {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
 426                          {1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0},
 427                          {1.0, 1.0, 1.0, -1.0},
 428                          {1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0},
 429                          {1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 1.0}
 430                        };
 431   int NumOfPoints[]={6,10,8,6,10,10,4,10,8};
 432
 433   for (i=0;i<NumOfPoints[num];i++)
 434    {
 435     ArrayX[num][i]*=MarkerScale;
 436     ArrayY[num][i]*=MarkerScale;
 437    }
 438
 439   if (num==HighlightMarker)
 440    gr_setcolor (White_63);
 441   else
 442    gr_setcolor (Blue_48);
 443
 444
 445   g3_rotate_point(&BasePoint,&Objects[MarkerObject[(Player_num*2)+num]].pos);
 446
 447   for (i=0;i<NumOfPoints[num];i+=2)
 448    {
 449
 450     FromPoint=BasePoint;
 451     ToPoint=BasePoint;
 452
 453     FromPoint.p3_x+=fixmul ((fl2f (ArrayX[num][i])),Matrix_scale.x);
 454     FromPoint.p3_y+=fixmul ((fl2f (ArrayY[num][i])),Matrix_scale.y);
 455     g3_code_point (&FromPoint);
 456     g3_project_point (&FromPoint);
 457
 458     ToPoint.p3_x+=fixmul ((fl2f (ArrayX[num][i+1])),Matrix_scale.x);
 459     ToPoint.p3_y+=fixmul ((fl2f (ArrayY[num][i+1])),Matrix_scale.y);
 460     g3_code_point (&ToPoint);
 461     g3_project_point (&ToPoint);
 462
 463     #if defined(MACINTOSH) && defined(POLY_ACC)
 464         {
 465                 int savePAEnabledState = PAEnabled;     // icky hack.  automap draw context is no longer valid when this is called.
 466                                                                                         // so we can not use the pa_draw_line function for rave
 467
 468                 PAEnabled = 0;
 469             g3_draw_line( &FromPoint, &ToPoint );
 470                 PAEnabled = savePAEnabledState;
 471         }
 472         #else
 473             g3_draw_line( &FromPoint, &ToPoint );
 474         #endif
 475
 476    }
 477  }
 478
 479 void DropMarker (int player_marker_num)
 480 {
 481         int marker_num = (Player_num*2)+player_marker_num;
 482         object *playerp = &Objects[Players[Player_num].objnum];
 483
 484         MarkerPoint[marker_num] = playerp->pos;
 485
 486         if (MarkerObject[marker_num] != -1)
 487                 obj_delete(MarkerObject[marker_num]);
 488
 489         MarkerObject[marker_num] = drop_marker_object(&playerp->pos,playerp->segnum,&playerp->orient,marker_num);
 490
 491 #ifdef NETWORK
 492         if (Game_mode & GM_MULTI)
 493                 multi_send_drop_marker (Player_num,playerp->pos,player_marker_num,MarkerMessage[marker_num]);
 494 #endif
 495
 496 }
 497
 498 extern char guidebot_name[];
 499
 500 void DropBuddyMarker(object *objp)
 501 {
 502         int     marker_num;
 503
 504         //      Find spare marker slot.  "if" code below should be an assert, but what if someone changes NUM_MARKERS or MAX_CROP_SINGLE and it never gets hit?
 505         marker_num = MAX_DROP_SINGLE+1;
 506         if (marker_num > NUM_MARKERS-1)
 507                 marker_num = NUM_MARKERS-1;
 508
 509    sprintf(MarkerMessage[marker_num], "RIP: %s",guidebot_name);
 510
 511         MarkerPoint[marker_num] = objp->pos;
 512
 513         if (MarkerObject[marker_num] != -1 && MarkerObject[marker_num] !=0)
 514                 obj_delete(MarkerObject[marker_num]);
 515
 516         MarkerObject[marker_num] = drop_marker_object(&objp->pos, objp->segnum, &objp->orient, marker_num);
 517
 518 }
 519
 520 #define MARKER_SPHERE_SIZE 0x58000
 521
 522 void DrawMarkers ()
 523  {
 524         int i,maxdrop;
 525         static int cyc=10,cycdir=1;
 526         g3s_point sphere_point;
 527
 528         if (Game_mode & GM_MULTI)
 529         maxdrop=2;
 530         else
 531         maxdrop=9;
 532
 533         for (i=0;i<maxdrop;i++)
 534                 if (MarkerObject[(Player_num*2)+i] != -1) {
 535
 536                         g3_rotate_point(&sphere_point,&Objects[MarkerObject[(Player_num*2)+i]].pos);
 537
 538                         gr_setcolor (gr_find_closest_color_current(cyc,0,0));
 539                         g3_draw_sphere(&sphere_point,MARKER_SPHERE_SIZE);
 540                         gr_setcolor (gr_find_closest_color_current(cyc+10,0,0));
 541                         g3_draw_sphere(&sphere_point,MARKER_SPHERE_SIZE/2);
 542                         gr_setcolor (gr_find_closest_color_current(cyc+20,0,0));
 543                         g3_draw_sphere(&sphere_point,MARKER_SPHERE_SIZE/4);
 544
 545                         DrawMarkerNumber (i);
 546                 }
 547
 548         if (cycdir)
 549                 cyc+=2;
 550         else
 551                 cyc-=2;
 552
 553         if (cyc>43)
 554          {
 555                 cyc=43;
 556                 cycdir=0;
 557          }
 558         else if (cyc<10)
 559          {
 560                 cyc=10;
 561                 cycdir=1;
 562          }
 563
 564  }
 565
 566 void ClearMarkers()
 567  {
 568         int i;
 569
 570         for (i=0;i<NUM_MARKERS;i++) {
 571                 MarkerMessage[i][0]=0;
 572                 MarkerObject[i]=-1;
 573         }
 574  }
 575
 576 void automap_clear_visited()
 577 {
 578         int i;
 579         for (i=0; i<MAX_SEGMENTS; i++ )
 580                 Automap_visited[i] = 0;
 581                           ClearMarkers();
 582 }
 583
 584 grs_canvas *name_canv_left,*name_canv_right;
 585 char name_level[128];
 586
 587 void draw_player( object * obj )
 588 {
 589         vms_vector arrow_pos, head_pos;
 590         g3s_point sphere_point, arrow_point, head_point;
 591
 592         // Draw Console player -- shaped like a ellipse with an arrow.
 593         g3_rotate_point(&sphere_point,&obj->pos);
 594         g3_draw_sphere(&sphere_point,obj->size);
 595
 596         // Draw shaft of arrow
 597         vm_vec_scale_add( &arrow_pos, &obj->pos, &obj->orient.fvec, obj->size*3 );
 598         g3_rotate_point(&arrow_point,&arrow_pos);
 599         #if defined(MACINTOSH) && defined(POLY_ACC)
 600         {
 601                 int savePAEnabledState = PAEnabled;     // icky hack.  automap draw context is no longer valid when this is called.
 602                                                                                         // so we can not use the pa_draw_line function for rave
 603
 604                 PAEnabled = 0;
 605             g3_draw_line( &sphere_point, &arrow_point );
 606                 PAEnabled = savePAEnabledState;
 607         }
 608         #else
 609                 g3_draw_line( &sphere_point, &arrow_point );
 610         #endif
 611
 612         // Draw right head of arrow
 613         vm_vec_scale_add( &head_pos, &obj->pos, &obj->orient.fvec, obj->size*2 );
 614         vm_vec_scale_add2( &head_pos, &obj->orient.rvec, obj->size*1 );
 615         g3_rotate_point(&head_point,&head_pos);
 616         #if     defined(MACINTOSH) && defined(POLY_ACC)
 617         {
 618                 int savePAEnabledState = PAEnabled;
 619                 PAEnabled = 0;
 620             g3_draw_line( &arrow_point, &head_point );
 621                 PAEnabled = savePAEnabledState;
 622         }
 623         #else
 624                 g3_draw_line( &arrow_point, &head_point );
 625         #endif
 626
 627         // Draw left head of arrow
 628         vm_vec_scale_add( &head_pos, &obj->pos, &obj->orient.fvec, obj->size*2 );
 629         vm_vec_scale_add2( &head_pos, &obj->orient.rvec, obj->size*(-1) );
 630         g3_rotate_point(&head_point,&head_pos);
 631         #if     defined(MACINTOSH) && defined(POLY_ACC)
 632         {
 633                 int savePAEnabledState = PAEnabled;
 634                 PAEnabled = 0;
 635             g3_draw_line( &arrow_point, &head_point );
 636                 PAEnabled = savePAEnabledState;
 637         }
 638         #else
 639                 g3_draw_line( &arrow_point, &head_point );
 640         #endif
 641
 642         // Draw player's up vector
 643         vm_vec_scale_add( &arrow_pos, &obj->pos, &obj->orient.uvec, obj->size*2 );
 644         g3_rotate_point(&arrow_point,&arrow_pos);
 645         #if     defined(MACINTOSH) && defined(POLY_ACC)
 646         {
 647                 int savePAEnabledState = PAEnabled;
 648                 PAEnabled = 0;
 649             g3_draw_line( &sphere_point, &arrow_point );
 650                 PAEnabled = savePAEnabledState;
 651         }
 652         #else
 653                 g3_draw_line( &sphere_point, &arrow_point );
 654         #endif
 655
 656
 657 }
 658
 659 int AutomapHires;
 660 #if defined(MACINTOSH) && defined(POLY_ACC)
 661
 662         void pa_mac_draw_automap_extras(void)
 663         {
 664                 int i;
 665                 int color;
 666                 object * objp;
 667                 g3s_point sphere_point;
 668
 669                 AutomapHires = 1;       // always on the mac
 670
 671                 // Draw player...
 672                 #ifdef NETWORK
 673                         if (Game_mode & GM_TEAM)
 674                                 color = get_team(Player_num);
 675                         else
 676                 #endif
 677                         color = Player_num;     // Note link to above if!
 678
 679                 gr_setcolor(gr_getcolor(player_rgb[color].r,player_rgb[color].g,player_rgb[color].b));
 680                 draw_player(&Objects[Players[Player_num].objnum]);
 681
 682                 DrawMarkers();
 683
 684                 if (HighlightMarker>-1 && MarkerMessage[HighlightMarker][0]!=0)
 685                  {
 686                         char msg[10+MARKER_MESSAGE_LEN+1];
 687
 688                         sprintf(msg,"Marker %d: %s",HighlightMarker+1,MarkerMessage[(Player_num*2)+HighlightMarker]);
 689
 690                         gr_setcolor (Red_48);
 691
 692                         modex_printf(5,20,msg,SMALL_FONT,Font_color_20);
 693                  }
 694
 695                 // Draw player(s)...
 696                 #ifdef NETWORK
 697                         if ( (Game_mode & (GM_TEAM | GM_MULTI_COOP)) || (Netgame.game_flags & NETGAME_FLAG_SHOW_MAP) )
 698                         {
 699                                 for (i=0; i<N_players; i++)
 700                                 {
 701                                         if ((i != Player_num) &&
 702                                                 ((Game_mode & GM_MULTI_COOP) || (get_team(Player_num) == get_team(i)) || (Netgame.game_flags & NETGAME_FLAG_SHOW_MAP)) )
 703                                         {
 704                                                 if ( Objects[Players[i].objnum].type == OBJ_PLAYER )
 705                                                 {
 706                                                         if (Game_mode & GM_TEAM)
 707                                                                 color = get_team(i);
 708                                                         else
 709                                                                 color = i;
 710                                                         gr_setcolor(gr_getcolor(player_rgb[color].r,player_rgb[color].g,player_rgb[color].b));
 711                                                         draw_player(&Objects[Players[i].objnum]);
 712                                                 }
 713                                         }
 714                                 }
 715                         }
 716                 #endif
 717
 718                 objp = &Objects[0];
 719                 for (i=0;i<=Highest_object_index;i++,objp++)
 720                 {
 721                         switch( objp->type )
 722                         {
 723                                 case OBJ_HOSTAGE:
 724                                         gr_setcolor(Hostage_color);
 725                                         g3_rotate_point(&sphere_point,&objp->pos);
 726                                         g3_draw_sphere(&sphere_point,objp->size);
 727                                         break;
 728                                 case OBJ_POWERUP:
 729                                         if ( Automap_visited[objp->segnum] )
 730                                         {
 731                                                 if ( (objp->id==POW_KEY_RED) || (objp->id==POW_KEY_BLUE) || (objp->id==POW_KEY_GOLD) )
 732                                                 {
 733                                                         switch (objp->id)
 734                                                         {
 735                                                                 case POW_KEY_RED:       gr_setcolor(gr_getcolor(63, 5, 5));     break;
 736                                                                 case POW_KEY_BLUE:      gr_setcolor(gr_getcolor(5, 5, 63)); break;
 737                                                                 case POW_KEY_GOLD:      gr_setcolor(gr_getcolor(63, 63, 10)); break;
 738                                                                 default:
 739                                                                         Error("Illegal key type: %i", objp->id);
 740                                                         }
 741                                                         g3_rotate_point(&sphere_point,&objp->pos);
 742                                                         g3_draw_sphere(&sphere_point,objp->size*4);
 743                                                 }
 744                                         }
 745                                         break;
 746                         }
 747                 }
 748
 749                 gr_bitmapm(AutomapHires?10:AutomapHires?10:5,5,&name_canv_left->cv_bitmap);
 750                 gr_bitmapm(grd_curcanv->cv_bitmap.bm_w-(AutomapHires?10:5)-name_canv_right->cv_bitmap.bm_w,AutomapHires?10:5,&name_canv_right->cv_bitmap);
 751         }
 752
 753         void pa_mac_draw_automap(void)
 754         {
 755                 vms_vector viewer_position;
 756
 757                 g3_start_frame();
 758                 render_start_frame();
 759                 pa_set_context(kAutoMapDrawContextID, NULL);
 760                 pa_render_start();
 761
 762                         vm_vec_scale_add(&viewer_position,&view_target,&ViewMatrix.fvec,-ViewDist );
 763                         g3_set_view_matrix(&viewer_position,&ViewMatrix,Automap_zoom);
 764
 765                         draw_all_edges();
 766
 767                 g3_end_frame();
 768                 pa_render_end();
 769         }
 770 #endif
 771
 772 void draw_automap()
 773 {
 774         int i;
 775         int color;
 776         object * objp;
 777         vms_vector viewer_position;
 778         g3s_point sphere_point;
 779
 780         #ifdef MACINTOSH
 781                 #ifdef POLY_ACC
 782                         if (PAEnabled)
 783                         {
 784                                 pa_mac_draw_automap();
 785                                 return;
 786                         }
 787                 #endif
 788         #endif
 789
 790 #ifndef AUTOMAP_DIRECT_RENDER
 791         if (!AutomapHires) {
 792                 WIN(mprintf((1, "Can't do lores automap in Windows!\n")));
 793                 WIN(Int3());
 794                 current_page ^= 1;
 795                 gr_set_current_canvas(&DrawingPages[current_page]);
 796         }
 797         else {
 798                 WINDOS(
 799                         dd_gr_set_current_canvas(&ddDrawingPage),
 800                         gr_set_current_canvas(&DrawingPage)
 801                 );
 802         }
 803 #endif
 804
 805 #if defined(POLY_ACC)
 806     pa_flush();
 807 #endif
 808
 809         WINDOS(
 810                 dd_gr_clear_canvas(BM_XRGB(0,0,0)),
 811                 gr_clear_canvas(BM_XRGB(0,0,0))
 812         );
 813
 814 WIN(DDGRLOCK(dd_grd_curcanv));
 815 {
 816         g3_start_frame();
 817         render_start_frame();
 818
 819         vm_vec_scale_add(&viewer_position,&view_target,&ViewMatrix.fvec,-ViewDist );
 820
 821         g3_set_view_matrix(&viewer_position,&ViewMatrix,Automap_zoom);
 822
 823 //      mprintf((0, "dd_grd_curcanv->canvas.cv_bitmap.bm_data= %x\n", dd_grd_curcanv->canvas.cv_bitmap.bm_data));
 824 //      mprintf((0, "grd_curcanv->cv_bitmap.bm_data= %x\n", grd_curcanv->cv_bitmap.bm_data));
 825
 826         draw_all_edges();
 827
 828         // Draw player...
 829 #ifdef NETWORK
 830         if (Game_mode & GM_TEAM)
 831                 color = get_team(Player_num);
 832         else
 833 #endif
 834                 color = Player_num;     // Note link to above if!
 835
 836         gr_setcolor(gr_getcolor(player_rgb[color].r,player_rgb[color].g,player_rgb[color].b));
 837         draw_player(&Objects[Players[Player_num].objnum]);
 838
 839         DrawMarkers();
 840
 841         if (HighlightMarker>-1 && MarkerMessage[HighlightMarker][0]!=0)
 842          {
 843                 char msg[10+MARKER_MESSAGE_LEN+1];
 844
 845                 sprintf(msg,"Marker %d: %s",HighlightMarker+1,MarkerMessage[(Player_num*2)+HighlightMarker]);
 846
 847                 gr_setcolor (Red_48);
 848
 849                 modex_printf(5,20,msg,SMALL_FONT,Font_color_20);
 850          }
 851
 852         // Draw player(s)...
 853 #ifdef NETWORK
 854         if ( (Game_mode & (GM_TEAM | GM_MULTI_COOP)) || (Netgame.game_flags & NETGAME_FLAG_SHOW_MAP) )  {
 855                 for (i=0; i<N_players; i++)             {
 856                         if ( (i != Player_num) && ((Game_mode & GM_MULTI_COOP) || (get_team(Player_num) == get_team(i)) || (Netgame.game_flags & NETGAME_FLAG_SHOW_MAP)) )      {
 857                                 if ( Objects[Players[i].objnum].type == OBJ_PLAYER )    {
 858                                         if (Game_mode & GM_TEAM)
 859                                                 color = get_team(i);
 860                                         else
 861                                                 color = i;
 862                                         gr_setcolor(gr_getcolor(player_rgb[color].r,player_rgb[color].g,player_rgb[color].b));
 863                                         draw_player(&Objects[Players[i].objnum]);
 864                                 }
 865                         }
 866                 }
 867         }
 868 #endif
 869
 870         objp = &Objects[0];
 871         for (i=0;i<=Highest_object_index;i++,objp++) {
 872                 switch( objp->type )    {
 873                 case OBJ_HOSTAGE:
 874                         gr_setcolor(Hostage_color);
 875                         g3_rotate_point(&sphere_point,&objp->pos);
 876                         g3_draw_sphere(&sphere_point,objp->size);
 877                         break;
 878                 case OBJ_POWERUP:
 879                         if ( Automap_visited[objp->segnum] )    {
 880                                 if ( (objp->id==POW_KEY_RED) || (objp->id==POW_KEY_BLUE) || (objp->id==POW_KEY_GOLD) )  {
 881                                         switch (objp->id) {
 882                                         case POW_KEY_RED:               gr_setcolor(gr_getcolor(63, 5, 5));     break;
 883                                         case POW_KEY_BLUE:      gr_setcolor(gr_getcolor(5, 5, 63)); break;
 884                                         case POW_KEY_GOLD:      gr_setcolor(gr_getcolor(63, 63, 10)); break;
 885                                         default:
 886                                                 Error("Illegal key type: %i", objp->id);
 887                                         }
 888                                         g3_rotate_point(&sphere_point,&objp->pos);
 889                                         g3_draw_sphere(&sphere_point,objp->size*4);
 890                                 }
 891                         }
 892                         break;
 893                 }
 894         }
 895
 896         g3_end_frame();
 897
 898         gr_bitmapm(AutomapHires?10:AutomapHires?10:5,5,&name_canv_left->cv_bitmap);
 899         gr_bitmapm(grd_curcanv->cv_bitmap.bm_w-(AutomapHires?10:5)-name_canv_right->cv_bitmap.bm_w,AutomapHires?10:5,&name_canv_right->cv_bitmap);
 900         gr_set_curfont(GAME_FONT);
 901         gr_set_fontcolor(BM_XRGB(0,31,0),-1);
 902         gr_uprintf(5,5,name_level);
 903 }
 904 WIN(DDGRUNLOCK(dd_grd_curcanv));
 905
 906 #ifdef OGL
 907         ogl_swap_buffers();
 908 #else
 909 #ifndef AUTOMAP_DIRECT_RENDER
 910         if (!AutomapHires)
 911                 gr_show_canvas( &Pages[current_page] );
 912         else {
 913         #ifndef WINDOWS
 914                 //gr_bm_ubitblt( Page.cv_bitmap.bm_w, Page.cv_bitmap.bm_h, Page.cv_bitmap.bm_x, Page.cv_bitmap.bm_y, 0, 0, &Page.cv_bitmap, &VR_screen_pages[0].cv_bitmap );
 915                 gr_bm_ubitblt( Page.cv_bitmap.bm_w, Page.cv_bitmap.bm_h, Page.cv_bitmap.bm_x, Page.cv_bitmap.bm_y, 0, 0, &Page.cv_bitmap, &grd_curscreen->sc_canvas.cv_bitmap );
 916         #else
 917                 dd_gr_blt_screen(&ddPage, 0,0,0,0,0,0,0,0);
 918         #endif
 919         }
 920         gr_update();
 921 #endif
 922 #endif
 923 }
 924
 925 #ifdef WINDOWS
 926 #define LEAVE_TIME 0x00010000
 927 #else
 928 #define LEAVE_TIME 0x4000
 929 #endif
 930
 931 #define WINDOW_WIDTH            288
 932
 933
 934 //print to canvas & double height
 935 grs_canvas *print_to_canvas(char *s,grs_font *font, int fc, int bc, int double_flag)
 936 {
 937         int y;
 938         ubyte *data;
 939         int rs;
 940         grs_canvas *temp_canv;
 941         grs_font *save_font;
 942         int w,h,aw;
 943
 944 WINDOS(
 945         dd_grs_canvas *save_canv,
 946         grs_canvas *save_canv
 947 );
 948
 949 WINDOS(
 950         save_canv = dd_grd_curcanv,
 951         save_canv = grd_curcanv
 952 );
 953
 954         save_font = grd_curcanv->cv_font;
 955         gr_set_curfont(font);                                   //set the font we're going to use
 956         gr_get_string_size(s,&w,&h,&aw);                //now get the string size
 957         gr_set_curfont(save_font);                              //restore real font
 958
 959         //temp_canv = gr_create_canvas(font->ft_w*strlen(s),font->ft_h*2);
 960         temp_canv = gr_create_canvas(w,font->ft_h*2);
 961
 962         gr_set_current_canvas(temp_canv);
 963         gr_set_curfont(font);
 964         gr_clear_canvas(TRANSPARENCY_COLOR);                                            //trans color
 965         gr_set_fontcolor(fc,bc);
 966         gr_printf(0,0,s);
 967
 968         //now double it, since we're drawing to 400-line modex screen
 969
 970         if (double_flag) {
 971                 data = temp_canv->cv_bitmap.bm_data;
 972                 rs = temp_canv->cv_bitmap.bm_rowsize;
 973
 974                 for (y=temp_canv->cv_bitmap.bm_h/2;y--;) {
 975                         memcpy(data+(rs*y*2),data+(rs*y),temp_canv->cv_bitmap.bm_w);
 976                         memcpy(data+(rs*(y*2+1)),data+(rs*y),temp_canv->cv_bitmap.bm_w);
 977                 }
 978         }
 979
 980 WINDOS(
 981         dd_gr_set_current_canvas(save_canv),
 982         gr_set_current_canvas(save_canv)
 983 );
 984
 985         return temp_canv;
 986 }
 987
 988 //print to buffer, double heights, and blit bitmap to screen
 989 void modex_printf(int x,int y,char *s,grs_font *font,int color)
 990 {
 991         grs_canvas *temp_canv;
 992
 993         temp_canv = print_to_canvas(s, font, color, -1, !AutomapHires);
 994
 995         gr_bitmapm(x,y,&temp_canv->cv_bitmap);
 996
 997         gr_free_canvas(temp_canv);
 998 }
 999
1000 //name for each group.  maybe move somewhere else
1001 char *system_name[] = {
1002                         "Zeta Aquilae",
1003                         "Quartzon System",
1004                         "Brimspark System",
1005                         "Limefrost Spiral",
1006                         "Baloris Prime",
1007                         "Omega System"};
1008
1009 void create_name_canv()
1010 {
1011         char    name_level_left[128],name_level_right[128];
1012
1013         if (Current_level_num > 0)
1014                 sprintf(name_level_left, "%s %i",TXT_LEVEL, Current_level_num);
1015         else
1016                 sprintf(name_level_left, "Secret Level %i",-Current_level_num);
1017
1018         if (Current_mission_num == Builtin_mission_num && Current_level_num>0)          //built-in mission
1019                 sprintf(name_level_right,"%s %d: ",system_name[(Current_level_num-1)/4],((Current_level_num-1)%4)+1);
1020         else
1021                 strcpy(name_level_right, " ");
1022
1023         strcat(name_level_right, Current_level_name);
1024
1025         gr_set_fontcolor(Green_31,-1);
1026         name_canv_left = print_to_canvas(name_level_left, SMALL_FONT, Green_31, -1, !AutomapHires);
1027         name_canv_right = print_to_canvas(name_level_right,SMALL_FONT, Green_31, -1, !AutomapHires);
1028
1029 }
1030
1031 void modex_print_message(int x, int y, char *str)
1032 {
1033         if (!AutomapHires) {
1034 #ifndef AUTOMAP_DIRECT_RENDER
1035                 int     i;
1036
1037                 for (i=0; i<2; i++ )    {
1038                         gr_set_current_canvas(&Pages[i]);
1039 #endif
1040
1041                         modex_printf(x, y, str, MEDIUM1_FONT,Font_color_20);
1042 #ifndef AUTOMAP_DIRECT_RENDER
1043                 }
1044                 gr_set_current_canvas(&DrawingPages[current_page]);
1045 #endif
1046         }
1047         else {
1048 #ifndef AUTOMAP_DIRECT_RENDER
1049                 gr_set_current_canvas(&Page);
1050 #endif
1051                 modex_printf(x, y, str, MEDIUM1_FONT,Font_color_20);
1052 #ifndef AUTOMAP_DIRECT_RENDER
1053                 gr_set_current_canvas(&DrawingPage);
1054 #endif
1055         }
1056 }
1057
1058 extern void GameLoop(int, int );
1059 extern int set_segment_depths(int start_seg, ubyte *segbuf);
1060
1061 int Automap_active = 0;
1062
1063 #ifdef RELEASE
1064 #define MAP_BACKGROUND_FILENAME (AutomapHires?"\x01MAPB.PCX":"\x01MAP.PCX")     //load only from hog file
1065 #else
1066 #define MAP_BACKGROUND_FILENAME ((AutomapHires && cfexist("mapb.pcx"))?"MAPB.PCX":"MAP.PCX")
1067 #endif
1068
1069 int Automap_always_hires=0;
1070 extern int MenuHiresAvailable;
1071
1072 extern int Current_display_mode;
1073
1074 u_int32_t automap_mode = SM(640,480);
1075 int automap_width = 640;
1076 int automap_height = 480;
1077 int automap_use_game_res=0;
1078
1079 void do_automap( int key_code ) {
1080         int done=0;
1081         vms_matrix      tempm;
1082         vms_angvec      tangles;
1083         int leave_mode=0;
1084         int first_time=1;
1085         int pcx_error;
1086 #if !defined(AUTOMAP_DIRECT_RENDER) || !defined(NDEBUG)
1087         int i;
1088 #endif
1089         int c, marker_num;
1090         fix entry_time;
1091         int pause_game=1;               // Set to 1 if everything is paused during automap...No pause during net.
1092         fix t1, t2;
1093         control_info saved_control_info;
1094         grs_bitmap Automap_background;
1095         int Max_segments_away = 0;
1096         int SegmentLimit = 1;
1097         ubyte pal[256*3];
1098         char maxdrop;
1099         int must_free_canvas=0;
1100
1101         WIN(int dd_VR_screen_mode_save);
1102         WIN(int redraw_screen=0);
1103
1104         Automap_active = 1;
1105
1106         init_automap_colors();
1107
1108         key_code = key_code;    // disable warning...
1109
1110         if ((Game_mode & GM_MULTI) && (Function_mode == FMODE_GAME) && (!Endlevel_sequence))
1111                 pause_game = 0;
1112
1113         if (pause_game) {
1114                 stop_time();
1115                 digi_pause_digi_sounds();
1116         }
1117
1118         Max_edges = min(MAX_EDGES_FROM_VERTS(Num_vertices),MAX_EDGES);                  //make maybe smaller than max
1119
1120         mprintf( (0, "Num_vertices=%d, Max_edges=%d, (MAX:%d)\n", Num_vertices, Max_edges, MAX_EDGES ));
1121         mprintf( (0, "Allocated %d K for automap edge list\n", (sizeof(Edge_info)+sizeof(short))*Max_edges/1024 ));
1122
1123         #if !defined (WINDOWS) && !defined(MACINTOSH)
1124         if ((Current_display_mode!=0 && Current_display_mode!=2) || (Automap_always_hires && MenuHiresAvailable)) {
1125 #if !defined(POLY_ACC)
1126                 //edit 4/23/99 Matt Mueller - don't switch res unless we need to
1127                 if (grd_curscreen->sc_mode != AUTOMAP_MODE)
1128                         gr_set_mode( AUTOMAP_MODE );
1129                 else
1130                         gr_set_current_canvas(NULL);
1131                 //end edit -MM
1132                 automap_width=grd_curscreen->sc_canvas.cv_bitmap.bm_w;
1133                 automap_height=grd_curscreen->sc_canvas.cv_bitmap.bm_h;
1134 #endif
1135                 PA_DFX (pa_set_frontbuffer_current());
1136                 AutomapHires = 1;
1137         }
1138         else {
1139                 gr_set_mode( SM(320, 400));
1140                 AutomapHires = 0;
1141         }
1142         #else
1143                 AutomapHires = 1;               //Mac & Windows(?) always in hires
1144         #endif
1145
1146         #ifdef WINDOWS
1147                 dd_VR_screen_mode_save = VR_screen_mode;
1148                 VR_screen_mode = SM95_640x480x8;        // HACK! Forcing reinit of 640x480
1149                 set_screen_mode(SCREEN_GAME);
1150         #endif
1151
1152         FontHires = FontHiresAvailable && AutomapHires;
1153
1154         create_name_canv();
1155
1156         gr_palette_clear();
1157
1158 WIN(AutomapRedraw:)
1159         if (!AutomapHires) {
1160 #ifndef MACINTOSH
1161 #ifndef AUTOMAP_DIRECT_RENDER
1162                 gr_init_sub_canvas(&Pages[0],grd_curcanv,0,0,320,400);
1163                 gr_init_sub_canvas(&Pages[1],grd_curcanv,0,401,320,400);
1164                 gr_init_sub_canvas(&DrawingPages[0],&Pages[0],16,69,WINDOW_WIDTH,272);
1165                 gr_init_sub_canvas(&DrawingPages[1],&Pages[1],16,69,WINDOW_WIDTH,272);
1166 #endif
1167
1168                 gr_init_bitmap_data (&Automap_background);
1169 //              pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME,&Automap_background,BM_LINEAR,pal);
1170 //              if ( pcx_error != PCX_ERROR_NONE )
1171 //                      Error("File %s - PCX error: %s",MAP_BACKGROUND_FILENAME,pcx_errormsg(pcx_error));
1172 //              gr_remap_bitmap_good( &Automap_background, pal, -1, -1 );
1173
1174 #ifndef AUTOMAP_DIRECT_RENDER
1175                 for (i=0; i<2; i++ )    {
1176                         gr_set_current_canvas(&Pages[i]);
1177 //                      gr_bitmap( 0, 0, &Automap_background );
1178 //                      modex_printf( 40, 22,TXT_AUTOMAP,HUGE_FONT,Font_color_20);
1179 //                      modex_printf( 30,353,TXT_TURN_SHIP,SMALL_FONT,Font_color_20);
1180 //                      modex_printf( 30,369,TXT_SLIDE_UPDOWN,SMALL_FONT,Font_color_20);
1181 //                      modex_printf( 30,385,TXT_VIEWING_DISTANCE,SMALL_FONT,Font_color_20);
1182                 }
1183                 gr_free_bitmap_data(&Automap_background);
1184                 gr_set_current_canvas(&DrawingPages[current_page]);
1185 #endif /* AUTOMAP_DIRECT_RENDER */
1186 #endif /* MACINTOSH */
1187         }
1188         else {
1189 #ifndef AUTOMAP_DIRECT_RENDER
1190                 if (VR_render_buffer[0].cv_w >= automap_width && VR_render_buffer[0].cv_h >= automap_height)
1191                 {
1192                         WIN(dd_gr_init_sub_canvas(&ddPage, &dd_VR_render_buffer[0], 0, 0, automap_width,automap_height));
1193
1194                         #if defined(MACINTOSH) && defined(POLY_ACC)
1195                                 if (PAEnabled)
1196                                 {
1197                                         // we want all the automap border stuff to be drawn straight to the screen
1198                                         gr_init_sub_canvas(&Page,&(grd_curscreen->sc_canvas),0, 0, automap_width, automap_height);
1199                                 }
1200                                 else
1201                                 {
1202                                         gr_init_sub_canvas(&Page,&VR_render_buffer[0],0, 0, automap_width, automap_height);
1203                                 }
1204                         #else
1205                                 gr_init_sub_canvas(&Page,&VR_render_buffer[0],0, 0, automap_width, automap_height);
1206                         #endif
1207
1208                 }
1209                 else {
1210                 #ifndef WINDOWS
1211                         void *raw_data;
1212                         MALLOC(raw_data,ubyte,automap_width*automap_height);
1213                         gr_init_canvas(&Page,raw_data,BM_LINEAR,automap_width,automap_height);
1214                 #else
1215                         dd_gr_init_canvas(&ddPage, BM_LINEAR, automap_width,automap_height);
1216                         gr_init_canvas(&Page,NULL,BM_LINEAR,automap_width,automap_height);
1217                 #endif
1218                         must_free_canvas = 1;
1219                 }
1220
1221                 WIN(dd_gr_init_sub_canvas(&ddDrawingPage, &ddPage, 0,0,automap_width,automap_height));
1222                 gr_init_sub_canvas(&DrawingPage,&Page, 0,0,automap_width,automap_height);
1223
1224                 WINDOS(
1225                         dd_gr_set_current_canvas(&ddPage),
1226                         gr_set_current_canvas(&Page)
1227                 );
1228 #endif
1229
1230 #if defined(POLY_ACC)
1231
1232                 #ifndef MACINTOSH
1233                 pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME,&(grd_curcanv->cv_bitmap),BM_LINEAR15,pal);
1234         #else
1235                 if ( PAEnabled )
1236                 {
1237                         pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME,&(grd_curcanv->cv_bitmap),BM_LINEAR15,pal);
1238                                 if ( pcx_error != PCX_ERROR_NONE )
1239                                 {
1240                                         Error("File %s - PCX error: %s",MAP_BACKGROUND_FILENAME,pcx_errormsg(pcx_error));
1241                                         return;
1242                                 }
1243                     }
1244                     else
1245                     {
1246                                 pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME,&(grd_curcanv->cv_bitmap),BM_LINEAR,pal);
1247                                 if ( pcx_error != PCX_ERROR_NONE )
1248                                 {
1249                                         Error("File %s - PCX error: %s",MAP_BACKGROUND_FILENAME,pcx_errormsg(pcx_error));
1250                                         return;
1251                                 }
1252
1253                                 gr_remap_bitmap_good( &(grd_curcanv->cv_bitmap), pal, -1, -1 );
1254                     }
1255             #endif
1256 #else
1257
1258                 WIN(DDGRLOCK(dd_grd_curcanv));
1259                         pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME,&(grd_curcanv->cv_bitmap),BM_LINEAR,pal);
1260                         if ( pcx_error != PCX_ERROR_NONE )      {
1261                                 //printf("File %s - PCX error: %s",MAP_BACKGROUND_FILENAME,pcx_errormsg(pcx_error));
1262                                 Error("File %s - PCX error: %s",MAP_BACKGROUND_FILENAME,pcx_errormsg(pcx_error));
1263                                 return;
1264                         }
1265
1266                         gr_remap_bitmap_good( &(grd_curcanv->cv_bitmap), pal, -1, -1 );
1267 #endif
1268
1269                         gr_set_curfont(HUGE_FONT);
1270                         gr_set_fontcolor(BM_XRGB(20, 20, 20), -1);
1271                         gr_printf( 80, 36,TXT_AUTOMAP,HUGE_FONT);
1272                         gr_set_curfont(SMALL_FONT);
1273                         gr_set_fontcolor(BM_XRGB(20, 20, 20), -1);
1274                         gr_printf( 60, 426,TXT_TURN_SHIP);
1275                         gr_printf( 60, 443,TXT_SLIDE_UPDOWN);
1276                         gr_printf( 60, 460,TXT_VIEWING_DISTANCE);
1277                 WIN(DDGRUNLOCK(dd_grd_curcanv));
1278
1279 #ifndef AUTOMAP_DIRECT_RENDER
1280                 WINDOS(
1281                         dd_gr_set_current_canvas(&ddDrawingPage),
1282                         gr_set_current_canvas(&DrawingPage)
1283                 );
1284 #endif
1285         }
1286
1287
1288 WIN(if (!redraw_screen) {)
1289         automap_build_edge_list();
1290
1291         if ( ViewDist==0 )
1292                 ViewDist = ZOOM_DEFAULT;
1293         ViewMatrix = Objects[Players[Player_num].objnum].orient;
1294
1295         tangles.p = PITCH_DEFAULT;
1296         tangles.h  = 0;
1297         tangles.b  = 0;
1298
1299         done = 0;
1300
1301         view_target = Objects[Players[Player_num].objnum].pos;
1302
1303         t1 = entry_time = timer_get_fixed_seconds();
1304         t2 = t1;
1305
1306         //Fill in Automap_visited from Objects[Players[Player_num].objnum].segnum
1307         Max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
1308         SegmentLimit = Max_segments_away;
1309
1310         adjust_segment_limit(SegmentLimit);
1311 WIN(})
1312
1313 WIN(if (redraw_screen) redraw_screen = 0);
1314
1315         while(!done)    {
1316                 if ( leave_mode==0 && Controls.automap_state && (timer_get_fixed_seconds()-entry_time)>LEAVE_TIME)
1317                         leave_mode = 1;
1318
1319                 if ( !Controls.automap_state && (leave_mode==1) )
1320                         done=1;
1321
1322                 if (!pause_game)        {
1323                         ushort old_wiggle;
1324                         saved_control_info = Controls;                          // Save controls so we can zero them
1325                         memset(&Controls,0,sizeof(control_info));       // Clear everything...
1326                         old_wiggle = ConsoleObject->mtype.phys_info.flags & PF_WIGGLE;  // Save old wiggle
1327                         ConsoleObject->mtype.phys_info.flags &= ~PF_WIGGLE;             // Turn off wiggle
1328                         #ifdef NETWORK
1329                         if (multi_menu_poll())
1330                                 done = 1;
1331                         #endif
1332 //                      GameLoop( 0, 0 );               // Do game loop with no rendering and no reading controls.
1333                         ConsoleObject->mtype.phys_info.flags |= old_wiggle;     // Restore wiggle
1334                         Controls = saved_control_info;
1335                 }
1336
1337         #ifndef WINDOWS
1338                 controls_read_all();
1339         #else
1340                 controls_read_all_win();
1341         #endif
1342
1343                 if ( Controls.automap_down_count )      {
1344                         if (leave_mode==0)
1345                                 done = 1;
1346                         c = 0;
1347                 }
1348
1349                 //see if redbook song needs to be restarted
1350                 songs_check_redbook_repeat();
1351
1352                 #ifdef WINDOWS
1353                 {
1354                         MSG msg;
1355                         DoMessageStuff(&msg);
1356                         if (_RedrawScreen) {
1357                                 _RedrawScreen = FALSE;
1358                                 redraw_screen = 1;
1359                                 goto AutomapRedraw;
1360                         }
1361
1362                         if (msg.message == WM_QUIT) exit(1);
1363
1364                         DDGRRESTORE;
1365                 }
1366                 #endif
1367
1368
1369                 while( (c=key_inkey()) )        {
1370                         switch( c ) {
1371                         #ifndef NDEBUG
1372                         case KEY_BACKSP: Int3(); break;
1373                         #endif
1374
1375                         case KEY_PRINT_SCREEN: {
1376                                 if (AutomapHires) {
1377                                 WINDOS(
1378                                         dd_gr_set_current_canvas(NULL),
1379                                                 gr_set_current_canvas(NULL)
1380                                 );
1381                                 }
1382 #ifndef AUTOMAP_DIRECT_RENDER
1383                                 else
1384                                         gr_set_current_canvas(&Pages[current_page]);
1385 #endif
1386                                 save_screen_shot(1);
1387                                 break;
1388                         }
1389
1390                         case KEY_ESC:
1391                                 if (leave_mode==0)
1392                                         done = 1;
1393                                  break;
1394
1395                         #ifndef NDEBUG
1396                         case KEY_DEBUGGED+KEY_F:        {
1397                                 for (i=0; i<=Highest_segment_index; i++ )
1398                                         Automap_visited[i] = 1;
1399                                 automap_build_edge_list();
1400                                 Max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
1401                                 SegmentLimit = Max_segments_away;
1402                                 adjust_segment_limit(SegmentLimit);
1403                                 }
1404                                 break;
1405                         #endif
1406
1407                         case KEY_MINUS:
1408                                 if (SegmentLimit > 1)           {
1409                                         SegmentLimit--;
1410                                         adjust_segment_limit(SegmentLimit);
1411                                 }
1412                                 break;
1413                         case KEY_EQUAL:
1414                                 if (SegmentLimit < Max_segments_away)   {
1415                                         SegmentLimit++;
1416                                         adjust_segment_limit(SegmentLimit);
1417                                 }
1418                                 break;
1419                         case KEY_1:
1420                         case KEY_2:
1421                         case KEY_3:
1422                         case KEY_4:
1423                         case KEY_5:
1424                         case KEY_6:
1425                         case KEY_7:
1426                         case KEY_8:
1427                         case KEY_9:
1428                         case KEY_0:
1429                                 if (Game_mode & GM_MULTI)
1430                                 maxdrop=2;
1431                                 else
1432                                 maxdrop=9;
1433
1434                         #ifndef MACINTOSH
1435                         marker_num = c-KEY_1;
1436                         #else
1437                         switch(c) {             // god this is stupid.....
1438                                 case KEY_1: marker_num = 0; break;
1439                                 case KEY_2: marker_num = 1; break;
1440                                 case KEY_3: marker_num = 2; break;
1441                                 case KEY_4: marker_num = 3; break;
1442                                 case KEY_5: marker_num = 4; break;
1443                                 case KEY_6: marker_num = 5; break;
1444                                 case KEY_7: marker_num = 6; break;
1445                                 case KEY_8: marker_num = 7; break;
1446                                 case KEY_9: marker_num = 8; break;
1447                                 case KEY_0: marker_num = 9; break;
1448                         }
1449                         #endif
1450             if (marker_num<=maxdrop)
1451                                  {
1452                                         if (MarkerObject[marker_num] != -1)
1453                                                 HighlightMarker=marker_num;
1454                                  }
1455                           break;
1456
1457                         case KEY_D+KEY_CTRLED:
1458 #ifndef AUTOMAP_DIRECT_RENDER
1459                                 if (current_page)               //menu will only work on page 0
1460                                         draw_automap(); //..so switch from 1 to 0
1461 #endif
1462
1463                                 if (HighlightMarker > -1 && MarkerObject[HighlightMarker] != -1) {
1464 #ifndef AUTOMAP_DIRECT_RENDER
1465                                         WINDOS(
1466                                                 dd_gr_set_current_canvas(&ddPages[current_page]),
1467                                                 gr_set_current_canvas(&Pages[current_page])
1468                                         );
1469 #endif
1470
1471                                         if (nm_messagebox( NULL, 2, TXT_YES, TXT_NO, "Delete Marker?" ) == 0) {
1472                                                 obj_delete(MarkerObject[HighlightMarker]);
1473                                                 MarkerObject[HighlightMarker]=-1;
1474                                                 MarkerMessage[HighlightMarker][0]=0;
1475                                                 HighlightMarker = -1;
1476                                         }
1477                                 }
1478                                 break;
1479
1480                         #ifndef RELEASE
1481                         case KEY_COMMA:
1482                                 if (MarkerScale>.5)
1483                                         MarkerScale-=.5;
1484                                 break;
1485                         case KEY_PERIOD:
1486                                 if (MarkerScale<30.0)
1487                                         MarkerScale+=.5;
1488                                 break;
1489                         #endif
1490
1491 //added 8/23/99 by Matt Mueller for hot key res/fullscreen changing, and menu access
1492 #if 0
1493                         case KEY_CTRLED+KEY_SHIFTED+KEY_PADDIVIDE:
1494                         case KEY_ALTED+KEY_CTRLED+KEY_PADDIVIDE:
1495                         case KEY_ALTED+KEY_SHIFTED+KEY_PADDIVIDE:
1496                                 d1x_options_menu();
1497                                 break;
1498                         case KEY_CTRLED+KEY_SHIFTED+KEY_PADMULTIPLY:
1499                         case KEY_ALTED+KEY_CTRLED+KEY_PADMULTIPLY:
1500                         case KEY_ALTED+KEY_SHIFTED+KEY_PADMULTIPLY:
1501                                 change_res();
1502                                 break;
1503                         case KEY_CTRLED+KEY_SHIFTED+KEY_PADMINUS:
1504                         case KEY_ALTED+KEY_CTRLED+KEY_PADMINUS:
1505                         case KEY_ALTED+KEY_SHIFTED+KEY_PADMINUS:
1506                                 //lower res
1507                                 //should we just cycle through the list that is displayed in the res change menu?
1508                                 // what if their card/X/etc can't handle that mode? hrm.
1509                                 //well, the quick access to the menu is good enough for now.
1510                                 break;
1511                         case KEY_CTRLED+KEY_SHIFTED+KEY_PADPLUS:
1512                         case KEY_ALTED+KEY_CTRLED+KEY_PADPLUS:
1513                         case KEY_ALTED+KEY_SHIFTED+KEY_PADPLUS:
1514                                 //increase res
1515                                 break;
1516 #endif
1517                         case KEY_CTRLED+KEY_SHIFTED+KEY_PADENTER:
1518                         case KEY_ALTED+KEY_CTRLED+KEY_PADENTER:
1519                         case KEY_ALTED+KEY_SHIFTED+KEY_PADENTER:
1520                                 gr_toggle_fullscreen_game();
1521                                 break;
1522 //end addition -MM
1523
1524               }
1525                 }
1526
1527                 if ( Controls.fire_primary_down_count ) {
1528                         // Reset orientation
1529                         ViewDist = ZOOM_DEFAULT;
1530                         tangles.p = PITCH_DEFAULT;
1531                         tangles.h  = 0;
1532                         tangles.b  = 0;
1533                         view_target = Objects[Players[Player_num].objnum].pos;
1534                 }
1535
1536                 ViewDist -= Controls.forward_thrust_time*ZOOM_SPEED_FACTOR;
1537
1538                 tangles.p += fixdiv( Controls.pitch_time, ROT_SPEED_DIVISOR );
1539                 tangles.h  += fixdiv( Controls.heading_time, ROT_SPEED_DIVISOR );
1540                 tangles.b  += fixdiv( Controls.bank_time, ROT_SPEED_DIVISOR*2 );
1541
1542                 if ( Controls.vertical_thrust_time || Controls.sideways_thrust_time )   {
1543                         vms_angvec      tangles1;
1544                         vms_vector      old_vt;
1545                         old_vt = view_target;
1546                         tangles1 = tangles;
1547                         vm_angles_2_matrix(&tempm,&tangles1);
1548                         vm_matrix_x_matrix(&ViewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
1549                         vm_vec_scale_add2( &view_target, &ViewMatrix.uvec, Controls.vertical_thrust_time*SLIDE_SPEED );
1550                         vm_vec_scale_add2( &view_target, &ViewMatrix.rvec, Controls.sideways_thrust_time*SLIDE_SPEED );
1551                         if ( vm_vec_dist_quick( &view_target, &Objects[Players[Player_num].objnum].pos) > i2f(1000) )   {
1552                                 view_target = old_vt;
1553                         }
1554                 }
1555
1556                 vm_angles_2_matrix(&tempm,&tangles);
1557                 vm_matrix_x_matrix(&ViewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
1558
1559                 if ( ViewDist < ZOOM_MIN_VALUE ) ViewDist = ZOOM_MIN_VALUE;
1560                 if ( ViewDist > ZOOM_MAX_VALUE ) ViewDist = ZOOM_MAX_VALUE;
1561
1562                 draw_automap();
1563
1564                 if ( first_time )       {
1565                         first_time = 0;
1566                         gr_palette_load( gr_palette );
1567                 }
1568
1569                 t2 = timer_get_fixed_seconds();
1570                 if (pause_game)
1571                         FrameTime=t2-t1;
1572                 t1 = t2;
1573         }
1574
1575         //d_free(Edges);
1576         //d_free(DrawingListBright);
1577
1578         gr_free_canvas(name_canv_left);  name_canv_left=NULL;
1579         gr_free_canvas(name_canv_right);  name_canv_right=NULL;
1580
1581         if (must_free_canvas)   {
1582 #ifndef AUTOMAP_DIRECT_RENDER
1583         WINDOS(
1584                 DDFreeSurface(ddPages[0].lpdds),
1585                 d_free(Page.cv_bitmap.bm_data)
1586         );
1587 #endif
1588         }
1589
1590         mprintf( (0, "Automap memory freed\n" ));
1591
1592         game_flush_inputs();
1593
1594         #if defined(POLY_ACC) && defined(MACINTOSH)
1595                 if (PAEnabled)
1596                 {
1597                         pa_set_context(kGamePlayDrawContextID, NULL);
1598                 }
1599         #endif
1600
1601         if (pause_game)
1602         {
1603                 start_time();
1604                 digi_resume_digi_sounds();
1605         }
1606
1607 #ifdef WINDOWS
1608         VR_screen_mode = dd_VR_screen_mode_save;
1609 #endif
1610
1611         Automap_active = 0;
1612 }
1613
1614 void adjust_segment_limit(int SegmentLimit)
1615 {
1616         int i,e1;
1617         Edge_info * e;
1618
1619         mprintf(( 0, "Seglimit: %d\n", SegmentLimit ));
1620
1621         for (i=0; i<=Highest_edge_index; i++ )  {
1622                 e = &Edges[i];
1623                 e->flags |= EF_TOO_FAR;
1624                 for (e1=0; e1<e->num_faces; e1++ )      {
1625                         if ( Automap_visited[e->segnum[e1]] <= SegmentLimit )   {
1626                                 e->flags &= (~EF_TOO_FAR);
1627                                 break;
1628                         }
1629                 }
1630         }
1631
1632 }
1633
1634 void draw_all_edges()
1635 {
1636         g3s_codes cc;
1637         int i,j,nbright;
1638         ubyte nfacing,nnfacing;
1639         Edge_info *e;
1640         vms_vector *tv1;
1641         fix distance;
1642         fix min_distance = 0x7fffffff;
1643         g3s_point *p1, *p2;
1644
1645
1646         nbright=0;
1647
1648         for (i=0; i<=Highest_edge_index; i++ )  {
1649                 //e = &Edges[Edge_used_list[i]];
1650                 e = &Edges[i];
1651                 if (!(e->flags & EF_USED)) continue;
1652
1653                 if ( e->flags & EF_TOO_FAR) continue;
1654
1655                 if (e->flags&EF_FRONTIER)       {                                               // A line that is between what we have seen and what we haven't
1656                         if ( (!(e->flags&EF_SECRET))&&(e->color==Wall_normal_color))
1657                                 continue;               // If a line isn't secret and is normal color, then don't draw it
1658                 }
1659
1660                 cc=rotate_list(2,e->verts);
1661                 distance = Segment_points[e->verts[1]].p3_z;
1662
1663                 if (min_distance>distance )
1664                         min_distance = distance;
1665
1666                 if (!cc.and)    {       //all off screen?
1667                         nfacing = nnfacing = 0;
1668                         tv1 = &Vertices[e->verts[0]];
1669                         j = 0;
1670                         while( j<e->num_faces && (nfacing==0 || nnfacing==0) )  {
1671                                 #ifdef COMPACT_SEGS
1672                                 vms_vector temp_v;
1673                                 get_side_normal(&Segments[e->segnum[j]], e->sides[j], 0, &temp_v );
1674                                 if (!g3_check_normal_facing( tv1, &temp_v ) )
1675                                 #else
1676                                 if (!g3_check_normal_facing( tv1, &Segments[e->segnum[j]].sides[e->sides[j]].normals[0] ) )
1677                                 #endif
1678                                         nfacing++;
1679                                 else
1680                                         nnfacing++;
1681                                 j++;
1682                         }
1683
1684                         if ( nfacing && nnfacing )      {
1685                                 // a contour line
1686                                 DrawingListBright[nbright++] = e-Edges;
1687                         } else if ( e->flags&(EF_DEFINING|EF_GRATE) )   {
1688                                 if ( nfacing == 0 )     {
1689                                         if ( e->flags & EF_NO_FADE )
1690                                                 gr_setcolor( e->color );
1691                                         else
1692                                                 gr_setcolor( gr_fade_table[e->color+256*8] );
1693                                         g3_draw_line( &Segment_points[e->verts[0]], &Segment_points[e->verts[1]] );
1694                                 }       else {
1695                                         DrawingListBright[nbright++] = e-Edges;
1696                                 }
1697                         }
1698                 }
1699         }
1700
1701 ///     mprintf( (0, "Min distance=%.2f, ViewDist=%.2f, Delta=%.2f\n", f2fl(min_distance), f2fl(ViewDist), f2fl(min_distance)- f2fl(ViewDist) ));
1702
1703         if ( min_distance < 0 ) min_distance = 0;
1704
1705         // Sort the bright ones using a shell sort
1706         {
1707                 int t;
1708                 int i, j, incr, v1, v2;
1709
1710                 incr = nbright / 2;
1711                 while( incr > 0 )       {
1712                         for (i=incr; i<nbright; i++ )   {
1713                                 j = i - incr;
1714                                 while (j>=0 )   {
1715                                         // compare element j and j+incr
1716                                         v1 = Edges[DrawingListBright[j]].verts[0];
1717                                         v2 = Edges[DrawingListBright[j+incr]].verts[0];
1718
1719                                         if (Segment_points[v1].p3_z < Segment_points[v2].p3_z) {
1720                                                 // If not in correct order, them swap 'em
1721                                                 t=DrawingListBright[j+incr];
1722                                                 DrawingListBright[j+incr]=DrawingListBright[j];
1723                                                 DrawingListBright[j]=t;
1724                                                 j -= incr;
1725                                         }
1726                                         else
1727                                                 break;
1728                                 }
1729                         }
1730                         incr = incr / 2;
1731                 }
1732         }
1733
1734         // Draw the bright ones
1735         for (i=0; i<nbright; i++ )      {
1736                 int color;
1737                 fix dist;
1738                 e = &Edges[DrawingListBright[i]];
1739                 p1 = &Segment_points[e->verts[0]];
1740                 p2 = &Segment_points[e->verts[1]];
1741                 dist = p1->p3_z - min_distance;
1742                 // Make distance be 1.0 to 0.0, where 0.0 is 10 segments away;
1743                 if ( dist < 0 ) dist=0;
1744                 if ( dist >= Automap_farthest_dist ) continue;
1745
1746                 if ( e->flags & EF_NO_FADE )    {
1747                         gr_setcolor( e->color );
1748                 } else {
1749                         dist = F1_0 - fixdiv( dist, Automap_farthest_dist );
1750                         color = f2i( dist*31 );
1751                         gr_setcolor( gr_fade_table[e->color+color*256] );
1752                 }
1753                 g3_draw_line( p1, p2 );
1754         }
1755
1756 }
1757
1758
1759 //==================================================================
1760 //
1761 // All routines below here are used to build the Edge list
1762 //
1763 //==================================================================
1764
1765
1766 //finds edge, filling in edge_ptr. if found old edge, returns index, else return -1
1767 static int automap_find_edge(int v0,int v1,Edge_info **edge_ptr)
1768 {
1769         long vv, evv;
1770         short hash,oldhash;
1771         int ret, ev0, ev1;
1772
1773         vv = (v1<<16) + v0;
1774
1775         oldhash = hash = ((v0*5+v1) % Max_edges);
1776
1777         ret = -1;
1778
1779         while (ret==-1) {
1780                 ev0 = (int)(Edges[hash].verts[0]);
1781                 ev1 = (int)(Edges[hash].verts[1]);
1782                 evv = (ev1<<16)+ev0;
1783                 if (Edges[hash].num_faces == 0 ) ret=0;
1784                 else if (evv == vv) ret=1;
1785                 else {
1786                         if (++hash==Max_edges) hash=0;
1787                         if (hash==oldhash) Error("Edge list full!");
1788                 }
1789         }
1790
1791         *edge_ptr = &Edges[hash];
1792
1793         if (ret == 0)
1794                 return -1;
1795         else
1796                 return hash;
1797
1798 }
1799
1800
1801 void add_one_edge( short va, short vb, ubyte color, ubyte side, short segnum, int hidden, int grate, int no_fade )      {
1802         int found;
1803         Edge_info *e;
1804         short tmp;
1805
1806         if ( Num_edges >= Max_edges)    {
1807                 // GET JOHN! (And tell him that his
1808                 // MAX_EDGES_FROM_VERTS formula is hosed.)
1809                 // If he's not around, save the mine,
1810                 // and send him  mail so he can look
1811                 // at the mine later. Don't modify it.
1812                 // This is important if this happens.
1813                 Int3();         // LOOK ABOVE!!!!!!
1814                 return;
1815         }
1816
1817         if ( va > vb )  {
1818                 tmp = va;
1819                 va = vb;
1820                 vb = tmp;
1821         }
1822
1823         found = automap_find_edge(va,vb,&e);
1824
1825         if (found == -1) {
1826                 e->verts[0] = va;
1827                 e->verts[1] = vb;
1828                 e->color = color;
1829                 e->num_faces = 1;
1830                 e->flags = EF_USED | EF_DEFINING;                       // Assume a normal line
1831                 e->sides[0] = side;
1832                 e->segnum[0] = segnum;
1833                 //Edge_used_list[Num_edges] = e-Edges;
1834                 if ( (e-Edges) > Highest_edge_index )
1835                         Highest_edge_index = e - Edges;
1836                 Num_edges++;
1837         } else {
1838                 //Assert(e->num_faces < 8 );
1839
1840                 if ( color != Wall_normal_color )
1841                         if (color != Wall_revealed_color)
1842                                 e->color = color;
1843
1844                 if ( e->num_faces < 4 ) {
1845                         e->sides[e->num_faces] = side;
1846                         e->segnum[e->num_faces] = segnum;
1847                         e->num_faces++;
1848                 }
1849         }
1850
1851         if ( grate )
1852                 e->flags |= EF_GRATE;
1853
1854         if ( hidden )
1855                 e->flags|=EF_SECRET;            // Mark this as a hidden edge
1856         if ( no_fade )
1857                 e->flags |= EF_NO_FADE;
1858 }
1859
1860 void add_one_unknown_edge( short va, short vb ) {
1861         int found;
1862         Edge_info *e;
1863         short tmp;
1864
1865         if ( va > vb )  {
1866                 tmp = va;
1867                 va = vb;
1868                 vb = tmp;
1869         }
1870
1871         found = automap_find_edge(va,vb,&e);
1872         if (found != -1)
1873                 e->flags|=EF_FRONTIER;          // Mark as a border edge
1874 }
1875
1876 #ifndef _GAMESEQ_H
1877 extern obj_position Player_init[];
1878 #endif
1879
1880 void add_segment_edges(segment *seg)
1881 {
1882         int     is_grate, no_fade;
1883         ubyte   color;
1884         int     sn;
1885         int     segnum = seg-Segments;
1886         int     hidden_flag;
1887         int ttype,trigger_num;
1888
1889         for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++) {
1890                 short   vertex_list[4];
1891
1892                 hidden_flag = 0;
1893
1894                 is_grate = 0;
1895                 no_fade = 0;
1896
1897                 color = 255;
1898                 if (seg->children[sn] == -1) {
1899                         color = Wall_normal_color;
1900                 }
1901
1902                 switch( Segment2s[segnum].special )     {
1903                 case SEGMENT_IS_FUELCEN:
1904                         color = BM_XRGB( 29, 27, 13 );
1905                         break;
1906                 case SEGMENT_IS_CONTROLCEN:
1907                         if (Control_center_present)
1908                                 color = BM_XRGB( 29, 0, 0 );
1909                         break;
1910                 case SEGMENT_IS_ROBOTMAKER:
1911                         color = BM_XRGB( 29, 0, 31 );
1912                         break;
1913                 }
1914
1915                 if (seg->sides[sn].wall_num > -1)       {
1916
1917                         trigger_num = Walls[seg->sides[sn].wall_num].trigger;
1918                         ttype = Triggers[trigger_num].type;
1919                         if (ttype==TT_SECRET_EXIT)
1920                                 {
1921                             color = BM_XRGB( 29, 0, 31 );
1922                                  no_fade=1;
1923                                  goto Here;
1924                                 }
1925
1926                         switch( Walls[seg->sides[sn].wall_num].type )   {
1927                         case WALL_DOOR:
1928                                 if (Walls[seg->sides[sn].wall_num].keys == KEY_BLUE) {
1929                                         no_fade = 1;
1930                                         color = Wall_door_blue;
1931                                         //mprintf((0, "Seg %i, side %i has BLUE wall\n", segnum, sn));
1932                                 } else if (Walls[seg->sides[sn].wall_num].keys == KEY_GOLD) {
1933                                         no_fade = 1;
1934                                         color = Wall_door_gold;
1935                                         //mprintf((0, "Seg %i, side %i has GOLD wall\n", segnum, sn));
1936                                 } else if (Walls[seg->sides[sn].wall_num].keys == KEY_RED) {
1937                                         no_fade = 1;
1938                                         color = Wall_door_red;
1939                                         //mprintf((0, "Seg %i, side %i has RED wall\n", segnum, sn));
1940                                 } else if (!(WallAnims[Walls[seg->sides[sn].wall_num].clip_num].flags & WCF_HIDDEN)) {
1941                                         int     connected_seg = seg->children[sn];
1942                                         if (connected_seg != -1) {
1943                                                 int connected_side = find_connect_side(seg, &Segments[connected_seg]);
1944                                                 int     keytype = Walls[Segments[connected_seg].sides[connected_side].wall_num].keys;
1945                                                 if ((keytype != KEY_BLUE) && (keytype != KEY_GOLD) && (keytype != KEY_RED))
1946                                                         color = Wall_door_color;
1947                                                 else {
1948                                                         switch (Walls[Segments[connected_seg].sides[connected_side].wall_num].keys) {
1949                                                                 case KEY_BLUE:  color = Wall_door_blue; no_fade = 1; break;
1950                                                                 case KEY_GOLD:  color = Wall_door_gold; no_fade = 1; break;
1951                                                                 case KEY_RED:   color = Wall_door_red;  no_fade = 1; break;
1952                                                                 default:        Error("Inconsistent data.  Supposed to be a colored wall, but not blue, gold or red.\n");
1953                                                         }
1954                                                         //mprintf((0, "Seg %i, side %i has a colored door on the other side.\n", segnum, sn));
1955                                                 }
1956
1957                                         }
1958                                 } else {
1959                                         color = Wall_normal_color;
1960                                         hidden_flag = 1;
1961                                         //mprintf((0, "Wall at seg:side %i:%i is hidden.\n", seg-Segments, sn));
1962                                 }
1963                                 break;
1964                         case WALL_CLOSED:
1965                                 // Make grates draw properly
1966                                 if (WALL_IS_DOORWAY(seg,sn) & WID_RENDPAST_FLAG)
1967                                         is_grate = 1;
1968                                 else
1969                                         hidden_flag = 1;
1970                                 color = Wall_normal_color;
1971                                 break;
1972                         case WALL_BLASTABLE:
1973                                 // Hostage doors
1974                                 color = Wall_door_color;
1975                                 break;
1976                         }
1977                 }
1978
1979                 if (segnum==Player_init[Player_num].segnum)
1980                         color = BM_XRGB(31,0,31);
1981
1982                 if ( color != 255 )     {
1983                         // If they have a map powerup, draw unvisited areas in dark blue.
1984                         if (Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL && (!Automap_visited[segnum]))
1985                                 color = Wall_revealed_color;
1986
1987
1988                         Here:
1989
1990                         get_side_verts(vertex_list,segnum,sn);
1991                         add_one_edge( vertex_list[0], vertex_list[1], color, sn, segnum, hidden_flag, 0, no_fade );
1992                         add_one_edge( vertex_list[1], vertex_list[2], color, sn, segnum, hidden_flag, 0, no_fade );
1993                         add_one_edge( vertex_list[2], vertex_list[3], color, sn, segnum, hidden_flag, 0, no_fade );
1994                         add_one_edge( vertex_list[3], vertex_list[0], color, sn, segnum, hidden_flag, 0, no_fade );
1995
1996                         if ( is_grate ) {
1997                                 add_one_edge( vertex_list[0], vertex_list[2], color, sn, segnum, hidden_flag, 1, no_fade );
1998                                 add_one_edge( vertex_list[1], vertex_list[3], color, sn, segnum, hidden_flag, 1, no_fade );
1999                         }
2000                 }
2001         }
2002
2003 }
2004
2005
2006 // Adds all the edges from a segment we haven't visited yet.
2007
2008 void add_unknown_segment_edges(segment *seg)
2009 {
2010         int sn;
2011         int segnum = seg-Segments;
2012
2013         for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++) {
2014                 short   vertex_list[4];
2015
2016                 // Only add edges that have no children
2017                 if (seg->children[sn] == -1) {
2018                         get_side_verts(vertex_list,segnum,sn);
2019
2020                         add_one_unknown_edge( vertex_list[0], vertex_list[1] );
2021                         add_one_unknown_edge( vertex_list[1], vertex_list[2] );
2022                         add_one_unknown_edge( vertex_list[2], vertex_list[3] );
2023                         add_one_unknown_edge( vertex_list[3], vertex_list[0] );
2024                 }
2025
2026
2027         }
2028
2029 }
2030
2031 void automap_build_edge_list()
2032 {
2033         int     i,e1,e2,s;
2034         Edge_info * e;
2035
2036         Automap_cheat = 0;
2037
2038         if ( Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL_CHEAT )
2039                 Automap_cheat = 1;              // Damn cheaters...
2040
2041         // clear edge list
2042         for (i=0; i<Max_edges; i++) {
2043                 Edges[i].num_faces = 0;
2044                 Edges[i].flags = 0;
2045         }
2046         Num_edges = 0;
2047         Highest_edge_index = -1;
2048
2049         if (Automap_cheat || (Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL) )       {
2050                 // Cheating, add all edges as visited
2051                 for (s=0; s<=Highest_segment_index; s++)
2052                         #ifdef EDITOR
2053                         if (Segments[s].segnum != -1)
2054                         #endif
2055                         {
2056                                 add_segment_edges(&Segments[s]);
2057                         }
2058         } else {
2059                 // Not cheating, add visited edges, and then unvisited edges
2060                 for (s=0; s<=Highest_segment_index; s++)
2061                         #ifdef EDITOR
2062                         if (Segments[s].segnum != -1)
2063                         #endif
2064                                 if (Automap_visited[s]) {
2065                                         add_segment_edges(&Segments[s]);
2066                                 }
2067
2068                 for (s=0; s<=Highest_segment_index; s++)
2069                         #ifdef EDITOR
2070                         if (Segments[s].segnum != -1)
2071                         #endif
2072                                 if (!Automap_visited[s]) {
2073                                         add_unknown_segment_edges(&Segments[s]);
2074                                 }
2075         }
2076
2077         // Find unnecessary lines (These are lines that don't have to be drawn because they have small curvature)
2078         for (i=0; i<=Highest_edge_index; i++ )  {
2079                 e = &Edges[i];
2080                 if (!(e->flags&EF_USED)) continue;
2081
2082                 for (e1=0; e1<e->num_faces; e1++ )      {
2083                         for (e2=1; e2<e->num_faces; e2++ )      {
2084                                 if ( (e1 != e2) && (e->segnum[e1] != e->segnum[e2]) )   {
2085                                         #ifdef COMPACT_SEGS
2086                                         vms_vector v1, v2;
2087                                         get_side_normal(&Segments[e->segnum[e1]], e->sides[e1], 0, &v1 );
2088                                         get_side_normal(&Segments[e->segnum[e2]], e->sides[e2], 0, &v2 );
2089                                         if ( vm_vec_dot(&v1,&v2) > (F1_0-(F1_0/10))  )  {
2090                                         #else
2091                                         if ( vm_vec_dot( &Segments[e->segnum[e1]].sides[e->sides[e1]].normals[0], &Segments[e->segnum[e2]].sides[e->sides[e2]].normals[0] ) > (F1_0-(F1_0/10))  )       {
2092                                         #endif
2093                                                 e->flags &= (~EF_DEFINING);
2094                                                 break;
2095                                         }
2096                                 }
2097                         }
2098                         if (!(e->flags & EF_DEFINING))
2099                                 break;
2100                 }
2101         }
2102
2103         mprintf( (0, "Automap used %d / %d edges\n", Num_edges, Max_edges  ));
2104
2105 }
2106
2107 char Marker_input [40];
2108 int Marker_index=0;
2109 ubyte DefiningMarkerMessage=0;
2110 ubyte MarkerBeingDefined;
2111 ubyte LastMarkerDropped;
2112
2113 void InitMarkerInput ()
2114  {
2115         int maxdrop,i;
2116
2117         //find free marker slot
2118
2119         if (Game_mode & GM_MULTI)
2120         maxdrop=MAX_DROP_MULTI;
2121         else
2122         maxdrop=MAX_DROP_SINGLE;
2123
2124         for (i=0;i<maxdrop;i++)
2125                 if (MarkerObject[(Player_num*2)+i] == -1)               //found free slot!
2126                         break;
2127
2128         if (i==maxdrop)         //no free slot
2129         {
2130                 if (Game_mode & GM_MULTI)
2131                         i = !LastMarkerDropped;         //in multi, replace older of two
2132                 else {
2133                         HUD_init_message("No free marker slots");
2134                         return;
2135                 }
2136         }
2137
2138         //got a free slot.  start inputting marker message
2139
2140         Marker_input[0]=0;
2141         Marker_index=0;
2142         DefiningMarkerMessage=1;
2143         MarkerBeingDefined = i;
2144  }
2145
2146 void MarkerInputMessage (int key)
2147  {
2148         switch( key )   {
2149         case KEY_F8:
2150         case KEY_ESC:
2151                 DefiningMarkerMessage = 0;
2152                 game_flush_inputs();
2153                 break;
2154         case KEY_LEFT:
2155         case KEY_BACKSP:
2156         case KEY_PAD4:
2157                 if (Marker_index > 0)
2158                         Marker_index--;
2159                 Marker_input[Marker_index] = 0;
2160                 break;
2161         case KEY_ENTER:
2162                 strcpy (MarkerMessage[(Player_num*2)+MarkerBeingDefined],Marker_input);
2163                 if (Game_mode & GM_MULTI)
2164                  strcpy (MarkerOwner[(Player_num*2)+MarkerBeingDefined],Players[Player_num].callsign);
2165                 DropMarker(MarkerBeingDefined);
2166                 LastMarkerDropped = MarkerBeingDefined;
2167                 game_flush_inputs();
2168                 DefiningMarkerMessage = 0;
2169                 break;
2170         default:
2171                 if ( key > 0 )
2172                  {
2173                   int ascii = key_to_ascii(key);
2174                   if ((ascii < 255 ))
2175                     if (Marker_index < 38 )
2176                       {
2177                         Marker_input[Marker_index++] = ascii;
2178                         Marker_input[Marker_index] = 0;
2179                       }
2180                  }
2181                 break;
2182
2183         }
2184  }
2185
2186
2187
2188