Subversion Repositories eduke32

Rev

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