Subversion Repositories eduke32

Rev

Rev 8519 | Rev 8685 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5196 hendricks2 1
//-------------------------------------------------------------------------
2
/*
3
Copyright (C) 1996, 2005 - 3D Realms Entertainment
4
 
5
This file is NOT part of Shadow Warrior version 1.2
6
However, it is either an older version of a file that is, or is
7
some test code written during the development of Shadow Warrior.
8
This file is provided purely for educational interest.
9
 
10
Shadow Warrior is free software; you can redistribute it and/or
11
modify it under the terms of the GNU General Public License
12
as published by the Free Software Foundation; either version 2
13
of the License, or (at your option) any later version.
14
 
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18
 
19
See the GNU General Public License for more details.
20
 
21
You should have received a copy of the GNU General Public License
22
along with this program; if not, write to the Free Software
23
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24
 
25
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
26
*/
27
//-------------------------------------------------------------------------
28
 
29
#include "build.h"
30
#include "editor.h"
31
#include "cache1d.h"
32
 
33
#include "keys.h"
34
#include "names2.h"
35
#include "game.h"
36
#include "tags.h"
37
#include "pal.h"
38
 
5217 hendricks2 39
#include "common.h"
5211 hendricks2 40
#include "common_game.h"
41
 
7539 hendricks2 42
#include "colormap.h"
7537 hendricks2 43
 
7539 hendricks2 44
 
7537 hendricks2 45
const char* AppProperName = "Wangulator";
46
const char* AppTechnicalName = "wangulator";
47
 
48
#if defined(_WIN32)
49
#define DEFAULT_GAME_EXEC "voidsw.exe"
50
#define DEFAULT_GAME_LOCAL_EXEC "voidsw.exe"
51
#else
52
#define DEFAULT_GAME_EXEC "voidsw"
53
#define DEFAULT_GAME_LOCAL_EXEC "./voidsw"
54
#endif
55
 
56
const char *DefaultGameExec = DEFAULT_GAME_EXEC;
57
const char *DefaultGameLocalExec = DEFAULT_GAME_LOCAL_EXEC;
58
 
59
#define SETUPFILENAME "wangulator.cfg"
60
const char *defaultsetupfilename = SETUPFILENAME;
61
char setupfilename[BMAX_PATH] = SETUPFILENAME;
62
 
8477 hendricks2 63
#define eitherALT   (keystatus[KEYSC_LALT] || keystatus[KEYSC_RALT])
64
#define eitherCTRL  (keystatus[KEYSC_LCTRL] || keystatus[KEYSC_RCTRL])
65
#define eitherSHIFT (keystatus[KEYSC_LSHIFT] || keystatus[KEYSC_RSHIFT])
7537 hendricks2 66
 
8477 hendricks2 67
#define PRESSED_KEYSC(Key) (keystatus[KEYSC_##Key] && !(keystatus[KEYSC_##Key]=0))
68
 
69
 
5196 hendricks2 70
#define M_RED 102
71
#define M_BLUE 198
72
 
73
 
74
void ToggleFAF(void);       // brooms.c
75
void FAF_AfterDrawRooms(void);  // brooms.c
5198 hendricks2 76
void ResetBuildFAF(void);   // brooms.c
5196 hendricks2 77
 
78
 
79
// Jim's Vars
80
 
81
#define BUILD_DEV_VER   0   // True if this is the developer version of build.
82
 
83
 
84
// Idle time counter
85
//int  idleclock=0;        // How much time is spent not touching the keyboard.
86
//int    slackerclock=0;       // Accumulated no keyboard time, adds every 30 secs
87
//int    oldtotalclock=0;
88
 
89
// Sprite lists
90
int numsprite[MAXSPRITES], multisprite[MAXSPRITES];
91
 
92
// Next available tag tracking vars
93
short siNextTag = 1;                    // Shows next available tag if there
94
// is an open gap in tagging
95
short siNextEndTag = 1;                 // Shows the hightest possible next
96
// tag
97
 
98
int loaded_numwalls;
99
// Boolean flags used for sprite searching
5198 hendricks2 100
SWBOOL bFindPicNum = TRUE;                // Default
101
SWBOOL bFindHiTag = FALSE;
102
SWBOOL bFindLowTag = FALSE;
103
SWBOOL bVoxelsOn = TRUE;                  // Turn voxels on by default
104
SWBOOL bSpinBobVoxels = TRUE;             // Do twizzly stuff to voxels
105
SWBOOL bAutoSize = TRUE;                  // Autosizing on/off
5196 hendricks2 106
 
107
// Globals used to hold current sprite type being searched for.
108
short FindPicNum = 0;
109
short FindSpriteNum = 0;
110
 
111
// My Function Prototypes
112
void ContextHelp(short spritenum);
7499 hendricks2 113
void LoadKVXFromScript(const char *filename);
5196 hendricks2 114
 
5198 hendricks2 115
//void LogUserTime( SWBOOL bIsLoggingIn );
5196 hendricks2 116
 
117
// voxelarray format is:
118
//      spritenumber, voxelnumber
5226 hendricks2 119
extern int aVoxelArray[MAXTILES];
5196 hendricks2 120
 
121
// Ken ALT highlighted array
122
extern short highlightsector[MAXSECTORS];
123
extern short highlightsectorcnt;
124
 
125
 
126
int DispMono = FALSE;
127
 
128
//
129
// KENS setup variables
130
//
131
 
132
#define MAX_STAG_INFO 1024
133
typedef struct
134
{
135
    char name[64];
136
    int flags;
137
} STAG_INFO, *STAG_INFOp;
138
 
139
STAG_INFO StagInfo[MAX_STAG_INFO];
140
 
7499 hendricks2 141
void PrintStatus(const char *string, int num, char x, char y, char color);
5196 hendricks2 142
 
143
#define NUMOPTIONS 8
144
char option[NUMOPTIONS] = {0, 0, 0, 0, 0, 0, 1, 0};
5216 hendricks2 145
char default_buildkeys[NUMBUILDKEYS] =
5196 hendricks2 146
{
147
    0xc8, 0xd0, 0xcb, 0xcd, 0x2a, 0x9d, 0x1d, 0x39,
148
    0x1e, 0x2c, 0xd1, 0xc9, 0x33, 0x34,
8460 hendricks2 149
    0x9c, 0x1c, 0xd, 0xc, 0xf, 0x29
5196 hendricks2 150
};
151
 
152
extern short pointhighlight, linehighlight;
153
extern short asksave;
154
short ExtSectorTag[MAXSECTORS][4];
155
static char tempbuf[256];
156
char ds[256];
157
 
158
enum
159
{
160
    CAPTION_NONE,
161
    CAPTION_DEFAULT,
162
    CAPTION_NAMES,
163
    CAPTION_MOST,
164
    CAPTION_ALL,
165
    CAPTION_MAX,
166
};
167
short CaptionMode = CAPTION_NAMES;
168
 
169
 
170
// RIGHT ALT selection key
171
extern short highlightsector[MAXSECTORS];
172
extern short highlightsectorcnt;
173
 
174
// RIGHT SHIFT selection key
175
#define SPRITE_FLAG 16384
5215 hendricks2 176
extern short highlight[MAXWALLS+MAXSPRITES];       // sprite nums are + 16348
5196 hendricks2 177
extern short highlightcnt;
178
 
179
// Variables copied with the tab key
5215 hendricks2 180
extern int32_t temppicnum, tempcstat, templotag, temphitag, tempextra;
5196 hendricks2 181
 
182
void SectorMoveFloorZ(int);
183
void SectorMoveCeilingZ(int);
184
 
5198 hendricks2 185
void BuildStagTable(void);
7499 hendricks2 186
void Message(const char *string, char color);
5196 hendricks2 187
void ShowMessage(void);
188
void ShadeMenu(void);
189
void FindNextTag(void);
190
void ShowNextTag(void);
191
void FindSprite(short picnum, short findspritenum);
192
void FindNextSprite(short picnum);
193
void SetClipdist2D(void);
5198 hendricks2 194
void DrawClipBox(short spritenum);
5196 hendricks2 195
 
196
//printext16 parameters:
197
//printext16(int xpos, int ypos, short col, short backcol,
198
//           char name[82], char fontsize)
199
//  xpos 0-639   (top left)
200
//  ypos 0-479   (top left)
201
//  col 0-15
202
//  backcol 0-15, -1 is transparent background
203
//  name
204
//  fontsize 0=8*8, 1=3*5
205
 
206
//drawline16 parameters:
207
// drawline16(int x1, int y1, int x2, int y2, char col)
208
//  x1, x2  0-639
209
//  y1, y2  0-143  (status bar is 144 high, origin is top-left of STATUS BAR)
210
//  col     0-15
211
 
212
//Detecting 2D / 3D mode:
213
//   qsetmode is 200 in 3D mode
214
//   qsetmode is 350/480 in 2D mode
215
//
216
//You can read these variables when F5-F8 is pressed in 3D mode only:
217
//
218
//   If (searchstat == 0)  WALL        searchsector=sector, searchwall=wall
219
//   If (searchstat == 1)  CEILING     searchsector=sector
220
//   If (searchstat == 2)  FLOOR       searchsector=sector
221
//   If (searchstat == 3)  SPRITE      searchsector=sector, searchwall=sprite
222
//   If (searchstat == 4)  MASKED WALL searchsector=sector, searchwall=wall
223
//
224
//   searchsector is the sector of the selected item for all 5 searchstat's
225
//
226
//   searchwall is undefined if searchstat is 1 or 2
227
//   searchwall is the wall if searchstat = 0 or 4
228
//   searchwall is the sprite if searchstat = 3 (Yeah, I know - it says wall,
229
//                                      but trust me, it's the sprite number)
230
 
5198 hendricks2 231
void
232
ResetKeys(void)
5196 hendricks2 233
{
234
    unsigned i;
235
 
236
    for (i = 0; i < SIZ(keystatus); i++)
237
    {
238
        KEY_PRESSED(i) = 0;
239
    }
240
}
241
 
242
void ExtPreCheckKeys(void)
243
{
244
    ToggleFAF();
245
}
246
 
247
 
248
// Toggle sprites on/off.  Good for frame rate checks.
5198 hendricks2 249
SWBOOL DebugActorFreeze = 0;
5196 hendricks2 250
 
251
void
252
ToggleSprites()
253
{
254
    spritetype *tspr;
255
 
256
 
257
    DebugActorFreeze++;
258
    if (DebugActorFreeze > 2)
259
        DebugActorFreeze = 0;
260
 
261
    // Don't show any sprites, period
262
    if (DebugActorFreeze == 2)
263
    {
264
        short i;
265
 
266
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
267
        {
268
            SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
269
//                if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
270
//                {
271
//                    SET(tspr->extra, SPRX_BLOCK);
272
//                    RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
273
//                }
274
        }
275
    }
276
 
277
 
278
    // Show all sprites except actors and ST's
279
    if (DebugActorFreeze == 1)
280
    {
281
        short i;
282
 
283
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
284
        {
285
            switch (tspr->picnum)
286
            {
287
            case COOLIE_RUN_R0:
288
            case ZOMBIE_RUN_R0:
289
            case NINJA_RUN_R0:
290
            case SERP_RUN_R0:
291
            case LAVA_RUN_R0:
292
            case SKEL_RUN_R0:
293
            case GORO_RUN_R0:
294
            case HORNET_RUN_R0:
295
            case SKULL_R0:
296
            case RIPPER_RUN_R0:
297
            case 2307:                  // ST1
298
            case 2308:                  // ST2
299
            case 2309:                  // QJ
300
            case 2310:                  // QJD
301
            case 2311:                  // QSJ
302
            case 2312:                  // QSCN
303
            case 2313:                  // QEXIT
304
                SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
305
//                      if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
306
//                      {
307
//                          SET(tspr->extra, SPRX_BLOCK);
308
//                          RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
309
//                      }
310
                break;
311
            }
312
        }
313
    }
314
 
315
 
316
    // Show all sprites
317
    if (DebugActorFreeze == FALSE)
318
    {
319
        short i;
320
 
321
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
322
        {
323
            RESET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
324
//                if (TEST(tspr->extra, SPRX_BLOCK))
325
//                    SET(tspr->cstat, CSTAT_SPRITE_BLOCK);
326
        }
327
    }
328
}
329
 
330
 
331
void
8519 hendricks2 332
DoAutoSize(tspriteptr_t tspr)
5196 hendricks2 333
{
334
    short i;
335
 
336
    if (!bAutoSize)
337
        return;
338
 
339
    switch (tspr->picnum)
340
    {
341
    case ICON_STAR:                     // 1793
342
        break;
343
    case ICON_UZI:                      // 1797
344
        tspr->xrepeat = 43;
345
        tspr->yrepeat = 40;
346
        break;
347
    case ICON_UZIFLOOR:         // 1807
348
        tspr->xrepeat = 43;
349
        tspr->yrepeat = 40;
350
        break;
351
    case ICON_LG_UZI_AMMO:              // 1799
352
        break;
353
    case ICON_HEART:                    // 1824
354
        break;
355
    case ICON_HEART_LG_AMMO:            // 1820
356
        break;
357
    case ICON_GUARD_HEAD:               // 1814
358
        break;
359
    case ICON_FIREBALL_LG_AMMO: // 3035
360
        break;
361
    case ICON_ROCKET:                   // 1843
362
        break;
363
    case ICON_SHOTGUN:                  // 1794
364
        tspr->xrepeat = 57;
365
        tspr->yrepeat = 58;
366
        break;
367
    case ICON_LG_ROCKET:                // 1796
368
        break;
369
    case ICON_LG_SHOTSHELL:             // 1823
370
        break;
371
    case ICON_MICRO_GUN:                // 1818
372
        break;
373
    case ICON_MICRO_BATTERY:            // 1800
374
        break;
375
    case ICON_GRENADE_LAUNCHER: // 1817
376
        tspr->xrepeat = 54;
377
        tspr->yrepeat = 52;
378
        break;
379
    case ICON_LG_GRENADE:               // 1831
380
        break;
381
    case ICON_LG_MINE:                  // 1842
382
        break;
383
    case ICON_RAIL_GUN:         // 1811
384
        tspr->xrepeat = 50;
385
        tspr->yrepeat = 54;
386
        break;
387
    case ICON_RAIL_AMMO:                // 1812
388
        break;
389
    case ICON_SM_MEDKIT:                // 1802
390
        break;
391
    case ICON_MEDKIT:                   // 1803
392
        break;
393
    case ICON_CHEMBOMB:
394
        tspr->xrepeat = 64;
395
        tspr->yrepeat = 47;
396
        break;
397
    case ICON_FLASHBOMB:
398
        tspr->xrepeat = 32;
399
        tspr->yrepeat = 34;
400
        break;
401
    case ICON_NUKE:
402
        break;
403
    case ICON_CALTROPS:
404
        tspr->xrepeat = 37;
405
        tspr->yrepeat = 30;
406
        break;
407
    case ICON_BOOSTER:                  // 1810
408
        tspr->xrepeat = 30;
409
        tspr->yrepeat = 38;
410
        break;
411
    case ICON_HEAT_CARD:                // 1819
412
        tspr->xrepeat = 46;
413
        tspr->yrepeat = 47;
414
        break;
415
    case ICON_REPAIR_KIT:               // 1813
416
        break;
417
    case ICON_EXPLOSIVE_BOX:            // 1801
418
        break;
419
    case ICON_ENVIRON_SUIT:             // 1837
420
        break;
421
    case ICON_FLY:                      // 1782
422
        break;
423
    case ICON_CLOAK:                    // 1826
424
        break;
425
    case ICON_NIGHT_VISION:             // 3031
426
        tspr->xrepeat = 59;
427
        tspr->yrepeat = 71;
428
        break;
429
    case ICON_NAPALM:                   // 3046
430
        break;
431
    case ICON_RING:                     // 3050
432
        break;
433
    case ICON_RINGAMMO:         // 3054
434
        break;
435
    case ICON_NAPALMAMMO:               // 3058
436
        break;
437
    case ICON_GRENADE:                  // 3059
438
        break;
439
    case ICON_ARMOR:                    // 3030
440
        tspr->xrepeat = 82;
441
        tspr->yrepeat = 84;
442
        break;
443
    case BLUE_KEY:                      // 1766
444
        break;
445
    case RED_KEY:                       // 1770
446
        break;
447
    case GREEN_KEY:                     // 1774
448
        break;
449
    case YELLOW_KEY:                    // 1778
450
        break;
451
    case BLUE_CARD:
452
    case RED_CARD:
453
    case GREEN_CARD:
454
    case YELLOW_CARD:
455
        tspr->xrepeat = 36;
456
        tspr->yrepeat = 33;
457
        break;
458
    case GOLD_SKELKEY:
459
    case SILVER_SKELKEY:
460
    case BRONZE_SKELKEY:
461
    case RED_SKELKEY:
462
        tspr->xrepeat = 39;
463
        tspr->yrepeat = 45;
464
        break;
465
    case SKEL_LOCKED:
466
    case SKEL_UNLOCKED:
467
        tspr->xrepeat = 47;
468
        tspr->yrepeat = 40;
469
        break;
470
    case RAMCARD_LOCKED:
471
    case RAMCARD_UNLOCKED:
472
    case CARD_LOCKED:
473
    case CARD_UNLOCKED:
474
        break;
475
    default:
476
        break;
477
    }
478
}
479
 
480
// Rotation angles for sprites
481
short rotang = 0;
482
 
483
void
8455 hendricks2 484
ExtAnalyzeSprites(int32_t ourx, int32_t oury, int32_t ourz, int32_t oura, int32_t smoothr)
5196 hendricks2 485
{
486
    int i, currsprite;
8519 hendricks2 487
    tspriteptr_t tspr;
5196 hendricks2 488
 
5215 hendricks2 489
    UNREFERENCED_PARAMETER(ourx);
490
    UNREFERENCED_PARAMETER(oury);
8455 hendricks2 491
    UNREFERENCED_PARAMETER(ourz);
5215 hendricks2 492
    UNREFERENCED_PARAMETER(oura);
493
    UNREFERENCED_PARAMETER(smoothr);
5196 hendricks2 494
 
495
    rotang += 4;
496
    if (rotang > 2047)
497
        rotang = 0;
498
 
499
    for (i = 0, tspr = &tsprite[0]; i < spritesortcnt; i++, tspr++)
500
    {
501
 
502
        // Take care of autosizing
503
        DoAutoSize(tspr);
504
 
505
        tspr->shade += 6;
506
        if (sector[tspr->sectnum].ceilingstat & 1)
507
            tspr->shade += sector[tspr->sectnum].ceilingshade;
508
        else
509
            tspr->shade += sector[tspr->sectnum].floorshade;
510
 
511
        if (tspr->picnum == ICON_ARMOR)
512
        {
513
            if (tspr->pal != 19)        // Red
514
                tspr->pal = 17;         // Gray
515
        }
516
 
517
        // Check for voxels
8596 hendricks2 518
        if (bVoxelsOn && usevoxels && videoGetRenderMode() != REND_POLYMER)
5196 hendricks2 519
        {
520
            if (bSpinBobVoxels)
521
            {
522
                switch (tspr->picnum)
523
                {
524
                case ICON_STAR: // 1793
525
                case ICON_UZI:          // 1797
526
                case ICON_UZIFLOOR:     // 1807
527
                case ICON_LG_UZI_AMMO:  // 1799
528
                case ICON_HEART:        // 1824
529
                case ICON_HEART_LG_AMMO:        // 1820
530
                case ICON_GUARD_HEAD:   // 1814
531
                case ICON_FIREBALL_LG_AMMO:     // 3035
532
                case ICON_ROCKET:       // 1843
533
                case ICON_SHOTGUN:      // 1794
534
                case ICON_LG_ROCKET:    // 1796
535
                case ICON_LG_SHOTSHELL: // 1823
536
                case ICON_MICRO_GUN:    // 1818
537
                case ICON_MICRO_BATTERY:        // 1800
538
                case ICON_GRENADE_LAUNCHER:     // 1817
539
                case ICON_LG_GRENADE:   // 1831
540
                case ICON_LG_MINE:      // 1842
541
                case ICON_RAIL_GUN:     // 1811
542
                case ICON_RAIL_AMMO:    // 1812
543
                case ICON_SM_MEDKIT:    // 1802
544
                case ICON_MEDKIT:       // 1803
545
                case ICON_BOOSTER:      // 1810
546
                case ICON_HEAT_CARD:    // 1819
547
                case ICON_REPAIR_KIT:   // 1813
548
                case ICON_EXPLOSIVE_BOX:        // 1801
549
                case ICON_ENVIRON_SUIT: // 1837
550
                case ICON_FLY:          // 1782
551
                case ICON_CLOAK:        // 1826
552
                case ICON_NIGHT_VISION: // 3031
553
                case ICON_NAPALM:       // 3046
554
                case ICON_RING: // 3050
555
                // case ICON_GOROAMMO:       // 3035
556
                // case ICON_HEARTAMMO:      // 1820
557
                case ICON_RINGAMMO:     // 3054
558
                case ICON_NAPALMAMMO:   // 3058
559
                case ICON_GRENADE:      // 3059
560
                // case ICON_OXYGEN:         // 1800
561
                case ICON_ARMOR:        // 3030
562
                case BLUE_KEY:          // 1766
563
                case RED_KEY:           // 1770
564
                case GREEN_KEY: // 1774
565
                case YELLOW_KEY:        // 1778
566
                case ICON_CHEMBOMB:
567
                case ICON_FLASHBOMB:
568
                case ICON_NUKE:
569
                case ICON_CALTROPS:
570
                    tspr->ang = rotang;
571
                    // tspr->z+=(sintable[(rotang*2)%2047]/16);
572
                    break;
573
                }
574
            }
575
 
576
            if (aVoxelArray[tspr->picnum] >= 0)
577
            {
578
 
579
                // Turn on voxels
580
                tspr->picnum = aVoxelArray[tspr->picnum];       // Get the voxel number
581
                tspr->cstat |= 48;      // Set stat to voxelize sprite
582
            }
583
        }
584
    }
585
 
586
}
587
 
5198 hendricks2 588
uint8_t*
589
BKeyPressed(void)
5196 hendricks2 590
{
5198 hendricks2 591
    uint8_t* k;
5196 hendricks2 592
 
5198 hendricks2 593
    for (k = (uint8_t*) & KEY_PRESSED(0); k < (uint8_t*) &KEY_PRESSED(SIZ(keystatus)); k++)
5196 hendricks2 594
    {
595
        if (*k)
596
            return k;
597
    }
598
 
599
    return NULL;
600
}
601
 
5198 hendricks2 602
uint8_t*
603
KeyPressedRange(uint8_t* kb, uint8_t* ke)
5196 hendricks2 604
{
5198 hendricks2 605
    uint8_t* k;
5196 hendricks2 606
 
607
    for (k = kb; k <= ke; k++)
608
    {
609
        if (*k)
610
            return k;
611
    }
612
 
613
    return NULL;
614
}
615
 
5198 hendricks2 616
void
617
ResetKeyRange(uint8_t* kb, uint8_t* ke)
5196 hendricks2 618
{
5198 hendricks2 619
    uint8_t* k;
5196 hendricks2 620
 
621
    for (k = kb; k <= ke; k++)
622
    {
623
        *k = 0;
624
    }
625
}
626
 
627
#if 0
628
void
629
ExtInit(void)
630
{
631
    int i, fil;
632
 
5217 hendricks2 633
    initgroupfile(G_GrpFile());
5196 hendricks2 634
    if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
635
    {
636
        read(fil, &option[0], NUMOPTIONS);
5216 hendricks2 637
        read(fil, &default_buildkeys[0], NUMKEYS);
638
        memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS);     // Trick to make build
5196 hendricks2 639
        // use setup.dat keys
640
        close(fil);
641
    }
642
    if (option[4] > 0)
643
        option[4] = 0;
644
    initmouse();
645
 
646
    initengine();
647
    vidoption = option[0];
648
    xdim = vesares[option[6] & 15][0];
649
    ydim = vesares[option[6] & 15][1];
650
 
651
#if 0
652
    switch (option[0])
653
    {
654
    case 0:
655
        initengine(0, chainxres[option[6] & 15], chainyres[option[6] >> 4]);
656
        break;
657
    case 1:
658
        initengine(1, vesares[option[6] & 15][0], vesares[option[6] & 15][1]);
659
        break;
660
    default:
661
        initengine(option[0], 320L, 200L);
662
    }
663
#endif
664
 
665
    InitPalette();
666
 
667
    kensplayerheight = 58;
668
    zmode = 0;
669
 
670
}
671
 
672
#endif
673
 
7499 hendricks2 674
const char *startwin_labeltext = "Starting Build Editor for Shadow Warrior...";
5196 hendricks2 675
 
7537 hendricks2 676
const char *ExtGetVer(void)
677
{
678
    return s_buildRev;
679
}
680
 
7538 hendricks2 681
void ExtSetupMapFilename(const char *mapname)
682
{
683
    UNREFERENCED_PARAMETER(mapname);
684
}
685
 
7537 hendricks2 686
int32_t ExtPreInit(int32_t argc,char const * const * argv)
687
{
8269 hendricks2 688
    SW_ExtPreInit(argc, argv);
7537 hendricks2 689
 
690
    OSD_SetLogFile("wangulator.log");
8333 hendricks2 691
    char tempbuf[256];
692
    snprintf(tempbuf, ARRAY_SIZE(tempbuf), "%s %s", AppProperName, s_buildRev);
693
    OSD_SetVersion(tempbuf, 10,0);
8457 hendricks2 694
    buildprintf("%s\n", tempbuf);
7537 hendricks2 695
    PrintBuildInfo();
696
 
697
    return 0;
698
}
699
 
5196 hendricks2 700
int
701
ExtInit(void)
702
{
703
    int rv = 0;
704
 
705
#ifndef BUILD_DEV_VER
706
    char ch;
707
 
708
    printf("\n------------------------------------------------------------------------------\n");
709
    printf("BUILD.EXE for Shadow Warrior\n\n");
710
    printf("Copyright (c) 1993 - 1997, 3D Realms Entertainment.\n");
711
    printf("\n");
712
    printf("IMPORTANT:  This editor and associated tools and utilities are NOT\n");
713
    printf("shareware and may NOT be freely distributed to any BBS, CD, floppy, or\n");
714
    printf("any other media.  These tools may NOT be sold or repackaged for sale in\n");
715
    printf("a commercial product.\n");
716
    printf("\n");
717
    printf("Any levels created with these editors and tools may only be used with the\n");
718
    printf("full (registered) copy of Shadow Warrior, and not the shareware version.\n");
719
    printf("Please refer to LICENSE.DOC for further information on levels created with\n");
720
    printf("BUILD.EXE.\n");
721
    printf("\n");
722
    printf("Press <Y> if you have read and accepted the terms of LICENSE.DOC,\n");
723
    printf("or any other key to abort the program. \n");
724
    printf("\n");
725
    ch = getch();
726
 
727
    if (ch == 'y' || ch == 'Y')         // if user press Y
728
    {
729
#endif
730
 
731
 
732
    int i, fil;
733
 
734
    // Store user log in time
735
    //LogUserTime(TRUE);              // Send true because user is logging
736
    // in.
737
 
8333 hendricks2 738
    OSD_SetParameters(0, 0, 0, 4, 2, 4, "^14", "^14", 0);
5196 hendricks2 739
 
8269 hendricks2 740
    SW_ExtInit();
5196 hendricks2 741
 
742
    /*
743
        if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
744
            {
745
            read(fil, &option[0], NUMOPTIONS);
5216 hendricks2 746
            read(fil, &default_buildkeys[0], NUMKEYS);
747
            memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS); // Trick to make build
5196 hendricks2 748
            // use setup.dat keys
749
            close(fil);
750
            }
751
        */
8269 hendricks2 752
    bpp = 32;
753
    if (loadsetup(SETUPFILENAME) < 0)
754
        buildputs("Configuration file not found, using defaults.\n"), rv = 1;
5216 hendricks2 755
    Bmemcpy((void *)buildkeys,(void *)default_buildkeys,NUMBUILDKEYS);       //Trick to make build use setup.dat keys
5196 hendricks2 756
    if (option[4] > 0)
757
        option[4] = 0;
758
 
759
    kensplayerheight = 58;
760
    zmode = 0;
761
 
8330 hendricks2 762
    SW_ScanGroups();
763
 
8458 hendricks2 764
    wm_msgbox("Pre-Release Software Warning", "%s is not ready for public use. Proceed with caution!", AppProperName);
765
 
5196 hendricks2 766
#ifndef BUILD_DEV_VER
767
}                                   // end user press Y
768
else
769
{
770
    printf("------------------------------------------------------------------------------\n");
771
    exit(0);
772
}
773
#endif
774
    return rv;
775
}
776
 
7539 hendricks2 777
int32_t ExtPostStartupWindow(void)
778
{
8330 hendricks2 779
    SW_LoadGroups();
7539 hendricks2 780
 
8269 hendricks2 781
    if (!g_useCwd)
782
        SW_CleanupSearchPaths();
783
 
7539 hendricks2 784
    if (engineInit())
785
    {
786
        wm_msgbox("Build Engine Initialisation Error",
787
                  "There was a problem initialising the Build engine: %s", engineerrstr);
788
        return -1;
789
    }
790
 
791
    InitPalette();
792
    SW_InitMultiPsky();
793
 
794
    return 0;
795
}
796
 
5345 hendricks2 797
void ExtPostInit(void)
798
{
8469 hendricks2 799
    palettePostLoadLookups();
5345 hendricks2 800
}
5196 hendricks2 801
 
802
void
803
ExtUnInit(void)
804
{
805
    uninitgroupfile();
8269 hendricks2 806
    writesetup(SETUPFILENAME);
5196 hendricks2 807
    // Store user log in time
808
    //LogUserTime(FALSE);                 // FALSE means user is logging out
809
    // now.
810
}
811
 
5198 hendricks2 812
void
813
SetSpriteExtra(void)
5196 hendricks2 814
{
815
    SPRITEp sp;
816
    int i;
817
 
818
#define DEFAULT_SKILL 2
819
 
820
    // for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
821
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
822
    {
823
        if (sp->picnum == ST1)
824
        {
825
            if (sp->owner == -1)
826
                sp->owner = 0;
827
        }
828
        else
829
        {
830
            sp->owner = -1;
831
        }
832
 
833
        if (sp->extra == -1)
834
        {
835
            sp->extra = 0;
836
            SET(sp->extra, DEFAULT_SKILL);
837
        }
838
    }
839
 
840
    // loaded_numwalls is what numwalls is after a load
841
    // only new walls get their extra's set
842
    if (loaded_numwalls != numwalls)
843
    {
844
        for (i = 0; i < numwalls; i++)
845
        {
846
            if (wall[i].extra != 0)
847
                wall[i].extra = 0;
848
        }
849
    }
850
    loaded_numwalls = numwalls;
851
}
852
 
5198 hendricks2 853
void
854
ResetSpriteFound(void)
5196 hendricks2 855
{
856
    SPRITEp sp;
857
 
858
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
859
    {
860
        RESET(sp->extra, SPRX_FOUND);
861
    }
862
}
863
 
8477 hendricks2 864
static void Keys2D()
865
{
866
    if (PRESSED_KEYSC(G))  // G (grid on/off)
867
    {
868
        if (autogrid)
869
        {
870
            grid = 8*eitherSHIFT;
5196 hendricks2 871
 
8477 hendricks2 872
            autogrid = 0;
873
        }
874
        else
875
        {
876
            grid += (1-2*eitherSHIFT);
877
            if (grid == -1 || grid == 9)
878
            {
879
                autogrid = 1;
880
                grid = 0;
881
            }
882
        }
883
 
884
        if (autogrid)
885
            printmessage16("Grid size: 9 (autosize)");
886
        else if (!grid)
887
            printmessage16("Grid off");
888
        else
889
            printmessage16("Grid size: %d (%d units)", grid, 2048>>grid);
890
    }
891
 
892
    if (autogrid)
893
    {
894
        grid = -1;
895
 
896
        while (grid++ < 7)
897
        {
898
            if (mulscale14((2048>>grid), zoom) <= 16)
899
                break;
900
        }
901
    }
902
}
903
 
5196 hendricks2 904
// imported from allen code
5198 hendricks2 905
void
906
Keys3D(void)
5196 hendricks2 907
{
908
    int i;
909
 
910
    // 'PGUP - Move a floor/ceiling sector up 8 pixels.
911
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGUP])
912
    {
913
        switch (searchstat)
914
        {
915
        case 1:                 // Ceiling
916
            sector[searchsector].ceilingz -= (1024 * 8);
917
            keystatus[KEYSC_PGUP] = 0;
918
            break;
919
        case 2:                 // Floor
920
            sector[searchsector].floorz -= (1024 * 8);
921
            keystatus[KEYSC_PGUP] = 0;
922
            break;
923
        }
924
 
925
    }
926
 
927
    // 'PGDN - Move a floor/ceiling sector down 8 pixels.
928
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGDN])
929
    {
930
        switch (searchstat)
931
        {
932
        case 1:                 // Ceiling
933
            sector[searchsector].ceilingz += (1024 * 8);
934
            keystatus[KEYSC_PGDN] = 0;
935
            break;
936
        case 2:                 // Floor
937
            sector[searchsector].floorz += (1024 * 8);
938
            keystatus[KEYSC_PGDN] = 0;
939
            break;
940
        }
941
    }
942
 
943
 
944
 
945
    // R - Set relative mode on a floor/ceiling.
946
    if (!keystatus[KEYSC_ENTER] && !keystatus[KEYSC_QUOTE] && keystatus[KEYSC_R])
947
    {
948
        switch (searchstat)
949
        {
950
        case 0:
951
        case 4:                 // Wall
952
            break;
953
        case 1:                 // Ceiling
954
            if (sector[searchsector].ceilingstat & 65)
955
                Message("Ceiling Relative OFF", M_RED);
956
            else
957
                Message("Ceiling Relative ON", M_BLUE);
958
            break;
959
        case 2:                 // Floor
960
            if (sector[searchsector].floorstat & 65)
961
                Message("Floor Relative OFF", M_RED);
962
            else
963
                Message("Floor Relative ON", M_BLUE);
964
            break;
965
        case 3:                 // Sprite
966
            break;
967
        }
968
    }
969
 
970
    // '+  = Shade down a floor ceiling while keeping sprites constant
971
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GPLUS])
972
    {
5198 hendricks2 973
        SWBOOL dospriteshade = FALSE;
5196 hendricks2 974
 
975
        keystatus[KEYSC_GPLUS] = 0;
976
 
977
        switch (searchstat)
978
        {
979
        case 1:
980
            if (sector[searchsector].ceilingstat & 1)
981
                dospriteshade = TRUE;
982
            if (sector[searchsector].ceilingshade > -128)
983
                sector[searchsector].ceilingshade--;
984
            break;
985
        case 2:
986
            if (!(sector[searchsector].ceilingstat & 1))
987
                dospriteshade = TRUE;
988
            if (sector[searchsector].floorshade > -128)
989
                sector[searchsector].floorshade--;
990
            break;
991
        default:
992
            break;
993
        }
994
 
995
        if (dospriteshade)
996
        {
997
            for (i = 0; i < MAXSPRITES; i++)
998
            {
999
                if (sprite[i].sectnum == searchsector)
1000
                {
1001
                    if (sprite[i].shade < 127)
1002
                        sprite[i].shade++;
1003
                }
1004
            }
1005
        }
1006
    }
1007
 
1008
    // '-  = Shade down a floor ceiling while keeping sprites constant
1009
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GMINUS])
1010
    {
5198 hendricks2 1011
        SWBOOL dospriteshade = FALSE;
5196 hendricks2 1012
 
1013
        keystatus[KEYSC_GMINUS] = 0;
1014
 
1015
        switch (searchstat)
1016
        {
1017
        case 1:
1018
            if (sector[searchsector].ceilingstat & 1)
1019
                dospriteshade = TRUE;
1020
            if (sector[searchsector].ceilingshade < 127)
1021
                sector[searchsector].ceilingshade++;
1022
            break;
1023
        case 2:
1024
            if (!(sector[searchsector].ceilingstat & 1))
1025
                dospriteshade = TRUE;
1026
            if (sector[searchsector].floorshade < 127)
1027
                sector[searchsector].floorshade++;
1028
            break;
1029
        default:
1030
            break;
1031
        }
1032
 
1033
        if (dospriteshade)
1034
        {
1035
            for (i = 0; i < MAXSPRITES; i++)
1036
            {
1037
                if (sprite[i].sectnum == searchsector)
1038
                {
1039
                    if (sprite[i].shade > -128)
1040
                        sprite[i].shade--;
1041
                }
1042
            }
1043
        }
1044
    }
1045
 
1046
 
1047
    // 'ENTER - Copies only the bitmap in the copy buffer to
1048
    // wall/ceiling/floor/sprite,
1049
    // whatever the cursor is pointing to. Does not copy x/y repeats etc.,
1050
    // like ENTER does.
1051
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_ENTER])       // ' ENTER
1052
    {
1053
        printext256(0, 0, 15, 0, "Put Graphic ONLY", 0);
1054
        keystatus[KEYSC_ENTER] = 0;
1055
        switch (searchstat)
1056
        {
1057
        case 0:
1058
            wall[searchwall].picnum = temppicnum;
1059
            break;
1060
        case 1:
1061
            sector[searchsector].ceilingpicnum = temppicnum;
1062
            break;
1063
        case 2:
1064
            sector[searchsector].floorpicnum = temppicnum;
1065
            break;
1066
        case 3:
1067
            sprite[searchwall].picnum = temppicnum;
1068
            break;
1069
        case 4:
1070
            wall[searchwall].overpicnum = temppicnum;
1071
            break;
1072
        }
1073
    }
1074
 
1075
    // ;S
1076
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_S])    // ; S
1077
    {
1078
        keystatus[KEYSC_S] = 0;
1079
        switch (searchstat)
1080
        {
1081
 
1082
        case 0:
1083
        case 4:
1084
            for (i = 0; i < MAXWALLS; i++)
1085
            {
1086
                if (wall[i].picnum == temppicnum)
1087
                {
1088
                    wall[i].shade = tempshade;
1089
                }
1090
            }
1091
            break;
1092
        case 1:
1093
        case 2:
1094
            for (i = 0; i < MAXSECTORS; i++)
1095
            {
1096
                if (searchstat)
1097
                    if (sector[i].ceilingpicnum == temppicnum)
1098
                    {
1099
                        sector[i].ceilingshade = tempshade;
1100
                    }
1101
                if (searchstat == 2)
1102
                    if (sector[i].floorpicnum == temppicnum)
1103
                    {
1104
                        sector[i].floorshade = tempshade;
1105
                    }
1106
            }
1107
            break;
1108
        case 3:
1109
            for (i = 0; i < MAXSPRITES; i++)
1110
            {
1111
                if (sprite[i].picnum == temppicnum)
1112
                {
1113
                    sprite[i].shade = tempshade;
1114
                }
1115
            }
1116
            break;
1117
        }
1118
    }
1119
 
1120
    // 'C - Does a global tile replacement using bitmap only, no x/y repeat,
1121
    // etc....
1122
    // Works for walls, sectors, or sprites.
1123
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_C])   // ' C
1124
    {
1125
        short searchpicnum = 0;
1126
        short w, start_wall, end_wall, currsector;
1127
 
1128
        keystatus[KEYSC_C] = 0;
1129
 
1130
        switch (searchstat)
1131
        {
1132
 
1133
        case 0:
1134
        case 4:
1135
            searchpicnum = wall[searchwall].picnum;
1136
            if (highlightsectorcnt <= 0)
1137
            {
1138
                for (i = 0; i < MAXWALLS; i++)
1139
                {
1140
                    if (wall[i].picnum == searchpicnum)
1141
                    {
1142
                        wall[i].picnum = temppicnum;
1143
                    }
1144
                }
1145
            }
1146
            else
1147
            {
1148
                for (i = 0; i < highlightsectorcnt; i++)
1149
                {
1150
                    currsector = highlightsector[i];
1151
                    start_wall = sector[currsector].wallptr;
1152
                    end_wall = start_wall + sector[currsector].wallnum;
1153
 
1154
                    for (w = start_wall; w < end_wall; w++)
1155
                    {
1156
                        if (wall[w].picnum == searchpicnum)
1157
                            wall[w].picnum = temppicnum;
1158
                    }
1159
                }
1160
            }
1161
            break;
1162
        case 1:
1163
            if (highlightsectorcnt <= 0)
1164
            {
1165
                searchpicnum = sector[searchsector].ceilingpicnum;
1166
                for (i = 0; i < MAXSECTORS; i++)
1167
                {
1168
                    if (sector[i].ceilingpicnum == searchpicnum)
1169
                    {
1170
                        sector[i].ceilingpicnum = temppicnum;
1171
                    }
1172
                }
1173
            }
1174
            else
1175
            {
1176
                for (i = 0; i < highlightsectorcnt; i++)
1177
                {
1178
                    currsector = highlightsector[i];
1179
 
1180
                    if (sector[currsector].ceilingpicnum == searchpicnum)
1181
                        sector[currsector].ceilingpicnum = temppicnum;
1182
                }
1183
            }
7533 hendricks2 1184
            break;
5196 hendricks2 1185
        case 2:
1186
            searchpicnum = sector[searchsector].floorpicnum;
1187
            if (highlightsectorcnt <= 0)
1188
            {
1189
                for (i = 0; i < MAXSECTORS; i++)
1190
                {
1191
                    if (sector[i].floorpicnum == searchpicnum)
1192
                    {
1193
                        sector[i].floorpicnum = temppicnum;
1194
                    }
1195
                }
1196
            }
1197
            else
1198
            {
1199
                for (i = 0; i < highlightsectorcnt; i++)
1200
                {
1201
                    currsector = highlightsector[i];
1202
 
1203
                    if (sector[currsector].floorpicnum == searchpicnum)
1204
                        sector[currsector].floorpicnum = temppicnum;
1205
                }
1206
            }
1207
            break;
1208
        case 3:
1209
            searchpicnum = sprite[searchwall].picnum;
1210
 
1211
            if (highlightsectorcnt <= 0)
1212
            {
1213
                for (i = 0; i < MAXSPRITES; i++)
1214
                {
1215
                    if (sprite[i].picnum == searchpicnum)
1216
                        sprite[i].picnum = temppicnum;
1217
                }
1218
            }
1219
            break;
1220
        default:
1221
            break;
1222
        }
1223
    }
1224
 
1225
    // 'T - Set's the low tag of a wall/sector/sprite.
1226
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_T])   // ' T
1227
    {
1228
        keystatus[KEYSC_T] = 0;
1229
        switch (searchstat)
1230
        {
1231
        case 0:
1232
        case 4:
1233
            strcpy(tempbuf, "Wall lotag: ");
1234
            wall[searchwall].lotag =
1235
                getnumber256(tempbuf, wall[searchwall].lotag, 65536L, 1);
1236
            break;
1237
        case 1:
1238
        case 2:
1239
            strcpy(tempbuf, "Sector lotag: ");
1240
            sector[searchsector].lotag =
1241
                getnumber256(tempbuf, sector[searchsector].lotag, 65536L, 1);
1242
            break;
1243
        case 3:
1244
            strcpy(tempbuf, "Sprite lotag: ");
1245
            sprite[searchwall].lotag =
1246
                getnumber256(tempbuf, sprite[searchwall].lotag, 65536L, 1);
1247
            // Find the next lotag
1248
            if (sprite[searchwall].picnum == ST1)
1249
            {
1250
                FindNextTag();
1251
                ShowNextTag();
1252
            }
1253
 
1254
            break;
1255
        }
1256
    }
1257
 
1258
    // 'H - Sets the high tag of a wall/sector/sprite.
1259
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_H])   // ' H
1260
    {
1261
        keystatus[KEYSC_H] = 0;
1262
        switch (searchstat)
1263
        {
1264
        case 0:
1265
        case 4:
1266
            strcpy(tempbuf, "Wall hitag: ");
1267
            wall[searchwall].hitag =
1268
                getnumber256(tempbuf, wall[searchwall].hitag, 65536L, 1);
1269
            break;
1270
        case 1:
1271
        case 2:
1272
            strcpy(tempbuf, "Sector hitag: ");
1273
            sector[searchsector].hitag =
1274
                getnumber256(tempbuf, sector[searchsector].hitag, 65536L, 1);
1275
            break;
1276
        case 3:
1277
            strcpy(tempbuf, "Sprite hitag: ");
1278
            sprite[searchwall].hitag =
1279
                getnumber256(tempbuf, sprite[searchwall].hitag, 65536L, 1);
1280
            break;
1281
        }
1282
    }
1283
 
1284
    // 'S - Sets the shade of a wall/sector/sprite using an entered input
1285
    // value
1286
    // between 0-65536.
1287
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_S])   // ' S
1288
    {
1289
        keystatus[KEYSC_S] = 0;
1290
        switch (searchstat)
1291
        {
1292
        case 0:
1293
        case 4:
1294
            strcpy(tempbuf, "Wall shade: ");
1295
            wall[searchwall].shade =
1296
                getnumber256(tempbuf, wall[searchwall].shade, 65536L, 1);
1297
            break;
1298
        case 1:
1299
        case 2:
1300
            strcpy(tempbuf, "Sector shade: ");
1301
            if (searchstat == 1)
1302
                sector[searchsector].ceilingshade =
1303
                    getnumber256(tempbuf, sector[searchsector].ceilingshade, 65536L, 1);
1304
            if (searchstat == 2)
1305
                sector[searchsector].floorshade =
1306
                    getnumber256(tempbuf, sector[searchsector].floorshade, 65536L, 1);
1307
            break;
1308
        case 3:
1309
            strcpy(tempbuf, "Sprite shade: ");
1310
            sprite[searchwall].shade =
1311
                getnumber256(tempbuf, sprite[searchwall].shade, 65536L, 1);
1312
            break;
1313
        }
1314
    }
1315
 
1316
    // 'V - Sets sector visibility on a sector using an input value between
1317
    // 0-65536.
1318
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_V])   // ' V
1319
    {
1320
        keystatus[KEYSC_V] = 0;
1321
        switch (searchstat)
1322
        {
1323
        case 1:
1324
        case 2:
1325
            strcpy(tempbuf, "Sector visibility: ");
1326
            sector[searchsector].visibility =
1327
                getnumber256(tempbuf, sector[searchsector].visibility, 65536L, 1);
1328
            break;
1329
        }
1330
    }
1331
 
1332
    // 'X - Toggles voxel sprites on/off
1333
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_X])   // ' X
1334
    {
1335
        keystatus[KEYSC_X] = 0;
1336
 
1337
        bVoxelsOn = !bVoxelsOn;
1338
    }
1339
 
1340
    // 'Z - Toggles voxel rotation on/off
1341
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_Z])   // ' Z
1342
    {
1343
        keystatus[KEYSC_Z] = 0;
1344
 
1345
        bSpinBobVoxels = !bSpinBobVoxels;
1346
    }
1347
 
1348
    // 'A - Toggles sprite autosizing on/off
1349
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_A])   // ' A
1350
    {
1351
        keystatus[KEYSC_A] = 0;
1352
 
1353
        bAutoSize = !bAutoSize;
1354
    }
1355
 
1356
    // 'M - Toggles sprites on/off
1357
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_M])   // ' M
1358
    {
1359
        keystatus[KEYSC_M] = 0;
1360
 
1361
        ToggleSprites();
1362
    }
1363
 
1364
    // 'P - Will copy palette to all sectors highlighted with R-Alt key
1365
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_P])   // ' P
1366
    {
1367
        short w, start_wall, end_wall, currsector;
1368
 
1369
        keystatus[KEYSC_P] = 0;
1370
 
1371
        for (i = 0; i < highlightsectorcnt; i++)
1372
        {
1373
            currsector = highlightsector[i];
1374
            sector[currsector].ceilingpal = temppal;
1375
            sector[currsector].floorpal = temppal;
1376
            // Do all the walls in the sector
1377
            start_wall = sector[currsector].wallptr;
1378
            end_wall = start_wall + sector[currsector].wallnum;
1379
 
1380
            for (w = start_wall; w < end_wall; w++)
1381
            {
1382
                wall[w].pal = temppal;
1383
            }
1384
        }
1385
    }
1386
 
1387
    // ;P - Will copy palette to all sectors highlighted with R-Alt key
1388
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_P])   // ; P
1389
    {
1390
        short w, start_wall, end_wall, currsector;
1391
 
1392
        keystatus[KEYSC_P] = 0;
1393
 
1394
        for (i = 0; i < highlightsectorcnt; i++)
1395
        {
1396
            currsector = highlightsector[i];
1397
 
1398
            if ((sector[currsector].ceilingpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1399
                sector[currsector].ceilingshade = 127;
1400
            if ((sector[currsector].floorpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1401
                sector[currsector].floorshade = 127;
1402
 
1403
            // Do all the walls in the sector
1404
            start_wall = sector[currsector].wallptr;
1405
            end_wall = start_wall + sector[currsector].wallnum;
1406
 
1407
            for (w = start_wall; w < end_wall; w++)
1408
            {
1409
                if ((wall[w].pal == temppal && temppal != 0) || (temppal == 0 && wall[w].pal != 0))
1410
                    wall[w].shade = 127;
1411
            }
1412
        }
1413
    }
1414
 
1415
    ShowMessage();
1416
}                                   // end Keys3D()
1417
 
1418
// Used to help print out the item status list
1419
void
7499 hendricks2 1420
PrintStatus(const char *string, int num, char x, char y, char color)
5196 hendricks2 1421
{
1422
    sprintf(tempbuf, "%s %d", string, num);
1423
    printext16(x * 8, ydim16+y * 8, color, -1, tempbuf, 0);
1424
}
1425
 
5214 hendricks2 1426
 
1427
static int32_t sw_getnumber256(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1428
{
1429
    return _getnumber256(namestart, num, maxnumber, sign, NULL);
1430
}
1431
static int32_t sw_getnumber16(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1432
{
1433
    return _getnumber16(namestart, num, maxnumber, sign, NULL);
1434
}
1435
static void sw_printmessage256(const char *text)
1436
{
1437
    printmessage256(0, 0, text);
1438
}
1439
static void sw_printmessage16(const char *text)
1440
{
8050 pogokeen 1441
    lastpm16time = (int32_t) totalclock;
7553 hendricks2 1442
    _printmessage16("%s", text);
5214 hendricks2 1443
}
1444
 
5198 hendricks2 1445
void
5196 hendricks2 1446
MoreKeys(short searchstat, short searchwall, short searchsector, short pointhighlight)
1447
{
1448
 
5214 hendricks2 1449
    typedef int32_t GET_NUM_FUNC (const char *, int32_t, int32_t, char);
5196 hendricks2 1450
    typedef GET_NUM_FUNC *GET_NUM_FUNCp;
5214 hendricks2 1451
    typedef void PRINT_MSG_FUNC (const char *);
5196 hendricks2 1452
    typedef PRINT_MSG_FUNC *PRINT_MSG_FUNCp;
1453
    SPRITEp sp;
1454
 
1455
    int i;
1456
    int value;
1457
 
1458
    GET_NUM_FUNCp getnumber;
1459
    PRINT_MSG_FUNCp printmessage;
1460
 
8476 hendricks2 1461
    if (in3dmode())
5196 hendricks2 1462
    {
5214 hendricks2 1463
        getnumber = sw_getnumber256;
1464
        printmessage = sw_printmessage256;
5196 hendricks2 1465
    }
1466
    else
1467
    {
5214 hendricks2 1468
        getnumber = sw_getnumber16;
1469
        printmessage = sw_printmessage16;
5196 hendricks2 1470
 
1471
        if (TEST(pointhighlight, SPRITE_FLAG))
1472
        {
1473
            searchstat = 3;
1474
            searchwall = RESET(pointhighlight, SPRITE_FLAG);
1475
        }
1476
        else
1477
        {
1478
            // for now make search stat invalid
1479
            searchstat = 5;
1480
        }
1481
    }
1482
 
1483
    sp = &sprite[searchwall];
1484
 
1485
 
1486
 
5228 hendricks2 1487
    if (KEY_PRESSED(KEYSC_RALT) && KEY_PRESSED(KEYSC_RCTRL))
5196 hendricks2 1488
    {
1489
        if (KEY_PRESSED(KEYSC_KPMINUS))
1490
        {
1491
            KEY_PRESSED(KEYSC_KPMINUS) = 0;
5207 hendricks2 1492
            g_visibility = g_visibility - (g_visibility >> 3);
5196 hendricks2 1493
 
5207 hendricks2 1494
            if (g_visibility < 0)
1495
                g_visibility = 16348;
5196 hendricks2 1496
        }
1497
        else if (KEY_PRESSED(KEYSC_KPPLUS))
1498
        {
1499
            KEY_PRESSED(KEYSC_KPPLUS) = 0;
5207 hendricks2 1500
            g_visibility = g_visibility + (g_visibility >> 3);
5196 hendricks2 1501
 
5207 hendricks2 1502
            if (g_visibility > 16348)
1503
                g_visibility = 0;
5196 hendricks2 1504
        }
1505
    }
1506
 
1507
 
1508
    if (keystatus[KEYSC_QUOTE])
1509
    {
1510
 
1511
        if (keystatus[KEYSC_K])   // ' K
1512
        {
1513
            short data;
1514
            SPRITEp sp = &sprite[searchwall];
1515
 
1516
            keystatus[KEYSC_K] = 0;
1517
            switch (searchstat)
1518
            {
1519
            case 3:
1520
                data = TEST(sp->extra, SPRX_SKILL);
1521
 
1522
                //data = getnumber256(tempbuf, data, 65536L);
1523
                data++; // Toggle
1524
 
1525
                if (data > 3)
1526
                    data = 0;
1527
 
1528
                RESET(sp->extra, SPRX_SKILL);
1529
                SET(sp->extra, data);
1530
                break;
1531
            }
1532
        }
1533
 
1534
        if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1535
        {
1536
            if (keystatus[KEYSC_1])
1537
            {
1538
                keystatus[KEYSC_1] = 0;
1539
                keystatus[KEYSC_SEMI] = 0;
1540
 
1541
                switch (searchstat)
1542
                {
1543
                case 3:
1544
                    sprintf(tempbuf, "Sprite tag 11 (shade) (snum = %d): ", searchwall);
1545
                    SPRITE_TAG11(searchwall) =
1546
                        getnumber(tempbuf, SPRITE_TAG11(searchwall), 65536L, 0);
1547
                    break;
1548
                }
1549
 
5218 hendricks2 1550
                printmessage(" ");
5196 hendricks2 1551
            }
1552
 
1553
            if (keystatus[KEYSC_2])
1554
            {
1555
                keystatus[KEYSC_2] = 0;
1556
                keystatus[KEYSC_SEMI] = 0;
1557
 
1558
                switch (searchstat)
1559
                {
1560
                case 3:
1561
                    strcpy(tempbuf, "Sprite tag 12 (pal): ");
1562
                    SPRITE_TAG12(searchwall) =
1563
                        getnumber(tempbuf, SPRITE_TAG12(searchwall), 65536L, 0);
1564
                    break;
1565
                }
1566
 
5218 hendricks2 1567
                printmessage(" ");
5196 hendricks2 1568
            }
1569
 
1570
            if (keystatus[KEYSC_3])
1571
            {
1572
                keystatus[KEYSC_3] = 0;
1573
 
1574
                switch (searchstat)
1575
                {
1576
                case 3:
1577
                    strcpy(tempbuf, "Sprite tag 13 (xoffset/yoffset): ");
1578
                    i = getnumber(tempbuf, SPRITE_TAG13(searchwall), 65536L, 0);
1579
                    SET_SPRITE_TAG13(searchwall, i);
1580
                    break;
1581
                }
1582
 
5218 hendricks2 1583
                printmessage(" ");
5196 hendricks2 1584
            }
1585
 
1586
            if (keystatus[KEYSC_4])
1587
            {
1588
                keystatus[KEYSC_4] = 0;
1589
 
1590
                switch (searchstat)
1591
                {
1592
                case 3:
1593
                    strcpy(tempbuf, "Sprite tag 14 (xrepeat/yrepeat): ");
1594
                    i = getnumber(tempbuf, SPRITE_TAG14(searchwall), 65536L, 0);
1595
                    SET_SPRITE_TAG14(searchwall, i);
1596
                    break;
1597
                }
1598
 
5218 hendricks2 1599
                printmessage(" ");
5196 hendricks2 1600
            }
1601
 
1602
            if (keystatus[KEYSC_5])
1603
            {
1604
                keystatus[KEYSC_5] = 0;
1605
 
1606
                switch (searchstat)
1607
                {
1608
                case 3:
1609
                    strcpy(tempbuf, "Sprite tag 15 (z): ");
1610
                    SPRITE_TAG15(searchwall) =
1611
                        getnumber(tempbuf, SPRITE_TAG15(searchwall), 65536L, 0);
1612
                    break;
1613
                }
1614
 
5218 hendricks2 1615
                printmessage(" ");
5196 hendricks2 1616
            }
1617
        }
1618
 
1619
        if (keystatus[KEYSC_1])
1620
        {
1621
            keystatus[KEYSC_1] = 0;
1622
 
1623
            switch (searchstat)
1624
            {
1625
            case 0:
1626
            case 4:
1627
                strcpy(tempbuf, "Wall tag 1 (hitag): ");
1628
                wall[searchwall].hitag =
1629
                    getnumber(tempbuf, wall[searchwall].hitag, 65536L, 0);
1630
                break;
1631
            case 1:
1632
            case 2:
1633
                strcpy(tempbuf, "Sector tag 1 (hitag): ");
1634
                sector[searchsector].hitag =
1635
                    getnumber(tempbuf, sector[searchsector].hitag, 65536L, 0);
1636
                break;
1637
            case 3:
1638
                strcpy(tempbuf, "Sprite tag 1 (hitag): ");
1639
                SPRITE_TAG1(searchwall) =
1640
                    getnumber(tempbuf, SPRITE_TAG1(searchwall), 65536L, 0);
1641
                break;
1642
            }
1643
 
5218 hendricks2 1644
            printmessage(" ");
5196 hendricks2 1645
        }
1646
 
1647
        if (keystatus[KEYSC_2])
1648
        {
1649
            keystatus[KEYSC_2] = 0;
1650
 
1651
            switch (searchstat)
1652
            {
1653
            case 0:
1654
            case 4:
1655
                strcpy(tempbuf, "Wall tag 2 (lotag): ");
1656
                wall[searchwall].lotag =
1657
                    getnumber(tempbuf, wall[searchwall].lotag, 65536L, 0);
1658
                break;
1659
            case 1:
1660
            case 2:
1661
                strcpy(tempbuf, "Sector tag 2 (lotag): ");
1662
                sector[searchsector].lotag =
1663
                    getnumber(tempbuf, sector[searchsector].lotag, 65536L, 0);
1664
                break;
1665
            case 3:
1666
                strcpy(tempbuf, "Sprite tag 2 (lotag): ");
1667
                SPRITE_TAG2(searchwall) =
1668
                    getnumber(tempbuf, SPRITE_TAG2(searchwall), 65536L, 0);
1669
                // Find the next lotag
1670
                if (sprite[searchwall].picnum == ST1)
1671
                {
1672
                    FindNextTag();
1673
                    ShowNextTag();
1674
                }
1675
                break;
1676
            }
5218 hendricks2 1677
            printmessage(" ");
5196 hendricks2 1678
        }
1679
 
1680
        if (keystatus[KEYSC_3])
1681
        {
1682
            keystatus[KEYSC_3] = 0;
1683
 
1684
            switch (searchstat)
1685
            {
1686
            case 0:
1687
            case 4:
1688
                strcpy(tempbuf, "Wall tag 3 (xpanning): ");
1689
                wall[searchwall].xpanning =
1690
                    getnumber(tempbuf, wall[searchwall].xpanning, 65536L, 0);
1691
                break;
1692
            case 1:
1693
            case 2:
1694
                strcpy(tempbuf, "Sector tag 3 (ceilingxpanning): ");
1695
                sector[searchsector].ceilingxpanning =
1696
                    getnumber(tempbuf, sector[searchsector].ceilingxpanning, 65536L, 0);
1697
                break;
1698
            case 3:
1699
                strcpy(tempbuf, "Sprite tag 3 (clipdist) : ");
1700
                SPRITE_TAG3(searchwall) =
1701
                    getnumber(tempbuf, SPRITE_TAG3(searchwall), 65536L, 0);
1702
 
1703
                break;
1704
            }
5218 hendricks2 1705
            printmessage(" ");
5196 hendricks2 1706
        }
1707
 
1708
        if (keystatus[KEYSC_4])
1709
        {
1710
            keystatus[KEYSC_4] = 0;
1711
 
1712
            switch (searchstat)
1713
            {
1714
            case 0:
1715
            case 4:
1716
                strcpy(tempbuf, "Wall tag 4 (ypanning): ");
1717
                wall[searchwall].ypanning =
1718
                    getnumber(tempbuf, wall[searchwall].ypanning, 65536L, 0);
1719
                break;
1720
            case 1:
1721
            case 2:
1722
                strcpy(tempbuf, "Sector tag 4 (ceilingypanning): ");
1723
                sector[searchsector].ceilingypanning =
1724
                    getnumber(tempbuf, sector[searchsector].ceilingypanning, 65536L, 0);
1725
                break;
1726
            case 3:
1727
                strcpy(tempbuf, "Sprite tag 4 (ang) : ");
1728
                SPRITE_TAG4(searchwall) =
1729
                    getnumber(tempbuf, SPRITE_TAG4(searchwall), 65536L, 0);
1730
                break;
1731
            }
5218 hendricks2 1732
            printmessage(" ");
5196 hendricks2 1733
        }
1734
 
1735
        if (keystatus[KEYSC_5])
1736
        {
1737
            keystatus[KEYSC_5] = 0;
1738
 
1739
            switch (searchstat)
1740
            {
1741
            case 0:
1742
            case 4:
1743
                break;
1744
            case 1:
1745
            case 2:
1746
                strcpy(tempbuf, "Sector tag 5 (floorxpanning): ");
1747
                sector[searchsector].floorxpanning =
1748
                    getnumber(tempbuf, sector[searchsector].floorxpanning, 65536L, 0);
1749
                break;
1750
            case 3:
1751
                strcpy(tempbuf, "Sprite tag 5 (xvel) : ");
1752
                SPRITE_TAG5(searchwall) =
1753
                    getnumber(tempbuf, SPRITE_TAG5(searchwall), 65536L, 0);
1754
                break;
1755
            }
5218 hendricks2 1756
            printmessage(" ");
5196 hendricks2 1757
        }
1758
 
1759
        if (keystatus[KEYSC_6])
1760
        {
1761
            keystatus[KEYSC_6] = 0;
1762
 
1763
            switch (searchstat)
1764
            {
1765
            case 0:
1766
            case 4:
1767
                break;
1768
            case 1:
1769
            case 2:
1770
                strcpy(tempbuf, "Sector tag 6 (floorypanning): ");
1771
                sector[searchsector].floorypanning =
1772
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1773
                break;
1774
            case 3:
1775
                strcpy(tempbuf, "Sprite tag 6 (yvel) : ");
1776
                SPRITE_TAG6(searchwall) =
1777
                    getnumber(tempbuf, SPRITE_TAG6(searchwall), 65536L, 0);
1778
                break;
1779
            }
5218 hendricks2 1780
            printmessage(" ");
5196 hendricks2 1781
        }
1782
 
1783
        if (keystatus[KEYSC_7])
1784
        {
1785
            keystatus[KEYSC_7] = 0;
1786
 
1787
            switch (searchstat)
1788
            {
1789
            case 0:
1790
            case 4:
1791
                break;
1792
            case 1:
1793
            case 2:
1794
                strcpy(tempbuf, "Sector tag 7 (floorypanning): ");
1795
                sector[searchsector].floorypanning =
1796
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1797
                break;
1798
            case 3:
1799
                strcpy(tempbuf, "Sprite tag 7 (zvel 1) <0-255> : ");
1800
                SPRITE_TAG7(searchwall) =
1801
                    getnumber(tempbuf, SPRITE_TAG7(searchwall), 65536L, 0);
1802
                break;
1803
            }
5218 hendricks2 1804
            printmessage(" ");
5196 hendricks2 1805
        }
1806
 
1807
        if (keystatus[KEYSC_8])
1808
        {
1809
            keystatus[KEYSC_8] = 0;
1810
 
1811
            switch (searchstat)
1812
            {
1813
            case 0:
1814
            case 4:
1815
                break;
1816
            case 1:
1817
            case 2:
1818
                break;
1819
            case 3:
1820
                strcpy(tempbuf, "Sprite tag 8 (zvel 2) <0-255> : ");
1821
                SPRITE_TAG8(searchwall) =
1822
                    getnumber(tempbuf, SPRITE_TAG8(searchwall), 65536L, 0);
1823
                break;
1824
            }
5218 hendricks2 1825
            printmessage(" ");
5196 hendricks2 1826
        }
1827
 
1828
        if (keystatus[KEYSC_9])
1829
        {
1830
            keystatus[KEYSC_9] = 0;
1831
 
1832
            switch (searchstat)
1833
            {
1834
            case 0:
1835
            case 4:
1836
                break;
1837
            case 1:
1838
            case 2:
1839
                break;
1840
            case 3:
1841
                strcpy(tempbuf, "Sprite tag 9 (owner 1) <0-255> : ");
1842
                SPRITE_TAG9(searchwall) =
1843
                    getnumber(tempbuf, SPRITE_TAG9(searchwall), 65536L, 0);
1844
                break;
1845
            }
5218 hendricks2 1846
            printmessage(" ");
5196 hendricks2 1847
        }
1848
 
1849
        if (keystatus[KEYSC_0])
1850
        {
1851
            keystatus[KEYSC_0] = 0;
1852
 
1853
            switch (searchstat)
1854
            {
1855
            case 0:
1856
            case 4:
1857
                break;
1858
            case 1:
1859
            case 2:
1860
                break;
1861
            case 3:
1862
                strcpy(tempbuf, "Sprite tag 10 (owner 2) <0-255> : ");
1863
                SPRITE_TAG10(searchwall) =
1864
                    getnumber(tempbuf, SPRITE_TAG10(searchwall), 65536L, 0);
1865
                break;
1866
            }
5218 hendricks2 1867
            printmessage(" ");
5196 hendricks2 1868
        }
1869
 
1870
    }
1871
 
1872
    if (!keystatus[KEYSC_SEMI])
1873
        return;
1874
 
1875
    if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1876
    {
1877
        if (keystatus[KEYSC_1])
1878
        {
1879
            keystatus[KEYSC_1] = 0;
1880
 
1881
            switch (searchstat)
1882
            {
1883
            case 3:
1884
                strcpy(tempbuf, "Boolean Sprite tag 11 (0 or 1): ");
1885
                value = !!TEST_BOOL11(sp);
1886
                value = getnumber(tempbuf, value, 65536L, 0);
1887
 
1888
                if (value)
1889
                    SET_BOOL11(sp);
1890
                else
1891
                    RESET_BOOL11(sp);
1892
 
1893
                break;
1894
            }
1895
 
5218 hendricks2 1896
            printmessage(" ");
5196 hendricks2 1897
        }
1898
    }
1899
    else
1900
    {
1901
        if (keystatus[KEYSC_1])
1902
        {
1903
            keystatus[KEYSC_1] = 0;
1904
 
1905
            switch (searchstat)
1906
            {
1907
            case 3:
1908
                strcpy(tempbuf, "Boolean Sprite tag 1 (0 or 1): ");
1909
                value = !!TEST_BOOL1(sp);
1910
                value = getnumber(tempbuf, value, 65536L, 0);
1911
 
1912
                if (value)
1913
                    SET_BOOL1(sp);
1914
                else
1915
                    RESET_BOOL1(sp);
1916
 
1917
                break;
1918
            }
1919
 
5218 hendricks2 1920
            printmessage(" ");
5196 hendricks2 1921
        }
1922
 
1923
        if (keystatus[KEYSC_2])
1924
        {
1925
            keystatus[KEYSC_2] = 0;
1926
 
1927
            switch (searchstat)
1928
            {
1929
            case 3:
1930
                strcpy(tempbuf, "Boolean Sprite tag 2 (0 or 1): ");
1931
                value = !!TEST_BOOL2(sp);
1932
                value = getnumber(tempbuf, value, 65536L, 0);
1933
 
1934
                if (value)
1935
                    SET_BOOL2(sp);
1936
                else
1937
                    RESET_BOOL2(sp);
1938
 
1939
                break;
1940
            }
1941
 
5218 hendricks2 1942
            printmessage(" ");
5196 hendricks2 1943
        }
1944
 
1945
 
1946
        if (keystatus[KEYSC_3])
1947
        {
1948
            keystatus[KEYSC_3] = 0;
1949
 
1950
            switch (searchstat)
1951
            {
1952
            case 3:
1953
                strcpy(tempbuf, "Boolean Sprite tag 3 (0 or 1): ");
1954
                value = !!TEST_BOOL3(sp);
1955
                value = getnumber(tempbuf, value, 65536L, 0);
1956
 
1957
                if (value)
1958
                    SET_BOOL3(sp);
1959
                else
1960
                    RESET_BOOL3(sp);
1961
 
1962
                break;
1963
            }
1964
 
5218 hendricks2 1965
            printmessage(" ");
5196 hendricks2 1966
        }
1967
 
1968
        if (keystatus[KEYSC_4])
1969
        {
1970
            keystatus[KEYSC_4] = 0;
1971
 
1972
            switch (searchstat)
1973
            {
1974
            case 3:
1975
                strcpy(tempbuf, "Boolean Sprite tag 4 (0 or 1): ");
1976
                value = !!TEST_BOOL4(sp);
1977
                value = getnumber(tempbuf, value, 65536L, 0);
1978
 
1979
                if (value)
1980
                    SET_BOOL4(sp);
1981
                else
1982
                    RESET_BOOL4(sp);
1983
 
1984
                break;
1985
            }
1986
 
5218 hendricks2 1987
            printmessage(" ");
5196 hendricks2 1988
        }
1989
 
1990
        if (keystatus[KEYSC_5])
1991
        {
1992
            keystatus[KEYSC_5] = 0;
1993
 
1994
            switch (searchstat)
1995
            {
1996
            case 3:
1997
                strcpy(tempbuf, "Boolean Sprite tag 5 (0 or 1): ");
1998
                value = !!TEST_BOOL5(sp);
1999
                value = getnumber(tempbuf, value, 65536L, 0);
2000
 
2001
                if (value)
2002
                    SET_BOOL5(sp);
2003
                else
2004
                    RESET_BOOL5(sp);
2005
 
2006
                break;
2007
            }
2008
 
5218 hendricks2 2009
            printmessage(" ");
5196 hendricks2 2010
        }
2011
 
2012
        if (keystatus[KEYSC_6])
2013
        {
2014
            keystatus[KEYSC_6] = 0;
2015
 
2016
            switch (searchstat)
2017
            {
2018
            case 3:
2019
                strcpy(tempbuf, "Boolean Sprite tag 6 (0 or 1): ");
2020
                value = !!TEST_BOOL6(sp);
2021
                value = getnumber(tempbuf, value, 65536L, 0);
2022
 
2023
                if (value)
2024
                    SET_BOOL6(sp);
2025
                else
2026
                    RESET_BOOL6(sp);
2027
 
2028
                break;
2029
            }
2030
 
5218 hendricks2 2031
            printmessage(" ");
5196 hendricks2 2032
        }
2033
 
2034
        if (keystatus[KEYSC_7])
2035
        {
2036
            keystatus[KEYSC_7] = 0;
2037
 
2038
            switch (searchstat)
2039
            {
2040
            case 3:
2041
                strcpy(tempbuf, "Boolean Sprite tag 7 (0 or 1): ");
2042
                value = !!TEST_BOOL7(sp);
2043
                value = getnumber(tempbuf, value, 65536L, 0);
2044
 
2045
                if (value)
2046
                    SET_BOOL7(sp);
2047
                else
2048
                    RESET_BOOL7(sp);
2049
 
2050
                break;
2051
            }
2052
 
5218 hendricks2 2053
            printmessage(" ");
5196 hendricks2 2054
        }
2055
 
2056
        if (keystatus[KEYSC_8])
2057
        {
2058
            keystatus[KEYSC_8] = 0;
2059
 
2060
            switch (searchstat)
2061
            {
2062
            case 3:
2063
                strcpy(tempbuf, "Boolean Sprite tag 8 (0 or 1): ");
2064
                value = !!TEST_BOOL8(sp);
2065
                value = getnumber(tempbuf, value, 65536L, 0);
2066
 
2067
                if (value)
2068
                    SET_BOOL8(sp);
2069
                else
2070
                    RESET_BOOL8(sp);
2071
 
2072
                break;
2073
            }
2074
 
5218 hendricks2 2075
            printmessage(" ");
5196 hendricks2 2076
        }
2077
 
2078
        if (keystatus[KEYSC_9])
2079
        {
2080
            keystatus[KEYSC_9] = 0;
2081
 
2082
            switch (searchstat)
2083
            {
2084
            case 3:
2085
                strcpy(tempbuf, "Boolean Sprite tag 9 (0 or 1): ");
2086
                value = !!TEST_BOOL9(sp);
2087
                value = getnumber(tempbuf, value, 65536L, 0);
2088
 
2089
                if (value)
2090
                    SET_BOOL9(sp);
2091
                else
2092
                    RESET_BOOL9(sp);
2093
 
2094
                break;
2095
            }
2096
 
5218 hendricks2 2097
            printmessage(" ");
5196 hendricks2 2098
        }
2099
 
2100
        if (keystatus[KEYSC_0])
2101
        {
2102
            keystatus[KEYSC_0] = 0;
2103
 
2104
            switch (searchstat)
2105
            {
2106
            case 3:
2107
                strcpy(tempbuf, "Boolean Sprite tag 10 (0 or 1): ");
2108
                value = !!TEST_BOOL10(sp);
2109
                value = getnumber(tempbuf, value, 65536L, 0);
2110
 
2111
                if (value)
2112
                    SET_BOOL10(sp);
2113
                else
2114
                    RESET_BOOL10(sp);
2115
 
2116
                break;
2117
            }
2118
 
5218 hendricks2 2119
            printmessage(" ");
5196 hendricks2 2120
        }
2121
    }
2122
}
2123
 
2124
 
2125
#define COINCURSOR 2440
2126
 
2127
int intro;
2128
void
2129
ExtCheckKeysNotice(void)
2130
{
2131
#if 0
8476 hendricks2 2132
    if (in3dmode())
5196 hendricks2 2133
    {
2134
        if (intro < 600)
2135
        {
2136
            intro++;
2137
            sprintf(tempbuf, BUILD_VER_MSG);
2138
            printext256(46 * 8, (24 * 8) - 1, 0, -1, tempbuf, 1);
2139
            printext256(46 * 8, 24 * 8, 15, -1, tempbuf, 1);
2140
            rotatesprite((320 - 8) << 16, (200 - 8) << 16, 64 << 9, 0, COINCURSOR + (((4 - totalclock >> 3)) & 7), 0, 0, 0, 0, 0, xdim - 1, ydim - 1);
2141
        }
2142
    }
2143
#endif
2144
}                                   // end
2145
 
2146
void
2147
ExtCheckKeys(void)
2148
{
2149
    extern short f_c;
2150
 
2151
//  int ticdiff=0;
2152
 
2153
    // Display BUILD notice
2154
    ExtCheckKeysNotice();
2155
 
2156
    FAF_AfterDrawRooms();
2157
 
2158
    // try it every time through the loop
2159
    SetSpriteExtra();
5207 hendricks2 2160
    sector[0].extra = g_visibility;
5196 hendricks2 2161
 
2162
//  if(!BKeyPressed())
2163
//      ticdiff = totalclock-oldtotalclock;  // Difference in tics from last time
2164
 
2165
//  oldtotalclock = totalclock; // Set old clock to new time
2166
 
2167
//  slackerclock += ticdiff;
2168
//  ticdiff = 0;            // Set it back to 0!
2169
 
2170
 
8476 hendricks2 2171
    if (in3dmode())
5196 hendricks2 2172
    {
2173
#define AVERAGEFRAMES 16
2174
        static int frameval[AVERAGEFRAMES], framecnt = 0;
2175
        int i;
2176
 
8050 pogokeen 2177
        i = (int32_t) totalclock;
5196 hendricks2 2178
        if (i != frameval[framecnt])
2179
        {
2180
            sprintf(tempbuf, "%d", ((120 * AVERAGEFRAMES) / (i - frameval[framecnt])) + f_c);
2181
            printext256(0L, 0L, 1, -1, tempbuf, 1);
2182
            frameval[framecnt] = i;
2183
        }
2184
        framecnt = ((framecnt + 1) & (AVERAGEFRAMES - 1));
2185
 
2186
    }
2187
 
2188
    MoreKeys(searchstat, searchwall, searchsector, pointhighlight);
2189
 
8476 hendricks2 2190
    if (in3dmode())
5196 hendricks2 2191
    {
2192
        Keys3D();
2193
 
2194
        if (KEY_PRESSED(KEYSC_W))
2195
        {
2196
            KEY_PRESSED(KEYSC_W) = 0;
2197
 
2198
            switch (searchstat)
2199
            {
2200
            case 0:
2201
            case 4:
2202
                wall[searchwall].picnum = temppicnum;
2203
                break;
2204
            case 1:
2205
                sector[searchsector].ceilingpicnum = temppicnum;
2206
                break;
2207
            case 2:
2208
                sector[searchsector].floorpicnum = temppicnum;
2209
                break;
2210
            case 3:
2211
                sprite[searchwall].picnum = temppicnum;
2212
                break;
2213
            }
2214
        }
2215
 
2216
        // calling this twice seems to speed up the movement
2217
        editinput();
2218
        editinput();
2219
    }
2220
    else
2221
    {
8477 hendricks2 2222
        Keys2D();
5196 hendricks2 2223
 
2224
        if (KEY_PRESSED(KEYSC_QUOTE) && KEY_PRESSED(KEYSC_M))
2225
        {
2226
            KEY_PRESSED(KEYSC_M) = FALSE;
2227
            ShadeMenu();
2228
        }
2229
 
2230
        // greater than & less than keys
2231
//        if (KEY_PRESSED(KEYSC_COMMA) || KEY_PRESSED(KEYSC_PERIOD))
2232
//            {
2233
//            KEY_PRESSED(KEYSC_COMMA) = KEY_PRESSED(KEYSC_PERIOD) = FALSE;
2234
//            }
2235
 
2236
        // c for clip boxes
2237
        // will find out
2238
        if (KEY_PRESSED(KEYSC_QUOTE) && KEY_PRESSED(KEYSC_V))
2239
        {
2240
            KEY_PRESSED(KEYSC_V) = FALSE;
2241
            CaptionMode++;
2242
            if (CaptionMode >= CAPTION_MAX)
2243
                CaptionMode = 0;
2244
        }
2245
 
2246
        if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_D])
2247
        {
2248
            keystatus[KEYSC_D] = 0;
2249
            SetClipdist2D();
2250
        }
2251
 
2252
    }
8484 hendricks2 2253
 
2254
    if ((in3dmode() && !m32_is2d3dmode()) || m32_is2d3dmode())
2255
    {
2256
#ifdef USE_OPENGL
2257
        int bakrendmode = rendmode;
2258
 
2259
        if (m32_is2d3dmode())
2260
            rendmode = REND_CLASSIC;
2261
#endif
2262
 
2263
        m32_showmouse();
2264
 
2265
#ifdef USE_OPENGL
2266
        rendmode = bakrendmode;
2267
#endif
2268
    }
5196 hendricks2 2269
}
2270
 
2271
void
2272
ExtLoadMap(const char *mapname)
2273
{
2274
    SPRITEp sp;
2275
    int i;
2276
 
2277
    BuildStagTable();
2278
 
2279
    SetSpriteExtra();
2280
 
2281
 
2282
#if 0
2283
    Old visibility New visibility
2284
    8->16384
2285
    9->8192
2286
    10->4096
2287
    11->2048
2288
    12->1024
2289
    13->512
2290
    14->256
2291
    15->128
2292
#endif
2293
 
2294
    // if in valid range set visiblity for the map
2295
    if (sector[0].extra != -1 && sector[0].extra > 0 && sector[0].extra < 16384)
5207 hendricks2 2296
        g_visibility = sector[0].extra;
5196 hendricks2 2297
 
2298
    else
2299
        // if NOT in valid range set a default
5207 hendricks2 2300
        g_visibility = 2;
5196 hendricks2 2301
 
2302
    // Load up voxel sprites from voxel script file
2303
    //LoadKVXFromScript("swvoxfil.txt");
2304
    loaded_numwalls = numwalls;
2305
}
2306
 
2307
void
2308
ExtSaveMap(const char *mapname)
2309
{
2310
    SPRITEp sp;
2311
    int i;
2312
 
2313
    SetSpriteExtra();
2314
    ResetSpriteFound();
2315
 
2316
    for (i = 0; i < MAXWALLS; i++)
2317
    {
2318
        if (wall[i].extra != 0)
2319
            wall[i].extra = 0;
2320
    }
2321
}
2322
 
2323
const char *
2324
ExtGetSectorCaption(short sectnum)
2325
{
2326
    if ((sector[sectnum].lotag | sector[sectnum].hitag) == 0)
2327
    {
2328
        tempbuf[0] = 0;
2329
    }
2330
    else
2331
    {
7500 hendricks2 2332
        sprintf(tempbuf, "%d,%d", TrackerCast(sector[sectnum].hitag),
2333
                TrackerCast(sector[sectnum].lotag));
5196 hendricks2 2334
    }
2335
    return tempbuf;
2336
}
2337
 
2338
const char *
2339
ExtGetWallCaption(short wallnum)
2340
{
2341
    if ((wall[wallnum].lotag | wall[wallnum].hitag) == 0)
2342
    {
2343
        tempbuf[0] = 0;
2344
    }
2345
    else
2346
    {
7500 hendricks2 2347
        sprintf(tempbuf, "%d,%d", TrackerCast(wall[wallnum].hitag),
2348
                TrackerCast(wall[wallnum].lotag));
5196 hendricks2 2349
    }
2350
    return tempbuf;
2351
}
2352
 
2353
const char *
2354
ExtGetSpriteCaption(short spritenum)
2355
{
2356
    SPRITEp sp = &sprite[spritenum];
7499 hendricks2 2357
    const char *p = "";
7534 hendricks2 2358
    char name[66];
5196 hendricks2 2359
    char tp[30];
2360
    char multi_str[30] = "";
5198 hendricks2 2361
    int16_t data;
5196 hendricks2 2362
 
2363
    data = TEST(sp->extra, SPRX_SKILL);
2364
 
2365
    // Non ST1 sprites that are tagged like them
2366
    if (TEST_BOOL1(sp) && sp->picnum != ST1)
2367
    {
5219 hendricks2 2368
        if ((uint16_t)SP_TAG1(sp) > 1006)
5196 hendricks2 2369
            sprintf(name, "Invalid Tag");
2370
        else
2371
            sprintf(name, "%s,", StagInfo[SP_TAG1(sp)].name);   // This page faults if
2372
        // invalid #
2373
 
2374
        p = name;
2375
    }
2376
    else
2377
        switch (sp->picnum)
2378
        {
2379
        case ST1:
5219 hendricks2 2380
            if ((uint16_t)SP_TAG1(sp) > 1006)
5196 hendricks2 2381
                sprintf(name, "Invalid Tag");
2382
            else
2383
                sprintf(name, "*%s,", StagInfo[SP_TAG1(sp)].name);
2384
            p = name;
2385
            break;
2386
        case ST_QUICK_JUMP:
2387
            p = "QJ,";
2388
            break;
2389
        case ST_QUICK_JUMP_DOWN:
2390
            p = "QJD,";
2391
            break;
2392
        case ST_QUICK_SUPER_JUMP:
2393
            p = "QSJ,";
2394
            break;
2395
        case ST_QUICK_EXIT:
2396
            p = "QEXIT,";
2397
            break;
2398
        case ST_QUICK_SCAN:
2399
            p = "QSCAN,";
2400
            break;
2401
        case ST_QUICK_OPERATE:
2402
            p = "QOPERATE,";
2403
            break;
2404
        case ST_QUICK_DUCK:
2405
            p = "QDUCK,";
2406
            break;
2407
        case ST_QUICK_DEFEND:
2408
            p = "QDEFEND,";
2409
            break;
2410
        case NINJA_RUN_R0:
2411
            p = "NINJA,";
2412
            break;
2413
        case GORO_RUN_R0:
2414
            p = "GAURD,";
2415
            break;
2416
        case COOLIE_RUN_R0:
2417
            p = "COOLIE,";
2418
            break;
2419
        case COOLG_RUN_R0:
2420
            p = "GHOST,";
2421
            break;
2422
        case RIPPER_RUN_R0:
2423
            p = "RIPPER,";
2424
            break;
2425
        case SKEL_RUN_R0:
2426
            p = "SKEL,";
2427
            break;
2428
        case HORNET_RUN_R0:
2429
            p = "HORNET,";
2430
            break;
2431
        case SERP_RUN_R0:
2432
            p = "SERP,";
2433
            break;
2434
        case SKULL_R0:
2435
            p = "SKULL,";
2436
            break;
2437
 
2438
        case ICON_STAR:
2439
            p = "STAR,";
2440
            break;
2441
        case ICON_LG_MINE:
2442
            p = "LG_MINE,";
2443
            break;
2444
        case ICON_GRENADE_LAUNCHER:
2445
            p = "GRENADE_LAUNCHER,";
2446
            break;
2447
        case ICON_LG_GRENADE:
2448
            p = "LG_GRENADE,";
2449
            break;
2450
        case ICON_MICRO_GUN:
2451
            p = "MICRO_GUN,";
2452
            break;
2453
        case ICON_MICRO_BATTERY:
2454
            p = "MICRO_BATTERY,";
2455
            break;
2456
        case ICON_SHOTGUN:
2457
            p = "RIOT_GUN,";
2458
            break;
2459
        case ICON_LG_SHOTSHELL:
2460
            p = "LG_SHOTSHELL,";
2461
            break;
2462
        case ICON_ROCKET:
2463
            p = "ROCKET,";
2464
            break;
2465
        case ICON_LG_ROCKET:
2466
            p = "LG_ROCKET,";
2467
            break;
2468
        case ICON_UZI:
2469
            p = "UZI,";
2470
            break;
2471
        case ICON_UZIFLOOR:
2472
            p = "UZI_FLOOR,";
2473
            break;
2474
        case ICON_LG_UZI_AMMO:
2475
            p = "LG_UZI_AMMO,";
2476
            break;
2477
        case ICON_GUARD_HEAD:
2478
            p = "FIRE,";
2479
            break;
2480
        case ICON_HEART:
2481
            p = "HEART,";
2482
            break;
2483
        case ICON_HEART_LG_AMMO:
2484
            p = "HEART_LG_AMMO,";
2485
            break;
2486
 
2487
        case ICON_SPELL:
2488
            p = "SPELL,";
2489
            break;
2490
        case ICON_EXPLOSIVE_BOX:
2491
            p = "CRATE,";
2492
            break;
2493
        case ICON_SM_MEDKIT:
2494
            p = "FIRST_AID,";
2495
            break;
2496
        case ICON_MEDKIT:
2497
            p = "MEDKIT,";
2498
            break;
2499
        case ICON_CHEMBOMB:
2500
            p = "CHEM_BOMB,";
2501
            break;
2502
        case ICON_FLASHBOMB:
2503
            p = "FLASH_BOMB,";
2504
            break;
2505
        case ICON_NUKE:
2506
            p = "NUKE_BOMB,";
2507
            break;
2508
        case ICON_CALTROPS:
2509
            p = "CALTROPS,";
2510
            break;
2511
        case ICON_BOOSTER:
2512
            p = "BOT_HEALTH,";
2513
            break;
2514
        case ICON_HEAT_CARD:
2515
            p = "HEAT_SEEKERS,";
2516
            break;
2517
//    case ICON_ENVIRON_SUIT:
2518
//        p = "EVIRON_SUIT,";
2519
//        break;
2520
        case ICON_CLOAK:
2521
            p = "SMOKE_BOMB,";
2522
            break;
2523
        case ICON_FLY:
2524
            p = "FLY,";
2525
            break;
2526
        case ICON_GOROAMMO:
2527
            p = "GAURDAMMO,";
2528
            break;
2529
        case ICON_RAIL_GUN:
2530
            p = "RAIL_GUN,";
2531
            break;
2532
        case ICON_RAIL_AMMO:
2533
            p = "RAIL_AMMO,";
2534
            break;
2535
        case ICON_REPAIR_KIT:
2536
            p = "REPAIR_KIT,";
2537
            break;
2538
        /*
2539
         * case ICON_GAUNTAMMO: p = "GAUNTAMMO,"; break;
2540
         */
2541
        case ICON_RINGAMMO:
2542
            p = "RINGAMMO,";
2543
            break;
2544
        case ICON_NAPALMAMMO:
2545
            p = "NAPALMAMMO,";
2546
            break;
2547
        case ICON_GRENADE:
2548
            p = "GRENADE,";
2549
            break;
2550
        case ICON_NIGHT_VISION:
2551
            p = "NIGHT_VISION,";
2552
            break;
2553
        case ICON_ARMOR:
2554
            p = "ARMOR,";
2555
            break;
2556
        case SKEL_LOCKED:
2557
            p = "SKELETON KEY LOCK,";
2558
            switch (sp->hitag)
2559
            {
2560
            case 1:
2561
                sp->pal = PALETTE_PLAYER9;
2562
                break;
2563
            case 2:
2564
                sp->pal = PALETTE_PLAYER7;
2565
                break;
2566
            case 3:
2567
                sp->pal = PALETTE_PLAYER6;
2568
                break;
2569
            case 4:
2570
                sp->pal = PALETTE_PLAYER4;
2571
                break;
2572
            case 5:
2573
                sp->pal = PALETTE_PLAYER4;
2574
                break;
2575
            case 6:
2576
                sp->pal = PALETTE_PLAYER1;
2577
                break;
2578
            case 7:
2579
                sp->pal = PALETTE_PLAYER8;
2580
                break;
2581
            case 8:
2582
                sp->pal = PALETTE_PLAYER9;
2583
                break;
2584
            }
2585
            break;
2586
        case RAMCARD_LOCKED:
2587
            p = "RAM CARD LOCK,";
2588
            switch (sp->hitag)
2589
            {
2590
            case 1:
2591
                sp->pal = PALETTE_PLAYER9;
2592
                break;
2593
            case 2:
2594
                sp->pal = PALETTE_PLAYER7;
2595
                break;
2596
            case 3:
2597
                sp->pal = PALETTE_PLAYER6;
2598
                break;
2599
            case 4:
2600
                sp->pal = PALETTE_PLAYER4;
2601
                break;
2602
            case 5:
2603
                sp->pal = PALETTE_PLAYER4;
2604
                break;
2605
            case 6:
2606
                sp->pal = PALETTE_PLAYER1;
2607
                break;
2608
            case 7:
2609
                sp->pal = PALETTE_PLAYER8;
2610
                break;
2611
            case 8:
2612
                sp->pal = PALETTE_PLAYER9;
2613
                break;
2614
            }
2615
            break;
2616
        case CARD_LOCKED:
2617
            p = "CARD KEY LOCK,";
2618
            switch (sp->hitag)
2619
            {
2620
            case 1:
2621
                sp->pal = PALETTE_PLAYER9;
2622
                break;
2623
            case 2:
2624
                sp->pal = PALETTE_PLAYER7;
2625
                break;
2626
            case 3:
2627
                sp->pal = PALETTE_PLAYER6;
2628
                break;
2629
            case 4:
2630
                sp->pal = PALETTE_PLAYER4;
2631
                break;
2632
            case 5:
2633
                sp->pal = PALETTE_PLAYER4;
2634
                break;
2635
            case 6:
2636
                sp->pal = PALETTE_PLAYER1;
2637
                break;
2638
            case 7:
2639
                sp->pal = PALETTE_PLAYER8;
2640
                break;
2641
            case 8:
2642
                sp->pal = PALETTE_PLAYER9;
2643
                break;
2644
            }
2645
            break;
2646
        case RED_KEY:
2647
            p = "RED KEY,";
2648
            sp->pal = PALETTE_PLAYER9;  // Hard set the palette
2649
            break;
2650
        case BLUE_KEY:
2651
            p = "BLUE KEY,";
2652
            sp->pal = PALETTE_PLAYER7;  // Hard set the palette
2653
            break;
2654
        case GREEN_KEY:
2655
            p = "GREEN KEY,";
2656
            sp->pal = PALETTE_PLAYER6;  // Hard set the palette
2657
            break;
2658
        case YELLOW_KEY:
2659
            p = "YEL KEY,";
2660
            sp->pal = PALETTE_PLAYER4;  // Hard set the palette
2661
            break;
2662
        case RED_CARD:
2663
            p = "RED CARD,";
2664
            sp->pal = PALETTE_PLAYER9;  // Hard set the palette
2665
            break;
2666
        case BLUE_CARD:
2667
            p = "BLUE CARD,";
2668
            sp->pal = PALETTE_PLAYER7;  // Hard set the palette
2669
            break;
2670
        case GREEN_CARD:
2671
            p = "GREEN CARD,";
2672
            sp->pal = PALETTE_PLAYER6;  // Hard set the palette
2673
            break;
2674
        case YELLOW_CARD:
2675
            p = "YEL CARD,";
2676
            sp->pal = PALETTE_PLAYER4;  // Hard set the palette
2677
            break;
2678
        case SILVER_SKELKEY:
2679
            p = "SILVER SKELKEY,";
2680
            sp->pal = PALETTE_PLAYER1;  // Hard set the palette
2681
            break;
2682
        case GOLD_SKELKEY:
2683
            p = "GOLD SKELKEY,";
2684
            sp->pal = PALETTE_PLAYER4;  // Hard set the palette
2685
            break;
2686
        case BRONZE_SKELKEY:
2687
            p = "BRONZE SKELKEY,";
2688
            sp->pal = PALETTE_PLAYER8;  // Hard set the palette
2689
            break;
2690
        case RED_SKELKEY:
2691
            p = "RED SKELKEY,";
2692
            sp->pal = PALETTE_PLAYER9;  // Hard set the palette
2693
            break;
2694
        case RED_KEY_STATUE:
2695
            p = "RED STAT,";
2696
            break;
2697
        case BLUE_KEY_STATUE:
2698
            p = "BLUE STAT,";
2699
            break;
2700
        case GREEN_KEY_STATUE:
2701
            p = "GREEN STAT,";
2702
            break;
2703
        case YELLOW_KEY_STATUE:
2704
            p = "YEL STAT,";
2705
            break;
2706
        default:
2707
            p = "";
2708
            break;
2709
        }
2710
 
2711
    if (sp->picnum != ST1)
2712
    {
2713
        if (sp->lotag == TAG_SPRITE_HIT_MATCH)
2714
        {
2715
            p = "TAG_SPRITE_HIT_MATCH";
2716
        }
2717
 
2718
        // multi
2719
        if (TEST(sp->extra, SPRX_MULTI_ITEM))
2720
            strcpy(multi_str, "MULTI,");
2721
    }
2722
 
2723
    // track
2724
    if (sp->picnum >= TRACK_SPRITE && sp->picnum < TRACK_SPRITE + 100)
2725
    {
2726
        sprintf(tp, "T%d,", sp->picnum - TRACK_SPRITE);
2727
        p = tp;
2728
    }
2729
 
2730
    switch (CaptionMode)
2731
    {
2732
    case CAPTION_NONE:
2733
        tempbuf[0] = 0;
2734
        break;
2735
 
2736
    case CAPTION_DEFAULT:
2737
        if ((sprite[spritenum].lotag | sprite[spritenum].hitag) == 0)
2738
            //tempbuf[0] = NULL;
2739
            sprintf(tempbuf, "S:%d", data);
2740
        else
7500 hendricks2 2741
            sprintf(tempbuf, "S:%d,%d,%d", data, TrackerCast(sprite[spritenum].hitag), TrackerCast(sprite[spritenum].lotag));
5196 hendricks2 2742
        break;
2743
 
2744
 
2745
    case CAPTION_NAMES:
2746
        // Show clip boxes in default mode
2747
        if (sp->hitag == SO_CLIP_BOX)
2748
            DrawClipBox(spritenum);
2749
        if (sp->hitag == SECT_SO_CLIP_DIST)
2750
            DrawClipBox(spritenum);
2751
 
2752
        if ((sprite[spritenum].lotag | sprite[spritenum].hitag) == 0)
2753
            sprintf(tempbuf, "S:%d,%s%s", data, p, multi_str);
2754
        else
2755
            // name and numbers - name only prints if not null string
7500 hendricks2 2756
            sprintf(tempbuf, "%s%s%d,%d", p, multi_str, TrackerCast(sprite[spritenum].hitag), TrackerCast(sprite[spritenum].lotag));
5196 hendricks2 2757
 
2758
        break;
2759
 
2760
    case CAPTION_MOST:
2761
        if ((sprite[spritenum].lotag | sprite[spritenum].hitag) == 0)
2762
            sprintf(tempbuf, "%s%s", p, multi_str);
2763
        else
2764
            sprintf(tempbuf, "%s%s%d,%d,%d,%d,%d,%d", p, multi_str,
7525 hendricks2 2765
                    TrackerCast(SPRITE_TAG1(spritenum)),
2766
                    TrackerCast(SPRITE_TAG2(spritenum)),
2767
                    TrackerCast(SPRITE_TAG3(spritenum)),
2768
                    TrackerCast(SPRITE_TAG4(spritenum)),
2769
                    TrackerCast(SPRITE_TAG5(spritenum)),
2770
                    TrackerCast(SPRITE_TAG6(spritenum)));
5196 hendricks2 2771
        break;
2772
 
2773
    case CAPTION_ALL:
2774
//            if (sp->hitag == SO_CLIP_BOX)
2775
//                DrawClipBox(spritenum);
2776
 
2777
        if ((sprite[spritenum].lotag | sprite[spritenum].hitag) == 0)
2778
            sprintf(tempbuf, "%s%s", p, multi_str);
2779
        else
2780
            sprintf(tempbuf, "%s%s%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", p, multi_str,
7525 hendricks2 2781
                    TrackerCast(SPRITE_TAG1(spritenum)),
2782
                    TrackerCast(SPRITE_TAG2(spritenum)),
2783
                    TrackerCast(SPRITE_TAG3(spritenum)),
2784
                    TrackerCast(SPRITE_TAG4(spritenum)),
2785
                    TrackerCast(SPRITE_TAG5(spritenum)),
2786
                    TrackerCast(SPRITE_TAG6(spritenum)),
5196 hendricks2 2787
                    SPRITE_TAG7(spritenum),
2788
                    SPRITE_TAG8(spritenum),
2789
                    SPRITE_TAG9(spritenum),
2790
                    SPRITE_TAG10(spritenum));
2791
        break;
2792
    }
2793
 
2794
 
2795
    return tempbuf;
2796
}
2797
 
5198 hendricks2 2798
void
5196 hendricks2 2799
SectorMidPoint(short sectnum, int *xmid, int *ymid, int *zmid)
2800
{
2801
    short startwall, endwall, j;
2802
    int xsum = 0, ysum = 0;
2803
    WALLp wp;
2804
 
2805
    startwall = sector[sectnum].wallptr;
2806
    endwall = startwall + sector[sectnum].wallnum - 1;
2807
 
2808
    for (wp = &wall[startwall], j = startwall; j <= endwall; wp++, j++)
2809
    {
2810
        xsum += wp->x;
2811
        ysum += wp->y;
2812
    }
2813
 
2814
    *xmid = xsum / (endwall - startwall + 1);
2815
    *ymid = ysum / (endwall - startwall + 1);
2816
 
2817
    *zmid = DIV2(sector[sectnum].floorz + sector[sectnum].ceilingz);
2818
}
2819
 
5198 hendricks2 2820
void
5196 hendricks2 2821
DrawClipBox(short spritenum)
2822
{
5227 hendricks2 2823
    int x = 0, y = 0, z;
5196 hendricks2 2824
    int radius;
2825
    extern int zoom;
2826
 
2827
    if (sprite[spritenum].hitag == SO_CLIP_BOX)
2828
    {
5201 hendricks2 2829
        x = mulscale14(sprite[spritenum].x - pos.x, zoom);
2830
        y = mulscale14(sprite[spritenum].y - pos.y, zoom);
5196 hendricks2 2831
    }
2832
    else if (sprite[spritenum].hitag == SECT_SO_CLIP_DIST)
2833
    {
2834
        SectorMidPoint(sprite[spritenum].sectnum,&x, &y, &z);
5201 hendricks2 2835
        x = mulscale14(x - pos.x, zoom);
2836
        y = mulscale14(y - pos.y, zoom);
5196 hendricks2 2837
    }
2838
 
2839
    x += 320;
2840
    y += 200;
2841
 
2842
    radius = mulscale14(sprite[spritenum].lotag, zoom);
2843
 
2844
#define BOX_COLOR 3
2845
    // upper
7509 hendricks2 2846
    editorDraw2dLine(x - radius, y - radius, x + radius, y - radius, BOX_COLOR);
5196 hendricks2 2847
    // lower
7509 hendricks2 2848
    editorDraw2dLine(x - radius, y + radius, x + radius, y + radius, BOX_COLOR);
5196 hendricks2 2849
    // left
7509 hendricks2 2850
    editorDraw2dLine(x - radius, y - radius, x - radius, y + radius, BOX_COLOR);
5196 hendricks2 2851
    // right
7509 hendricks2 2852
    editorDraw2dLine(x + radius, y - radius, x + radius, y + radius, BOX_COLOR);
5196 hendricks2 2853
}
2854
 
2855
void
2856
ExtShowSectorData(short sectnum)        // F5
2857
{
2858
    int i, x, y, x2;
2859
 
8476 hendricks2 2860
    if (in3dmode())
5196 hendricks2 2861
        return;
2862
 
2863
    clearmidstatbar16();                // Clear middle of status bar
2864
 
2865
 
2866
//  if (keystatus[KEYSC_F5] )
2867
//  {
2868
    KEY_PRESSED(KEYSC_F5) = 0;
2869
    for (i = 0; i < MAXSPRITES; i++)
2870
        numsprite[i] = 0;
2871
    for (i = 0; i < MAXSPRITES; i++)
2872
        multisprite[i] = 0;
2873
    for (i = 0; i < MAXSPRITES; i++)
2874
    {
2875
        if (sprite[i].statnum == 0)
2876
        {
2877
            if (TEST(sprite[i].extra, SPRX_MULTI_ITEM))
2878
            {
2879
                if (sprite[i].picnum == ICON_UZIFLOOR)
2880
                    multisprite[ICON_UZI]++;
2881
                else
2882
                    multisprite[sprite[i].picnum]++;
2883
 
2884
            }
2885
            else
2886
            {
2887
                if (sprite[i].picnum == ICON_UZIFLOOR)
2888
                    numsprite[ICON_UZI]++;
2889
                else
2890
                    numsprite[sprite[i].picnum]++;
2891
            }
2892
        }
2893
    }
2894
 
2895
 
2896
    clearmidstatbar16();                // Clear middle of status bar
2897
 
2898
    x = 1;
2899
    x2 = 14;
2900
    y = 4;
2901
    printext16(x * 8, ydim16+y * 8, 11, -1, "Item Count", 0);
2902
    PrintStatus("10%Health=", numsprite[ICON_SM_MEDKIT], x, y + 2, 11);
2903
    PrintStatus("", multisprite[ICON_SM_MEDKIT], x2, y + 2, 1);
2904
    PrintStatus("HealthBot=", numsprite[ICON_BOOSTER], x, y + 3, 11);
2905
    PrintStatus("", multisprite[ICON_BOOSTER], x2, y + 3, 1);
2906
    PrintStatus("Armor    =", numsprite[ICON_ARMOR], x, y + 4, 11);
2907
    PrintStatus("", multisprite[ICON_ARMOR], x2, y + 4, 1);
2908
 
2909
    x = 17;
2910
    x2 = 30;
2911
    y = 4;
2912
    printext16(x * 8, ydim16+y * 8, 11, -1, "Inventory", 0);
2913
    PrintStatus("Med-Kit  =", numsprite[ICON_MEDKIT], x, y + 2, 11);
2914
    PrintStatus("", multisprite[ICON_MEDKIT], x2, y + 2, 1);
2915
    PrintStatus("Bio_Suit =", numsprite[ICON_ENVIRON_SUIT], x, y + 3, 11);
2916
    PrintStatus("", multisprite[ICON_ENVIRON_SUIT], x2, y + 3, 1);
2917
    PrintStatus("NightGogs=", numsprite[ICON_NIGHT_VISION], x, y + 4, 11);
2918
    PrintStatus("", multisprite[ICON_NIGHT_VISION], x2, y + 4, 1);
2919
    PrintStatus("SmokeBomb=", numsprite[ICON_CLOAK], x, y + 5, 11);
2920
    PrintStatus("", multisprite[ICON_CLOAK], x2, y + 5, 1);
2921
    PrintStatus("Tool_Box =", numsprite[ICON_REPAIR_KIT], x, y + 6, 11);
2922
    PrintStatus("", multisprite[ICON_REPAIR_KIT], x2, y + 6, 1);
2923
    PrintStatus("Heat_Card=", numsprite[ICON_HEAT_CARD], x, y + 7, 11);
2924
    PrintStatus("", multisprite[ICON_HEAT_CARD], x2, y + 7, 1);
2925
    PrintStatus("FlashBomb=", numsprite[ICON_FLASHBOMB], x, y + 8, 11);
2926
    PrintStatus("", multisprite[ICON_FLASHBOMB], x2, y + 8, 1);
2927
    PrintStatus("Caltrops =", numsprite[ICON_CALTROPS], x, y + 9, 11);
2928
    PrintStatus("", multisprite[ICON_CALTROPS], x2, y + 9, 1);
2929
 
2930
    x = 33;
2931
    x2 = 46;
2932
    y = 4;
2933
    printext16(x * 8, ydim16+y * 8, 11, -1, "Weapon Count", 0);
2934
    PrintStatus("Shuriken =", numsprite[ICON_STAR], x, y + 2, 11);
2935
    PrintStatus("", multisprite[ICON_STAR], x2, y + 2, 1);
2936
    PrintStatus("Uzi      =", numsprite[ICON_UZI], x, y + 3, 11);
2937
    PrintStatus("", multisprite[ICON_UZI], x2, y + 3, 1);
2938
    PrintStatus("Riot_Gun =", numsprite[ICON_SHOTGUN], x, y + 4, 11);
2939
    PrintStatus("", multisprite[ICON_SHOTGUN], x2, y + 4, 1);
2940
    PrintStatus("Misl_Bat =", numsprite[ICON_MICRO_GUN], x, y + 5, 11);
2941
    PrintStatus("", multisprite[ICON_MICRO_GUN], x2, y + 5, 1);
2942
    PrintStatus("40mm     =", numsprite[ICON_GRENADE_LAUNCHER], x, y + 6, 11);
2943
    PrintStatus("", multisprite[ICON_GRENADE_LAUNCHER], x2, y + 6, 1);
2944
    PrintStatus("Mines    =", numsprite[ICON_LG_MINE], x, y + 7, 11);
2945
    PrintStatus("", multisprite[ICON_LG_MINE], x2, y + 7, 1);
2946
    PrintStatus("Rail_Gun =", numsprite[ICON_RAIL_GUN], x, y + 8, 11);
2947
    PrintStatus("", multisprite[ICON_RAIL_GUN], x2, y + 8, 1);
2948
    PrintStatus("Evil Head=", numsprite[ICON_GUARD_HEAD], x, y + 9, 11);
2949
    PrintStatus("", multisprite[ICON_GUARD_HEAD], x2, y + 9, 1);
2950
    PrintStatus("Heart    =", numsprite[ICON_HEART], x, y + 10, 11);
2951
    PrintStatus("", multisprite[ICON_HEART], x2, y + 10, 1);
2952
 
2953
    x = 49;
2954
    x2 = 62;
2955
    y = 4;
2956
    printext16(x * 8, ydim16+y * 8, 11, -1, "Ammo Count", 0);
2957
    PrintStatus("Bullets  =", numsprite[ICON_LG_UZI_AMMO], x, y + 2, 11);
2958
    PrintStatus("", multisprite[ICON_LG_UZI_AMMO], x2, y + 2, 1);
2959
    PrintStatus("ShotShell=", numsprite[ICON_LG_SHOTSHELL], x, y + 3, 11);
2960
    PrintStatus("", multisprite[ICON_LG_SHOTSHELL], x2, y + 3, 1);
2961
    PrintStatus("Rockets  =", numsprite[ICON_MICRO_BATTERY], x, y + 4, 11);
2962
    PrintStatus("", multisprite[ICON_MICRO_BATTERY], x2, y + 4, 1);
2963
    PrintStatus("40mmShell=", numsprite[ICON_LG_GRENADE], x, y + 5, 11);
2964
    PrintStatus("", multisprite[ICON_LG_GRENADE], x2, y + 5, 1);
2965
    PrintStatus("Rail_Pack=", numsprite[ICON_RAIL_AMMO], x, y + 6, 11);
2966
    PrintStatus("", multisprite[ICON_RAIL_AMMO], x2, y + 6, 1);
2967
 
2968
 
2969
    // Show next tags
2970
    FindNextTag();
2971
    ShowNextTag();
2972
    /*
2973
            printext16(65*8,ydim16+4*8,11,-1,"MISC",0);
2974
            PrintStatus("Secrets =",secrets,65,6,11);
2975
            printext16(65*8,ydim16+7*8,11,-1,"ACTORS",0);
2976
            PrintStatus("Skill 1 =",totalactors1,65,8,11);
2977
            PrintStatus("Skill 2 =",totalactors2,65,9,11);
2978
            PrintStatus("Skill 3 =",totalactors3,65,10,11);
2979
            PrintStatus("Skill 4 =",totalactors4,65,11,11);
2980
            PrintStatus("Respawn =",totalrespawn,65,12,11);
2981
    */
2982</