main/bmread.c

   1 /* $Id: bmread.c,v 1.14 2005-02-26 07:04:47 chris 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 to parse bitmaps.tbl
  18  * Only used for editor, since the registered version of descent 1.
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <conf.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31
  32 #include "pstypes.h"
  33 #include "inferno.h"
  34 #include "gr.h"
  35 #include "bm.h"
  36 #include "gamepal.h"
  37 #include "u_mem.h"
  38 #include "mono.h"
  39 #include "error.h"
  40 #include "object.h"
  41 #include "vclip.h"
  42 #include "effects.h"
  43 #include "polyobj.h"
  44 #include "wall.h"
  45 #include "textures.h"
  46 #include "game.h"
  47 #ifdef NETWORK
  48 #include "multi.h"
  49 #endif
  50
  51 #include "iff.h"
  52 #include "cfile.h"
  53
  54 #include "hostage.h"
  55 #include "powerup.h"
  56 #include "laser.h"
  57 #include "sounds.h"
  58 #include "piggy.h"
  59 #include "aistruct.h"
  60 #include "robot.h"
  61 #include "weapon.h"
  62 #include "gauges.h"
  63 #include "player.h"
  64 #include "endlevel.h"
  65 #include "cntrlcen.h"
  66 #include "args.h"
  67 #include "text.h"
  68 #include "interp.h"
  69 #include "strutil.h"
  70
  71 #include "editor/texpage.h"
  72
  73 #define BM_NONE                 -1
  74 #define BM_COCKPIT               0
  75 #define BM_TEXTURES              2
  76 #define BM_UNUSED                        3
  77 #define BM_VCLIP                         4
  78 #define BM_EFFECTS          5
  79 #define BM_ECLIP                         6
  80 #define BM_WEAPON                        7
  81 #define BM_DEMO                  8
  82 #define BM_ROBOTEX          9
  83 #define BM_WALL_ANIMS   12
  84 #define BM_WCLIP                        13
  85 #define BM_ROBOT                        14
  86 #define BM_GAUGES                       20
  87 #define BM_GAUGES_HIRES 21
  88
  89 #define MAX_BITMAPS_PER_BRUSH 30
  90
  91 extern player_ship only_player_ship;            // In bm.c
  92
  93 extern short            N_ObjBitmaps;                   // in bm.c
  94 short           N_ObjBitmapPtrs=0;
  95 static int                      Num_robot_ais = 0;
  96 int     TmapList[MAX_TEXTURES];
  97 char    Powerup_names[MAX_POWERUP_TYPES][POWERUP_NAME_LENGTH];
  98 char    Robot_names[MAX_ROBOT_TYPES][ROBOT_NAME_LENGTH];
  99
 100 //---------------- Internal variables ---------------------------
 101 static int                      Registered_only = 0;            //      Gets set by ! in column 1.
 102 static int                      SuperX = -1;
 103 static int                      Installed=0;
 104 static char             *arg;
 105 static short            tmap_count = 0;
 106 static short            texture_count = 0;
 107 static short            clip_count = 0;
 108 static short            clip_num;
 109 static short            sound_num;
 110 static short            frames;
 111 static float            time;
 112 static int                      hit_sound = -1;
 113 static sbyte            bm_flag = BM_NONE;
 114 static int                      abm_flag = 0;
 115 static int                      rod_flag = 0;
 116 static short            wall_open_sound, wall_close_sound,wall_explodes,wall_blastable, wall_hidden;
 117 float           vlighting=0;
 118 static int                      obj_eclip;
 119 static char             *dest_bm;               //clip number to play when destroyed
 120 static int                      dest_vclip;             //what vclip to play when exploding
 121 static int                      dest_eclip;             //what eclip to play when exploding
 122 static fix                      dest_size;              //3d size of explosion
 123 static int                      crit_clip;              //clip number to play when destroyed
 124 static int                      crit_flag;              //flag if this is a destroyed eclip
 125 static int                      tmap1_flag;             //flag if this is used as tmap_num (not tmap_num2)
 126 static int                      num_sounds=0;
 127
 128 int     linenum;                //line int table currently being parsed
 129
 130 //------------------- Useful macros and variables ---------------
 131 extern void remove_char( char * s, char c );    // in piggy.c
 132 #define REMOVE_EOL(s)           remove_char((s),'\n')
 133 #define REMOVE_COMMENTS(s)      remove_char((s),';')
 134 #define REMOVE_DOTS(s)          remove_char((s),'.')
 135
 136 #define IFTOK(str) if (!strcmp(arg, str))
 137 extern char *space;                     // in piggy.c
 138 //--unused-- char *equal = { "=" };
 139 extern char *equal_space;       // in piggy.c
 140
 141
 142 //      For the sake of LINT, defining prototypes to module's functions
 143 void bm_read_alias(void);
 144 void bm_read_marker(void);
 145 void bm_read_robot_ai(void);
 146 void bm_read_powerup(int unused_flag);
 147 void bm_read_hostage(void);
 148 void bm_read_robot(void);
 149 void bm_read_weapon(int unused_flag);
 150 void bm_read_reactor(void);
 151 void bm_read_exitmodel(void);
 152 void bm_read_player_ship(void);
 153 void bm_read_some_file(void);
 154 void bm_read_sound(void);
 155 void bm_write_extra_robots(void);
 156 void clear_to_end_of_line(void);
 157 void verify_textures(void);
 158
 159
 160 //---------------------------------------------------------------
 161 int compute_average_pixel(grs_bitmap *new)
 162 {
 163         int     row, column, color;
 164         char    *pptr;
 165         int     total_red, total_green, total_blue;
 166
 167         pptr = (char *)new->bm_data;
 168
 169         total_red = 0;
 170         total_green = 0;
 171         total_blue = 0;
 172
 173         for (row=0; row<new->bm_h; row++)
 174                 for (column=0; column<new->bm_w; column++) {
 175                         color = *pptr++;
 176                         total_red += gr_palette[color*3];
 177                         total_green += gr_palette[color*3+1];
 178                         total_blue += gr_palette[color*3+2];
 179                 }
 180
 181         total_red /= (new->bm_h * new->bm_w);
 182         total_green /= (new->bm_h * new->bm_w);
 183         total_blue /= (new->bm_h * new->bm_w);
 184
 185         return BM_XRGB(total_red/2, total_green/2, total_blue/2);
 186 }
 187
 188 //---------------------------------------------------------------
 189 // Loads a bitmap from either the piggy file, a r64 file, or a
 190 // whatever extension is passed.
 191
 192 bitmap_index bm_load_sub( char * filename )
 193 {
 194         bitmap_index bitmap_num;
 195         grs_bitmap * new;
 196         ubyte newpal[256*3];
 197         int iff_error;          //reference parm to avoid warning message
 198         char fname[20];
 199
 200         bitmap_num.index = 0;
 201
 202 #ifdef SHAREWARE
 203         if (Registered_only) {
 204                 //mprintf( 0, "Skipping registered-only bitmap '%s'\n", filename );
 205                 return bitmap_num;
 206         }
 207 #endif
 208
 209         _splitpath(  filename, NULL, NULL, fname, NULL );
 210
 211         bitmap_num=piggy_find_bitmap( fname );
 212         if (bitmap_num.index)   {
 213                 //mprintf(( 0, "Found bitmap '%s' in pig!\n", fname ));
 214                 return bitmap_num;
 215         }
 216
 217         MALLOC( new, grs_bitmap, 1 );
 218         iff_error = iff_read_bitmap(filename,new,BM_LINEAR,newpal);
 219         new->bm_handle=0;
 220         if (iff_error != IFF_NO_ERROR)          {
 221                 mprintf((1, "File %s - IFF error: %s",filename,iff_errormsg(iff_error)));
 222                 Error("File <%s> - IFF error: %s, line %d",filename,iff_errormsg(iff_error),linenum);
 223         }
 224
 225         if ( iff_has_transparency )
 226                 gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
 227         else
 228                 gr_remap_bitmap_good( new, newpal, -1, SuperX );
 229
 230         new->avg_color = compute_average_pixel(new);
 231
 232         // -- mprintf((0, "N" ));
 233         bitmap_num = piggy_register_bitmap( new, fname, 0 );
 234         d_free( new );
 235         return bitmap_num;
 236 }
 237
 238 extern ubyte bogus_bitmap_initialized;
 239 extern digi_sound bogus_sound;
 240
 241 void ab_load( char * filename, bitmap_index bmp[], int *nframes )
 242 {
 243         grs_bitmap * bm[MAX_BITMAPS_PER_BRUSH];
 244         bitmap_index bi;
 245         int i;
 246         int iff_error;          //reference parm to avoid warning message
 247         ubyte newpal[768];
 248         char fname[20];
 249         char tempname[20];
 250
 251 #ifdef SHAREWARE
 252         if (Registered_only) {
 253                 Assert( bogus_bitmap_initialized != 0 );
 254                 mprintf(( 0, "Skipping registered-only animation '%s'\n", filename ));
 255                 bmp[0].index = 0;               //index of bogus bitmap==0 (I think)            //&bogus_bitmap;
 256                 *nframes = 1;
 257                 return;
 258         }
 259 #endif
 260
 261
 262         _splitpath( filename, NULL, NULL, fname, NULL );
 263
 264         for (i=0; i<MAX_BITMAPS_PER_BRUSH; i++ )        {
 265                 sprintf( tempname, "%s#%d", fname, i );
 266                 bi = piggy_find_bitmap( tempname );
 267                 if ( !bi.index )
 268                         break;
 269                 bmp[i] = bi;
 270                 //mprintf(( 0, "Found animation frame %d, %s, in piggy file\n", i, tempname ));
 271         }
 272
 273         if (i) {
 274                 *nframes = i;
 275                 return;
 276         }
 277
 278 //      Note that last argument passes an address to the array newpal (which is a pointer).
 279 //      type mismatch found using lint, will substitute this line with an adjusted
 280 //      one.  If fatal error, then it can be easily changed.
 281 //      iff_error = iff_read_animbrush(filename,bm,MAX_BITMAPS_PER_BRUSH,nframes,&newpal);
 282    iff_error = iff_read_animbrush(filename,bm,MAX_BITMAPS_PER_BRUSH,nframes,newpal);
 283         if (iff_error != IFF_NO_ERROR)  {
 284                 mprintf((1,"File %s - IFF error: %s",filename,iff_errormsg(iff_error)));
 285                 Error("File <%s> - IFF error: %s, line %d",filename,iff_errormsg(iff_error),linenum);
 286         }
 287
 288         for (i=0;i< *nframes; i++)      {
 289                 bitmap_index new_bmp;
 290                 sprintf( tempname, "%s#%d", fname, i );
 291                 if ( iff_has_transparency )
 292                         gr_remap_bitmap_good( bm[i], newpal, iff_transparent_color, SuperX );
 293                 else
 294                         gr_remap_bitmap_good( bm[i], newpal, -1, SuperX );
 295
 296                 bm[i]->avg_color = compute_average_pixel(bm[i]);
 297
 298                 new_bmp = piggy_register_bitmap( bm[i], tempname, 0 );
 299                 d_free( bm[i] );
 300                 bmp[i] = new_bmp;
 301                 if (!i)
 302                         mprintf((0, "Registering %s in piggy file.", tempname ));
 303                 else
 304                         mprintf((0, "."));
 305         }
 306         mprintf((0, "\n"));
 307 }
 308
 309 int ds_load( char * filename )  {
 310         int i;
 311         CFILE * cfp;
 312         digi_sound new;
 313         char fname[20];
 314         char rawname[100];
 315
 316 #ifdef SHAREWARE
 317         if (Registered_only) {
 318                 //mprintf( 0, "Skipping registered-only sound '%s'\n", filename );
 319                 return 0;       //don't know what I should return here          //&bogus_sound;
 320         }
 321 #endif
 322
 323         removeext(filename, fname);
 324         sprintf(rawname, "%s.%s", fname, (digi_sample_rate==SAMPLE_RATE_22K) ? "r22" : "raw");
 325
 326         i=piggy_find_sound( fname );
 327         if (i!=255)     {
 328                 return i;
 329         }
 330
 331         cfp = cfopen( rawname, "rb" );
 332
 333         if (cfp!=NULL) {
 334                 new.length      = cfilelength( cfp );
 335                 MALLOC( new.data, ubyte, new.length );
 336                 cfread( new.data, 1, new.length, cfp );
 337                 cfclose(cfp);
 338                 // -- mprintf( (0, "S" ));
 339                 // -- mprintf( (0, "<%s>", rawname ));
 340         } else {
 341                 mprintf( (1, "Warning: Couldn't find '%s'\n", filename ));
 342                 return 255;
 343         }
 344         i = piggy_register_sound( &new, fname, 0 );
 345         return i;
 346 }
 347
 348 //parse a float
 349 float get_float()
 350 {
 351         char *xarg;
 352
 353         xarg = strtok( NULL, space );
 354         return atof( xarg );
 355 }
 356
 357 //parse an int
 358 int get_int()
 359 {
 360         char *xarg;
 361
 362         xarg = strtok( NULL, space );
 363         return atoi( xarg );
 364 }
 365
 366 // rotates a byte left one bit, preserving the bit falling off the right
 367 //void
 368 //rotate_left(char *c)
 369 //{
 370 //      int found;
 371 //
 372 //      found = 0;
 373 //      if (*c & 0x80)
 374 //              found = 1;
 375 //      *c = *c << 1;
 376 //      if (found)
 377 //              *c |= 0x01;
 378 //}
 379
 380 //loads a texture and returns the texture num
 381 int get_texture(char *name)
 382 {
 383         char short_name[FILENAME_LEN];
 384         int i;
 385
 386         strcpy(short_name,name);
 387         REMOVE_DOTS(short_name);
 388         for (i=0;i<texture_count;i++)
 389                 if (!stricmp(TmapInfo[i].filename,short_name))
 390                         break;
 391         if (i==texture_count) {
 392                 Textures[texture_count] = bm_load_sub(name);
 393                 strcpy( TmapInfo[texture_count].filename, short_name);
 394                 texture_count++;
 395                 Assert(texture_count < MAX_TEXTURES);
 396                 NumTextures = texture_count;
 397         }
 398
 399         return i;
 400 }
 401
 402 #define LINEBUF_SIZE 600
 403
 404 #define DEFAULT_PIG_PALETTE     "groupa.256"
 405
 406 //-----------------------------------------------------------------
 407 // Initializes all bitmaps from BITMAPS.TBL file.
 408 // This is called when the editor is IN.
 409 // If no editor, bm_init() is called.
 410 int bm_init_use_tbl()
 411 {
 412         CFILE   * InfoFile;
 413         char    inputline[LINEBUF_SIZE];
 414         int     i, have_bin_tbl;
 415
 416         // Open BITMAPS.TBL for reading.
 417         have_bin_tbl = 0;
 418         InfoFile = cfopen( "BITMAPS.TBL", "rb" );
 419         if (InfoFile == NULL) {
 420                 InfoFile = cfopen("BITMAPS.BIN", "rb");
 421                 if (InfoFile == NULL)
 422                         return 0;       //missing BITMAPS.TBL and BITMAPS.BIN file
 423                 have_bin_tbl = 1;
 424         }
 425
 426         gr_use_palette_table(DEFAULT_PIG_PALETTE);
 427
 428         load_palette(DEFAULT_PIG_PALETTE,-2,0);         //special: tell palette code which pig is loaded
 429
 430         init_polygon_models();
 431
 432         ObjType[0] = OL_PLAYER;
 433         ObjId[0] = 0;
 434         Num_total_object_types = 1;
 435
 436         for (i=0; i<MAX_SOUNDS; i++ )   {
 437                 Sounds[i] = 255;
 438                 AltSounds[i] = 255;
 439         }
 440
 441         for (i=0; i<MAX_TEXTURES; i++ ) {
 442                 TmapInfo[i].eclip_num = -1;
 443                 TmapInfo[i].flags = 0;
 444                 TmapInfo[i].slide_u = TmapInfo[i].slide_v = 0;
 445                 TmapInfo[i].destroyed = -1;
 446         }
 447
 448         for (i=0;i<MAX_REACTORS;i++)
 449                 Reactors[i].model_num = -1;
 450
 451         Num_effects = 0;
 452         for (i=0; i<MAX_EFFECTS; i++ ) {
 453                 //Effects[i].bm_ptr = (grs_bitmap **) -1;
 454                 Effects[i].changing_wall_texture = -1;
 455                 Effects[i].changing_object_texture = -1;
 456                 Effects[i].segnum = -1;
 457                 Effects[i].vc.num_frames = -1;          //another mark of being unused
 458         }
 459
 460         for (i=0;i<MAX_POLYGON_MODELS;i++)
 461                 Dying_modelnums[i] = Dead_modelnums[i] = -1;
 462
 463         Num_vclips = 0;
 464         for (i=0; i<VCLIP_MAXNUM; i++ ) {
 465                 Vclip[i].num_frames = -1;
 466                 Vclip[i].flags = 0;
 467         }
 468
 469         for (i=0; i<MAX_WALL_ANIMS; i++ )
 470                 WallAnims[i].num_frames = -1;
 471         Num_wall_anims = 0;
 472
 473         setbuf(stdout, NULL);   // unbuffered output via printf
 474
 475         if (Installed)
 476                 return 1;
 477
 478         Installed = 1;
 479
 480         piggy_init();           //don't care about error, since no pig is ok for editor
 481
 482 //      if ( FindArg( "-nobm" ) )       {
 483 //              piggy_read_sounds();
 484 //              return 0;
 485 //      }
 486         linenum = 0;
 487
 488         cfseek( InfoFile, 0L, SEEK_SET);
 489
 490         while (cfgets(inputline, LINEBUF_SIZE, InfoFile)) {
 491                 int l;
 492                 char *temp_ptr;
 493
 494                 linenum++;
 495
 496                 if (inputline[0]==' ' || inputline[0]=='\t') {
 497                         char *t;
 498                         for (t=inputline;*t && *t!='\n';t++)
 499                                 if (! (*t==' ' || *t=='\t')) {
 500                                         mprintf((1,"Suspicious: line %d of BITMAPS.TBL starts with whitespace\n",linenum));
 501                                         break;
 502                                 }
 503                 }
 504
 505                 if (have_bin_tbl) {                             // is this a binary tbl file
 506                         decode_text_line (inputline);
 507                 } else {
 508                         while (inputline[(l=strlen(inputline))-2]=='\\') {
 509                                 if (!isspace(inputline[l-3])) {         //if not space before backslash...
 510                                         inputline[l-2] = ' ';                           //add one
 511                                         l++;
 512                                 }
 513                                 cfgets(inputline+l-2,LINEBUF_SIZE-(l-2), InfoFile);
 514                                 linenum++;
 515                         }
 516                 }
 517
 518                 REMOVE_EOL(inputline);
 519                 if (strchr(inputline, ';')!=NULL) REMOVE_COMMENTS(inputline);
 520
 521                 if (strlen(inputline) == LINEBUF_SIZE-1)
 522                         Error("Possible line truncation in BITMAPS.TBL on line %d\n",linenum);
 523
 524                 SuperX = -1;
 525
 526                 if ( (temp_ptr=strstr( inputline, "superx=" )) )        {
 527                         SuperX = atoi( &temp_ptr[7] );
 528                         Assert(SuperX == 254);
 529                                 //the superx color isn't kept around, so the new piggy regeneration
 530                                 //code doesn't know what it is, so it assumes that it's 254, so
 531                                 //this code requires that it be 254
 532
 533                 }
 534
 535                 arg = strtok( inputline, space );
 536                 if (arg[0] == '@') {
 537                         arg++;
 538                         Registered_only = 1;
 539                 } else
 540                         Registered_only = 0;
 541
 542                 while (arg != NULL )
 543                         {
 544                         // Check all possible flags and defines.
 545                         if (*arg == '$') bm_flag = BM_NONE; // reset to no flags as default.
 546
 547                         IFTOK("$COCKPIT")                       bm_flag = BM_COCKPIT;
 548                         else IFTOK("$GAUGES")           {bm_flag = BM_GAUGES;   clip_count = 0;}
 549                         else IFTOK("$GAUGES_HIRES"){bm_flag = BM_GAUGES_HIRES; clip_count = 0;}
 550                         else IFTOK("$SOUND")            bm_read_sound();
 551                         else IFTOK("$DOOR_ANIMS")       bm_flag = BM_WALL_ANIMS;
 552                         else IFTOK("$WALL_ANIMS")       bm_flag = BM_WALL_ANIMS;
 553                         else IFTOK("$TEXTURES")         bm_flag = BM_TEXTURES;
 554                         else IFTOK("$VCLIP")                    {bm_flag = BM_VCLIP;            vlighting = 0;  clip_count = 0;}
 555                         else IFTOK("$ECLIP")                    {bm_flag = BM_ECLIP;            vlighting = 0;  clip_count = 0; obj_eclip=0; dest_bm=NULL; dest_vclip=-1; dest_eclip=-1; dest_size=-1; crit_clip=-1; crit_flag=0; sound_num=-1;}
 556                         else IFTOK("$WCLIP")                    {bm_flag = BM_WCLIP;            vlighting = 0;  clip_count = 0; wall_explodes = wall_blastable = 0; wall_open_sound=wall_close_sound=-1; tmap1_flag=0; wall_hidden=0;}
 557
 558                         else IFTOK("$EFFECTS")          {bm_flag = BM_EFFECTS;  clip_num = 0;}
 559                         else IFTOK("$ALIAS")                    bm_read_alias();
 560
 561                         #ifdef EDITOR
 562                         else IFTOK("!METALS_FLAG")              TextureMetals = texture_count;
 563                         else IFTOK("!LIGHTS_FLAG")              TextureLights = texture_count;
 564                         else IFTOK("!EFFECTS_FLAG")     TextureEffects = texture_count;
 565                         #endif
 566
 567                         else IFTOK("lighting")                  TmapInfo[texture_count-1].lighting = fl2f(get_float());
 568                         else IFTOK("damage")                    TmapInfo[texture_count-1].damage = fl2f(get_float());
 569                         else IFTOK("volatile")                  TmapInfo[texture_count-1].flags |= TMI_VOLATILE;
 570                         else IFTOK("goal_blue")                 TmapInfo[texture_count-1].flags |= TMI_GOAL_BLUE;
 571                         else IFTOK("goal_red")                  TmapInfo[texture_count-1].flags |= TMI_GOAL_RED;
 572                         else IFTOK("water")                             TmapInfo[texture_count-1].flags |= TMI_WATER;
 573                         else IFTOK("force_field")               TmapInfo[texture_count-1].flags |= TMI_FORCE_FIELD;
 574                         else IFTOK("slide")                             {TmapInfo[texture_count-1].slide_u = fl2f(get_float())>>8; TmapInfo[texture_count-1].slide_v = fl2f(get_float())>>8;}
 575                         else IFTOK("destroyed")                 {int t=texture_count-1; TmapInfo[t].destroyed = get_texture(strtok( NULL, space ));}
 576                         //else IFTOK("Num_effects")             Num_effects = get_int();
 577                         else IFTOK("Num_wall_anims")    Num_wall_anims = get_int();
 578                         else IFTOK("clip_num")                  clip_num = get_int();
 579                         else IFTOK("dest_bm")                   dest_bm = strtok( NULL, space );
 580                         else IFTOK("dest_vclip")                dest_vclip = get_int();
 581                         else IFTOK("dest_eclip")                dest_eclip = get_int();
 582                         else IFTOK("dest_size")                 dest_size = fl2f(get_float());
 583                         else IFTOK("crit_clip")                 crit_clip = get_int();
 584                         else IFTOK("crit_flag")                 crit_flag = get_int();
 585                         else IFTOK("sound_num")                 sound_num = get_int();
 586                         else IFTOK("frames")                    frames = get_int();
 587                         else IFTOK("time")                              time = get_float();
 588                         else IFTOK("obj_eclip")                 obj_eclip = get_int();
 589                         else IFTOK("hit_sound")                 hit_sound = get_int();
 590                         else IFTOK("abm_flag")                  abm_flag = get_int();
 591                         else IFTOK("tmap1_flag")                tmap1_flag = get_int();
 592                         else IFTOK("vlighting")                 vlighting = get_float();
 593                         else IFTOK("rod_flag")                  rod_flag = get_int();
 594                         else IFTOK("superx")                    get_int();
 595                         else IFTOK("open_sound")                wall_open_sound = get_int();
 596                         else IFTOK("close_sound")               wall_close_sound = get_int();
 597                         else IFTOK("explodes")                  wall_explodes = get_int();
 598                         else IFTOK("blastable")                 wall_blastable = get_int();
 599                         else IFTOK("hidden")                            wall_hidden = get_int();
 600                         else IFTOK("$ROBOT_AI")                 bm_read_robot_ai();
 601
 602                         else IFTOK("$POWERUP")                  {bm_read_powerup(0);            continue;}
 603                         else IFTOK("$POWERUP_UNUSED")   {bm_read_powerup(1);            continue;}
 604                         else IFTOK("$HOSTAGE")                  {bm_read_hostage();             continue;}
 605                         else IFTOK("$ROBOT")                            {bm_read_robot();                       continue;}
 606                         else IFTOK("$WEAPON")                   {bm_read_weapon(0);             continue;}
 607                         else IFTOK("$WEAPON_UNUSED")    {bm_read_weapon(1);             continue;}
 608                         else IFTOK("$REACTOR")                  {bm_read_reactor();             continue;}
 609                         else IFTOK("$MARKER")                   {bm_read_marker();              continue;}
 610                         else IFTOK("$PLAYER_SHIP")              {bm_read_player_ship(); continue;}
 611                         else IFTOK("$EXIT") {
 612                                 #ifdef SHAREWARE
 613                                         bm_read_exitmodel();
 614                                 #else
 615                                         clear_to_end_of_line();
 616                                 #endif
 617                                 continue;
 618                         }
 619                         else    {               //not a special token, must be a bitmap!
 620
 621                                 // Remove any illegal/unwanted spaces and tabs at this point.
 622                                 while ((*arg=='\t') || (*arg==' ')) arg++;
 623                                 if (*arg == '\0') { break; }
 624
 625                                 //check for '=' in token, indicating error
 626                                 if (strchr(arg,'='))
 627                                         Error("Unknown token <'%s'> on line %d of BITMAPS.TBL",arg,linenum);
 628
 629                                 // Otherwise, 'arg' is apparently a bitmap filename.
 630                                 // Load bitmap and process it below:
 631                                 bm_read_some_file();
 632
 633                         }
 634
 635                         arg = strtok( NULL, equal_space );
 636                         continue;
 637       }
 638         }
 639
 640         NumTextures = texture_count;
 641         Num_tmaps = tmap_count;
 642
 643         Textures[NumTextures++].index = 0;              //entry for bogus tmap
 644
 645         cfclose( InfoFile );
 646
 647         atexit(bm_close);
 648
 649         Assert(N_robot_types == Num_robot_ais);         //should be one ai info per robot
 650
 651         #ifdef SHAREWARE
 652         init_endlevel();                //this is here so endlevel bitmaps go into pig
 653         #endif
 654
 655         verify_textures();
 656
 657         //check for refereced but unused clip count
 658         for (i=0; i<MAX_EFFECTS; i++ )
 659                 if (    (
 660                                   (Effects[i].changing_wall_texture!=-1) ||
 661                                   (Effects[i].changing_object_texture!=-1)
 662              )
 663                          && (Effects[i].vc.num_frames==-1) )
 664                         Error("EClip %d referenced (by polygon object?), but not defined",i);
 665
 666         #ifndef NDEBUG
 667         {
 668                 int used;
 669                 for (i=used=0; i<num_sounds; i++ )
 670                         if (Sounds[i] != 255)
 671                                 used++;
 672                 mprintf((0,"Sound slots used: %d of %d, highest index %d\n",used,MAX_SOUNDS,num_sounds));
 673
 674                 //make sure all alt sounds refer to valid main sounds
 675                 for (i=used=0; i<num_sounds; i++ ) {
 676                         int alt = AltSounds[i];
 677                         Assert(alt==0 || alt==-1 || Sounds[alt]!=255);
 678                 }
 679         }
 680         #endif
 681
 682         piggy_read_sounds();
 683
 684         #ifdef EDITOR
 685         piggy_dump_all();
 686         #endif
 687
 688         gr_use_palette_table(DEFAULT_PALETTE);
 689
 690         return 0;
 691 }
 692
 693 void verify_textures()
 694 {
 695         grs_bitmap * bmp;
 696         int i,j;
 697         j=0;
 698         for (i=0; i<Num_tmaps; i++ )    {
 699                 bmp = &GameBitmaps[Textures[i].index];
 700                 if ( (bmp->bm_w!=64)||(bmp->bm_h!=64)||(bmp->bm_rowsize!=64) )  {
 701                         mprintf( (1, "ERROR: Texture '%s' isn't 64x64 !\n", TmapInfo[i].filename ));
 702                         j++;
 703                 }
 704         }
 705         if (j)
 706                 Error("%d textures were not 64x64.  See mono screen for list.",j);
 707
 708         for (i=0;i<Num_effects;i++)
 709                 if (Effects[i].changing_object_texture != -1)
 710                         if (GameBitmaps[ObjBitmaps[Effects[i].changing_object_texture].index].bm_w!=64 || GameBitmaps[ObjBitmaps[Effects[i].changing_object_texture].index].bm_h!=64)
 711                                 Error("Effect %d is used on object, but is not 64x64",i);
 712
 713 }
 714
 715 void bm_read_alias()
 716 {
 717         char *t;
 718
 719         Assert(Num_aliases < MAX_ALIASES);
 720
 721         t = strtok( NULL, space );  strncpy(alias_list[Num_aliases].alias_name,t,sizeof(alias_list[Num_aliases].alias_name));
 722         t = strtok( NULL, space );  strncpy(alias_list[Num_aliases].file_name,t,sizeof(alias_list[Num_aliases].file_name));
 723
 724         Num_aliases++;
 725 }
 726
 727 //--unused-- void dump_all_transparent_textures()
 728 //--unused-- {
 729 //--unused--    FILE * fp;
 730 //--unused--    int i,j,k;
 731 //--unused--    ubyte * p;
 732 //--unused--    fp = fopen( "XPARENT.LST", "wt" );
 733 //--unused--    for (i=0; i<Num_tmaps; i++ )    {
 734 //--unused--            k = 0;
 735 //--unused--            p = Textures[i]->bm_data;
 736 //--unused--            for (j=0; j<64*64; j++ )
 737 //--unused--                    if ( (*p++)==255 ) k++;
 738 //--unused--            if ( k )        {
 739 //--unused--                    fprintf( fp, "'%s' has %d transparent pixels\n", TmapInfo[i].filename, k );
 740 //--unused--            }
 741 //--unused--    }
 742 //--unused--    fclose(fp);
 743 //--unused-- }
 744
 745
 746 void bm_close()
 747 {
 748         if (Installed)
 749         {
 750                 Installed=0;
 751         }
 752 }
 753
 754 void set_lighting_flag(sbyte *bp)
 755 {
 756         if (vlighting < 0)
 757                 *bp |= BM_FLAG_NO_LIGHTING;
 758         else
 759                 *bp &= (0xff ^ BM_FLAG_NO_LIGHTING);
 760 }
 761
 762 void set_texture_name(char *name)
 763 {
 764         strcpy ( TmapInfo[texture_count].filename, name );
 765         REMOVE_DOTS(TmapInfo[texture_count].filename);
 766 }
 767
 768 void bm_read_eclip()
 769 {
 770         bitmap_index bitmap;
 771         int dest_bm_num = 0;
 772
 773         Assert(clip_num < MAX_EFFECTS);
 774
 775         if (clip_num+1 > Num_effects)
 776                 Num_effects = clip_num+1;
 777
 778         Effects[clip_num].flags = 0;
 779
 780         //load the dest bitmap first, so that after this routine, the last-loaded
 781         //texture will be the monitor, so that lighting parameter will be applied
 782         //to the correct texture
 783         if (dest_bm) {                  //deal with bitmap for blown up clip
 784                 char short_name[FILENAME_LEN];
 785                 int i;
 786                 strcpy(short_name,dest_bm);
 787                 REMOVE_DOTS(short_name);
 788                 for (i=0;i<texture_count;i++)
 789                         if (!stricmp(TmapInfo[i].filename,short_name))
 790                                 break;
 791                 if (i==texture_count) {
 792                         Textures[texture_count] = bm_load_sub(dest_bm);
 793                         strcpy( TmapInfo[texture_count].filename, short_name);
 794                         texture_count++;
 795                         Assert(texture_count < MAX_TEXTURES);
 796                         NumTextures = texture_count;
 797                 }
 798                 else if (Textures[i].index == 0)                //was found, but registered out
 799                         Textures[i] = bm_load_sub(dest_bm);
 800                 dest_bm_num = i;
 801         }
 802
 803         if (!abm_flag)  {
 804                 bitmap = bm_load_sub(arg);
 805
 806                 Effects[clip_num].vc.play_time = fl2f(time);
 807                 Effects[clip_num].vc.num_frames = frames;
 808                 Effects[clip_num].vc.frame_time = fl2f(time)/frames;
 809
 810                 Assert(clip_count < frames);
 811                 Effects[clip_num].vc.frames[clip_count] = bitmap;
 812                 set_lighting_flag(&GameBitmaps[bitmap.index].bm_flags);
 813
 814                 Assert(!obj_eclip);             //obj eclips for non-abm files not supported!
 815                 Assert(crit_flag==0);
 816
 817                 if (clip_count == 0) {
 818                         Effects[clip_num].changing_wall_texture = texture_count;
 819                         Assert(tmap_count < MAX_TEXTURES);
 820                         TmapList[tmap_count++] = texture_count;
 821                         Textures[texture_count] = bitmap;
 822                         set_texture_name(arg);
 823                         Assert(texture_count < MAX_TEXTURES);
 824                         texture_count++;
 825                         TmapInfo[texture_count].eclip_num = clip_num;
 826                         NumTextures = texture_count;
 827                 }
 828
 829                 clip_count++;
 830
 831         } else {
 832                 bitmap_index bm[MAX_BITMAPS_PER_BRUSH];
 833                 abm_flag = 0;
 834
 835                 ab_load( arg, bm, &Effects[clip_num].vc.num_frames );
 836
 837                 //printf("EC%d.", clip_num);
 838                 Effects[clip_num].vc.play_time = fl2f(time);
 839                 Effects[clip_num].vc.frame_time = Effects[clip_num].vc.play_time/Effects[clip_num].vc.num_frames;
 840
 841                 clip_count = 0;
 842                 set_lighting_flag( &GameBitmaps[bm[clip_count].index].bm_flags);
 843                 Effects[clip_num].vc.frames[clip_count] = bm[clip_count];
 844
 845                 if (!obj_eclip && !crit_flag) {
 846                         Effects[clip_num].changing_wall_texture = texture_count;
 847                         Assert(tmap_count < MAX_TEXTURES);
 848                         TmapList[tmap_count++] = texture_count;
 849                         Textures[texture_count] = bm[clip_count];
 850                         set_texture_name( arg );
 851                         Assert(texture_count < MAX_TEXTURES);
 852                         TmapInfo[texture_count].eclip_num = clip_num;
 853                         texture_count++;
 854                         NumTextures = texture_count;
 855                 }
 856
 857                 if (obj_eclip) {
 858
 859                         if (Effects[clip_num].changing_object_texture == -1) {          //first time referenced
 860                                 Effects[clip_num].changing_object_texture = N_ObjBitmaps;               // XChange ObjectBitmaps
 861                                 N_ObjBitmaps++;
 862                         }
 863
 864                         ObjBitmaps[Effects[clip_num].changing_object_texture] = Effects[clip_num].vc.frames[0];
 865                 }
 866
 867                 //if for an object, Effects_bm_ptrs set in object load
 868
 869                 for(clip_count=1;clip_count < Effects[clip_num].vc.num_frames; clip_count++) {
 870                         set_lighting_flag( &GameBitmaps[bm[clip_count].index].bm_flags);
 871                         Effects[clip_num].vc.frames[clip_count] = bm[clip_count];
 872                 }
 873
 874         }
 875
 876         Effects[clip_num].crit_clip = crit_clip;
 877         Effects[clip_num].sound_num = sound_num;
 878
 879         if (dest_bm) {                  //deal with bitmap for blown up clip
 880
 881                 Effects[clip_num].dest_bm_num = dest_bm_num;
 882
 883                 if (dest_vclip==-1)
 884                         Error("Desctuction vclip missing on line %d",linenum);
 885                 if (dest_size==-1)
 886                         Error("Desctuction vclip missing on line %d",linenum);
 887
 888                 Effects[clip_num].dest_vclip = dest_vclip;
 889                 Effects[clip_num].dest_size = dest_size;
 890
 891                 Effects[clip_num].dest_eclip = dest_eclip;
 892         }
 893         else {
 894                 Effects[clip_num].dest_bm_num = -1;
 895                 Effects[clip_num].dest_eclip = -1;
 896         }
 897
 898         if (crit_flag)
 899                 Effects[clip_num].flags |= EF_CRITICAL;
 900 }
 901
 902
 903 void bm_read_gauges()
 904 {
 905         bitmap_index bitmap;
 906         int i, num_abm_frames;
 907
 908         if (!abm_flag)  {
 909                 bitmap = bm_load_sub(arg);
 910                 Assert(clip_count < MAX_GAUGE_BMS);
 911                 Gauges[clip_count] = bitmap;
 912                 clip_count++;
 913         } else {
 914                 bitmap_index bm[MAX_BITMAPS_PER_BRUSH];
 915                 abm_flag = 0;
 916                 ab_load( arg, bm, &num_abm_frames );
 917                 for (i=clip_count; i<clip_count+num_abm_frames; i++) {
 918                         Assert(i < MAX_GAUGE_BMS);
 919                         Gauges[i] = bm[i-clip_count];
 920                 }
 921                 clip_count += num_abm_frames;
 922         }
 923 }
 924
 925 void bm_read_gauges_hires()
 926 {
 927         bitmap_index bitmap;
 928         int i, num_abm_frames;
 929
 930         if (!abm_flag)  {
 931                 bitmap = bm_load_sub(arg);
 932                 Assert(clip_count < MAX_GAUGE_BMS);
 933                 Gauges_hires[clip_count] = bitmap;
 934                 clip_count++;
 935         } else {
 936                 bitmap_index bm[MAX_BITMAPS_PER_BRUSH];
 937                 abm_flag = 0;
 938                 ab_load( arg, bm, &num_abm_frames );
 939                 for (i=clip_count; i<clip_count+num_abm_frames; i++) {
 940                         Assert(i < MAX_GAUGE_BMS);
 941                         Gauges_hires[i] = bm[i-clip_count];
 942                 }
 943                 clip_count += num_abm_frames;
 944         }
 945 }
 946
 947 void bm_read_wclip()
 948 {
 949         bitmap_index bitmap;
 950         Assert(clip_num < MAX_WALL_ANIMS);
 951
 952         WallAnims[clip_num].flags = 0;
 953
 954         if (wall_explodes)      WallAnims[clip_num].flags |= WCF_EXPLODES;
 955         if (wall_blastable)     WallAnims[clip_num].flags |= WCF_BLASTABLE;
 956         if (wall_hidden)                WallAnims[clip_num].flags |= WCF_HIDDEN;
 957         if (tmap1_flag)         WallAnims[clip_num].flags |= WCF_TMAP1;
 958
 959         if (!abm_flag)  {
 960                 bitmap = bm_load_sub(arg);
 961                 if ( (WallAnims[clip_num].num_frames>-1) && (clip_count==0) )
 962                         Error( "Wall Clip %d is already used!", clip_num );
 963                 WallAnims[clip_num].play_time = fl2f(time);
 964                 WallAnims[clip_num].num_frames = frames;
 965                 //WallAnims[clip_num].frame_time = fl2f(time)/frames;
 966                 Assert(clip_count < frames);
 967                 WallAnims[clip_num].frames[clip_count++] = texture_count;
 968                 WallAnims[clip_num].open_sound = wall_open_sound;
 969                 WallAnims[clip_num].close_sound = wall_close_sound;
 970                 Textures[texture_count] = bitmap;
 971                 set_lighting_flag(&GameBitmaps[bitmap.index].bm_flags);
 972                 set_texture_name( arg );
 973                 Assert(texture_count < MAX_TEXTURES);
 974                 texture_count++;
 975                 NumTextures = texture_count;
 976                 if (clip_num >= Num_wall_anims) Num_wall_anims = clip_num+1;
 977         } else {
 978                 bitmap_index bm[MAX_BITMAPS_PER_BRUSH];
 979                 int nframes;
 980                 if ( (WallAnims[clip_num].num_frames>-1)  )
 981                         Error( "AB_Wall clip %d is already used!", clip_num );
 982                 abm_flag = 0;
 983                 ab_load( arg, bm, &nframes );
 984                 WallAnims[clip_num].num_frames = nframes;
 985                 //printf("WC");
 986                 WallAnims[clip_num].play_time = fl2f(time);
 987                 //WallAnims[clip_num].frame_time = fl2f(time)/nframes;
 988                 WallAnims[clip_num].open_sound = wall_open_sound;
 989                 WallAnims[clip_num].close_sound = wall_close_sound;
 990
 991                 WallAnims[clip_num].close_sound = wall_close_sound;
 992                 strcpy(WallAnims[clip_num].filename, arg);
 993                 REMOVE_DOTS(WallAnims[clip_num].filename);
 994
 995                 if (clip_num >= Num_wall_anims) Num_wall_anims = clip_num+1;
 996
 997                 set_lighting_flag(&GameBitmaps[bm[clip_count].index].bm_flags);
 998
 999                 for (clip_count=0;clip_count < WallAnims[clip_num].num_frames; clip_count++)    {
1000                         //printf("%d", clip_count);
1001                         Textures[texture_count] = bm[clip_count];
1002                         set_lighting_flag(&GameBitmaps[bm[clip_count].index].bm_flags);
1003                         WallAnims[clip_num].frames[clip_count] = texture_count;
1004                         REMOVE_DOTS(arg);
1005                         sprintf( TmapInfo[texture_count].filename, "%s#%d", arg, clip_count);
1006                         Assert(texture_count < MAX_TEXTURES);
1007                         texture_count++;
1008                         NumTextures = texture_count;
1009                 }
1010         }
1011 }
1012
1013 void bm_read_vclip()
1014 {
1015         bitmap_index bi;
1016         Assert(clip_num < VCLIP_MAXNUM);
1017
1018         if (clip_num >= Num_vclips)
1019                 Num_vclips = clip_num+1;
1020
1021         if (!abm_flag)  {
1022                 if ( (Vclip[clip_num].num_frames>-1) && (clip_count==0)  )
1023                         Error( "Vclip %d is already used!", clip_num );
1024                 bi = bm_load_sub(arg);
1025                 Vclip[clip_num].play_time = fl2f(time);
1026                 Vclip[clip_num].num_frames = frames;
1027                 Vclip[clip_num].frame_time = fl2f(time)/frames;
1028                 Vclip[clip_num].light_value = fl2f(vlighting);
1029                 Vclip[clip_num].sound_num = sound_num;
1030                 set_lighting_flag(&GameBitmaps[bi.index].bm_flags);
1031                 Assert(clip_count < frames);
1032                 Vclip[clip_num].frames[clip_count++] = bi;
1033                 if (rod_flag) {
1034                         rod_flag=0;
1035                         Vclip[clip_num].flags |= VF_ROD;
1036                 }
1037
1038         } else  {
1039                 bitmap_index bm[MAX_BITMAPS_PER_BRUSH];
1040                 abm_flag = 0;
1041                 if ( (Vclip[clip_num].num_frames>-1)  )
1042                         Error( "AB_Vclip %d is already used!", clip_num );
1043                 ab_load( arg, bm, &Vclip[clip_num].num_frames );
1044
1045                 if (rod_flag) {
1046                         //int i;
1047                         rod_flag=0;
1048                         Vclip[clip_num].flags |= VF_ROD;
1049                 }
1050                 //printf("VC");
1051                 Vclip[clip_num].play_time = fl2f(time);
1052                 Vclip[clip_num].frame_time = fl2f(time)/Vclip[clip_num].num_frames;
1053                 Vclip[clip_num].light_value = fl2f(vlighting);
1054                 Vclip[clip_num].sound_num = sound_num;
1055                 set_lighting_flag(&GameBitmaps[bm[clip_count].index].bm_flags);
1056
1057                 for (clip_count=0;clip_count < Vclip[clip_num].num_frames; clip_count++) {
1058                         //printf("%d", clip_count);
1059                         set_lighting_flag(&GameBitmaps[bm[clip_count].index].bm_flags);
1060                         Vclip[clip_num].frames[clip_count] = bm[clip_count];
1061                 }
1062         }
1063 }
1064
1065 // ------------------------------------------------------------------------------
1066 void get4fix(fix *fixp)
1067 {
1068         char    *curtext;
1069         int     i;
1070
1071         for (i=0; i<NDL; i++) {
1072                 curtext = strtok(NULL, space);
1073                 fixp[i] = fl2f(atof(curtext));
1074         }
1075 }
1076
1077 // ------------------------------------------------------------------------------
1078 void get4byte(sbyte *bytep)
1079 {
1080         char    *curtext;
1081         int     i;
1082
1083         for (i=0; i<NDL; i++) {
1084                 curtext = strtok(NULL, space);
1085                 bytep[i] = atoi(curtext);
1086         }
1087 }
1088
1089 // ------------------------------------------------------------------------------
1090 //      Convert field of view from an angle in 0..360 to cosine.
1091 void adjust_field_of_view(fix *fovp)
1092 {
1093         int             i;
1094         fixang  tt;
1095         float           ff;
1096         fix             temp;
1097
1098         for (i=0; i<NDL; i++) {
1099                 ff = - f2fl(fovp[i]);
1100                 if (ff > 179) {
1101                         mprintf((1, "Warning: Bogus field of view (%7.3f).  Must be in 0..179.\n", ff));
1102                         ff = 179;
1103                 }
1104                 ff = ff/360;
1105                 tt = fl2f(ff);
1106                 fix_sincos(tt, &temp, &fovp[i]);
1107         }
1108 }
1109
1110 void clear_to_end_of_line(void)
1111 {
1112         arg = strtok( NULL, space );
1113         while (arg != NULL)
1114                 arg = strtok( NULL, space );
1115 }
1116
1117 void bm_read_sound()
1118 {
1119         int sound_num;
1120         int alt_sound_num;
1121
1122         sound_num = get_int();
1123         alt_sound_num = get_int();
1124
1125         if ( sound_num>=MAX_SOUNDS )
1126                 Error( "Too many sound files.\n" );
1127
1128         if (sound_num >= num_sounds)
1129                 num_sounds = sound_num+1;
1130
1131         if (Sounds[sound_num] != 255)
1132                 Error("Sound num %d already used, bitmaps.tbl, line %d\n",sound_num,linenum);
1133
1134         arg = strtok(NULL, space);
1135
1136         Sounds[sound_num] = ds_load(arg);
1137
1138         if ( alt_sound_num == 0 )
1139                 AltSounds[sound_num] = sound_num;
1140         else if (alt_sound_num < 0 )
1141                 AltSounds[sound_num] = 255;
1142         else
1143                 AltSounds[sound_num] = alt_sound_num;
1144
1145         if (Sounds[sound_num] == 255)
1146                 Error("Can't load soundfile <%s>",arg);
1147 }
1148
1149 // ------------------------------------------------------------------------------
1150 void bm_read_robot_ai()
1151 {
1152         char                    *robotnum_text;
1153         int                     robotnum;
1154         robot_info      *robptr;
1155
1156         robotnum_text = strtok(NULL, space);
1157         robotnum = atoi(robotnum_text);
1158         Assert(robotnum < MAX_ROBOT_TYPES);
1159         robptr = &Robot_info[robotnum];
1160
1161         Assert(robotnum == Num_robot_ais);              //make sure valid number
1162
1163 #ifdef SHAREWARE
1164         if (Registered_only) {
1165                 Num_robot_ais++;
1166                 clear_to_end_of_line();
1167                 return;
1168         }
1169 #endif
1170
1171         Num_robot_ais++;
1172
1173         get4fix(robptr->field_of_view);
1174         get4fix(robptr->firing_wait);
1175         get4fix(robptr->firing_wait2);
1176         get4byte(robptr->rapidfire_count);
1177         get4fix(robptr->turn_time);
1178 //      get4fix(robptr->fire_power);
1179 //      get4fix(robptr->shield);
1180         get4fix(robptr->max_speed);
1181         get4fix(robptr->circle_distance);
1182         get4byte(robptr->evade_speed);
1183
1184         robptr->always_0xabcd   = 0xabcd;
1185
1186         adjust_field_of_view(robptr->field_of_view);
1187
1188 }
1189
1190 //      ----------------------------------------------------------------------------------------------
1191 //this will load a bitmap for a polygon models.  it puts the bitmap into
1192 //the array ObjBitmaps[], and also deals with animating bitmaps
1193 //returns a pointer to the bitmap
1194 grs_bitmap *load_polymodel_bitmap(char *name)
1195 {
1196         Assert(N_ObjBitmaps < MAX_OBJ_BITMAPS);
1197
1198 //      Assert( N_ObjBitmaps == N_ObjBitmapPtrs );
1199
1200         if (name[0] == '%') {           //an animating bitmap!
1201                 int eclip_num;
1202
1203                 eclip_num = atoi(name+1);
1204
1205                 if (Effects[eclip_num].changing_object_texture == -1) {         //first time referenced
1206                         Effects[eclip_num].changing_object_texture = N_ObjBitmaps;
1207                         ObjBitmapPtrs[N_ObjBitmapPtrs++] = N_ObjBitmaps;
1208                         N_ObjBitmaps++;
1209                 } else {
1210                         ObjBitmapPtrs[N_ObjBitmapPtrs++] = Effects[eclip_num].changing_object_texture;
1211                 }
1212                 Assert(N_ObjBitmaps < MAX_OBJ_BITMAPS);
1213                 Assert(N_ObjBitmapPtrs < MAX_OBJ_BITMAPS);
1214                 return NULL;
1215         }
1216         else    {
1217                 ObjBitmaps[N_ObjBitmaps] = bm_load_sub(name);
1218                 if (GameBitmaps[ObjBitmaps[N_ObjBitmaps].index].bm_w!=64 || GameBitmaps[ObjBitmaps[N_ObjBitmaps].index].bm_h!=64)
1219                         Error("Bitmap <%s> is not 64x64",name);
1220                 ObjBitmapPtrs[N_ObjBitmapPtrs++] = N_ObjBitmaps;
1221                 N_ObjBitmaps++;
1222                 Assert(N_ObjBitmaps < MAX_OBJ_BITMAPS);
1223                 Assert(N_ObjBitmapPtrs < MAX_OBJ_BITMAPS);
1224                 return &GameBitmaps[ObjBitmaps[N_ObjBitmaps-1].index];
1225         }
1226 }
1227
1228 #define MAX_MODEL_VARIANTS      4
1229
1230 // ------------------------------------------------------------------------------
1231 void bm_read_robot()
1232 {
1233         char                    *model_name[MAX_MODEL_VARIANTS];
1234         int                     n_models,i;
1235         int                     first_bitmap_num[MAX_MODEL_VARIANTS];
1236         char                    *equal_ptr;
1237         int                     exp1_vclip_num=-1;
1238         int                     exp1_sound_num=-1;
1239         int                     exp2_vclip_num=-1;
1240         int                     exp2_sound_num=-1;
1241         fix                     lighting = F1_0/2;              // Default
1242         fix                     strength = F1_0*10;             // Default strength
1243         fix                     mass = f1_0*4;
1244         fix                     drag = f1_0/2;
1245         short           weapon_type = 0, weapon_type2 = -1;
1246         int                     g,s;
1247         char                    name[ROBOT_NAME_LENGTH];
1248         int                     contains_count=0, contains_id=0, contains_prob=0, contains_type=0, behavior=AIB_NORMAL;
1249         int                     companion = 0, smart_blobs=0, energy_blobs=0, badass=0, energy_drain=0, kamikaze=0, thief=0, pursuit=0, lightcast=0, death_roll=0;
1250         fix                     glow=0, aim=F1_0;
1251         int                     deathroll_sound = SOUND_BOSS_SHARE_DIE; //default
1252         int                     score_value=1000;
1253         int                     cloak_type=0;           //      Default = this robot does not cloak
1254         int                     attack_type=0;          //      Default = this robot attacks by firing (1=lunge)
1255         int                     boss_flag=0;                            //      Default = robot is not a boss.
1256         int                     see_sound = ROBOT_SEE_SOUND_DEFAULT;
1257         int                     attack_sound = ROBOT_ATTACK_SOUND_DEFAULT;
1258         int                     claw_sound = ROBOT_CLAW_SOUND_DEFAULT;
1259         int                     taunt_sound = ROBOT_SEE_SOUND_DEFAULT;
1260         ubyte flags=0;
1261
1262         Assert(N_robot_types < MAX_ROBOT_TYPES);
1263
1264 #ifdef SHAREWARE
1265         if (Registered_only) {
1266                 Robot_info[N_robot_types].model_num = -1;
1267                 N_robot_types++;
1268                 Assert(N_robot_types < MAX_ROBOT_TYPES);
1269                 Num_total_object_types++;
1270                 Assert(Num_total_object_types < MAX_OBJTYPE);
1271                 clear_to_end_of_line();
1272                 return;
1273         }
1274 #endif
1275
1276         model_name[0] = strtok( NULL, space );
1277         first_bitmap_num[0] = N_ObjBitmapPtrs;
1278         n_models = 1;
1279
1280         // Process bitmaps
1281         bm_flag=BM_ROBOT;
1282         arg = strtok( NULL, space );
1283         while (arg!=NULL)       {
1284                 equal_ptr = strchr( arg, '=' );
1285                 if ( equal_ptr )        {
1286                         *equal_ptr='\0';
1287                         equal_ptr++;
1288                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1289                         if (!stricmp( arg, "exp1_vclip" ))      {
1290                                 exp1_vclip_num = atoi(equal_ptr);
1291                         } else if (!stricmp( arg, "exp2_vclip" ))       {
1292                                 exp2_vclip_num = atoi(equal_ptr);
1293                         } else if (!stricmp( arg, "exp1_sound" ))       {
1294                                 exp1_sound_num = atoi(equal_ptr);
1295                         } else if (!stricmp( arg, "exp2_sound" ))       {
1296                                 exp2_sound_num = atoi(equal_ptr);
1297                         } else if (!stricmp( arg, "lighting" )) {
1298                                 lighting = fl2f(atof(equal_ptr));
1299                                 if ( (lighting < 0) || (lighting > F1_0 )) {
1300                                         mprintf( (1, "In bitmaps.tbl, lighting value of %.2f is out of range 0..1.\n", f2fl(lighting)));
1301                                         Error( "In bitmaps.tbl, lighting value of %.2f is out of range 0..1.\n", f2fl(lighting));
1302                                 }
1303                         } else if (!stricmp( arg, "weapon_type" )) {
1304                                 weapon_type = atoi(equal_ptr);
1305                         } else if (!stricmp( arg, "weapon_type2" )) {
1306                                 weapon_type2 = atoi(equal_ptr);
1307                         } else if (!stricmp( arg, "strength" )) {
1308                                 strength = i2f(atoi(equal_ptr));
1309                         } else if (!stricmp( arg, "mass" )) {
1310                                 mass = fl2f(atof(equal_ptr));
1311                         } else if (!stricmp( arg, "drag" )) {
1312                                 drag = fl2f(atof(equal_ptr));
1313                         } else if (!stricmp( arg, "contains_id" )) {
1314                                 contains_id = atoi(equal_ptr);
1315                         } else if (!stricmp( arg, "contains_type" )) {
1316                                 contains_type = atoi(equal_ptr);
1317                         } else if (!stricmp( arg, "contains_count" )) {
1318                                 contains_count = atoi(equal_ptr);
1319                         } else if (!stricmp( arg, "companion" )) {
1320                                 companion = atoi(equal_ptr);
1321                         } else if (!stricmp( arg, "badass" )) {
1322                                 badass = atoi(equal_ptr);
1323                         } else if (!stricmp( arg, "lightcast" )) {
1324                                 lightcast = atoi(equal_ptr);
1325                         } else if (!stricmp( arg, "glow" )) {
1326                                 glow = fl2f(atof(equal_ptr));
1327                         } else if (!stricmp( arg, "death_roll" )) {
1328                                 death_roll = atoi(equal_ptr);
1329                         } else if (!stricmp( arg, "deathroll_sound" )) {
1330                                 deathroll_sound = atoi(equal_ptr);
1331                         } else if (!stricmp( arg, "thief" )) {
1332                                 thief = atoi(equal_ptr);
1333                         } else if (!stricmp( arg, "kamikaze" )) {
1334                                 kamikaze = atoi(equal_ptr);
1335                         } else if (!stricmp( arg, "pursuit" )) {
1336                                 pursuit = atoi(equal_ptr);
1337                         } else if (!stricmp( arg, "smart_blobs" )) {
1338                                 smart_blobs = atoi(equal_ptr);
1339                         } else if (!stricmp( arg, "energy_blobs" )) {
1340                                 energy_blobs = atoi(equal_ptr);
1341                         } else if (!stricmp( arg, "energy_drain" )) {
1342                                 energy_drain = atoi(equal_ptr);
1343                         } else if (!stricmp( arg, "contains_prob" )) {
1344                                 contains_prob = atoi(equal_ptr);
1345                         } else if (!stricmp( arg, "cloak_type" )) {
1346                                 cloak_type = atoi(equal_ptr);
1347                         } else if (!stricmp( arg, "attack_type" )) {
1348                                 attack_type = atoi(equal_ptr);
1349                         } else if (!stricmp( arg, "boss" )) {
1350                                 boss_flag = atoi(equal_ptr);
1351                         } else if (!stricmp( arg, "score_value" )) {
1352                                 score_value = atoi(equal_ptr);
1353                         } else if (!stricmp( arg, "see_sound" )) {
1354                                 see_sound = atoi(equal_ptr);
1355                         } else if (!stricmp( arg, "attack_sound" )) {
1356                                 attack_sound = atoi(equal_ptr);
1357                         } else if (!stricmp( arg, "claw_sound" )) {
1358                                 claw_sound = atoi(equal_ptr);
1359                         } else if (!stricmp( arg, "taunt_sound" )) {
1360                                 taunt_sound = atoi(equal_ptr);
1361                         } else if (!stricmp( arg, "aim" )) {
1362                                 aim = fl2f(atof(equal_ptr));
1363                         } else if (!stricmp( arg, "big_radius" )) {
1364                                 if (atoi(equal_ptr))
1365                                         flags |= RIF_BIG_RADIUS;
1366                         } else if (!stricmp( arg, "behavior" )) {
1367                                 if (!stricmp(equal_ptr, "STILL"))
1368                                         behavior = AIB_STILL;
1369                                 else if (!stricmp(equal_ptr, "NORMAL"))
1370                                         behavior = AIB_NORMAL;
1371                                 else if (!stricmp(equal_ptr, "BEHIND"))
1372                                         behavior = AIB_BEHIND;
1373                                 else if (!stricmp(equal_ptr, "RUN_FROM"))
1374                                         behavior = AIB_RUN_FROM;
1375                                 else if (!stricmp(equal_ptr, "SNIPE"))
1376                                         behavior = AIB_SNIPE;
1377                                 else if (!stricmp(equal_ptr, "STATION"))
1378                                         behavior = AIB_STATION;
1379                                 else if (!stricmp(equal_ptr, "FOLLOW"))
1380                                         behavior = AIB_FOLLOW;
1381                                 else
1382                                         Int3(); //      Error.  Illegal behavior type for current robot.
1383                         } else if (!stricmp( arg, "name" )) {
1384                                 Assert(strlen(equal_ptr) < ROBOT_NAME_LENGTH);  //      Oops, name too long.
1385                                 strcpy(name, &equal_ptr[1]);
1386                                 name[strlen(name)-1] = 0;
1387                         } else if (!stricmp( arg, "simple_model" )) {
1388                                 model_name[n_models] = equal_ptr;
1389                                 first_bitmap_num[n_models] = N_ObjBitmapPtrs;
1390                                 n_models++;
1391                                 Assert(n_models < MAX_MODEL_VARIANTS);
1392                         } else {
1393                                 Int3();
1394                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
1395                         }
1396                 } else {                        // Must be a texture specification...
1397                         load_polymodel_bitmap(arg);
1398                 }
1399                 arg = strtok( NULL, space );
1400         }
1401
1402         //clear out anim info
1403         for (g=0;g<MAX_GUNS+1;g++)
1404                 for (s=0;s<N_ANIM_STATES;s++)
1405                         Robot_info[N_robot_types].anim_states[g][s].n_joints = 0;       //inialize to zero
1406
1407         first_bitmap_num[n_models] = N_ObjBitmapPtrs;
1408
1409         for (i=0;i<n_models;i++) {
1410                 int n_textures;
1411                 int model_num,last_model_num=0;
1412
1413                 n_textures = first_bitmap_num[i+1] - first_bitmap_num[i];
1414
1415                 model_num = load_polygon_model(model_name[i],n_textures,first_bitmap_num[i],(i==0)?&Robot_info[N_robot_types]:NULL);
1416
1417                 if (i==0)
1418                         Robot_info[N_robot_types].model_num = model_num;
1419                 else
1420                         Polygon_models[last_model_num].simpler_model = model_num+1;
1421
1422                 last_model_num = model_num;
1423         }
1424
1425         if ((glow > i2f(15)) || (glow < 0) || (glow != 0 && glow < 0x1000)) {
1426                 mprintf((0,"Invalid glow value %x for robot %d\n",glow,N_robot_types));
1427                 Int3();
1428         }
1429
1430         ObjType[Num_total_object_types] = OL_ROBOT;
1431         ObjId[Num_total_object_types] = N_robot_types;
1432
1433         Robot_info[N_robot_types].exp1_vclip_num = exp1_vclip_num;
1434         Robot_info[N_robot_types].exp2_vclip_num = exp2_vclip_num;
1435         Robot_info[N_robot_types].exp1_sound_num = exp1_sound_num;
1436         Robot_info[N_robot_types].exp2_sound_num = exp2_sound_num;
1437         Robot_info[N_robot_types].lighting = lighting;
1438         Robot_info[N_robot_types].weapon_type = weapon_type;
1439         Robot_info[N_robot_types].weapon_type2 = weapon_type2;
1440         Robot_info[N_robot_types].strength = strength;
1441         Robot_info[N_robot_types].mass = mass;
1442         Robot_info[N_robot_types].drag = drag;
1443         Robot_info[N_robot_types].cloak_type = cloak_type;
1444         Robot_info[N_robot_types].attack_type = attack_type;
1445         Robot_info[N_robot_types].boss_flag = boss_flag;
1446
1447         Robot_info[N_robot_types].contains_id = contains_id;
1448         Robot_info[N_robot_types].contains_count = contains_count;
1449         Robot_info[N_robot_types].contains_prob = contains_prob;
1450         Robot_info[N_robot_types].companion = companion;
1451         Robot_info[N_robot_types].badass = badass;
1452         Robot_info[N_robot_types].lightcast = lightcast;
1453         Robot_info[N_robot_types].glow = (glow>>12);            //convert to 4:4
1454         Robot_info[N_robot_types].death_roll = death_roll;
1455         Robot_info[N_robot_types].deathroll_sound = deathroll_sound;
1456         Robot_info[N_robot_types].thief = thief;
1457         Robot_info[N_robot_types].flags = flags;
1458         Robot_info[N_robot_types].kamikaze = kamikaze;
1459         Robot_info[N_robot_types].pursuit = pursuit;
1460         Robot_info[N_robot_types].smart_blobs = smart_blobs;
1461         Robot_info[N_robot_types].energy_blobs = energy_blobs;
1462         Robot_info[N_robot_types].energy_drain = energy_drain;
1463         Robot_info[N_robot_types].score_value = score_value;
1464         Robot_info[N_robot_types].see_sound = see_sound;
1465         Robot_info[N_robot_types].attack_sound = attack_sound;
1466         Robot_info[N_robot_types].claw_sound = claw_sound;
1467         Robot_info[N_robot_types].taunt_sound = taunt_sound;
1468         Robot_info[N_robot_types].behavior = behavior;          //      Default behavior for this robot, if coming out of matcen.
1469         Robot_info[N_robot_types].aim = min(f2i(aim*255), 255);         //      how well this robot type can aim.  255=perfect
1470
1471         if (contains_type)
1472                 Robot_info[N_robot_types].contains_type = OBJ_ROBOT;
1473         else
1474                 Robot_info[N_robot_types].contains_type = OBJ_POWERUP;
1475
1476         strcpy(Robot_names[N_robot_types], name);
1477
1478         N_robot_types++;
1479         Num_total_object_types++;
1480
1481         Assert(N_robot_types < MAX_ROBOT_TYPES);
1482         Assert(Num_total_object_types < MAX_OBJTYPE);
1483
1484         bm_flag = BM_NONE;
1485 }
1486
1487 //read a reactor model
1488 void bm_read_reactor()
1489 {
1490         char *model_name, *model_name_dead=NULL;
1491         int first_bitmap_num, first_bitmap_num_dead=0, n_normal_bitmaps;
1492         char *equal_ptr;
1493         short model_num;
1494         short explosion_vclip_num = -1;
1495         short explosion_sound_num = SOUND_ROBOT_DESTROYED;
1496         fix     lighting = F1_0/2;              // Default
1497         int type=-1;
1498         fix strength=0;
1499
1500         Assert(Num_reactors < MAX_REACTORS);
1501
1502 #ifdef SHAREWARE
1503         if (Registered_only) {
1504                 Num_reactors++;
1505                 clear_to_end_of_line();
1506                 return;
1507         }
1508 #endif
1509
1510         model_name = strtok( NULL, space );
1511
1512         // Process bitmaps
1513         bm_flag = BM_NONE;
1514         arg = strtok( NULL, space );
1515         first_bitmap_num = N_ObjBitmapPtrs;
1516
1517         type = OL_CONTROL_CENTER;
1518
1519         while (arg!=NULL)       {
1520
1521                 equal_ptr = strchr( arg, '=' );
1522
1523                 if ( equal_ptr )        {
1524                         *equal_ptr='\0';
1525                         equal_ptr++;
1526
1527                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1528
1529                         //@@if (!stricmp(arg,"type")) {
1530                         //@@    if (!stricmp(equal_ptr,"controlcen"))
1531                         //@@            type = OL_CONTROL_CENTER;
1532                         //@@    else if (!stricmp(equal_ptr,"clutter"))
1533                         //@@            type = OL_CLUTTER;
1534                         //@@}
1535
1536                         if (!stricmp( arg, "exp_vclip" ))       {
1537                                 explosion_vclip_num = atoi(equal_ptr);
1538                         } else if (!stricmp( arg, "dead_pof" )) {
1539                                 model_name_dead = equal_ptr;
1540                                 first_bitmap_num_dead=N_ObjBitmapPtrs;
1541                         } else if (!stricmp( arg, "exp_sound" ))        {
1542                                 explosion_sound_num = atoi(equal_ptr);
1543                         } else if (!stricmp( arg, "lighting" )) {
1544                                 lighting = fl2f(atof(equal_ptr));
1545                                 if ( (lighting < 0) || (lighting > F1_0 )) {
1546                                         mprintf( (1, "In bitmaps.tbl, lighting value of %.2f is out of range 0..1.\n", f2fl(lighting)));
1547                                         Error( "In bitmaps.tbl, lighting value of %.2f is out of range 0..1.\n", f2fl(lighting));
1548                                 }
1549                         } else if (!stricmp( arg, "strength" )) {
1550                                 strength = fl2f(atof(equal_ptr));
1551                         } else {
1552                                 Int3();
1553                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
1554                         }
1555                 } else {                        // Must be a texture specification...
1556                         load_polymodel_bitmap(arg);
1557                 }
1558                 arg = strtok( NULL, space );
1559         }
1560
1561         if ( model_name_dead )
1562                 n_normal_bitmaps = first_bitmap_num_dead-first_bitmap_num;
1563         else
1564                 n_normal_bitmaps = N_ObjBitmapPtrs-first_bitmap_num;
1565
1566         model_num = load_polygon_model(model_name,n_normal_bitmaps,first_bitmap_num,NULL);
1567
1568         if ( model_name_dead )
1569                 Dead_modelnums[model_num]  = load_polygon_model(model_name_dead,N_ObjBitmapPtrs-first_bitmap_num_dead,first_bitmap_num_dead,NULL);
1570         else
1571                 Dead_modelnums[model_num] = -1;
1572
1573         if (type == -1)
1574                 Error("No object type specfied for object in BITMAPS.TBL on line %d\n",linenum);
1575
1576         Reactors[Num_reactors].model_num = model_num;
1577         Reactors[Num_reactors].n_guns = read_model_guns(model_name,Reactors[Num_reactors].gun_points,Reactors[Num_reactors].gun_dirs,NULL);
1578
1579         ObjType[Num_total_object_types] = type;
1580         ObjId[Num_total_object_types] = Num_reactors;
1581         ObjStrength[Num_total_object_types] = strength;
1582
1583         //printf( "Object type %d is a control center\n", Num_total_object_types );
1584         Num_total_object_types++;
1585         Assert(Num_total_object_types < MAX_OBJTYPE);
1586
1587         Num_reactors++;
1588 }
1589
1590 //read the marker object
1591 void bm_read_marker()
1592 {
1593         char *model_name;
1594         int first_bitmap_num, n_normal_bitmaps;
1595         char *equal_ptr;
1596
1597         model_name = strtok( NULL, space );
1598
1599         // Process bitmaps
1600         bm_flag = BM_NONE;
1601         arg = strtok( NULL, space );
1602         first_bitmap_num = N_ObjBitmapPtrs;
1603
1604         while (arg!=NULL)       {
1605
1606                 equal_ptr = strchr( arg, '=' );
1607
1608                 if ( equal_ptr )        {
1609                         *equal_ptr='\0';
1610                         equal_ptr++;
1611
1612                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1613                         mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
1614                         Int3();
1615
1616                 } else {                        // Must be a texture specification...
1617                         load_polymodel_bitmap(arg);
1618                 }
1619                 arg = strtok( NULL, space );
1620         }
1621
1622         n_normal_bitmaps = N_ObjBitmapPtrs-first_bitmap_num;
1623
1624         Marker_model_num = load_polygon_model(model_name,n_normal_bitmaps,first_bitmap_num,NULL);
1625 }
1626
1627 #ifdef SHAREWARE
1628 //read the exit model
1629 void bm_read_exitmodel()
1630 {
1631         char *model_name, *model_name_dead=NULL;
1632         int first_bitmap_num, first_bitmap_num_dead, n_normal_bitmaps;
1633         char *equal_ptr;
1634         short model_num;
1635
1636         model_name = strtok( NULL, space );
1637
1638         // Process bitmaps
1639         bm_flag = BM_NONE;
1640         arg = strtok( NULL, space );
1641         first_bitmap_num = N_ObjBitmapPtrs;
1642
1643         while (arg!=NULL)       {
1644
1645                 equal_ptr = strchr( arg, '=' );
1646
1647                 if ( equal_ptr )        {
1648                         *equal_ptr='\0';
1649                         equal_ptr++;
1650
1651                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1652
1653                         if (!stricmp( arg, "dead_pof" ))        {
1654                                 model_name_dead = equal_ptr;
1655                                 first_bitmap_num_dead=N_ObjBitmapPtrs;
1656                         } else {
1657                                 Int3();
1658                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
1659                         }
1660                 } else {                        // Must be a texture specification...
1661                         load_polymodel_bitmap(arg);
1662                 }
1663                 arg = strtok( NULL, space );
1664         }
1665
1666         if ( model_name_dead )
1667                 n_normal_bitmaps = first_bitmap_num_dead-first_bitmap_num;
1668         else
1669                 n_normal_bitmaps = N_ObjBitmapPtrs-first_bitmap_num;
1670
1671         model_num = load_polygon_model(model_name,n_normal_bitmaps,first_bitmap_num,NULL);
1672
1673         if ( model_name_dead )
1674                 Dead_modelnums[model_num]  = load_polygon_model(model_name_dead,N_ObjBitmapPtrs-first_bitmap_num_dead,first_bitmap_num_dead,NULL);
1675         else
1676                 Dead_modelnums[model_num] = -1;
1677
1678 //@@    ObjType[Num_total_object_types] = type;
1679 //@@    ObjId[Num_total_object_types] = model_num;
1680 //@@    ObjStrength[Num_total_object_types] = strength;
1681 //@@
1682 //@@    //printf( "Object type %d is a control center\n", Num_total_object_types );
1683 //@@    Num_total_object_types++;
1684 //@@    Assert(Num_total_object_types < MAX_OBJTYPE);
1685
1686         exit_modelnum = model_num;
1687         destroyed_exit_modelnum = Dead_modelnums[model_num];
1688
1689 }
1690 #endif
1691
1692 void bm_read_player_ship()
1693 {
1694         char    *model_name_dying=NULL;
1695         char    *model_name[MAX_MODEL_VARIANTS];
1696         int     n_models=0,i;
1697         int     first_bitmap_num[MAX_MODEL_VARIANTS];
1698         char *equal_ptr;
1699         robot_info ri;
1700         int last_multi_bitmap_num=-1;
1701
1702         // Process bitmaps
1703         bm_flag = BM_NONE;
1704
1705         arg = strtok( NULL, space );
1706
1707         Player_ship->mass = Player_ship->drag = 0;      //stupid defaults
1708         Player_ship->expl_vclip_num = -1;
1709
1710         while (arg!=NULL)       {
1711
1712                 equal_ptr = strchr( arg, '=' );
1713
1714                 if ( equal_ptr )        {
1715
1716                         *equal_ptr='\0';
1717                         equal_ptr++;
1718
1719                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1720
1721                         if (!stricmp( arg, "model" )) {
1722                                 Assert(n_models==0);
1723                                 model_name[0] = equal_ptr;
1724                                 first_bitmap_num[0] = N_ObjBitmapPtrs;
1725                                 n_models = 1;
1726                         } else if (!stricmp( arg, "simple_model" )) {
1727                                 model_name[n_models] = equal_ptr;
1728                                 first_bitmap_num[n_models] = N_ObjBitmapPtrs;
1729                                 n_models++;
1730                                 Assert(n_models < MAX_MODEL_VARIANTS);
1731
1732                                 if (First_multi_bitmap_num!=-1 && last_multi_bitmap_num==-1)
1733                                         last_multi_bitmap_num=N_ObjBitmapPtrs;
1734                         }
1735                         else if (!stricmp( arg, "mass" ))
1736                                 Player_ship->mass = fl2f(atof(equal_ptr));
1737                         else if (!stricmp( arg, "drag" ))
1738                                 Player_ship->drag = fl2f(atof(equal_ptr));
1739 //                      else if (!stricmp( arg, "low_thrust" ))
1740 //                              Player_ship->low_thrust = fl2f(atof(equal_ptr));
1741                         else if (!stricmp( arg, "max_thrust" ))
1742                                 Player_ship->max_thrust = fl2f(atof(equal_ptr));
1743                         else if (!stricmp( arg, "reverse_thrust" ))
1744                                 Player_ship->reverse_thrust = fl2f(atof(equal_ptr));
1745                         else if (!stricmp( arg, "brakes" ))
1746                                 Player_ship->brakes = fl2f(atof(equal_ptr));
1747                         else if (!stricmp( arg, "wiggle" ))
1748                                 Player_ship->wiggle = fl2f(atof(equal_ptr));
1749                         else if (!stricmp( arg, "max_rotthrust" ))
1750                                 Player_ship->max_rotthrust = fl2f(atof(equal_ptr));
1751                         else if (!stricmp( arg, "dying_pof" ))
1752                                 model_name_dying = equal_ptr;
1753                         else if (!stricmp( arg, "expl_vclip_num" ))
1754                                 Player_ship->expl_vclip_num=atoi(equal_ptr);
1755                         else {
1756                                 Int3();
1757                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
1758                         }
1759                 }
1760                 else if (!stricmp( arg, "multi_textures" )) {
1761
1762                         First_multi_bitmap_num = N_ObjBitmapPtrs;
1763                         first_bitmap_num[n_models] = N_ObjBitmapPtrs;
1764
1765                 }
1766                 else                    // Must be a texture specification...
1767
1768                         load_polymodel_bitmap(arg);
1769
1770                 arg = strtok( NULL, space );
1771         }
1772
1773         Assert(model_name != NULL);
1774
1775         if (First_multi_bitmap_num!=-1 && last_multi_bitmap_num==-1)
1776                 last_multi_bitmap_num=N_ObjBitmapPtrs;
1777
1778         if (First_multi_bitmap_num==-1)
1779                 first_bitmap_num[n_models] = N_ObjBitmapPtrs;
1780
1781 #ifdef NETWORK
1782         Assert(last_multi_bitmap_num-First_multi_bitmap_num == (MAX_NUM_NET_PLAYERS-1)*2);
1783 #endif
1784
1785         for (i=0;i<n_models;i++) {
1786                 int n_textures;
1787                 int model_num,last_model_num=0;
1788
1789                 n_textures = first_bitmap_num[i+1] - first_bitmap_num[i];
1790
1791                 model_num = load_polygon_model(model_name[i],n_textures,first_bitmap_num[i],(i==0)?&ri:NULL);
1792
1793                 if (i==0)
1794                         Player_ship->model_num = model_num;
1795                 else
1796                         Polygon_models[last_model_num].simpler_model = model_num+1;
1797
1798                 last_model_num = model_num;
1799         }
1800
1801         if ( model_name_dying ) {
1802                 Assert(n_models);
1803                 Dying_modelnums[Player_ship->model_num]  = load_polygon_model(model_name_dying,first_bitmap_num[1]-first_bitmap_num[0],first_bitmap_num[0],NULL);
1804         }
1805
1806         Assert(ri.n_guns == N_PLAYER_GUNS);
1807
1808         //calc player gun positions
1809
1810         {
1811                 polymodel *pm;
1812                 robot_info *r;
1813                 vms_vector pnt;
1814                 int mn;                         //submodel number
1815                 int gun_num;
1816
1817                 r = &ri;
1818                 pm = &Polygon_models[Player_ship->model_num];
1819
1820                 for (gun_num=0;gun_num<r->n_guns;gun_num++) {
1821
1822                         pnt = r->gun_points[gun_num];
1823                         mn = r->gun_submodels[gun_num];
1824
1825                         //instance up the tree for this gun
1826                         while (mn != 0) {
1827                                 vm_vec_add2(&pnt,&pm->submodel_offsets[mn]);
1828                                 mn = pm->submodel_parents[mn];
1829                         }
1830
1831                         Player_ship->gun_points[gun_num] = pnt;
1832
1833                 }
1834         }
1835
1836
1837 }
1838
1839 void bm_read_some_file()
1840 {
1841
1842         switch (bm_flag) {
1843         case BM_NONE:
1844                 Error("Trying to read bitmap <%s> with bm_flag==BM_NONE on line %d of BITMAPS.TBL",arg,linenum);
1845                 break;
1846         case BM_COCKPIT:        {
1847                 bitmap_index bitmap;
1848                 bitmap = bm_load_sub(arg);
1849                 Assert( Num_cockpits < N_COCKPIT_BITMAPS );
1850                 cockpit_bitmap[Num_cockpits++] = bitmap;
1851                 //bm_flag = BM_NONE;
1852                 return;
1853                 }
1854                 break;
1855         case BM_GAUGES:
1856                 bm_read_gauges();
1857                 return;
1858                 break;
1859         case BM_GAUGES_HIRES:
1860                 bm_read_gauges_hires();
1861                 return;
1862                 break;
1863         case BM_WEAPON:
1864                 bm_read_weapon(0);
1865                 return;
1866                 break;
1867         case BM_VCLIP:
1868                 bm_read_vclip();
1869                 return;
1870                 break;
1871         case BM_ECLIP:
1872                 bm_read_eclip();
1873                 return;
1874                 break;
1875         case BM_TEXTURES:                       {
1876                 bitmap_index bitmap;
1877                 bitmap = bm_load_sub(arg);
1878                 Assert(tmap_count < MAX_TEXTURES);
1879                 TmapList[tmap_count++] = texture_count;
1880                 Textures[texture_count] = bitmap;
1881                 set_texture_name( arg );
1882                 Assert(texture_count < MAX_TEXTURES);
1883                 texture_count++;
1884                 NumTextures = texture_count;
1885                 return;
1886                 }
1887                 break;
1888         case BM_WCLIP:
1889                 bm_read_wclip();
1890                 return;
1891                 break;
1892         }
1893
1894         Error("Trying to read bitmap <%s> with unknown bm_flag <%x> on line %d of BITMAPS.TBL",arg,bm_flag,linenum);
1895 }
1896
1897 // ------------------------------------------------------------------------------
1898 //      If unused_flag is set, then this is just a placeholder.  Don't actually reference vclips or load bbms.
1899 void bm_read_weapon(int unused_flag)
1900 {
1901         int     i,n;
1902         int     n_models=0;
1903         char    *equal_ptr;
1904         char    *pof_file_inner=NULL;
1905         char    *model_name[MAX_MODEL_VARIANTS];
1906         int     first_bitmap_num[MAX_MODEL_VARIANTS];
1907         int     lighted;                                        //flag for whether is a texture is lighted
1908
1909         Assert(N_weapon_types < MAX_WEAPON_TYPES);
1910
1911         n = N_weapon_types;
1912         N_weapon_types++;
1913         Assert(N_weapon_types <= MAX_WEAPON_TYPES);
1914
1915         if (unused_flag) {
1916                 clear_to_end_of_line();
1917                 return;
1918         }
1919
1920 #ifdef SHAREWARE
1921         if (Registered_only) {
1922                 clear_to_end_of_line();
1923                 return;
1924         }
1925 #endif
1926
1927         // Initialize weapon array
1928         Weapon_info[n].render_type = WEAPON_RENDER_NONE;                // 0=laser, 1=blob, 2=object
1929         Weapon_info[n].bitmap.index = 0;
1930         Weapon_info[n].model_num = -1;
1931         Weapon_info[n].model_num_inner = -1;
1932         Weapon_info[n].blob_size = 0x1000;                                                                      // size of blob
1933         Weapon_info[n].flash_vclip = -1;
1934         Weapon_info[n].flash_sound = SOUND_LASER_FIRED;
1935         Weapon_info[n].flash_size = 0;
1936         Weapon_info[n].robot_hit_vclip = -1;
1937         Weapon_info[n].robot_hit_sound = -1;
1938         Weapon_info[n].wall_hit_vclip = -1;
1939         Weapon_info[n].wall_hit_sound = -1;
1940         Weapon_info[n].impact_size = 0;
1941         for (i=0; i<NDL; i++) {
1942                 Weapon_info[n].strength[i] = F1_0;
1943                 Weapon_info[n].speed[i] = F1_0*10;
1944         }
1945         Weapon_info[n].mass = F1_0;
1946         Weapon_info[n].thrust = 0;
1947         Weapon_info[n].drag = 0;
1948         Weapon_info[n].persistent = 0;
1949
1950         Weapon_info[n].energy_usage = 0;                                        //      How much fuel is consumed to fire this weapon.
1951         Weapon_info[n].ammo_usage = 0;                                  //      How many units of ammunition it uses.
1952         Weapon_info[n].fire_wait = F1_0/4;                              //      Time until this weapon can be fired again.
1953         Weapon_info[n].fire_count = 1;                                  //      Number of bursts fired from EACH GUN per firing.  For weapons which fire from both sides, 3*fire_count shots will be fired.
1954         Weapon_info[n].damage_radius = 0;                               //      Radius of damage for missiles, not lasers.  Does damage to objects within this radius of hit point.
1955 //--01/19/95, mk--      Weapon_info[n].damage_force = 0;                                        //      Force (movement) due to explosion
1956         Weapon_info[n].destroyable = 1;                                 //      Weapons default to destroyable
1957         Weapon_info[n].matter = 0;                                                      //      Weapons default to not being constructed of matter (they are energy!)
1958         Weapon_info[n].bounce = 0;                                                      //      Weapons default to not bouncing off walls
1959
1960         Weapon_info[n].flags = 0;
1961
1962         Weapon_info[n].lifetime = WEAPON_DEFAULT_LIFETIME;                                      //      Number of bursts fired from EACH GUN per firing.  For weapons which fire from both sides, 3*fire_count shots will be fired.
1963
1964         Weapon_info[n].po_len_to_width_ratio = F1_0*10;
1965
1966         Weapon_info[n].picture.index = 0;
1967         Weapon_info[n].hires_picture.index = 0;
1968         Weapon_info[n].homing_flag = 0;
1969
1970         Weapon_info[n].flash = 0;
1971         Weapon_info[n].multi_damage_scale = F1_0;
1972         Weapon_info[n].afterburner_size = 0;
1973         Weapon_info[n].children = -1;
1974
1975         // Process arguments
1976         arg = strtok( NULL, space );
1977
1978         lighted = 1;                    //assume first texture is lighted
1979
1980         Weapon_info[n].speedvar = 128;
1981
1982         while (arg!=NULL)       {
1983                 equal_ptr = strchr( arg, '=' );
1984                 if ( equal_ptr )        {
1985                         *equal_ptr='\0';
1986                         equal_ptr++;
1987                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
1988                         if (!stricmp( arg, "laser_bmp" ))       {
1989                                 // Load bitmap with name equal_ptr
1990
1991                                 Weapon_info[n].bitmap = bm_load_sub(equal_ptr);         //load_polymodel_bitmap(equal_ptr);
1992                                 Weapon_info[n].render_type = WEAPON_RENDER_LASER;
1993
1994                         } else if (!stricmp( arg, "blob_bmp" )) {
1995                                 // Load bitmap with name equal_ptr
1996
1997                                 Weapon_info[n].bitmap = bm_load_sub(equal_ptr);         //load_polymodel_bitmap(equal_ptr);
1998                                 Weapon_info[n].render_type = WEAPON_RENDER_BLOB;
1999
2000                         } else if (!stricmp( arg, "weapon_vclip" ))     {
2001                                 // Set vclip to play for this weapon.
2002                                 Weapon_info[n].bitmap.index = 0;
2003                                 Weapon_info[n].render_type = WEAPON_RENDER_VCLIP;
2004                                 Weapon_info[n].weapon_vclip = atoi(equal_ptr);
2005
2006                         } else if (!stricmp( arg, "none_bmp" )) {
2007                                 Weapon_info[n].bitmap = bm_load_sub(equal_ptr);
2008                                 Weapon_info[n].render_type = WEAPON_RENDER_NONE;
2009
2010                         } else if (!stricmp( arg, "weapon_pof" ))       {
2011                                 // Load pof file
2012                                 Assert(n_models==0);
2013                                 model_name[0] = equal_ptr;
2014                                 first_bitmap_num[0] = N_ObjBitmapPtrs;
2015                                 n_models=1;
2016                         } else if (!stricmp( arg, "simple_model" )) {
2017                                 model_name[n_models] = equal_ptr;
2018                                 first_bitmap_num[n_models] = N_ObjBitmapPtrs;
2019                                 n_models++;
2020                                 Assert(n_models < MAX_MODEL_VARIANTS);
2021                         } else if (!stricmp( arg, "weapon_pof_inner" )) {
2022                                 // Load pof file
2023                                 pof_file_inner = equal_ptr;
2024                         } else if (!stricmp( arg, "strength" )) {
2025                                 for (i=0; i<NDL-1; i++) {
2026                                         Weapon_info[n].strength[i] = fl2f(atof(equal_ptr));
2027                                         equal_ptr = strtok(NULL, space);
2028                                 }
2029                                 Weapon_info[n].strength[i] = i2f(atoi(equal_ptr));
2030                         } else if (!stricmp( arg, "mass" )) {
2031                                 Weapon_info[n].mass = fl2f(atof(equal_ptr));
2032                         } else if (!stricmp( arg, "drag" )) {
2033                                 Weapon_info[n].drag = fl2f(atof(equal_ptr));
2034                         } else if (!stricmp( arg, "thrust" )) {
2035                                 Weapon_info[n].thrust = fl2f(atof(equal_ptr));
2036                         } else if (!stricmp( arg, "matter" )) {
2037                                 Weapon_info[n].matter = atoi(equal_ptr);
2038                         } else if (!stricmp( arg, "bounce" )) {
2039                                 Weapon_info[n].bounce = atoi(equal_ptr);
2040                         } else if (!stricmp( arg, "speed" )) {
2041                                 for (i=0; i<NDL-1; i++) {
2042                                         Weapon_info[n].speed[i] = i2f(atoi(equal_ptr));
2043                                         equal_ptr = strtok(NULL, space);
2044                                 }
2045                                 Weapon_info[n].speed[i] = i2f(atoi(equal_ptr));
2046                         } else if (!stricmp( arg, "speedvar" )) {
2047                                 Weapon_info[n].speedvar = (atoi(equal_ptr) * 128) / 100;
2048                         } else if (!stricmp( arg, "flash_vclip" ))      {
2049                                 Weapon_info[n].flash_vclip = atoi(equal_ptr);
2050                         } else if (!stricmp( arg, "flash_sound" ))      {
2051                                 Weapon_info[n].flash_sound = atoi(equal_ptr);
2052                         } else if (!stricmp( arg, "flash_size" ))       {
2053                                 Weapon_info[n].flash_size = fl2f(atof(equal_ptr));
2054                         } else if (!stricmp( arg, "blob_size" ))        {
2055                                 Weapon_info[n].blob_size = fl2f(atof(equal_ptr));
2056                         } else if (!stricmp( arg, "robot_hit_vclip" ))  {
2057                                 Weapon_info[n].robot_hit_vclip = atoi(equal_ptr);
2058                         } else if (!stricmp( arg, "robot_hit_sound" ))  {
2059                                 Weapon_info[n].robot_hit_sound = atoi(equal_ptr);
2060                         } else if (!stricmp( arg, "wall_hit_vclip" ))   {
2061                                 Weapon_info[n].wall_hit_vclip = atoi(equal_ptr);
2062                         } else if (!stricmp( arg, "wall_hit_sound" ))   {
2063                                 Weapon_info[n].wall_hit_sound = atoi(equal_ptr);
2064                         } else if (!stricmp( arg, "impact_size" ))      {
2065                                 Weapon_info[n].impact_size = fl2f(atof(equal_ptr));
2066                         } else if (!stricmp( arg, "lighted" ))  {
2067                                 lighted = atoi(equal_ptr);
2068                         } else if (!stricmp( arg, "lw_ratio" )) {
2069                                 Weapon_info[n].po_len_to_width_ratio = fl2f(atof(equal_ptr));
2070                         } else if (!stricmp( arg, "lightcast" ))        {
2071                                 Weapon_info[n].light = fl2f(atof(equal_ptr));
2072                         } else if (!stricmp( arg, "persistent" ))       {
2073                                 Weapon_info[n].persistent = atoi(equal_ptr);
2074                         } else if (!stricmp(arg, "energy_usage" )) {
2075                                 Weapon_info[n].energy_usage = fl2f(atof(equal_ptr));
2076                         } else if (!stricmp(arg, "ammo_usage" )) {
2077                                 Weapon_info[n].ammo_usage = atoi(equal_ptr);
2078                         } else if (!stricmp(arg, "fire_wait" )) {
2079                                 Weapon_info[n].fire_wait = fl2f(atof(equal_ptr));
2080                         } else if (!stricmp(arg, "fire_count" )) {
2081                                 Weapon_info[n].fire_count = atoi(equal_ptr);
2082                         } else if (!stricmp(arg, "damage_radius" )) {
2083                                 Weapon_info[n].damage_radius = fl2f(atof(equal_ptr));
2084 //--01/19/95, mk--                      } else if (!stricmp(arg, "damage_force" )) {
2085 //--01/19/95, mk--                              Weapon_info[n].damage_force = fl2f(atof(equal_ptr));
2086                         } else if (!stricmp(arg, "lifetime" )) {
2087                                 Weapon_info[n].lifetime = fl2f(atof(equal_ptr));
2088                         } else if (!stricmp(arg, "destroyable" )) {
2089                                 Weapon_info[n].destroyable = atoi(equal_ptr);
2090                         } else if (!stricmp(arg, "picture" )) {
2091                                 Weapon_info[n].picture = bm_load_sub(equal_ptr);
2092                         } else if (!stricmp(arg, "hires_picture" )) {
2093                                 Weapon_info[n].hires_picture = bm_load_sub(equal_ptr);
2094                         } else if (!stricmp(arg, "homing" )) {
2095                                 Weapon_info[n].homing_flag = !!atoi(equal_ptr);
2096                         } else if (!stricmp(arg, "flash" )) {
2097                                 Weapon_info[n].flash = atoi(equal_ptr);
2098                         } else if (!stricmp(arg, "multi_damage_scale" )) {
2099                                 Weapon_info[n].multi_damage_scale = fl2f(atof(equal_ptr));
2100                         } else if (!stricmp(arg, "afterburner_size" )) {
2101                                 Weapon_info[n].afterburner_size = f2i(16*fl2f(atof(equal_ptr)));
2102                         } else if (!stricmp(arg, "children" )) {
2103                                 Weapon_info[n].children = atoi(equal_ptr);
2104                         } else if (!stricmp(arg, "placable" )) {
2105                                 if (atoi(equal_ptr)) {
2106                                         Weapon_info[n].flags |= WIF_PLACABLE;
2107
2108                                         Assert(Num_total_object_types < MAX_OBJTYPE);
2109                                         ObjType[Num_total_object_types] = OL_WEAPON;
2110                                         ObjId[Num_total_object_types] = n;
2111                                         Num_total_object_types++;
2112                                 }
2113                         } else {
2114                                 Int3();
2115                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
2116                         }
2117                 } else {                        // Must be a texture specification...
2118                         grs_bitmap *bm;
2119
2120                         bm = load_polymodel_bitmap(arg);
2121                         if (! lighted)
2122                                 bm->bm_flags |= BM_FLAG_NO_LIGHTING;
2123
2124                         lighted = 1;                    //default for next bitmap is lighted
2125                 }
2126                 arg = strtok( NULL, space );
2127         }
2128
2129         first_bitmap_num[n_models] = N_ObjBitmapPtrs;
2130
2131         for (i=0;i<n_models;i++) {
2132                 int n_textures;
2133                 int model_num,last_model_num=0;
2134
2135                 n_textures = first_bitmap_num[i+1] - first_bitmap_num[i];
2136
2137                 model_num = load_polygon_model(model_name[i],n_textures,first_bitmap_num[i],NULL);
2138
2139                 if (i==0) {
2140                         Weapon_info[n].render_type = WEAPON_RENDER_POLYMODEL;
2141                         Weapon_info[n].model_num = model_num;
2142                 }
2143                 else
2144                         Polygon_models[last_model_num].simpler_model = model_num+1;
2145
2146                 last_model_num = model_num;
2147         }
2148
2149         if ( pof_file_inner )   {
2150                 Assert(n_models);
2151                 Weapon_info[n].model_num_inner = load_polygon_model(pof_file_inner,first_bitmap_num[1]-first_bitmap_num[0],first_bitmap_num[0],NULL);
2152         }
2153
2154         if ((Weapon_info[n].ammo_usage == 0) && (Weapon_info[n].energy_usage == 0))
2155                 mprintf((1, "Warning: Weapon %i has ammo and energy usage of 0.\n", n));
2156
2157 // -- render type of none is now legal --       Assert( Weapon_info[n].render_type != WEAPON_RENDER_NONE );
2158 }
2159
2160
2161
2162
2163
2164 // ------------------------------------------------------------------------------
2165 #define DEFAULT_POWERUP_SIZE i2f(3)
2166
2167 void bm_read_powerup(int unused_flag)
2168 {
2169         int n;
2170         char    *equal_ptr;
2171
2172         Assert(N_powerup_types < MAX_POWERUP_TYPES);
2173
2174         n = N_powerup_types;
2175         N_powerup_types++;
2176
2177         if (unused_flag) {
2178                 clear_to_end_of_line();
2179                 return;
2180         }
2181
2182         // Initialize powerup array
2183         Powerup_info[n].light = F1_0/3;         //      Default lighting value.
2184         Powerup_info[n].vclip_num = -1;
2185         Powerup_info[n].hit_sound = -1;
2186         Powerup_info[n].size = DEFAULT_POWERUP_SIZE;
2187         Powerup_names[n][0] = 0;
2188
2189         // Process arguments
2190         arg = strtok( NULL, space );
2191
2192         while (arg!=NULL)       {
2193                 equal_ptr = strchr( arg, '=' );
2194                 if ( equal_ptr )        {
2195                         *equal_ptr='\0';
2196                         equal_ptr++;
2197                         // if we have john=cool, arg is 'john' and equal_ptr is 'cool'
2198                         if (!stricmp( arg, "vclip_num" ))       {
2199                                 Powerup_info[n].vclip_num = atoi(equal_ptr);
2200                         } else if (!stricmp( arg, "light" ))    {
2201                                 Powerup_info[n].light = fl2f(atof(equal_ptr));
2202                         } else if (!stricmp( arg, "hit_sound" ))        {
2203                                 Powerup_info[n].hit_sound = atoi(equal_ptr);
2204                         } else if (!stricmp( arg, "name" )) {
2205                                 Assert(strlen(equal_ptr) < POWERUP_NAME_LENGTH);        //      Oops, name too long.
2206                                 strcpy(Powerup_names[n], &equal_ptr[1]);
2207                                 Powerup_names[n][strlen(Powerup_names[n])-1] = 0;
2208                         } else if (!stricmp( arg, "size" ))     {
2209                                 Powerup_info[n].size = fl2f(atof(equal_ptr));
2210                         } else {
2211                                 Int3();
2212                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
2213                         }
2214                 } else {                        // Must be a texture specification...
2215                         Int3();
2216                         mprintf( (1, "Invalid argument, %s in bitmaps.tbl\n", arg ));
2217                 }
2218                 arg = strtok( NULL, space );
2219         }
2220
2221         ObjType[Num_total_object_types] = OL_POWERUP;
2222         ObjId[Num_total_object_types] = n;
2223         //printf( "Object type %d is a powerup\n", Num_total_object_types );
2224         Num_total_object_types++;
2225         Assert(Num_total_object_types < MAX_OBJTYPE);
2226
2227 }
2228
2229 void bm_read_hostage()
2230 {
2231         int n;
2232         char    *equal_ptr;
2233
2234         Assert(N_hostage_types < MAX_HOSTAGE_TYPES);
2235
2236         n = N_hostage_types;
2237         N_hostage_types++;
2238
2239         // Process arguments
2240         arg = strtok( NULL, space );
2241
2242         while (arg!=NULL)       {
2243                 equal_ptr = strchr( arg, '=' );
2244                 if ( equal_ptr )        {
2245                         *equal_ptr='\0';
2246                         equal_ptr++;
2247
2248                         if (!stricmp( arg, "vclip_num" ))
2249
2250                                 Hostage_vclip_num[n] = atoi(equal_ptr);
2251
2252                         else {
2253                                 Int3();
2254                                 mprintf( (1, "Invalid parameter, %s=%s in bitmaps.tbl\n", arg, equal_ptr ));
2255                         }
2256
2257                 } else {
2258                         Int3();
2259                         mprintf( (1, "Invalid argument, %s in bitmaps.tbl at line %d\n", arg, linenum ));
2260                 }
2261                 arg = strtok( NULL, space );
2262         }
2263
2264         ObjType[Num_total_object_types] = OL_HOSTAGE;
2265         ObjId[Num_total_object_types] = n;
2266         //printf( "Object type %d is a hostage\n", Num_total_object_types );
2267         Num_total_object_types++;
2268         Assert(Num_total_object_types < MAX_OBJTYPE);
2269
2270 }
2271
2272 //these values are the number of each item in the release of d2
2273 //extra items added after the release get written in an additional hamfile
2274 #define N_D2_ROBOT_TYPES                66
2275 #define N_D2_ROBOT_JOINTS               1145
2276 #define N_D2_POLYGON_MODELS     166
2277 #define N_D2_OBJBITMAPS                 422
2278 #define N_D2_OBJBITMAPPTRS              502
2279 #define N_D2_WEAPON_TYPES               62
2280
2281 void bm_write_all(FILE *fp)
2282 {
2283         int i,t;
2284         FILE *tfile;
2285         int s=0;
2286
2287 tfile = fopen("hamfile.lst","wt");
2288
2289         t = NumTextures-1;      //don't save bogus texture
2290         fwrite( &t, sizeof(int), 1, fp );
2291         fwrite( Textures, sizeof(bitmap_index), t, fp );
2292         for (i=0;i<t;i++)
2293                 fwrite( &TmapInfo[i], sizeof(*TmapInfo)-sizeof(TmapInfo->filename)-sizeof(TmapInfo->pad2), 1, fp );
2294
2295 fprintf(tfile,"NumTextures = %d, Textures array = %d, TmapInfo array = %d\n",NumTextures,sizeof(bitmap_index)*NumTextures,sizeof(tmap_info)*NumTextures);
2296
2297         t = MAX_SOUNDS;
2298         fwrite( &t, sizeof(int), 1, fp );
2299         fwrite( Sounds, sizeof(ubyte), t, fp );
2300         fwrite( AltSounds, sizeof(ubyte), t, fp );
2301
2302 fprintf(tfile,"Num Sounds = %d, Sounds array = %d, AltSounds array = %d\n",t,t,t);
2303
2304         fwrite( &Num_vclips, sizeof(int), 1, fp );
2305         fwrite( Vclip, sizeof(vclip), Num_vclips, fp );
2306
2307 fprintf(tfile,"Num_vclips = %d, Vclip array = %d\n",Num_vclips,sizeof(vclip)*Num_vclips);
2308
2309         fwrite( &Num_effects, sizeof(int), 1, fp );
2310         fwrite( Effects, sizeof(eclip), Num_effects, fp );
2311
2312 fprintf(tfile,"Num_effects = %d, Effects array = %d\n",Num_effects,sizeof(eclip)*Num_effects);
2313
2314         fwrite( &Num_wall_anims, sizeof(int), 1, fp );
2315         fwrite( WallAnims, sizeof(wclip), Num_wall_anims, fp );
2316
2317 fprintf(tfile,"Num_wall_anims = %d, WallAnims array = %d\n",Num_wall_anims,sizeof(wclip)*Num_wall_anims);
2318
2319         t = N_D2_ROBOT_TYPES;
2320         fwrite( &t, sizeof(int), 1, fp );
2321         fwrite( Robot_info, sizeof(robot_info), t, fp );
2322
2323 fprintf(tfile,"N_robot_types = %d, Robot_info array = %d\n",t,sizeof(robot_info)*N_robot_types);
2324
2325         t = N_D2_ROBOT_JOINTS;
2326         fwrite( &t, sizeof(int), 1, fp );
2327         fwrite( Robot_joints, sizeof(jointpos), t, fp );
2328
2329 fprintf(tfile,"N_robot_joints = %d, Robot_joints array = %d\n",t,sizeof(jointpos)*N_robot_joints);
2330
2331         t = N_D2_WEAPON_TYPES;
2332         fwrite( &t, sizeof(int), 1, fp );
2333         fwrite( Weapon_info, sizeof(weapon_info), t, fp );
2334
2335 fprintf(tfile,"N_weapon_types = %d, Weapon_info array = %d\n",N_weapon_types,sizeof(weapon_info)*N_weapon_types);
2336
2337         fwrite( &N_powerup_types, sizeof(int), 1, fp );
2338         fwrite( Powerup_info, sizeof(powerup_type_info), N_powerup_types, fp );
2339
2340 fprintf(tfile,"N_powerup_types = %d, Powerup_info array = %d\n",N_powerup_types,sizeof(powerup_info)*N_powerup_types);
2341
2342         t = N_D2_POLYGON_MODELS;
2343         fwrite( &t, sizeof(int), 1, fp );
2344         fwrite( Polygon_models, sizeof(polymodel), t, fp );
2345
2346 fprintf(tfile,"N_polygon_models = %d, Polygon_models array = %d\n",t,sizeof(polymodel)*t);
2347
2348         for (i=0; i<t; i++ )    {
2349                 g3_uninit_polygon_model(Polygon_models[i].model_data);  //get RGB colors
2350                 fwrite( Polygon_models[i].model_data, sizeof(ubyte), Polygon_models[i].model_data_size, fp );
2351 fprintf(tfile,"  Model %d, data size = %d\n",i,Polygon_models[i].model_data_size); s+=Polygon_models[i].model_data_size;
2352                 g3_init_polygon_model(Polygon_models[i].model_data);    //map colors again
2353         }
2354 fprintf(tfile,"Total model size = %d\n",s);
2355
2356         fwrite( Dying_modelnums, sizeof(int), t, fp );
2357         fwrite( Dead_modelnums, sizeof(int), t, fp );
2358
2359 fprintf(tfile,"Dying_modelnums array = %d, Dead_modelnums array = %d\n",sizeof(int)*t,sizeof(int)*t);
2360
2361         t = MAX_GAUGE_BMS;
2362         fwrite( &t, sizeof(int), 1, fp );
2363         fwrite( Gauges, sizeof(bitmap_index), t, fp );
2364         fwrite( Gauges_hires, sizeof(bitmap_index), t, fp );
2365
2366 fprintf(tfile,"Num gauge bitmaps = %d, Gauges array = %d, Gauges_hires array = %d\n",t,sizeof(bitmap_index)*t,sizeof(bitmap_index)*t);
2367
2368         t = MAX_OBJ_BITMAPS;
2369         fwrite( &t, sizeof(int), 1, fp );
2370         fwrite( ObjBitmaps, sizeof(bitmap_index), t, fp );
2371         fwrite( ObjBitmapPtrs, sizeof(ushort), t, fp );
2372
2373 fprintf(tfile,"Num obj bitmaps = %d, ObjBitmaps array = %d, ObjBitmapPtrs array = %d\n",t,sizeof(bitmap_index)*t,sizeof(ushort)*t);
2374
2375         fwrite( &only_player_ship, sizeof(player_ship), 1, fp );
2376
2377 fprintf(tfile,"player_ship size = %d\n",sizeof(player_ship));
2378
2379         fwrite( &Num_cockpits, sizeof(int), 1, fp );
2380         fwrite( cockpit_bitmap, sizeof(bitmap_index), Num_cockpits, fp );
2381
2382 fprintf(tfile,"Num_cockpits = %d, cockpit_bitmaps array = %d\n",Num_cockpits,sizeof(bitmap_index)*Num_cockpits);
2383
2384 //@@    fwrite( &Num_total_object_types, sizeof(int), 1, fp );
2385 //@@    fwrite( ObjType, sizeof(sbyte), Num_total_object_types, fp );
2386 //@@    fwrite( ObjId, sizeof(sbyte), Num_total_object_types, fp );
2387 //@@    fwrite( ObjStrength, sizeof(fix), Num_total_object_types, fp );
2388
2389 fprintf(tfile,"Num_total_object_types = %d, ObjType array = %d, ObjId array = %d, ObjStrength array = %d\n",Num_total_object_types,Num_total_object_types,Num_total_object_types,sizeof(fix)*Num_total_object_types);
2390
2391         fwrite( &First_multi_bitmap_num, sizeof(int), 1, fp );
2392
2393         fwrite( &Num_reactors, sizeof(Num_reactors), 1, fp );
2394         fwrite( Reactors, sizeof(*Reactors), Num_reactors, fp);
2395
2396 fprintf(tfile,"Num_reactors = %d, Reactors array = %d\n",Num_reactors,sizeof(*Reactors)*Num_reactors);
2397
2398         fwrite( &Marker_model_num, sizeof(Marker_model_num), 1, fp);
2399
2400         //@@fwrite( &N_controlcen_guns, sizeof(int), 1, fp );
2401         //@@fwrite( controlcen_gun_points, sizeof(vms_vector), N_controlcen_guns, fp );
2402         //@@fwrite( controlcen_gun_dirs, sizeof(vms_vector), N_controlcen_guns, fp );
2403
2404         #ifdef SHAREWARE
2405         fwrite( &exit_modelnum, sizeof(int), 1, fp );
2406         fwrite( &destroyed_exit_modelnum, sizeof(int), 1, fp );
2407         #endif
2408
2409 fclose(tfile);
2410
2411         bm_write_extra_robots();
2412 }
2413
2414 void bm_write_extra_robots()
2415 {
2416         FILE *fp;
2417         u_int32_t t;
2418         int i;
2419
2420         fp = fopen("robots.ham","wb");
2421
2422         t = 0x5848414d; /* 'XHAM' */
2423         fwrite( &t, sizeof(int), 1, fp );
2424         t = 1;  //version
2425         fwrite( &t, sizeof(int), 1, fp );
2426
2427         //write weapon info
2428         t = N_weapon_types - N_D2_WEAPON_TYPES;
2429         fwrite( &t, sizeof(int), 1, fp );
2430         fwrite( &Weapon_info[N_D2_WEAPON_TYPES], sizeof(weapon_info), t, fp );
2431
2432         //now write robot info
2433
2434         t = N_robot_types - N_D2_ROBOT_TYPES;
2435         fwrite( &t, sizeof(int), 1, fp );
2436         fwrite( &Robot_info[N_D2_ROBOT_TYPES], sizeof(robot_info), t, fp );
2437
2438         t = N_robot_joints - N_D2_ROBOT_JOINTS;
2439         fwrite( &t, sizeof(int), 1, fp );
2440         fwrite( &Robot_joints[N_D2_ROBOT_JOINTS], sizeof(jointpos), t, fp );
2441
2442         t = N_polygon_models - N_D2_POLYGON_MODELS;
2443         fwrite( &t, sizeof(int), 1, fp );
2444         fwrite( &Polygon_models[N_D2_POLYGON_MODELS], sizeof(polymodel), t, fp );
2445
2446         for (i=N_D2_POLYGON_MODELS; i<N_polygon_models; i++ )   {
2447                 g3_uninit_polygon_model(Polygon_models[i].model_data);  //get RGB colors
2448                 fwrite( Polygon_models[i].model_data, sizeof(ubyte), Polygon_models[i].model_data_size, fp );
2449                 g3_init_polygon_model(Polygon_models[i].model_data);    //map colors again
2450         }
2451
2452         fwrite( &Dying_modelnums[N_D2_POLYGON_MODELS], sizeof(int), t, fp );
2453         fwrite( &Dead_modelnums[N_D2_POLYGON_MODELS], sizeof(int), t, fp );
2454
2455         t = N_ObjBitmaps - N_D2_OBJBITMAPS;
2456         fwrite( &t, sizeof(int), 1, fp );
2457         fwrite( &ObjBitmaps[N_D2_OBJBITMAPS], sizeof(bitmap_index), t, fp );
2458
2459         t = N_ObjBitmapPtrs - N_D2_OBJBITMAPPTRS;
2460         fwrite( &t, sizeof(int), 1, fp );
2461         fwrite( &ObjBitmapPtrs[N_D2_OBJBITMAPPTRS], sizeof(ushort), t, fp );
2462
2463         fwrite( ObjBitmapPtrs, sizeof(ushort), t, fp );
2464
2465         fclose(fp);
2466 }