Subversion Repositories eduke32

Rev

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