Subversion Repositories eduke32

Rev

Rev 8519 | Rev 8685 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 8519 Rev 8596
1
//-------------------------------------------------------------------------
1
//-------------------------------------------------------------------------
2
/*
2
/*
3
Copyright (C) 1996, 2005 - 3D Realms Entertainment
3
Copyright (C) 1996, 2005 - 3D Realms Entertainment
4

4

5
This file is NOT part of Shadow Warrior version 1.2
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
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.
7
some test code written during the development of Shadow Warrior.
8
This file is provided purely for educational interest.
8
This file is provided purely for educational interest.
9

9

10
Shadow Warrior is free software; you can redistribute it and/or
10
Shadow Warrior is free software; you can redistribute it and/or
11
modify it under the terms of the GNU General Public License
11
modify it under the terms of the GNU General Public License
12
as published by the Free Software Foundation; either version 2
12
as published by the Free Software Foundation; either version 2
13
of the License, or (at your option) any later version.
13
of the License, or (at your option) any later version.
14

14

15
This program is distributed in the hope that it will be useful,
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18

18

19
See the GNU General Public License for more details.
19
See the GNU General Public License for more details.
20

20

21
You should have received a copy of the GNU General Public License
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
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.
23
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24

24

25
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
25
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
26
*/
26
*/
27
//-------------------------------------------------------------------------
27
//-------------------------------------------------------------------------
28
28
29
#include "build.h"
29
#include "build.h"
30
#include "editor.h"
30
#include "editor.h"
31
#include "cache1d.h"
31
#include "cache1d.h"
32
32
33
#include "keys.h"
33
#include "keys.h"
34
#include "names2.h"
34
#include "names2.h"
35
#include "game.h"
35
#include "game.h"
36
#include "tags.h"
36
#include "tags.h"
37
#include "pal.h"
37
#include "pal.h"
38
38
39
#include "common.h"
39
#include "common.h"
40
#include "common_game.h"
40
#include "common_game.h"
41
41
42
#include "colormap.h"
42
#include "colormap.h"
43
43
44
44
45
const char* AppProperName = "Wangulator";
45
const char* AppProperName = "Wangulator";
46
const char* AppTechnicalName = "wangulator";
46
const char* AppTechnicalName = "wangulator";
47
47
48
#if defined(_WIN32)
48
#if defined(_WIN32)
49
#define DEFAULT_GAME_EXEC "voidsw.exe"
49
#define DEFAULT_GAME_EXEC "voidsw.exe"
50
#define DEFAULT_GAME_LOCAL_EXEC "voidsw.exe"
50
#define DEFAULT_GAME_LOCAL_EXEC "voidsw.exe"
51
#else
51
#else
52
#define DEFAULT_GAME_EXEC "voidsw"
52
#define DEFAULT_GAME_EXEC "voidsw"
53
#define DEFAULT_GAME_LOCAL_EXEC "./voidsw"
53
#define DEFAULT_GAME_LOCAL_EXEC "./voidsw"
54
#endif
54
#endif
55
55
56
const char *DefaultGameExec = DEFAULT_GAME_EXEC;
56
const char *DefaultGameExec = DEFAULT_GAME_EXEC;
57
const char *DefaultGameLocalExec = DEFAULT_GAME_LOCAL_EXEC;
57
const char *DefaultGameLocalExec = DEFAULT_GAME_LOCAL_EXEC;
58
58
59
#define SETUPFILENAME "wangulator.cfg"
59
#define SETUPFILENAME "wangulator.cfg"
60
const char *defaultsetupfilename = SETUPFILENAME;
60
const char *defaultsetupfilename = SETUPFILENAME;
61
char setupfilename[BMAX_PATH] = SETUPFILENAME;
61
char setupfilename[BMAX_PATH] = SETUPFILENAME;
62
62
63
#define eitherALT   (keystatus[KEYSC_LALT] || keystatus[KEYSC_RALT])
63
#define eitherALT   (keystatus[KEYSC_LALT] || keystatus[KEYSC_RALT])
64
#define eitherCTRL  (keystatus[KEYSC_LCTRL] || keystatus[KEYSC_RCTRL])
64
#define eitherCTRL  (keystatus[KEYSC_LCTRL] || keystatus[KEYSC_RCTRL])
65
#define eitherSHIFT (keystatus[KEYSC_LSHIFT] || keystatus[KEYSC_RSHIFT])
65
#define eitherSHIFT (keystatus[KEYSC_LSHIFT] || keystatus[KEYSC_RSHIFT])
66
66
67
#define PRESSED_KEYSC(Key) (keystatus[KEYSC_##Key] && !(keystatus[KEYSC_##Key]=0))
67
#define PRESSED_KEYSC(Key) (keystatus[KEYSC_##Key] && !(keystatus[KEYSC_##Key]=0))
68
68
69
69
70
#define M_RED 102
70
#define M_RED 102
71
#define M_BLUE 198
71
#define M_BLUE 198
72
72
73
73
74
void ToggleFAF(void);       // brooms.c
74
void ToggleFAF(void);       // brooms.c
75
void FAF_AfterDrawRooms(void);  // brooms.c
75
void FAF_AfterDrawRooms(void);  // brooms.c
76
void ResetBuildFAF(void);   // brooms.c
76
void ResetBuildFAF(void);   // brooms.c
77
77
78
78
79
// Jim's Vars
79
// Jim's Vars
80
80
81
#define BUILD_DEV_VER   0   // True if this is the developer version of build.
81
#define BUILD_DEV_VER   0   // True if this is the developer version of build.
82
82
83
83
84
// Idle time counter
84
// Idle time counter
85
//int  idleclock=0;        // How much time is spent not touching the keyboard.
85
//int  idleclock=0;        // How much time is spent not touching the keyboard.
86
//int    slackerclock=0;       // Accumulated no keyboard time, adds every 30 secs
86
//int    slackerclock=0;       // Accumulated no keyboard time, adds every 30 secs
87
//int    oldtotalclock=0;
87
//int    oldtotalclock=0;
88
88
89
// Sprite lists
89
// Sprite lists
90
int numsprite[MAXSPRITES], multisprite[MAXSPRITES];
90
int numsprite[MAXSPRITES], multisprite[MAXSPRITES];
91
91
92
// Next available tag tracking vars
92
// Next available tag tracking vars
93
short siNextTag = 1;                    // Shows next available tag if there
93
short siNextTag = 1;                    // Shows next available tag if there
94
// is an open gap in tagging
94
// is an open gap in tagging
95
short siNextEndTag = 1;                 // Shows the hightest possible next
95
short siNextEndTag = 1;                 // Shows the hightest possible next
96
// tag
96
// tag
97
97
98
int loaded_numwalls;
98
int loaded_numwalls;
99
// Boolean flags used for sprite searching
99
// Boolean flags used for sprite searching
100
SWBOOL bFindPicNum = TRUE;                // Default
100
SWBOOL bFindPicNum = TRUE;                // Default
101
SWBOOL bFindHiTag = FALSE;
101
SWBOOL bFindHiTag = FALSE;
102
SWBOOL bFindLowTag = FALSE;
102
SWBOOL bFindLowTag = FALSE;
103
SWBOOL bVoxelsOn = TRUE;                  // Turn voxels on by default
103
SWBOOL bVoxelsOn = TRUE;                  // Turn voxels on by default
104
SWBOOL bSpinBobVoxels = TRUE;             // Do twizzly stuff to voxels
104
SWBOOL bSpinBobVoxels = TRUE;             // Do twizzly stuff to voxels
105
SWBOOL bAutoSize = TRUE;                  // Autosizing on/off
105
SWBOOL bAutoSize = TRUE;                  // Autosizing on/off
106
106
107
// Globals used to hold current sprite type being searched for.
107
// Globals used to hold current sprite type being searched for.
108
short FindPicNum = 0;
108
short FindPicNum = 0;
109
short FindSpriteNum = 0;
109
short FindSpriteNum = 0;
110
110
111
// My Function Prototypes
111
// My Function Prototypes
112
void ContextHelp(short spritenum);
112
void ContextHelp(short spritenum);
113
void LoadKVXFromScript(const char *filename);
113
void LoadKVXFromScript(const char *filename);
114
114
115
//void LogUserTime( SWBOOL bIsLoggingIn );
115
//void LogUserTime( SWBOOL bIsLoggingIn );
116
116
117
// voxelarray format is:
117
// voxelarray format is:
118
//      spritenumber, voxelnumber
118
//      spritenumber, voxelnumber
119
extern int aVoxelArray[MAXTILES];
119
extern int aVoxelArray[MAXTILES];
120
120
121
// Ken ALT highlighted array
121
// Ken ALT highlighted array
122
extern short highlightsector[MAXSECTORS];
122
extern short highlightsector[MAXSECTORS];
123
extern short highlightsectorcnt;
123
extern short highlightsectorcnt;
124
124
125
125
126
int DispMono = FALSE;
126
int DispMono = FALSE;
127
127
128
//
128
//
129
// KENS setup variables
129
// KENS setup variables
130
//
130
//
131
131
132
#define MAX_STAG_INFO 1024
132
#define MAX_STAG_INFO 1024
133
typedef struct
133
typedef struct
134
{
134
{
135
    char name[64];
135
    char name[64];
136
    int flags;
136
    int flags;
137
} STAG_INFO, *STAG_INFOp;
137
} STAG_INFO, *STAG_INFOp;
138
138
139
STAG_INFO StagInfo[MAX_STAG_INFO];
139
STAG_INFO StagInfo[MAX_STAG_INFO];
140
140
141
void PrintStatus(const char *string, int num, char x, char y, char color);
141
void PrintStatus(const char *string, int num, char x, char y, char color);
142
142
143
#define NUMOPTIONS 8
143
#define NUMOPTIONS 8
144
char option[NUMOPTIONS] = {0, 0, 0, 0, 0, 0, 1, 0};
144
char option[NUMOPTIONS] = {0, 0, 0, 0, 0, 0, 1, 0};
145
char default_buildkeys[NUMBUILDKEYS] =
145
char default_buildkeys[NUMBUILDKEYS] =
146
{
146
{
147
    0xc8, 0xd0, 0xcb, 0xcd, 0x2a, 0x9d, 0x1d, 0x39,
147
    0xc8, 0xd0, 0xcb, 0xcd, 0x2a, 0x9d, 0x1d, 0x39,
148
    0x1e, 0x2c, 0xd1, 0xc9, 0x33, 0x34,
148
    0x1e, 0x2c, 0xd1, 0xc9, 0x33, 0x34,
149
    0x9c, 0x1c, 0xd, 0xc, 0xf, 0x29
149
    0x9c, 0x1c, 0xd, 0xc, 0xf, 0x29
150
};
150
};
151
151
152
extern short pointhighlight, linehighlight;
152
extern short pointhighlight, linehighlight;
153
extern short asksave;
153
extern short asksave;
154
short ExtSectorTag[MAXSECTORS][4];
154
short ExtSectorTag[MAXSECTORS][4];
155
static char tempbuf[256];
155
static char tempbuf[256];
156
char ds[256];
156
char ds[256];
157
157
158
enum
158
enum
159
{
159
{
160
    CAPTION_NONE,
160
    CAPTION_NONE,
161
    CAPTION_DEFAULT,
161
    CAPTION_DEFAULT,
162
    CAPTION_NAMES,
162
    CAPTION_NAMES,
163
    CAPTION_MOST,
163
    CAPTION_MOST,
164
    CAPTION_ALL,
164
    CAPTION_ALL,
165
    CAPTION_MAX,
165
    CAPTION_MAX,
166
};
166
};
167
short CaptionMode = CAPTION_NAMES;
167
short CaptionMode = CAPTION_NAMES;
168
168
169
169
170
// RIGHT ALT selection key
170
// RIGHT ALT selection key
171
extern short highlightsector[MAXSECTORS];
171
extern short highlightsector[MAXSECTORS];
172
extern short highlightsectorcnt;
172
extern short highlightsectorcnt;
173
173
174
// RIGHT SHIFT selection key
174
// RIGHT SHIFT selection key
175
#define SPRITE_FLAG 16384
175
#define SPRITE_FLAG 16384
176
extern short highlight[MAXWALLS+MAXSPRITES];       // sprite nums are + 16348
176
extern short highlight[MAXWALLS+MAXSPRITES];       // sprite nums are + 16348
177
extern short highlightcnt;
177
extern short highlightcnt;
178
178
179
// Variables copied with the tab key
179
// Variables copied with the tab key
180
extern int32_t temppicnum, tempcstat, templotag, temphitag, tempextra;
180
extern int32_t temppicnum, tempcstat, templotag, temphitag, tempextra;
181
181
182
void SectorMoveFloorZ(int);
182
void SectorMoveFloorZ(int);
183
void SectorMoveCeilingZ(int);
183
void SectorMoveCeilingZ(int);
184
184
185
void BuildStagTable(void);
185
void BuildStagTable(void);
186
void Message(const char *string, char color);
186
void Message(const char *string, char color);
187
void ShowMessage(void);
187
void ShowMessage(void);
188
void ShadeMenu(void);
188
void ShadeMenu(void);
189
void FindNextTag(void);
189
void FindNextTag(void);
190
void ShowNextTag(void);
190
void ShowNextTag(void);
191
void FindSprite(short picnum, short findspritenum);
191
void FindSprite(short picnum, short findspritenum);
192
void FindNextSprite(short picnum);
192
void FindNextSprite(short picnum);
193
void SetClipdist2D(void);
193
void SetClipdist2D(void);
194
void DrawClipBox(short spritenum);
194
void DrawClipBox(short spritenum);
195
195
196
//printext16 parameters:
196
//printext16 parameters:
197
//printext16(int xpos, int ypos, short col, short backcol,
197
//printext16(int xpos, int ypos, short col, short backcol,
198
//           char name[82], char fontsize)
198
//           char name[82], char fontsize)
199
//  xpos 0-639   (top left)
199
//  xpos 0-639   (top left)
200
//  ypos 0-479   (top left)
200
//  ypos 0-479   (top left)
201
//  col 0-15
201
//  col 0-15
202
//  backcol 0-15, -1 is transparent background
202
//  backcol 0-15, -1 is transparent background
203
//  name
203
//  name
204
//  fontsize 0=8*8, 1=3*5
204
//  fontsize 0=8*8, 1=3*5
205
205
206
//drawline16 parameters:
206
//drawline16 parameters:
207
// drawline16(int x1, int y1, int x2, int y2, char col)
207
// drawline16(int x1, int y1, int x2, int y2, char col)
208
//  x1, x2  0-639
208
//  x1, x2  0-639
209
//  y1, y2  0-143  (status bar is 144 high, origin is top-left of STATUS BAR)
209
//  y1, y2  0-143  (status bar is 144 high, origin is top-left of STATUS BAR)
210
//  col     0-15
210
//  col     0-15
211
211
212
//Detecting 2D / 3D mode:
212
//Detecting 2D / 3D mode:
213
//   qsetmode is 200 in 3D mode
213
//   qsetmode is 200 in 3D mode
214
//   qsetmode is 350/480 in 2D mode
214
//   qsetmode is 350/480 in 2D mode
215
//
215
//
216
//You can read these variables when F5-F8 is pressed in 3D mode only:
216
//You can read these variables when F5-F8 is pressed in 3D mode only:
217
//
217
//
218
//   If (searchstat == 0)  WALL        searchsector=sector, searchwall=wall
218
//   If (searchstat == 0)  WALL        searchsector=sector, searchwall=wall
219
//   If (searchstat == 1)  CEILING     searchsector=sector
219
//   If (searchstat == 1)  CEILING     searchsector=sector
220
//   If (searchstat == 2)  FLOOR       searchsector=sector
220
//   If (searchstat == 2)  FLOOR       searchsector=sector
221
//   If (searchstat == 3)  SPRITE      searchsector=sector, searchwall=sprite
221
//   If (searchstat == 3)  SPRITE      searchsector=sector, searchwall=sprite
222
//   If (searchstat == 4)  MASKED WALL searchsector=sector, searchwall=wall
222
//   If (searchstat == 4)  MASKED WALL searchsector=sector, searchwall=wall
223
//
223
//
224
//   searchsector is the sector of the selected item for all 5 searchstat's
224
//   searchsector is the sector of the selected item for all 5 searchstat's
225
//
225
//
226
//   searchwall is undefined if searchstat is 1 or 2
226
//   searchwall is undefined if searchstat is 1 or 2
227
//   searchwall is the wall if searchstat = 0 or 4
227
//   searchwall is the wall if searchstat = 0 or 4
228
//   searchwall is the sprite if searchstat = 3 (Yeah, I know - it says wall,
228
//   searchwall is the sprite if searchstat = 3 (Yeah, I know - it says wall,
229
//                                      but trust me, it's the sprite number)
229
//                                      but trust me, it's the sprite number)
230
230
231
void
231
void
232
ResetKeys(void)
232
ResetKeys(void)
233
{
233
{
234
    unsigned i;
234
    unsigned i;
235
235
236
    for (i = 0; i < SIZ(keystatus); i++)
236
    for (i = 0; i < SIZ(keystatus); i++)
237
    {
237
    {
238
        KEY_PRESSED(i) = 0;
238
        KEY_PRESSED(i) = 0;
239
    }
239
    }
240
}
240
}
241
241
242
void ExtPreCheckKeys(void)
242
void ExtPreCheckKeys(void)
243
{
243
{
244
    ToggleFAF();
244
    ToggleFAF();
245
}
245
}
246
246
247
247
248
// Toggle sprites on/off.  Good for frame rate checks.
248
// Toggle sprites on/off.  Good for frame rate checks.
249
SWBOOL DebugActorFreeze = 0;
249
SWBOOL DebugActorFreeze = 0;
250
250
251
void
251
void
252
ToggleSprites()
252
ToggleSprites()
253
{
253
{
254
    spritetype *tspr;
254
    spritetype *tspr;
255
255
256
256
257
    DebugActorFreeze++;
257
    DebugActorFreeze++;
258
    if (DebugActorFreeze > 2)
258
    if (DebugActorFreeze > 2)
259
        DebugActorFreeze = 0;
259
        DebugActorFreeze = 0;
260
260
261
    // Don't show any sprites, period
261
    // Don't show any sprites, period
262
    if (DebugActorFreeze == 2)
262
    if (DebugActorFreeze == 2)
263
    {
263
    {
264
        short i;
264
        short i;
265
265
266
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
266
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
267
        {
267
        {
268
            SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
268
            SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
269
//                if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
269
//                if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
270
//                {
270
//                {
271
//                    SET(tspr->extra, SPRX_BLOCK);
271
//                    SET(tspr->extra, SPRX_BLOCK);
272
//                    RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
272
//                    RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
273
//                }
273
//                }
274
        }
274
        }
275
    }
275
    }
276
276
277
277
278
    // Show all sprites except actors and ST's
278
    // Show all sprites except actors and ST's
279
    if (DebugActorFreeze == 1)
279
    if (DebugActorFreeze == 1)
280
    {
280
    {
281
        short i;
281
        short i;
282
282
283
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
283
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
284
        {
284
        {
285
            switch (tspr->picnum)
285
            switch (tspr->picnum)
286
            {
286
            {
287
            case COOLIE_RUN_R0:
287
            case COOLIE_RUN_R0:
288
            case ZOMBIE_RUN_R0:
288
            case ZOMBIE_RUN_R0:
289
            case NINJA_RUN_R0:
289
            case NINJA_RUN_R0:
290
            case SERP_RUN_R0:
290
            case SERP_RUN_R0:
291
            case LAVA_RUN_R0:
291
            case LAVA_RUN_R0:
292
            case SKEL_RUN_R0:
292
            case SKEL_RUN_R0:
293
            case GORO_RUN_R0:
293
            case GORO_RUN_R0:
294
            case HORNET_RUN_R0:
294
            case HORNET_RUN_R0:
295
            case SKULL_R0:
295
            case SKULL_R0:
296
            case RIPPER_RUN_R0:
296
            case RIPPER_RUN_R0:
297
            case 2307:                  // ST1
297
            case 2307:                  // ST1
298
            case 2308:                  // ST2
298
            case 2308:                  // ST2
299
            case 2309:                  // QJ
299
            case 2309:                  // QJ
300
            case 2310:                  // QJD
300
            case 2310:                  // QJD
301
            case 2311:                  // QSJ
301
            case 2311:                  // QSJ
302
            case 2312:                  // QSCN
302
            case 2312:                  // QSCN
303
            case 2313:                  // QEXIT
303
            case 2313:                  // QEXIT
304
                SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
304
                SET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
305
//                      if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
305
//                      if (TEST(tspr->cstat, CSTAT_SPRITE_BLOCK))
306
//                      {
306
//                      {
307
//                          SET(tspr->extra, SPRX_BLOCK);
307
//                          SET(tspr->extra, SPRX_BLOCK);
308
//                          RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
308
//                          RESET(tspr->cstat, CSTAT_SPRITE_BLOCK);
309
//                      }
309
//                      }
310
                break;
310
                break;
311
            }
311
            }
312
        }
312
        }
313
    }
313
    }
314
314
315
315
316
    // Show all sprites
316
    // Show all sprites
317
    if (DebugActorFreeze == FALSE)
317
    if (DebugActorFreeze == FALSE)
318
    {
318
    {
319
        short i;
319
        short i;
320
320
321
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
321
        for (i = 0, tspr = &sprite[0]; i < MAXSPRITES; i++, tspr++)
322
        {
322
        {
323
            RESET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
323
            RESET(tspr->cstat, CSTAT_SPRITE_INVISIBLE);
324
//                if (TEST(tspr->extra, SPRX_BLOCK))
324
//                if (TEST(tspr->extra, SPRX_BLOCK))
325
//                    SET(tspr->cstat, CSTAT_SPRITE_BLOCK);
325
//                    SET(tspr->cstat, CSTAT_SPRITE_BLOCK);
326
        }
326
        }
327
    }
327
    }
328
}
328
}
329
329
330
330
331
void
331
void
332
DoAutoSize(tspriteptr_t tspr)
332
DoAutoSize(tspriteptr_t tspr)
333
{
333
{
334
    short i;
334
    short i;
335
335
336
    if (!bAutoSize)
336
    if (!bAutoSize)
337
        return;
337
        return;
338
338
339
    switch (tspr->picnum)
339
    switch (tspr->picnum)
340
    {
340
    {
341
    case ICON_STAR:                     // 1793
341
    case ICON_STAR:                     // 1793
342
        break;
342
        break;
343
    case ICON_UZI:                      // 1797
343
    case ICON_UZI:                      // 1797
344
        tspr->xrepeat = 43;
344
        tspr->xrepeat = 43;
345
        tspr->yrepeat = 40;
345
        tspr->yrepeat = 40;
346
        break;
346
        break;
347
    case ICON_UZIFLOOR:         // 1807
347
    case ICON_UZIFLOOR:         // 1807
348
        tspr->xrepeat = 43;
348
        tspr->xrepeat = 43;
349
        tspr->yrepeat = 40;
349
        tspr->yrepeat = 40;
350
        break;
350
        break;
351
    case ICON_LG_UZI_AMMO:              // 1799
351
    case ICON_LG_UZI_AMMO:              // 1799
352
        break;
352
        break;
353
    case ICON_HEART:                    // 1824
353
    case ICON_HEART:                    // 1824
354
        break;
354
        break;
355
    case ICON_HEART_LG_AMMO:            // 1820
355
    case ICON_HEART_LG_AMMO:            // 1820
356
        break;
356
        break;
357
    case ICON_GUARD_HEAD:               // 1814
357
    case ICON_GUARD_HEAD:               // 1814
358
        break;
358
        break;
359
    case ICON_FIREBALL_LG_AMMO: // 3035
359
    case ICON_FIREBALL_LG_AMMO: // 3035
360
        break;
360
        break;
361
    case ICON_ROCKET:                   // 1843
361
    case ICON_ROCKET:                   // 1843
362
        break;
362
        break;
363
    case ICON_SHOTGUN:                  // 1794
363
    case ICON_SHOTGUN:                  // 1794
364
        tspr->xrepeat = 57;
364
        tspr->xrepeat = 57;
365
        tspr->yrepeat = 58;
365
        tspr->yrepeat = 58;
366
        break;
366
        break;
367
    case ICON_LG_ROCKET:                // 1796
367
    case ICON_LG_ROCKET:                // 1796
368
        break;
368
        break;
369
    case ICON_LG_SHOTSHELL:             // 1823
369
    case ICON_LG_SHOTSHELL:             // 1823
370
        break;
370
        break;
371
    case ICON_MICRO_GUN:                // 1818
371
    case ICON_MICRO_GUN:                // 1818
372
        break;
372
        break;
373
    case ICON_MICRO_BATTERY:            // 1800
373
    case ICON_MICRO_BATTERY:            // 1800
374
        break;
374
        break;
375
    case ICON_GRENADE_LAUNCHER: // 1817
375
    case ICON_GRENADE_LAUNCHER: // 1817
376
        tspr->xrepeat = 54;
376
        tspr->xrepeat = 54;
377
        tspr->yrepeat = 52;
377
        tspr->yrepeat = 52;
378
        break;
378
        break;
379
    case ICON_LG_GRENADE:               // 1831
379
    case ICON_LG_GRENADE:               // 1831
380
        break;
380
        break;
381
    case ICON_LG_MINE:                  // 1842
381
    case ICON_LG_MINE:                  // 1842
382
        break;
382
        break;
383
    case ICON_RAIL_GUN:         // 1811
383
    case ICON_RAIL_GUN:         // 1811
384
        tspr->xrepeat = 50;
384
        tspr->xrepeat = 50;
385
        tspr->yrepeat = 54;
385
        tspr->yrepeat = 54;
386
        break;
386
        break;
387
    case ICON_RAIL_AMMO:                // 1812
387
    case ICON_RAIL_AMMO:                // 1812
388
        break;
388
        break;
389
    case ICON_SM_MEDKIT:                // 1802
389
    case ICON_SM_MEDKIT:                // 1802
390
        break;
390
        break;
391
    case ICON_MEDKIT:                   // 1803
391
    case ICON_MEDKIT:                   // 1803
392
        break;
392
        break;
393
    case ICON_CHEMBOMB:
393
    case ICON_CHEMBOMB:
394
        tspr->xrepeat = 64;
394
        tspr->xrepeat = 64;
395
        tspr->yrepeat = 47;
395
        tspr->yrepeat = 47;
396
        break;
396
        break;
397
    case ICON_FLASHBOMB:
397
    case ICON_FLASHBOMB:
398
        tspr->xrepeat = 32;
398
        tspr->xrepeat = 32;
399
        tspr->yrepeat = 34;
399
        tspr->yrepeat = 34;
400
        break;
400
        break;
401
    case ICON_NUKE:
401
    case ICON_NUKE:
402
        break;
402
        break;
403
    case ICON_CALTROPS:
403
    case ICON_CALTROPS:
404
        tspr->xrepeat = 37;
404
        tspr->xrepeat = 37;
405
        tspr->yrepeat = 30;
405
        tspr->yrepeat = 30;
406
        break;
406
        break;
407
    case ICON_BOOSTER:                  // 1810
407
    case ICON_BOOSTER:                  // 1810
408
        tspr->xrepeat = 30;
408
        tspr->xrepeat = 30;
409
        tspr->yrepeat = 38;
409
        tspr->yrepeat = 38;
410
        break;
410
        break;
411
    case ICON_HEAT_CARD:                // 1819
411
    case ICON_HEAT_CARD:                // 1819
412
        tspr->xrepeat = 46;
412
        tspr->xrepeat = 46;
413
        tspr->yrepeat = 47;
413
        tspr->yrepeat = 47;
414
        break;
414
        break;
415
    case ICON_REPAIR_KIT:               // 1813
415
    case ICON_REPAIR_KIT:               // 1813
416
        break;
416
        break;
417
    case ICON_EXPLOSIVE_BOX:            // 1801
417
    case ICON_EXPLOSIVE_BOX:            // 1801
418
        break;
418
        break;
419
    case ICON_ENVIRON_SUIT:             // 1837
419
    case ICON_ENVIRON_SUIT:             // 1837
420
        break;
420
        break;
421
    case ICON_FLY:                      // 1782
421
    case ICON_FLY:                      // 1782
422
        break;
422
        break;
423
    case ICON_CLOAK:                    // 1826
423
    case ICON_CLOAK:                    // 1826
424
        break;
424
        break;
425
    case ICON_NIGHT_VISION:             // 3031
425
    case ICON_NIGHT_VISION:             // 3031
426
        tspr->xrepeat = 59;
426
        tspr->xrepeat = 59;
427
        tspr->yrepeat = 71;
427
        tspr->yrepeat = 71;
428
        break;
428
        break;
429
    case ICON_NAPALM:                   // 3046
429
    case ICON_NAPALM:                   // 3046
430
        break;
430
        break;
431
    case ICON_RING:                     // 3050
431
    case ICON_RING:                     // 3050
432
        break;
432
        break;
433
    case ICON_RINGAMMO:         // 3054
433
    case ICON_RINGAMMO:         // 3054
434
        break;
434
        break;
435
    case ICON_NAPALMAMMO:               // 3058
435
    case ICON_NAPALMAMMO:               // 3058
436
        break;
436
        break;
437
    case ICON_GRENADE:                  // 3059
437
    case ICON_GRENADE:                  // 3059
438
        break;
438
        break;
439
    case ICON_ARMOR:                    // 3030
439
    case ICON_ARMOR:                    // 3030
440
        tspr->xrepeat = 82;
440
        tspr->xrepeat = 82;
441
        tspr->yrepeat = 84;
441
        tspr->yrepeat = 84;
442
        break;
442
        break;
443
    case BLUE_KEY:                      // 1766
443
    case BLUE_KEY:                      // 1766
444
        break;
444
        break;
445
    case RED_KEY:                       // 1770
445
    case RED_KEY:                       // 1770
446
        break;
446
        break;
447
    case GREEN_KEY:                     // 1774
447
    case GREEN_KEY:                     // 1774
448
        break;
448
        break;
449
    case YELLOW_KEY:                    // 1778
449
    case YELLOW_KEY:                    // 1778
450
        break;
450
        break;
451
    case BLUE_CARD:
451
    case BLUE_CARD:
452
    case RED_CARD:
452
    case RED_CARD:
453
    case GREEN_CARD:
453
    case GREEN_CARD:
454
    case YELLOW_CARD:
454
    case YELLOW_CARD:
455
        tspr->xrepeat = 36;
455
        tspr->xrepeat = 36;
456
        tspr->yrepeat = 33;
456
        tspr->yrepeat = 33;
457
        break;
457
        break;
458
    case GOLD_SKELKEY:
458
    case GOLD_SKELKEY:
459
    case SILVER_SKELKEY:
459
    case SILVER_SKELKEY:
460
    case BRONZE_SKELKEY:
460
    case BRONZE_SKELKEY:
461
    case RED_SKELKEY:
461
    case RED_SKELKEY:
462
        tspr->xrepeat = 39;
462
        tspr->xrepeat = 39;
463
        tspr->yrepeat = 45;
463
        tspr->yrepeat = 45;
464
        break;
464
        break;
465
    case SKEL_LOCKED:
465
    case SKEL_LOCKED:
466
    case SKEL_UNLOCKED:
466
    case SKEL_UNLOCKED:
467
        tspr->xrepeat = 47;
467
        tspr->xrepeat = 47;
468
        tspr->yrepeat = 40;
468
        tspr->yrepeat = 40;
469
        break;
469
        break;
470
    case RAMCARD_LOCKED:
470
    case RAMCARD_LOCKED:
471
    case RAMCARD_UNLOCKED:
471
    case RAMCARD_UNLOCKED:
472
    case CARD_LOCKED:
472
    case CARD_LOCKED:
473
    case CARD_UNLOCKED:
473
    case CARD_UNLOCKED:
474
        break;
474
        break;
475
    default:
475
    default:
476
        break;
476
        break;
477
    }
477
    }
478
}
478
}
479
479
480
// Rotation angles for sprites
480
// Rotation angles for sprites
481
short rotang = 0;
481
short rotang = 0;
482
482
483
void
483
void
484
ExtAnalyzeSprites(int32_t ourx, int32_t oury, int32_t ourz, int32_t oura, int32_t smoothr)
484
ExtAnalyzeSprites(int32_t ourx, int32_t oury, int32_t ourz, int32_t oura, int32_t smoothr)
485
{
485
{
486
    int i, currsprite;
486
    int i, currsprite;
487
    tspriteptr_t tspr;
487
    tspriteptr_t tspr;
488
488
489
    UNREFERENCED_PARAMETER(ourx);
489
    UNREFERENCED_PARAMETER(ourx);
490
    UNREFERENCED_PARAMETER(oury);
490
    UNREFERENCED_PARAMETER(oury);
491
    UNREFERENCED_PARAMETER(ourz);
491
    UNREFERENCED_PARAMETER(ourz);
492
    UNREFERENCED_PARAMETER(oura);
492
    UNREFERENCED_PARAMETER(oura);
493
    UNREFERENCED_PARAMETER(smoothr);
493
    UNREFERENCED_PARAMETER(smoothr);
494
494
495
    rotang += 4;
495
    rotang += 4;
496
    if (rotang > 2047)
496
    if (rotang > 2047)
497
        rotang = 0;
497
        rotang = 0;
498
498
499
    for (i = 0, tspr = &tsprite[0]; i < spritesortcnt; i++, tspr++)
499
    for (i = 0, tspr = &tsprite[0]; i < spritesortcnt; i++, tspr++)
500
    {
500
    {
501
501
502
        // Take care of autosizing
502
        // Take care of autosizing
503
        DoAutoSize(tspr);
503
        DoAutoSize(tspr);
504
504
505
        tspr->shade += 6;
505
        tspr->shade += 6;
506
        if (sector[tspr->sectnum].ceilingstat & 1)
506
        if (sector[tspr->sectnum].ceilingstat & 1)
507
            tspr->shade += sector[tspr->sectnum].ceilingshade;
507
            tspr->shade += sector[tspr->sectnum].ceilingshade;
508
        else
508
        else
509
            tspr->shade += sector[tspr->sectnum].floorshade;
509
            tspr->shade += sector[tspr->sectnum].floorshade;
510
510
511
        if (tspr->picnum == ICON_ARMOR)
511
        if (tspr->picnum == ICON_ARMOR)
512
        {
512
        {
513
            if (tspr->pal != 19)        // Red
513
            if (tspr->pal != 19)        // Red
514
                tspr->pal = 17;         // Gray
514
                tspr->pal = 17;         // Gray
515
        }
515
        }
516
516
517
        // Check for voxels
517
        // Check for voxels
518
        if (bVoxelsOn)
518
        if (bVoxelsOn && usevoxels && videoGetRenderMode() != REND_POLYMER)
519
        {
519
        {
520
            if (bSpinBobVoxels)
520
            if (bSpinBobVoxels)
521
            {
521
            {
522
                switch (tspr->picnum)
522
                switch (tspr->picnum)
523
                {
523
                {
524
                case ICON_STAR: // 1793
524
                case ICON_STAR: // 1793
525
                case ICON_UZI:          // 1797
525
                case ICON_UZI:          // 1797
526
                case ICON_UZIFLOOR:     // 1807
526
                case ICON_UZIFLOOR:     // 1807
527
                case ICON_LG_UZI_AMMO:  // 1799
527
                case ICON_LG_UZI_AMMO:  // 1799
528
                case ICON_HEART:        // 1824
528
                case ICON_HEART:        // 1824
529
                case ICON_HEART_LG_AMMO:        // 1820
529
                case ICON_HEART_LG_AMMO:        // 1820
530
                case ICON_GUARD_HEAD:   // 1814
530
                case ICON_GUARD_HEAD:   // 1814
531
                case ICON_FIREBALL_LG_AMMO:     // 3035
531
                case ICON_FIREBALL_LG_AMMO:     // 3035
532
                case ICON_ROCKET:       // 1843
532
                case ICON_ROCKET:       // 1843
533
                case ICON_SHOTGUN:      // 1794
533
                case ICON_SHOTGUN:      // 1794
534
                case ICON_LG_ROCKET:    // 1796
534
                case ICON_LG_ROCKET:    // 1796
535
                case ICON_LG_SHOTSHELL: // 1823
535
                case ICON_LG_SHOTSHELL: // 1823
536
                case ICON_MICRO_GUN:    // 1818
536
                case ICON_MICRO_GUN:    // 1818
537
                case ICON_MICRO_BATTERY:        // 1800
537
                case ICON_MICRO_BATTERY:        // 1800
538
                case ICON_GRENADE_LAUNCHER:     // 1817
538
                case ICON_GRENADE_LAUNCHER:     // 1817
539
                case ICON_LG_GRENADE:   // 1831
539
                case ICON_LG_GRENADE:   // 1831
540
                case ICON_LG_MINE:      // 1842
540
                case ICON_LG_MINE:      // 1842
541
                case ICON_RAIL_GUN:     // 1811
541
                case ICON_RAIL_GUN:     // 1811
542
                case ICON_RAIL_AMMO:    // 1812
542
                case ICON_RAIL_AMMO:    // 1812
543
                case ICON_SM_MEDKIT:    // 1802
543
                case ICON_SM_MEDKIT:    // 1802
544
                case ICON_MEDKIT:       // 1803
544
                case ICON_MEDKIT:       // 1803
545
                case ICON_BOOSTER:      // 1810
545
                case ICON_BOOSTER:      // 1810
546
                case ICON_HEAT_CARD:    // 1819
546
                case ICON_HEAT_CARD:    // 1819
547
                case ICON_REPAIR_KIT:   // 1813
547
                case ICON_REPAIR_KIT:   // 1813
548
                case ICON_EXPLOSIVE_BOX:        // 1801
548
                case ICON_EXPLOSIVE_BOX:        // 1801
549
                case ICON_ENVIRON_SUIT: // 1837
549
                case ICON_ENVIRON_SUIT: // 1837
550
                case ICON_FLY:          // 1782
550
                case ICON_FLY:          // 1782
551
                case ICON_CLOAK:        // 1826
551
                case ICON_CLOAK:        // 1826
552
                case ICON_NIGHT_VISION: // 3031
552
                case ICON_NIGHT_VISION: // 3031
553
                case ICON_NAPALM:       // 3046
553
                case ICON_NAPALM:       // 3046
554
                case ICON_RING: // 3050
554
                case ICON_RING: // 3050
555
                // case ICON_GOROAMMO:       // 3035
555
                // case ICON_GOROAMMO:       // 3035
556
                // case ICON_HEARTAMMO:      // 1820
556
                // case ICON_HEARTAMMO:      // 1820
557
                case ICON_RINGAMMO:     // 3054
557
                case ICON_RINGAMMO:     // 3054
558
                case ICON_NAPALMAMMO:   // 3058
558
                case ICON_NAPALMAMMO:   // 3058
559
                case ICON_GRENADE:      // 3059
559
                case ICON_GRENADE:      // 3059
560
                // case ICON_OXYGEN:         // 1800
560
                // case ICON_OXYGEN:         // 1800
561
                case ICON_ARMOR:        // 3030
561
                case ICON_ARMOR:        // 3030
562
                case BLUE_KEY:          // 1766
562
                case BLUE_KEY:          // 1766
563
                case RED_KEY:           // 1770
563
                case RED_KEY:           // 1770
564
                case GREEN_KEY: // 1774
564
                case GREEN_KEY: // 1774
565
                case YELLOW_KEY:        // 1778
565
                case YELLOW_KEY:        // 1778
566
                case ICON_CHEMBOMB:
566
                case ICON_CHEMBOMB:
567
                case ICON_FLASHBOMB:
567
                case ICON_FLASHBOMB:
568
                case ICON_NUKE:
568
                case ICON_NUKE:
569
                case ICON_CALTROPS:
569
                case ICON_CALTROPS:
570
                    tspr->ang = rotang;
570
                    tspr->ang = rotang;
571
                    // tspr->z+=(sintable[(rotang*2)%2047]/16);
571
                    // tspr->z+=(sintable[(rotang*2)%2047]/16);
572
                    break;
572
                    break;
573
                }
573
                }
574
            }
574
            }
575
575
576
            if (aVoxelArray[tspr->picnum] >= 0)
576
            if (aVoxelArray[tspr->picnum] >= 0)
577
            {
577
            {
578
578
579
                // Turn on voxels
579
                // Turn on voxels
580
                tspr->picnum = aVoxelArray[tspr->picnum];       // Get the voxel number
580
                tspr->picnum = aVoxelArray[tspr->picnum];       // Get the voxel number
581
                tspr->cstat |= 48;      // Set stat to voxelize sprite
581
                tspr->cstat |= 48;      // Set stat to voxelize sprite
582
            }
582
            }
583
        }
583
        }
584
    }
584
    }
585
585
586
}
586
}
587
587
588
uint8_t*
588
uint8_t*
589
BKeyPressed(void)
589
BKeyPressed(void)
590
{
590
{
591
    uint8_t* k;
591
    uint8_t* k;
592
592
593
    for (k = (uint8_t*) & KEY_PRESSED(0); k < (uint8_t*) &KEY_PRESSED(SIZ(keystatus)); k++)
593
    for (k = (uint8_t*) & KEY_PRESSED(0); k < (uint8_t*) &KEY_PRESSED(SIZ(keystatus)); k++)
594
    {
594
    {
595
        if (*k)
595
        if (*k)
596
            return k;
596
            return k;
597
    }
597
    }
598
598
599
    return NULL;
599
    return NULL;
600
}
600
}
601
601
602
uint8_t*
602
uint8_t*
603
KeyPressedRange(uint8_t* kb, uint8_t* ke)
603
KeyPressedRange(uint8_t* kb, uint8_t* ke)
604
{
604
{
605
    uint8_t* k;
605
    uint8_t* k;
606
606
607
    for (k = kb; k <= ke; k++)
607
    for (k = kb; k <= ke; k++)
608
    {
608
    {
609
        if (*k)
609
        if (*k)
610
            return k;
610
            return k;
611
    }
611
    }
612
612
613
    return NULL;
613
    return NULL;
614
}
614
}
615
615
616
void
616
void
617
ResetKeyRange(uint8_t* kb, uint8_t* ke)
617
ResetKeyRange(uint8_t* kb, uint8_t* ke)
618
{
618
{
619
    uint8_t* k;
619
    uint8_t* k;
620
620
621
    for (k = kb; k <= ke; k++)
621
    for (k = kb; k <= ke; k++)
622
    {
622
    {
623
        *k = 0;
623
        *k = 0;
624
    }
624
    }
625
}
625
}
626
626
627
#if 0
627
#if 0
628
void
628
void
629
ExtInit(void)
629
ExtInit(void)
630
{
630
{
631
    int i, fil;
631
    int i, fil;
632
632
633
    initgroupfile(G_GrpFile());
633
    initgroupfile(G_GrpFile());
634
    if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
634
    if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
635
    {
635
    {
636
        read(fil, &option[0], NUMOPTIONS);
636
        read(fil, &option[0], NUMOPTIONS);
637
        read(fil, &default_buildkeys[0], NUMKEYS);
637
        read(fil, &default_buildkeys[0], NUMKEYS);
638
        memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS);     // Trick to make build
638
        memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS);     // Trick to make build
639
        // use setup.dat keys
639
        // use setup.dat keys
640
        close(fil);
640
        close(fil);
641
    }
641
    }
642
    if (option[4] > 0)
642
    if (option[4] > 0)
643
        option[4] = 0;
643
        option[4] = 0;
644
    initmouse();
644
    initmouse();
645
645
646
    initengine();
646
    initengine();
647
    vidoption = option[0];
647
    vidoption = option[0];
648
    xdim = vesares[option[6] & 15][0];
648
    xdim = vesares[option[6] & 15][0];
649
    ydim = vesares[option[6] & 15][1];
649
    ydim = vesares[option[6] & 15][1];
650
650
651
#if 0
651
#if 0
652
    switch (option[0])
652
    switch (option[0])
653
    {
653
    {
654
    case 0:
654
    case 0:
655
        initengine(0, chainxres[option[6] & 15], chainyres[option[6] >> 4]);
655
        initengine(0, chainxres[option[6] & 15], chainyres[option[6] >> 4]);
656
        break;
656
        break;
657
    case 1:
657
    case 1:
658
        initengine(1, vesares[option[6] & 15][0], vesares[option[6] & 15][1]);
658
        initengine(1, vesares[option[6] & 15][0], vesares[option[6] & 15][1]);
659
        break;
659
        break;
660
    default:
660
    default:
661
        initengine(option[0], 320L, 200L);
661
        initengine(option[0], 320L, 200L);
662
    }
662
    }
663
#endif
663
#endif
664
664
665
    InitPalette();
665
    InitPalette();
666
666
667
    kensplayerheight = 58;
667
    kensplayerheight = 58;
668
    zmode = 0;
668
    zmode = 0;
669
669
670
}
670
}
671
671
672
#endif
672
#endif
673
673
674
const char *startwin_labeltext = "Starting Build Editor for Shadow Warrior...";
674
const char *startwin_labeltext = "Starting Build Editor for Shadow Warrior...";
675
675
676
const char *ExtGetVer(void)
676
const char *ExtGetVer(void)
677
{
677
{
678
    return s_buildRev;
678
    return s_buildRev;
679
}
679
}
680
680
681
void ExtSetupMapFilename(const char *mapname)
681
void ExtSetupMapFilename(const char *mapname)
682
{
682
{
683
    UNREFERENCED_PARAMETER(mapname);
683
    UNREFERENCED_PARAMETER(mapname);
684
}
684
}
685
685
686
int32_t ExtPreInit(int32_t argc,char const * const * argv)
686
int32_t ExtPreInit(int32_t argc,char const * const * argv)
687
{
687
{
688
    SW_ExtPreInit(argc, argv);
688
    SW_ExtPreInit(argc, argv);
689
689
690
    OSD_SetLogFile("wangulator.log");
690
    OSD_SetLogFile("wangulator.log");
691
    char tempbuf[256];
691
    char tempbuf[256];
692
    snprintf(tempbuf, ARRAY_SIZE(tempbuf), "%s %s", AppProperName, s_buildRev);
692
    snprintf(tempbuf, ARRAY_SIZE(tempbuf), "%s %s", AppProperName, s_buildRev);
693
    OSD_SetVersion(tempbuf, 10,0);
693
    OSD_SetVersion(tempbuf, 10,0);
694
    buildprintf("%s\n", tempbuf);
694
    buildprintf("%s\n", tempbuf);
695
    PrintBuildInfo();
695
    PrintBuildInfo();
696
696
697
    return 0;
697
    return 0;
698
}
698
}
699
699
700
int
700
int
701
ExtInit(void)
701
ExtInit(void)
702
{
702
{
703
    int rv = 0;
703
    int rv = 0;
704
704
705
#ifndef BUILD_DEV_VER
705
#ifndef BUILD_DEV_VER
706
    char ch;
706
    char ch;
707
707
708
    printf("\n------------------------------------------------------------------------------\n");
708
    printf("\n------------------------------------------------------------------------------\n");
709
    printf("BUILD.EXE for Shadow Warrior\n\n");
709
    printf("BUILD.EXE for Shadow Warrior\n\n");
710
    printf("Copyright (c) 1993 - 1997, 3D Realms Entertainment.\n");
710
    printf("Copyright (c) 1993 - 1997, 3D Realms Entertainment.\n");
711
    printf("\n");
711
    printf("\n");
712
    printf("IMPORTANT:  This editor and associated tools and utilities are NOT\n");
712
    printf("IMPORTANT:  This editor and associated tools and utilities are NOT\n");
713
    printf("shareware and may NOT be freely distributed to any BBS, CD, floppy, or\n");
713
    printf("shareware and may NOT be freely distributed to any BBS, CD, floppy, or\n");
714
    printf("any other media.  These tools may NOT be sold or repackaged for sale in\n");
714
    printf("any other media.  These tools may NOT be sold or repackaged for sale in\n");
715
    printf("a commercial product.\n");
715
    printf("a commercial product.\n");
716
    printf("\n");
716
    printf("\n");
717
    printf("Any levels created with these editors and tools may only be used with the\n");
717
    printf("Any levels created with these editors and tools may only be used with the\n");
718
    printf("full (registered) copy of Shadow Warrior, and not the shareware version.\n");
718
    printf("full (registered) copy of Shadow Warrior, and not the shareware version.\n");
719
    printf("Please refer to LICENSE.DOC for further information on levels created with\n");
719
    printf("Please refer to LICENSE.DOC for further information on levels created with\n");
720
    printf("BUILD.EXE.\n");
720
    printf("BUILD.EXE.\n");
721
    printf("\n");
721
    printf("\n");
722
    printf("Press <Y> if you have read and accepted the terms of LICENSE.DOC,\n");
722
    printf("Press <Y> if you have read and accepted the terms of LICENSE.DOC,\n");
723
    printf("or any other key to abort the program. \n");
723
    printf("or any other key to abort the program. \n");
724
    printf("\n");
724
    printf("\n");
725
    ch = getch();
725
    ch = getch();
726
726
727
    if (ch == 'y' || ch == 'Y')         // if user press Y
727
    if (ch == 'y' || ch == 'Y')         // if user press Y
728
    {
728
    {
729
#endif
729
#endif
730
730
731
731
732
    int i, fil;
732
    int i, fil;
733
733
734
    // Store user log in time
734
    // Store user log in time
735
    //LogUserTime(TRUE);              // Send true because user is logging
735
    //LogUserTime(TRUE);              // Send true because user is logging
736
    // in.
736
    // in.
737
737
738
    OSD_SetParameters(0, 0, 0, 4, 2, 4, "^14", "^14", 0);
738
    OSD_SetParameters(0, 0, 0, 4, 2, 4, "^14", "^14", 0);
739
739
740
    SW_ExtInit();
740
    SW_ExtInit();
741
741
742
    /*
742
    /*
743
        if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
743
        if ((fil = open("setup.dat", O_BINARY | O_RDWR, S_IREAD)) != -1)
744
            {
744
            {
745
            read(fil, &option[0], NUMOPTIONS);
745
            read(fil, &option[0], NUMOPTIONS);
746
            read(fil, &default_buildkeys[0], NUMKEYS);
746
            read(fil, &default_buildkeys[0], NUMKEYS);
747
            memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS); // Trick to make build
747
            memcpy((void *) buildkeys, (void *) default_buildkeys, NUMKEYS); // Trick to make build
748
            // use setup.dat keys
748
            // use setup.dat keys
749
            close(fil);
749
            close(fil);
750
            }
750
            }
751
        */
751
        */
752
    bpp = 32;
752
    bpp = 32;
753
    if (loadsetup(SETUPFILENAME) < 0)
753
    if (loadsetup(SETUPFILENAME) < 0)
754
        buildputs("Configuration file not found, using defaults.\n"), rv = 1;
754
        buildputs("Configuration file not found, using defaults.\n"), rv = 1;
755
    Bmemcpy((void *)buildkeys,(void *)default_buildkeys,NUMBUILDKEYS);       //Trick to make build use setup.dat keys
755
    Bmemcpy((void *)buildkeys,(void *)default_buildkeys,NUMBUILDKEYS);       //Trick to make build use setup.dat keys
756
    if (option[4] > 0)
756
    if (option[4] > 0)
757
        option[4] = 0;
757
        option[4] = 0;
758
758
759
    kensplayerheight = 58;
759
    kensplayerheight = 58;
760
    zmode = 0;
760
    zmode = 0;
761
761
762
    SW_ScanGroups();
762
    SW_ScanGroups();
763
763
764
    wm_msgbox("Pre-Release Software Warning", "%s is not ready for public use. Proceed with caution!", AppProperName);
764
    wm_msgbox("Pre-Release Software Warning", "%s is not ready for public use. Proceed with caution!", AppProperName);
765
765
766
#ifndef BUILD_DEV_VER
766
#ifndef BUILD_DEV_VER
767
}                                   // end user press Y
767
}                                   // end user press Y
768
else
768
else
769
{
769
{
770
    printf("------------------------------------------------------------------------------\n");
770
    printf("------------------------------------------------------------------------------\n");
771
    exit(0);
771
    exit(0);
772
}
772
}
773
#endif
773
#endif
774
    return rv;
774
    return rv;
775
}
775
}
776
776
777
int32_t ExtPostStartupWindow(void)
777
int32_t ExtPostStartupWindow(void)
778
{
778
{
779
    SW_LoadGroups();
779
    SW_LoadGroups();
780
780
781
    if (!g_useCwd)
781
    if (!g_useCwd)
782
        SW_CleanupSearchPaths();
782
        SW_CleanupSearchPaths();
783
783
784
    if (engineInit())
784
    if (engineInit())
785
    {
785
    {
786
        wm_msgbox("Build Engine Initialisation Error",
786
        wm_msgbox("Build Engine Initialisation Error",
787
                  "There was a problem initialising the Build engine: %s", engineerrstr);
787
                  "There was a problem initialising the Build engine: %s", engineerrstr);
788
        return -1;
788
        return -1;
789
    }
789
    }
790
790
791
    InitPalette();
791
    InitPalette();
792
    SW_InitMultiPsky();
792
    SW_InitMultiPsky();
793
793
794
    return 0;
794
    return 0;
795
}
795
}
796
796
797
void ExtPostInit(void)
797
void ExtPostInit(void)
798
{
798
{
799
    palettePostLoadLookups();
799
    palettePostLoadLookups();
800
}
800
}
801
801
802
void
802
void
803
ExtUnInit(void)
803
ExtUnInit(void)
804
{
804
{
805
    uninitgroupfile();
805
    uninitgroupfile();
806
    writesetup(SETUPFILENAME);
806
    writesetup(SETUPFILENAME);
807
    // Store user log in time
807
    // Store user log in time
808
    //LogUserTime(FALSE);                 // FALSE means user is logging out
808
    //LogUserTime(FALSE);                 // FALSE means user is logging out
809
    // now.
809
    // now.
810
}
810
}
811
811
812
void
812
void
813
SetSpriteExtra(void)
813
SetSpriteExtra(void)
814
{
814
{
815
    SPRITEp sp;
815
    SPRITEp sp;
816
    int i;
816
    int i;
817
817
818
#define DEFAULT_SKILL 2
818
#define DEFAULT_SKILL 2
819
819
820
    // for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
820
    // for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
821
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
821
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
822
    {
822
    {
823
        if (sp->picnum == ST1)
823
        if (sp->picnum == ST1)
824
        {
824
        {
825
            if (sp->owner == -1)
825
            if (sp->owner == -1)
826
                sp->owner = 0;
826
                sp->owner = 0;
827
        }
827
        }
828
        else
828
        else
829
        {
829
        {
830
            sp->owner = -1;
830
            sp->owner = -1;
831
        }
831
        }
832
832
833
        if (sp->extra == -1)
833
        if (sp->extra == -1)
834
        {
834
        {
835
            sp->extra = 0;
835
            sp->extra = 0;
836
            SET(sp->extra, DEFAULT_SKILL);
836
            SET(sp->extra, DEFAULT_SKILL);
837
        }
837
        }
838
    }
838
    }
839
839
840
    // loaded_numwalls is what numwalls is after a load
840
    // loaded_numwalls is what numwalls is after a load
841
    // only new walls get their extra's set
841
    // only new walls get their extra's set
842
    if (loaded_numwalls != numwalls)
842
    if (loaded_numwalls != numwalls)
843
    {
843
    {
844
        for (i = 0; i < numwalls; i++)
844
        for (i = 0; i < numwalls; i++)
845
        {
845
        {
846
            if (wall[i].extra != 0)
846
            if (wall[i].extra != 0)
847
                wall[i].extra = 0;
847
                wall[i].extra = 0;
848
        }
848
        }
849
    }
849
    }
850
    loaded_numwalls = numwalls;
850
    loaded_numwalls = numwalls;
851
}
851
}
852
852
853
void
853
void
854
ResetSpriteFound(void)
854
ResetSpriteFound(void)
855
{
855
{
856
    SPRITEp sp;
856
    SPRITEp sp;
857
857
858
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
858
    for (sp = sprite; sp < &sprite[MAXSPRITES]; sp++)
859
    {
859
    {
860
        RESET(sp->extra, SPRX_FOUND);
860
        RESET(sp->extra, SPRX_FOUND);
861
    }
861
    }
862
}
862
}
863
863
864
static void Keys2D()
864
static void Keys2D()
865
{
865
{
866
    if (PRESSED_KEYSC(G))  // G (grid on/off)
866
    if (PRESSED_KEYSC(G))  // G (grid on/off)
867
    {
867
    {
868
        if (autogrid)
868
        if (autogrid)
869
        {
869
        {
870
            grid = 8*eitherSHIFT;
870
            grid = 8*eitherSHIFT;
871
871
872
            autogrid = 0;
872
            autogrid = 0;
873
        }
873
        }
874
        else
874
        else
875
        {
875
        {
876
            grid += (1-2*eitherSHIFT);
876
            grid += (1-2*eitherSHIFT);
877
            if (grid == -1 || grid == 9)
877
            if (grid == -1 || grid == 9)
878
            {
878
            {
879
                autogrid = 1;
879
                autogrid = 1;
880
                grid = 0;
880
                grid = 0;
881
            }
881
            }
882
        }
882
        }
883
883
884
        if (autogrid)
884
        if (autogrid)
885
            printmessage16("Grid size: 9 (autosize)");
885
            printmessage16("Grid size: 9 (autosize)");
886
        else if (!grid)
886
        else if (!grid)
887
            printmessage16("Grid off");
887
            printmessage16("Grid off");
888
        else
888
        else
889
            printmessage16("Grid size: %d (%d units)", grid, 2048>>grid);
889
            printmessage16("Grid size: %d (%d units)", grid, 2048>>grid);
890
    }
890
    }
891
891
892
    if (autogrid)
892
    if (autogrid)
893
    {
893
    {
894
        grid = -1;
894
        grid = -1;
895
895
896
        while (grid++ < 7)
896
        while (grid++ < 7)
897
        {
897
        {
898
            if (mulscale14((2048>>grid), zoom) <= 16)
898
            if (mulscale14((2048>>grid), zoom) <= 16)
899
                break;
899
                break;
900
        }
900
        }
901
    }
901
    }
902
}
902
}
903
903
904
// imported from allen code
904
// imported from allen code
905
void
905
void
906
Keys3D(void)
906
Keys3D(void)
907
{
907
{
908
    int i;
908
    int i;
909
909
910
    // 'PGUP - Move a floor/ceiling sector up 8 pixels.
910
    // 'PGUP - Move a floor/ceiling sector up 8 pixels.
911
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGUP])
911
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGUP])
912
    {
912
    {
913
        switch (searchstat)
913
        switch (searchstat)
914
        {
914
        {
915
        case 1:                 // Ceiling
915
        case 1:                 // Ceiling
916
            sector[searchsector].ceilingz -= (1024 * 8);
916
            sector[searchsector].ceilingz -= (1024 * 8);
917
            keystatus[KEYSC_PGUP] = 0;
917
            keystatus[KEYSC_PGUP] = 0;
918
            break;
918
            break;
919
        case 2:                 // Floor
919
        case 2:                 // Floor
920
            sector[searchsector].floorz -= (1024 * 8);
920
            sector[searchsector].floorz -= (1024 * 8);
921
            keystatus[KEYSC_PGUP] = 0;
921
            keystatus[KEYSC_PGUP] = 0;
922
            break;
922
            break;
923
        }
923
        }
924
924
925
    }
925
    }
926
926
927
    // 'PGDN - Move a floor/ceiling sector down 8 pixels.
927
    // 'PGDN - Move a floor/ceiling sector down 8 pixels.
928
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGDN])
928
    if (keystatus[KEYSC_RCTRL] && keystatus[KEYSC_PGDN])
929
    {
929
    {
930
        switch (searchstat)
930
        switch (searchstat)
931
        {
931
        {
932
        case 1:                 // Ceiling
932
        case 1:                 // Ceiling
933
            sector[searchsector].ceilingz += (1024 * 8);
933
            sector[searchsector].ceilingz += (1024 * 8);
934
            keystatus[KEYSC_PGDN] = 0;
934
            keystatus[KEYSC_PGDN] = 0;
935
            break;
935
            break;
936
        case 2:                 // Floor
936
        case 2:                 // Floor
937
            sector[searchsector].floorz += (1024 * 8);
937
            sector[searchsector].floorz += (1024 * 8);
938
            keystatus[KEYSC_PGDN] = 0;
938
            keystatus[KEYSC_PGDN] = 0;
939
            break;
939
            break;
940
        }
940
        }
941
    }
941
    }
942
942
943
943
944
944
945
    // R - Set relative mode on a floor/ceiling.
945
    // R - Set relative mode on a floor/ceiling.
946
    if (!keystatus[KEYSC_ENTER] && !keystatus[KEYSC_QUOTE] && keystatus[KEYSC_R])
946
    if (!keystatus[KEYSC_ENTER] && !keystatus[KEYSC_QUOTE] && keystatus[KEYSC_R])
947
    {
947
    {
948
        switch (searchstat)
948
        switch (searchstat)
949
        {
949
        {
950
        case 0:
950
        case 0:
951
        case 4:                 // Wall
951
        case 4:                 // Wall
952
            break;
952
            break;
953
        case 1:                 // Ceiling
953
        case 1:                 // Ceiling
954
            if (sector[searchsector].ceilingstat & 65)
954
            if (sector[searchsector].ceilingstat & 65)
955
                Message("Ceiling Relative OFF", M_RED);
955
                Message("Ceiling Relative OFF", M_RED);
956
            else
956
            else
957
                Message("Ceiling Relative ON", M_BLUE);
957
                Message("Ceiling Relative ON", M_BLUE);
958
            break;
958
            break;
959
        case 2:                 // Floor
959
        case 2:                 // Floor
960
            if (sector[searchsector].floorstat & 65)
960
            if (sector[searchsector].floorstat & 65)
961
                Message("Floor Relative OFF", M_RED);
961
                Message("Floor Relative OFF", M_RED);
962
            else
962
            else
963
                Message("Floor Relative ON", M_BLUE);
963
                Message("Floor Relative ON", M_BLUE);
964
            break;
964
            break;
965
        case 3:                 // Sprite
965
        case 3:                 // Sprite
966
            break;
966
            break;
967
        }
967
        }
968
    }
968
    }
969
969
970
    // '+  = Shade down a floor ceiling while keeping sprites constant
970
    // '+  = Shade down a floor ceiling while keeping sprites constant
971
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GPLUS])
971
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GPLUS])
972
    {
972
    {
973
        SWBOOL dospriteshade = FALSE;
973
        SWBOOL dospriteshade = FALSE;
974
974
975
        keystatus[KEYSC_GPLUS] = 0;
975
        keystatus[KEYSC_GPLUS] = 0;
976
976
977
        switch (searchstat)
977
        switch (searchstat)
978
        {
978
        {
979
        case 1:
979
        case 1:
980
            if (sector[searchsector].ceilingstat & 1)
980
            if (sector[searchsector].ceilingstat & 1)
981
                dospriteshade = TRUE;
981
                dospriteshade = TRUE;
982
            if (sector[searchsector].ceilingshade > -128)
982
            if (sector[searchsector].ceilingshade > -128)
983
                sector[searchsector].ceilingshade--;
983
                sector[searchsector].ceilingshade--;
984
            break;
984
            break;
985
        case 2:
985
        case 2:
986
            if (!(sector[searchsector].ceilingstat & 1))
986
            if (!(sector[searchsector].ceilingstat & 1))
987
                dospriteshade = TRUE;
987
                dospriteshade = TRUE;
988
            if (sector[searchsector].floorshade > -128)
988
            if (sector[searchsector].floorshade > -128)
989
                sector[searchsector].floorshade--;
989
                sector[searchsector].floorshade--;
990
            break;
990
            break;
991
        default:
991
        default:
992
            break;
992
            break;
993
        }
993
        }
994
994
995
        if (dospriteshade)
995
        if (dospriteshade)
996
        {
996
        {
997
            for (i = 0; i < MAXSPRITES; i++)
997
            for (i = 0; i < MAXSPRITES; i++)
998
            {
998
            {
999
                if (sprite[i].sectnum == searchsector)
999
                if (sprite[i].sectnum == searchsector)
1000
                {
1000
                {
1001
                    if (sprite[i].shade < 127)
1001
                    if (sprite[i].shade < 127)
1002
                        sprite[i].shade++;
1002
                        sprite[i].shade++;
1003
                }
1003
                }
1004
            }
1004
            }
1005
        }
1005
        }
1006
    }
1006
    }
1007
1007
1008
    // '-  = Shade down a floor ceiling while keeping sprites constant
1008
    // '-  = Shade down a floor ceiling while keeping sprites constant
1009
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GMINUS])
1009
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_GMINUS])
1010
    {
1010
    {
1011
        SWBOOL dospriteshade = FALSE;
1011
        SWBOOL dospriteshade = FALSE;
1012
1012
1013
        keystatus[KEYSC_GMINUS] = 0;
1013
        keystatus[KEYSC_GMINUS] = 0;
1014
1014
1015
        switch (searchstat)
1015
        switch (searchstat)
1016
        {
1016
        {
1017
        case 1:
1017
        case 1:
1018
            if (sector[searchsector].ceilingstat & 1)
1018
            if (sector[searchsector].ceilingstat & 1)
1019
                dospriteshade = TRUE;
1019
                dospriteshade = TRUE;
1020
            if (sector[searchsector].ceilingshade < 127)
1020
            if (sector[searchsector].ceilingshade < 127)
1021
                sector[searchsector].ceilingshade++;
1021
                sector[searchsector].ceilingshade++;
1022
            break;
1022
            break;
1023
        case 2:
1023
        case 2:
1024
            if (!(sector[searchsector].ceilingstat & 1))
1024
            if (!(sector[searchsector].ceilingstat & 1))
1025
                dospriteshade = TRUE;
1025
                dospriteshade = TRUE;
1026
            if (sector[searchsector].floorshade < 127)
1026
            if (sector[searchsector].floorshade < 127)
1027
                sector[searchsector].floorshade++;
1027
                sector[searchsector].floorshade++;
1028
            break;
1028
            break;
1029
        default:
1029
        default:
1030
            break;
1030
            break;
1031
        }
1031
        }
1032
1032
1033
        if (dospriteshade)
1033
        if (dospriteshade)
1034
        {
1034
        {
1035
            for (i = 0; i < MAXSPRITES; i++)
1035
            for (i = 0; i < MAXSPRITES; i++)
1036
            {
1036
            {
1037
                if (sprite[i].sectnum == searchsector)
1037
                if (sprite[i].sectnum == searchsector)
1038
                {
1038
                {
1039
                    if (sprite[i].shade > -128)
1039
                    if (sprite[i].shade > -128)
1040
                        sprite[i].shade--;
1040
                        sprite[i].shade--;
1041
                }
1041
                }
1042
            }
1042
            }
1043
        }
1043
        }
1044
    }
1044
    }
1045
1045
1046
1046
1047
    // 'ENTER - Copies only the bitmap in the copy buffer to
1047
    // 'ENTER - Copies only the bitmap in the copy buffer to
1048
    // wall/ceiling/floor/sprite,
1048
    // wall/ceiling/floor/sprite,
1049
    // whatever the cursor is pointing to. Does not copy x/y repeats etc.,
1049
    // whatever the cursor is pointing to. Does not copy x/y repeats etc.,
1050
    // like ENTER does.
1050
    // like ENTER does.
1051
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_ENTER])       // ' ENTER
1051
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_ENTER])       // ' ENTER
1052
    {
1052
    {
1053
        printext256(0, 0, 15, 0, "Put Graphic ONLY", 0);
1053
        printext256(0, 0, 15, 0, "Put Graphic ONLY", 0);
1054
        keystatus[KEYSC_ENTER] = 0;
1054
        keystatus[KEYSC_ENTER] = 0;
1055
        switch (searchstat)
1055
        switch (searchstat)
1056
        {
1056
        {
1057
        case 0:
1057
        case 0:
1058
            wall[searchwall].picnum = temppicnum;
1058
            wall[searchwall].picnum = temppicnum;
1059
            break;
1059
            break;
1060
        case 1:
1060
        case 1:
1061
            sector[searchsector].ceilingpicnum = temppicnum;
1061
            sector[searchsector].ceilingpicnum = temppicnum;
1062
            break;
1062
            break;
1063
        case 2:
1063
        case 2:
1064
            sector[searchsector].floorpicnum = temppicnum;
1064
            sector[searchsector].floorpicnum = temppicnum;
1065
            break;
1065
            break;
1066
        case 3:
1066
        case 3:
1067
            sprite[searchwall].picnum = temppicnum;
1067
            sprite[searchwall].picnum = temppicnum;
1068
            break;
1068
            break;
1069
        case 4:
1069
        case 4:
1070
            wall[searchwall].overpicnum = temppicnum;
1070
            wall[searchwall].overpicnum = temppicnum;
1071
            break;
1071
            break;
1072
        }
1072
        }
1073
    }
1073
    }
1074
1074
1075
    // ;S
1075
    // ;S
1076
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_S])    // ; S
1076
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_S])    // ; S
1077
    {
1077
    {
1078
        keystatus[KEYSC_S] = 0;
1078
        keystatus[KEYSC_S] = 0;
1079
        switch (searchstat)
1079
        switch (searchstat)
1080
        {
1080
        {
1081
1081
1082
        case 0:
1082
        case 0:
1083
        case 4:
1083
        case 4:
1084
            for (i = 0; i < MAXWALLS; i++)
1084
            for (i = 0; i < MAXWALLS; i++)
1085
            {
1085
            {
1086
                if (wall[i].picnum == temppicnum)
1086
                if (wall[i].picnum == temppicnum)
1087
                {
1087
                {
1088
                    wall[i].shade = tempshade;
1088
                    wall[i].shade = tempshade;
1089
                }
1089
                }
1090
            }
1090
            }
1091
            break;
1091
            break;
1092
        case 1:
1092
        case 1:
1093
        case 2:
1093
        case 2:
1094
            for (i = 0; i < MAXSECTORS; i++)
1094
            for (i = 0; i < MAXSECTORS; i++)
1095
            {
1095
            {
1096
                if (searchstat)
1096
                if (searchstat)
1097
                    if (sector[i].ceilingpicnum == temppicnum)
1097
                    if (sector[i].ceilingpicnum == temppicnum)
1098
                    {
1098
                    {
1099
                        sector[i].ceilingshade = tempshade;
1099
                        sector[i].ceilingshade = tempshade;
1100
                    }
1100
                    }
1101
                if (searchstat == 2)
1101
                if (searchstat == 2)
1102
                    if (sector[i].floorpicnum == temppicnum)
1102
                    if (sector[i].floorpicnum == temppicnum)
1103
                    {
1103
                    {
1104
                        sector[i].floorshade = tempshade;
1104
                        sector[i].floorshade = tempshade;
1105
                    }
1105
                    }
1106
            }
1106
            }
1107
            break;
1107
            break;
1108
        case 3:
1108
        case 3:
1109
            for (i = 0; i < MAXSPRITES; i++)
1109
            for (i = 0; i < MAXSPRITES; i++)
1110
            {
1110
            {
1111
                if (sprite[i].picnum == temppicnum)
1111
                if (sprite[i].picnum == temppicnum)
1112
                {
1112
                {
1113
                    sprite[i].shade = tempshade;
1113
                    sprite[i].shade = tempshade;
1114
                }
1114
                }
1115
            }
1115
            }
1116
            break;
1116
            break;
1117
        }
1117
        }
1118
    }
1118
    }
1119
1119
1120
    // 'C - Does a global tile replacement using bitmap only, no x/y repeat,
1120
    // 'C - Does a global tile replacement using bitmap only, no x/y repeat,
1121
    // etc....
1121
    // etc....
1122
    // Works for walls, sectors, or sprites.
1122
    // Works for walls, sectors, or sprites.
1123
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_C])   // ' C
1123
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_C])   // ' C
1124
    {
1124
    {
1125
        short searchpicnum = 0;
1125
        short searchpicnum = 0;
1126
        short w, start_wall, end_wall, currsector;
1126
        short w, start_wall, end_wall, currsector;
1127
1127
1128
        keystatus[KEYSC_C] = 0;
1128
        keystatus[KEYSC_C] = 0;
1129
1129
1130
        switch (searchstat)
1130
        switch (searchstat)
1131
        {
1131
        {
1132
1132
1133
        case 0:
1133
        case 0:
1134
        case 4:
1134
        case 4:
1135
            searchpicnum = wall[searchwall].picnum;
1135
            searchpicnum = wall[searchwall].picnum;
1136
            if (highlightsectorcnt <= 0)
1136
            if (highlightsectorcnt <= 0)
1137
            {
1137
            {
1138
                for (i = 0; i < MAXWALLS; i++)
1138
                for (i = 0; i < MAXWALLS; i++)
1139
                {
1139
                {
1140
                    if (wall[i].picnum == searchpicnum)
1140
                    if (wall[i].picnum == searchpicnum)
1141
                    {
1141
                    {
1142
                        wall[i].picnum = temppicnum;
1142
                        wall[i].picnum = temppicnum;
1143
                    }
1143
                    }
1144
                }
1144
                }
1145
            }
1145
            }
1146
            else
1146
            else
1147
            {
1147
            {
1148
                for (i = 0; i < highlightsectorcnt; i++)
1148
                for (i = 0; i < highlightsectorcnt; i++)
1149
                {
1149
                {
1150
                    currsector = highlightsector[i];
1150
                    currsector = highlightsector[i];
1151
                    start_wall = sector[currsector].wallptr;
1151
                    start_wall = sector[currsector].wallptr;
1152
                    end_wall = start_wall + sector[currsector].wallnum;
1152
                    end_wall = start_wall + sector[currsector].wallnum;
1153
1153
1154
                    for (w = start_wall; w < end_wall; w++)
1154
                    for (w = start_wall; w < end_wall; w++)
1155
                    {
1155
                    {
1156
                        if (wall[w].picnum == searchpicnum)
1156
                        if (wall[w].picnum == searchpicnum)
1157
                            wall[w].picnum = temppicnum;
1157
                            wall[w].picnum = temppicnum;
1158
                    }
1158
                    }
1159
                }
1159
                }
1160
            }
1160
            }
1161
            break;
1161
            break;
1162
        case 1:
1162
        case 1:
1163
            if (highlightsectorcnt <= 0)
1163
            if (highlightsectorcnt <= 0)
1164
            {
1164
            {
1165
                searchpicnum = sector[searchsector].ceilingpicnum;
1165
                searchpicnum = sector[searchsector].ceilingpicnum;
1166
                for (i = 0; i < MAXSECTORS; i++)
1166
                for (i = 0; i < MAXSECTORS; i++)
1167
                {
1167
                {
1168
                    if (sector[i].ceilingpicnum == searchpicnum)
1168
                    if (sector[i].ceilingpicnum == searchpicnum)
1169
                    {
1169
                    {
1170
                        sector[i].ceilingpicnum = temppicnum;
1170
                        sector[i].ceilingpicnum = temppicnum;
1171
                    }
1171
                    }
1172
                }
1172
                }
1173
            }
1173
            }
1174
            else
1174
            else
1175
            {
1175
            {
1176
                for (i = 0; i < highlightsectorcnt; i++)
1176
                for (i = 0; i < highlightsectorcnt; i++)
1177
                {
1177
                {
1178
                    currsector = highlightsector[i];
1178
                    currsector = highlightsector[i];
1179
1179
1180
                    if (sector[currsector].ceilingpicnum == searchpicnum)
1180
                    if (sector[currsector].ceilingpicnum == searchpicnum)
1181
                        sector[currsector].ceilingpicnum = temppicnum;
1181
                        sector[currsector].ceilingpicnum = temppicnum;
1182
                }
1182
                }
1183
            }
1183
            }
1184
            break;
1184
            break;
1185
        case 2:
1185
        case 2:
1186
            searchpicnum = sector[searchsector].floorpicnum;
1186
            searchpicnum = sector[searchsector].floorpicnum;
1187
            if (highlightsectorcnt <= 0)
1187
            if (highlightsectorcnt <= 0)
1188
            {
1188
            {
1189
                for (i = 0; i < MAXSECTORS; i++)
1189
                for (i = 0; i < MAXSECTORS; i++)
1190
                {
1190
                {
1191
                    if (sector[i].floorpicnum == searchpicnum)
1191
                    if (sector[i].floorpicnum == searchpicnum)
1192
                    {
1192
                    {
1193
                        sector[i].floorpicnum = temppicnum;
1193
                        sector[i].floorpicnum = temppicnum;
1194
                    }
1194
                    }
1195
                }
1195
                }
1196
            }
1196
            }
1197
            else
1197
            else
1198
            {
1198
            {
1199
                for (i = 0; i < highlightsectorcnt; i++)
1199
                for (i = 0; i < highlightsectorcnt; i++)
1200
                {
1200
                {
1201
                    currsector = highlightsector[i];
1201
                    currsector = highlightsector[i];
1202
1202
1203
                    if (sector[currsector].floorpicnum == searchpicnum)
1203
                    if (sector[currsector].floorpicnum == searchpicnum)
1204
                        sector[currsector].floorpicnum = temppicnum;
1204
                        sector[currsector].floorpicnum = temppicnum;
1205
                }
1205
                }
1206
            }
1206
            }
1207
            break;
1207
            break;
1208
        case 3:
1208
        case 3:
1209
            searchpicnum = sprite[searchwall].picnum;
1209
            searchpicnum = sprite[searchwall].picnum;
1210
1210
1211
            if (highlightsectorcnt <= 0)
1211
            if (highlightsectorcnt <= 0)
1212
            {
1212
            {
1213
                for (i = 0; i < MAXSPRITES; i++)
1213
                for (i = 0; i < MAXSPRITES; i++)
1214
                {
1214
                {
1215
                    if (sprite[i].picnum == searchpicnum)
1215
                    if (sprite[i].picnum == searchpicnum)
1216
                        sprite[i].picnum = temppicnum;
1216
                        sprite[i].picnum = temppicnum;
1217
                }
1217
                }
1218
            }
1218
            }
1219
            break;
1219
            break;
1220
        default:
1220
        default:
1221
            break;
1221
            break;
1222
        }
1222
        }
1223
    }
1223
    }
1224
1224
1225
    // 'T - Set's the low tag of a wall/sector/sprite.
1225
    // 'T - Set's the low tag of a wall/sector/sprite.
1226
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_T])   // ' T
1226
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_T])   // ' T
1227
    {
1227
    {
1228
        keystatus[KEYSC_T] = 0;
1228
        keystatus[KEYSC_T] = 0;
1229
        switch (searchstat)
1229
        switch (searchstat)
1230
        {
1230
        {
1231
        case 0:
1231
        case 0:
1232
        case 4:
1232
        case 4:
1233
            strcpy(tempbuf, "Wall lotag: ");
1233
            strcpy(tempbuf, "Wall lotag: ");
1234
            wall[searchwall].lotag =
1234
            wall[searchwall].lotag =
1235
                getnumber256(tempbuf, wall[searchwall].lotag, 65536L, 1);
1235
                getnumber256(tempbuf, wall[searchwall].lotag, 65536L, 1);
1236
            break;
1236
            break;
1237
        case 1:
1237
        case 1:
1238
        case 2:
1238
        case 2:
1239
            strcpy(tempbuf, "Sector lotag: ");
1239
            strcpy(tempbuf, "Sector lotag: ");
1240
            sector[searchsector].lotag =
1240
            sector[searchsector].lotag =
1241
                getnumber256(tempbuf, sector[searchsector].lotag, 65536L, 1);
1241
                getnumber256(tempbuf, sector[searchsector].lotag, 65536L, 1);
1242
            break;
1242
            break;
1243
        case 3:
1243
        case 3:
1244
            strcpy(tempbuf, "Sprite lotag: ");
1244
            strcpy(tempbuf, "Sprite lotag: ");
1245
            sprite[searchwall].lotag =
1245
            sprite[searchwall].lotag =
1246
                getnumber256(tempbuf, sprite[searchwall].lotag, 65536L, 1);
1246
                getnumber256(tempbuf, sprite[searchwall].lotag, 65536L, 1);
1247
            // Find the next lotag
1247
            // Find the next lotag
1248
            if (sprite[searchwall].picnum == ST1)
1248
            if (sprite[searchwall].picnum == ST1)
1249
            {
1249
            {
1250
                FindNextTag();
1250
                FindNextTag();
1251
                ShowNextTag();
1251
                ShowNextTag();
1252
            }
1252
            }
1253
1253
1254
            break;
1254
            break;
1255
        }
1255
        }
1256
    }
1256
    }
1257
1257
1258
    // 'H - Sets the high tag of a wall/sector/sprite.
1258
    // 'H - Sets the high tag of a wall/sector/sprite.
1259
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_H])   // ' H
1259
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_H])   // ' H
1260
    {
1260
    {
1261
        keystatus[KEYSC_H] = 0;
1261
        keystatus[KEYSC_H] = 0;
1262
        switch (searchstat)
1262
        switch (searchstat)
1263
        {
1263
        {
1264
        case 0:
1264
        case 0:
1265
        case 4:
1265
        case 4:
1266
            strcpy(tempbuf, "Wall hitag: ");
1266
            strcpy(tempbuf, "Wall hitag: ");
1267
            wall[searchwall].hitag =
1267
            wall[searchwall].hitag =
1268
                getnumber256(tempbuf, wall[searchwall].hitag, 65536L, 1);
1268
                getnumber256(tempbuf, wall[searchwall].hitag, 65536L, 1);
1269
            break;
1269
            break;
1270
        case 1:
1270
        case 1:
1271
        case 2:
1271
        case 2:
1272
            strcpy(tempbuf, "Sector hitag: ");
1272
            strcpy(tempbuf, "Sector hitag: ");
1273
            sector[searchsector].hitag =
1273
            sector[searchsector].hitag =
1274
                getnumber256(tempbuf, sector[searchsector].hitag, 65536L, 1);
1274
                getnumber256(tempbuf, sector[searchsector].hitag, 65536L, 1);
1275
            break;
1275
            break;
1276
        case 3:
1276
        case 3:
1277
            strcpy(tempbuf, "Sprite hitag: ");
1277
            strcpy(tempbuf, "Sprite hitag: ");
1278
            sprite[searchwall].hitag =
1278
            sprite[searchwall].hitag =
1279
                getnumber256(tempbuf, sprite[searchwall].hitag, 65536L, 1);
1279
                getnumber256(tempbuf, sprite[searchwall].hitag, 65536L, 1);
1280
            break;
1280
            break;
1281
        }
1281
        }
1282
    }
1282
    }
1283
1283
1284
    // 'S - Sets the shade of a wall/sector/sprite using an entered input
1284
    // 'S - Sets the shade of a wall/sector/sprite using an entered input
1285
    // value
1285
    // value
1286
    // between 0-65536.
1286
    // between 0-65536.
1287
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_S])   // ' S
1287
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_S])   // ' S
1288
    {
1288
    {
1289
        keystatus[KEYSC_S] = 0;
1289
        keystatus[KEYSC_S] = 0;
1290
        switch (searchstat)
1290
        switch (searchstat)
1291
        {
1291
        {
1292
        case 0:
1292
        case 0:
1293
        case 4:
1293
        case 4:
1294
            strcpy(tempbuf, "Wall shade: ");
1294
            strcpy(tempbuf, "Wall shade: ");
1295
            wall[searchwall].shade =
1295
            wall[searchwall].shade =
1296
                getnumber256(tempbuf, wall[searchwall].shade, 65536L, 1);
1296
                getnumber256(tempbuf, wall[searchwall].shade, 65536L, 1);
1297
            break;
1297
            break;
1298
        case 1:
1298
        case 1:
1299
        case 2:
1299
        case 2:
1300
            strcpy(tempbuf, "Sector shade: ");
1300
            strcpy(tempbuf, "Sector shade: ");
1301
            if (searchstat == 1)
1301
            if (searchstat == 1)
1302
                sector[searchsector].ceilingshade =
1302
                sector[searchsector].ceilingshade =
1303
                    getnumber256(tempbuf, sector[searchsector].ceilingshade, 65536L, 1);
1303
                    getnumber256(tempbuf, sector[searchsector].ceilingshade, 65536L, 1);
1304
            if (searchstat == 2)
1304
            if (searchstat == 2)
1305
                sector[searchsector].floorshade =
1305
                sector[searchsector].floorshade =
1306
                    getnumber256(tempbuf, sector[searchsector].floorshade, 65536L, 1);
1306
                    getnumber256(tempbuf, sector[searchsector].floorshade, 65536L, 1);
1307
            break;
1307
            break;
1308
        case 3:
1308
        case 3:
1309
            strcpy(tempbuf, "Sprite shade: ");
1309
            strcpy(tempbuf, "Sprite shade: ");
1310
            sprite[searchwall].shade =
1310
            sprite[searchwall].shade =
1311
                getnumber256(tempbuf, sprite[searchwall].shade, 65536L, 1);
1311
                getnumber256(tempbuf, sprite[searchwall].shade, 65536L, 1);
1312
            break;
1312
            break;
1313
        }
1313
        }
1314
    }
1314
    }
1315
1315
1316
    // 'V - Sets sector visibility on a sector using an input value between
1316
    // 'V - Sets sector visibility on a sector using an input value between
1317
    // 0-65536.
1317
    // 0-65536.
1318
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_V])   // ' V
1318
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_V])   // ' V
1319
    {
1319
    {
1320
        keystatus[KEYSC_V] = 0;
1320
        keystatus[KEYSC_V] = 0;
1321
        switch (searchstat)
1321
        switch (searchstat)
1322
        {
1322
        {
1323
        case 1:
1323
        case 1:
1324
        case 2:
1324
        case 2:
1325
            strcpy(tempbuf, "Sector visibility: ");
1325
            strcpy(tempbuf, "Sector visibility: ");
1326
            sector[searchsector].visibility =
1326
            sector[searchsector].visibility =
1327
                getnumber256(tempbuf, sector[searchsector].visibility, 65536L, 1);
1327
                getnumber256(tempbuf, sector[searchsector].visibility, 65536L, 1);
1328
            break;
1328
            break;
1329
        }
1329
        }
1330
    }
1330
    }
1331
1331
1332
    // 'X - Toggles voxel sprites on/off
1332
    // 'X - Toggles voxel sprites on/off
1333
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_X])   // ' X
1333
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_X])   // ' X
1334
    {
1334
    {
1335
        keystatus[KEYSC_X] = 0;
1335
        keystatus[KEYSC_X] = 0;
1336
1336
1337
        bVoxelsOn = !bVoxelsOn;
1337
        bVoxelsOn = !bVoxelsOn;
1338
    }
1338
    }
1339
1339
1340
    // 'Z - Toggles voxel rotation on/off
1340
    // 'Z - Toggles voxel rotation on/off
1341
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_Z])   // ' Z
1341
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_Z])   // ' Z
1342
    {
1342
    {
1343
        keystatus[KEYSC_Z] = 0;
1343
        keystatus[KEYSC_Z] = 0;
1344
1344
1345
        bSpinBobVoxels = !bSpinBobVoxels;
1345
        bSpinBobVoxels = !bSpinBobVoxels;
1346
    }
1346
    }
1347
1347
1348
    // 'A - Toggles sprite autosizing on/off
1348
    // 'A - Toggles sprite autosizing on/off
1349
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_A])   // ' A
1349
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_A])   // ' A
1350
    {
1350
    {
1351
        keystatus[KEYSC_A] = 0;
1351
        keystatus[KEYSC_A] = 0;
1352
1352
1353
        bAutoSize = !bAutoSize;
1353
        bAutoSize = !bAutoSize;
1354
    }
1354
    }
1355
1355
1356
    // 'M - Toggles sprites on/off
1356
    // 'M - Toggles sprites on/off
1357
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_M])   // ' M
1357
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_M])   // ' M
1358
    {
1358
    {
1359
        keystatus[KEYSC_M] = 0;
1359
        keystatus[KEYSC_M] = 0;
1360
1360
1361
        ToggleSprites();
1361
        ToggleSprites();
1362
    }
1362
    }
1363
1363
1364
    // 'P - Will copy palette to all sectors highlighted with R-Alt key
1364
    // 'P - Will copy palette to all sectors highlighted with R-Alt key
1365
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_P])   // ' P
1365
    if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_P])   // ' P
1366
    {
1366
    {
1367
        short w, start_wall, end_wall, currsector;
1367
        short w, start_wall, end_wall, currsector;
1368
1368
1369
        keystatus[KEYSC_P] = 0;
1369
        keystatus[KEYSC_P] = 0;
1370
1370
1371
        for (i = 0; i < highlightsectorcnt; i++)
1371
        for (i = 0; i < highlightsectorcnt; i++)
1372
        {
1372
        {
1373
            currsector = highlightsector[i];
1373
            currsector = highlightsector[i];
1374
            sector[currsector].ceilingpal = temppal;
1374
            sector[currsector].ceilingpal = temppal;
1375
            sector[currsector].floorpal = temppal;
1375
            sector[currsector].floorpal = temppal;
1376
            // Do all the walls in the sector
1376
            // Do all the walls in the sector
1377
            start_wall = sector[currsector].wallptr;
1377
            start_wall = sector[currsector].wallptr;
1378
            end_wall = start_wall + sector[currsector].wallnum;
1378
            end_wall = start_wall + sector[currsector].wallnum;
1379
1379
1380
            for (w = start_wall; w < end_wall; w++)
1380
            for (w = start_wall; w < end_wall; w++)
1381
            {
1381
            {
1382
                wall[w].pal = temppal;
1382
                wall[w].pal = temppal;
1383
            }
1383
            }
1384
        }
1384
        }
1385
    }
1385
    }
1386
1386
1387
    // ;P - Will copy palette to all sectors highlighted with R-Alt key
1387
    // ;P - Will copy palette to all sectors highlighted with R-Alt key
1388
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_P])   // ; P
1388
    if (keystatus[KEYSC_SEMI] && keystatus[KEYSC_P])   // ; P
1389
    {
1389
    {
1390
        short w, start_wall, end_wall, currsector;
1390
        short w, start_wall, end_wall, currsector;
1391
1391
1392
        keystatus[KEYSC_P] = 0;
1392
        keystatus[KEYSC_P] = 0;
1393
1393
1394
        for (i = 0; i < highlightsectorcnt; i++)
1394
        for (i = 0; i < highlightsectorcnt; i++)
1395
        {
1395
        {
1396
            currsector = highlightsector[i];
1396
            currsector = highlightsector[i];
1397
1397
1398
            if ((sector[currsector].ceilingpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1398
            if ((sector[currsector].ceilingpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1399
                sector[currsector].ceilingshade = 127;
1399
                sector[currsector].ceilingshade = 127;
1400
            if ((sector[currsector].floorpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1400
            if ((sector[currsector].floorpal == temppal && temppal != 0) || (temppal == 0 && sector[currsector].ceilingpal != 0))
1401
                sector[currsector].floorshade = 127;
1401
                sector[currsector].floorshade = 127;
1402
1402
1403
            // Do all the walls in the sector
1403
            // Do all the walls in the sector
1404
            start_wall = sector[currsector].wallptr;
1404
            start_wall = sector[currsector].wallptr;
1405
            end_wall = start_wall + sector[currsector].wallnum;
1405
            end_wall = start_wall + sector[currsector].wallnum;
1406
1406
1407
            for (w = start_wall; w < end_wall; w++)
1407
            for (w = start_wall; w < end_wall; w++)
1408
            {
1408
            {
1409
                if ((wall[w].pal == temppal && temppal != 0) || (temppal == 0 && wall[w].pal != 0))
1409
                if ((wall[w].pal == temppal && temppal != 0) || (temppal == 0 && wall[w].pal != 0))
1410
                    wall[w].shade = 127;
1410
                    wall[w].shade = 127;
1411
            }
1411
            }
1412
        }
1412
        }
1413
    }
1413
    }
1414
1414
1415
    ShowMessage();
1415
    ShowMessage();
1416
}                                   // end Keys3D()
1416
}                                   // end Keys3D()
1417
1417
1418
// Used to help print out the item status list
1418
// Used to help print out the item status list
1419
void
1419
void
1420
PrintStatus(const char *string, int num, char x, char y, char color)
1420
PrintStatus(const char *string, int num, char x, char y, char color)
1421
{
1421
{
1422
    sprintf(tempbuf, "%s %d", string, num);
1422
    sprintf(tempbuf, "%s %d", string, num);
1423
    printext16(x * 8, ydim16+y * 8, color, -1, tempbuf, 0);
1423
    printext16(x * 8, ydim16+y * 8, color, -1, tempbuf, 0);
1424
}
1424
}
1425
1425
1426
1426
1427
static int32_t sw_getnumber256(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1427
static int32_t sw_getnumber256(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1428
{
1428
{
1429
    return _getnumber256(namestart, num, maxnumber, sign, NULL);
1429
    return _getnumber256(namestart, num, maxnumber, sign, NULL);
1430
}
1430
}
1431
static int32_t sw_getnumber16(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1431
static int32_t sw_getnumber16(const char *namestart, int32_t num, int32_t maxnumber, char sign)
1432
{
1432
{
1433
    return _getnumber16(namestart, num, maxnumber, sign, NULL);
1433
    return _getnumber16(namestart, num, maxnumber, sign, NULL);
1434
}
1434
}
1435
static void sw_printmessage256(const char *text)
1435
static void sw_printmessage256(const char *text)
1436
{
1436
{
1437
    printmessage256(0, 0, text);
1437
    printmessage256(0, 0, text);
1438
}
1438
}
1439
static void sw_printmessage16(const char *text)
1439
static void sw_printmessage16(const char *text)
1440
{
1440
{
1441
    lastpm16time = (int32_t) totalclock;
1441
    lastpm16time = (int32_t) totalclock;
1442
    _printmessage16("%s", text);
1442
    _printmessage16("%s", text);
1443
}
1443
}
1444
1444
1445
void
1445
void
1446
MoreKeys(short searchstat, short searchwall, short searchsector, short pointhighlight)
1446
MoreKeys(short searchstat, short searchwall, short searchsector, short pointhighlight)
1447
{
1447
{
1448
1448
1449
    typedef int32_t GET_NUM_FUNC (const char *, int32_t, int32_t, char);
1449
    typedef int32_t GET_NUM_FUNC (const char *, int32_t, int32_t, char);
1450
    typedef GET_NUM_FUNC *GET_NUM_FUNCp;
1450
    typedef GET_NUM_FUNC *GET_NUM_FUNCp;
1451
    typedef void PRINT_MSG_FUNC (const char *);
1451
    typedef void PRINT_MSG_FUNC (const char *);
1452
    typedef PRINT_MSG_FUNC *PRINT_MSG_FUNCp;
1452
    typedef PRINT_MSG_FUNC *PRINT_MSG_FUNCp;
1453
    SPRITEp sp;
1453
    SPRITEp sp;
1454
1454
1455
    int i;
1455
    int i;
1456
    int value;
1456
    int value;
1457
1457
1458
    GET_NUM_FUNCp getnumber;
1458
    GET_NUM_FUNCp getnumber;
1459
    PRINT_MSG_FUNCp printmessage;
1459
    PRINT_MSG_FUNCp printmessage;
1460
1460
1461
    if (in3dmode())
1461
    if (in3dmode())
1462
    {
1462
    {
1463
        getnumber = sw_getnumber256;
1463
        getnumber = sw_getnumber256;
1464
        printmessage = sw_printmessage256;
1464
        printmessage = sw_printmessage256;
1465
    }
1465
    }
1466
    else
1466
    else
1467
    {
1467
    {
1468
        getnumber = sw_getnumber16;
1468
        getnumber = sw_getnumber16;
1469
        printmessage = sw_printmessage16;
1469
        printmessage = sw_printmessage16;
1470
1470
1471
        if (TEST(pointhighlight, SPRITE_FLAG))
1471
        if (TEST(pointhighlight, SPRITE_FLAG))
1472
        {
1472
        {
1473
            searchstat = 3;
1473
            searchstat = 3;
1474
            searchwall = RESET(pointhighlight, SPRITE_FLAG);
1474
            searchwall = RESET(pointhighlight, SPRITE_FLAG);
1475
        }
1475
        }
1476
        else
1476
        else
1477
        {
1477
        {
1478
            // for now make search stat invalid
1478
            // for now make search stat invalid
1479
            searchstat = 5;
1479
            searchstat = 5;
1480
        }
1480
        }
1481
    }
1481
    }
1482
1482
1483
    sp = &sprite[searchwall];
1483
    sp = &sprite[searchwall];
1484
1484
1485
1485
1486
1486
1487
    if (KEY_PRESSED(KEYSC_RALT) && KEY_PRESSED(KEYSC_RCTRL))
1487
    if (KEY_PRESSED(KEYSC_RALT) && KEY_PRESSED(KEYSC_RCTRL))
1488
    {
1488
    {
1489
        if (KEY_PRESSED(KEYSC_KPMINUS))
1489
        if (KEY_PRESSED(KEYSC_KPMINUS))
1490
        {
1490
        {
1491
            KEY_PRESSED(KEYSC_KPMINUS) = 0;
1491
            KEY_PRESSED(KEYSC_KPMINUS) = 0;
1492
            g_visibility = g_visibility - (g_visibility >> 3);
1492
            g_visibility = g_visibility - (g_visibility >> 3);
1493
1493
1494
            if (g_visibility < 0)
1494
            if (g_visibility < 0)
1495
                g_visibility = 16348;
1495
                g_visibility = 16348;
1496
        }
1496
        }
1497
        else if (KEY_PRESSED(KEYSC_KPPLUS))
1497
        else if (KEY_PRESSED(KEYSC_KPPLUS))
1498
        {
1498
        {
1499
            KEY_PRESSED(KEYSC_KPPLUS) = 0;
1499
            KEY_PRESSED(KEYSC_KPPLUS) = 0;
1500
            g_visibility = g_visibility + (g_visibility >> 3);
1500
            g_visibility = g_visibility + (g_visibility >> 3);
1501
1501
1502
            if (g_visibility > 16348)
1502
            if (g_visibility > 16348)
1503
                g_visibility = 0;
1503
                g_visibility = 0;
1504
        }
1504
        }
1505
    }
1505
    }
1506
1506
1507
1507
1508
    if (keystatus[KEYSC_QUOTE])
1508
    if (keystatus[KEYSC_QUOTE])
1509
    {
1509
    {
1510
1510
1511
        if (keystatus[KEYSC_K])   // ' K
1511
        if (keystatus[KEYSC_K])   // ' K
1512
        {
1512
        {
1513
            short data;
1513
            short data;
1514
            SPRITEp sp = &sprite[searchwall];
1514
            SPRITEp sp = &sprite[searchwall];
1515
1515
1516
            keystatus[KEYSC_K] = 0;
1516
            keystatus[KEYSC_K] = 0;
1517
            switch (searchstat)
1517
            switch (searchstat)
1518
            {
1518
            {
1519
            case 3:
1519
            case 3:
1520
                data = TEST(sp->extra, SPRX_SKILL);
1520
                data = TEST(sp->extra, SPRX_SKILL);
1521
1521
1522
                //data = getnumber256(tempbuf, data, 65536L);
1522
                //data = getnumber256(tempbuf, data, 65536L);
1523
                data++; // Toggle
1523
                data++; // Toggle
1524
1524
1525
                if (data > 3)
1525
                if (data > 3)
1526
                    data = 0;
1526
                    data = 0;
1527
1527
1528
                RESET(sp->extra, SPRX_SKILL);
1528
                RESET(sp->extra, SPRX_SKILL);
1529
                SET(sp->extra, data);
1529
                SET(sp->extra, data);
1530
                break;
1530
                break;
1531
            }
1531
            }
1532
        }
1532
        }
1533
1533
1534
        if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1534
        if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1535
        {
1535
        {
1536
            if (keystatus[KEYSC_1])
1536
            if (keystatus[KEYSC_1])
1537
            {
1537
            {
1538
                keystatus[KEYSC_1] = 0;
1538
                keystatus[KEYSC_1] = 0;
1539
                keystatus[KEYSC_SEMI] = 0;
1539
                keystatus[KEYSC_SEMI] = 0;
1540
1540
1541
                switch (searchstat)
1541
                switch (searchstat)
1542
                {
1542
                {
1543
                case 3:
1543
                case 3:
1544
                    sprintf(tempbuf, "Sprite tag 11 (shade) (snum = %d): ", searchwall);
1544
                    sprintf(tempbuf, "Sprite tag 11 (shade) (snum = %d): ", searchwall);
1545
                    SPRITE_TAG11(searchwall) =
1545
                    SPRITE_TAG11(searchwall) =
1546
                        getnumber(tempbuf, SPRITE_TAG11(searchwall), 65536L, 0);
1546
                        getnumber(tempbuf, SPRITE_TAG11(searchwall), 65536L, 0);
1547
                    break;
1547
                    break;
1548
                }
1548
                }
1549
1549
1550
                printmessage(" ");
1550
                printmessage(" ");
1551
            }
1551
            }
1552
1552
1553
            if (keystatus[KEYSC_2])
1553
            if (keystatus[KEYSC_2])
1554
            {
1554
            {
1555
                keystatus[KEYSC_2] = 0;
1555
                keystatus[KEYSC_2] = 0;
1556
                keystatus[KEYSC_SEMI] = 0;
1556
                keystatus[KEYSC_SEMI] = 0;
1557
1557
1558
                switch (searchstat)
1558
                switch (searchstat)
1559
                {
1559
                {
1560
                case 3:
1560
                case 3:
1561
                    strcpy(tempbuf, "Sprite tag 12 (pal): ");
1561
                    strcpy(tempbuf, "Sprite tag 12 (pal): ");
1562
                    SPRITE_TAG12(searchwall) =
1562
                    SPRITE_TAG12(searchwall) =
1563
                        getnumber(tempbuf, SPRITE_TAG12(searchwall), 65536L, 0);
1563
                        getnumber(tempbuf, SPRITE_TAG12(searchwall), 65536L, 0);
1564
                    break;
1564
                    break;
1565
                }
1565
                }
1566
1566
1567
                printmessage(" ");
1567
                printmessage(" ");
1568
            }
1568
            }
1569
1569
1570
            if (keystatus[KEYSC_3])
1570
            if (keystatus[KEYSC_3])
1571
            {
1571
            {
1572
                keystatus[KEYSC_3] = 0;
1572
                keystatus[KEYSC_3] = 0;
1573
1573
1574
                switch (searchstat)
1574
                switch (searchstat)
1575
                {
1575
                {
1576
                case 3:
1576
                case 3:
1577
                    strcpy(tempbuf, "Sprite tag 13 (xoffset/yoffset): ");
1577
                    strcpy(tempbuf, "Sprite tag 13 (xoffset/yoffset): ");
1578
                    i = getnumber(tempbuf, SPRITE_TAG13(searchwall), 65536L, 0);
1578
                    i = getnumber(tempbuf, SPRITE_TAG13(searchwall), 65536L, 0);
1579
                    SET_SPRITE_TAG13(searchwall, i);
1579
                    SET_SPRITE_TAG13(searchwall, i);
1580
                    break;
1580
                    break;
1581
                }
1581
                }
1582
1582
1583
                printmessage(" ");
1583
                printmessage(" ");
1584
            }
1584
            }
1585
1585
1586
            if (keystatus[KEYSC_4])
1586
            if (keystatus[KEYSC_4])
1587
            {
1587
            {
1588
                keystatus[KEYSC_4] = 0;
1588
                keystatus[KEYSC_4] = 0;
1589
1589
1590
                switch (searchstat)
1590
                switch (searchstat)
1591
                {
1591
                {
1592
                case 3:
1592
                case 3:
1593
                    strcpy(tempbuf, "Sprite tag 14 (xrepeat/yrepeat): ");
1593
                    strcpy(tempbuf, "Sprite tag 14 (xrepeat/yrepeat): ");
1594
                    i = getnumber(tempbuf, SPRITE_TAG14(searchwall), 65536L, 0);
1594
                    i = getnumber(tempbuf, SPRITE_TAG14(searchwall), 65536L, 0);
1595
                    SET_SPRITE_TAG14(searchwall, i);
1595
                    SET_SPRITE_TAG14(searchwall, i);
1596
                    break;
1596
                    break;
1597
                }
1597
                }
1598
1598
1599
                printmessage(" ");
1599
                printmessage(" ");
1600
            }
1600
            }
1601
1601
1602
            if (keystatus[KEYSC_5])
1602
            if (keystatus[KEYSC_5])
1603
            {
1603
            {
1604
                keystatus[KEYSC_5] = 0;
1604
                keystatus[KEYSC_5] = 0;
1605
1605
1606
                switch (searchstat)
1606
                switch (searchstat)
1607
                {
1607
                {
1608
                case 3:
1608
                case 3:
1609
                    strcpy(tempbuf, "Sprite tag 15 (z): ");
1609
                    strcpy(tempbuf, "Sprite tag 15 (z): ");
1610
                    SPRITE_TAG15(searchwall) =
1610
                    SPRITE_TAG15(searchwall) =
1611
                        getnumber(tempbuf, SPRITE_TAG15(searchwall), 65536L, 0);
1611
                        getnumber(tempbuf, SPRITE_TAG15(searchwall), 65536L, 0);
1612
                    break;
1612
                    break;
1613
                }
1613
                }
1614
1614
1615
                printmessage(" ");
1615
                printmessage(" ");
1616
            }
1616
            }
1617
        }
1617
        }
1618
1618
1619
        if (keystatus[KEYSC_1])
1619
        if (keystatus[KEYSC_1])
1620
        {
1620
        {
1621
            keystatus[KEYSC_1] = 0;
1621
            keystatus[KEYSC_1] = 0;
1622
1622
1623
            switch (searchstat)
1623
            switch (searchstat)
1624
            {
1624
            {
1625
            case 0:
1625
            case 0:
1626
            case 4:
1626
            case 4:
1627
                strcpy(tempbuf, "Wall tag 1 (hitag): ");
1627
                strcpy(tempbuf, "Wall tag 1 (hitag): ");
1628
                wall[searchwall].hitag =
1628
                wall[searchwall].hitag =
1629
                    getnumber(tempbuf, wall[searchwall].hitag, 65536L, 0);
1629
                    getnumber(tempbuf, wall[searchwall].hitag, 65536L, 0);
1630
                break;
1630
                break;
1631
            case 1:
1631
            case 1:
1632
            case 2:
1632
            case 2:
1633
                strcpy(tempbuf, "Sector tag 1 (hitag): ");
1633
                strcpy(tempbuf, "Sector tag 1 (hitag): ");
1634
                sector[searchsector].hitag =
1634
                sector[searchsector].hitag =
1635
                    getnumber(tempbuf, sector[searchsector].hitag, 65536L, 0);
1635
                    getnumber(tempbuf, sector[searchsector].hitag, 65536L, 0);
1636
                break;
1636
                break;
1637
            case 3:
1637
            case 3:
1638
                strcpy(tempbuf, "Sprite tag 1 (hitag): ");
1638
                strcpy(tempbuf, "Sprite tag 1 (hitag): ");
1639
                SPRITE_TAG1(searchwall) =
1639
                SPRITE_TAG1(searchwall) =
1640
                    getnumber(tempbuf, SPRITE_TAG1(searchwall), 65536L, 0);
1640
                    getnumber(tempbuf, SPRITE_TAG1(searchwall), 65536L, 0);
1641
                break;
1641
                break;
1642
            }
1642
            }
1643
1643
1644
            printmessage(" ");
1644
            printmessage(" ");
1645
        }
1645
        }
1646
1646
1647
        if (keystatus[KEYSC_2])
1647
        if (keystatus[KEYSC_2])
1648
        {
1648
        {
1649
            keystatus[KEYSC_2] = 0;
1649
            keystatus[KEYSC_2] = 0;
1650
1650
1651
            switch (searchstat)
1651
            switch (searchstat)
1652
            {
1652
            {
1653
            case 0:
1653
            case 0:
1654
            case 4:
1654
            case 4:
1655
                strcpy(tempbuf, "Wall tag 2 (lotag): ");
1655
                strcpy(tempbuf, "Wall tag 2 (lotag): ");
1656
                wall[searchwall].lotag =
1656
                wall[searchwall].lotag =
1657
                    getnumber(tempbuf, wall[searchwall].lotag, 65536L, 0);
1657
                    getnumber(tempbuf, wall[searchwall].lotag, 65536L, 0);
1658
                break;
1658
                break;
1659
            case 1:
1659
            case 1:
1660
            case 2:
1660
            case 2:
1661
                strcpy(tempbuf, "Sector tag 2 (lotag): ");
1661
                strcpy(tempbuf, "Sector tag 2 (lotag): ");
1662
                sector[searchsector].lotag =
1662
                sector[searchsector].lotag =
1663
                    getnumber(tempbuf, sector[searchsector].lotag, 65536L, 0);
1663
                    getnumber(tempbuf, sector[searchsector].lotag, 65536L, 0);
1664
                break;
1664
                break;
1665
            case 3:
1665
            case 3:
1666
                strcpy(tempbuf, "Sprite tag 2 (lotag): ");
1666
                strcpy(tempbuf, "Sprite tag 2 (lotag): ");
1667
                SPRITE_TAG2(searchwall) =
1667
                SPRITE_TAG2(searchwall) =
1668
                    getnumber(tempbuf, SPRITE_TAG2(searchwall), 65536L, 0);
1668
                    getnumber(tempbuf, SPRITE_TAG2(searchwall), 65536L, 0);
1669
                // Find the next lotag
1669
                // Find the next lotag
1670
                if (sprite[searchwall].picnum == ST1)
1670
                if (sprite[searchwall].picnum == ST1)
1671
                {
1671
                {
1672
                    FindNextTag();
1672
                    FindNextTag();
1673
                    ShowNextTag();
1673
                    ShowNextTag();
1674
                }
1674
                }
1675
                break;
1675
                break;
1676
            }
1676
            }
1677
            printmessage(" ");
1677
            printmessage(" ");
1678
        }
1678
        }
1679
1679
1680
        if (keystatus[KEYSC_3])
1680
        if (keystatus[KEYSC_3])
1681
        {
1681
        {
1682
            keystatus[KEYSC_3] = 0;
1682
            keystatus[KEYSC_3] = 0;
1683
1683
1684
            switch (searchstat)
1684
            switch (searchstat)
1685
            {
1685
            {
1686
            case 0:
1686
            case 0:
1687
            case 4:
1687
            case 4:
1688
                strcpy(tempbuf, "Wall tag 3 (xpanning): ");
1688
                strcpy(tempbuf, "Wall tag 3 (xpanning): ");
1689
                wall[searchwall].xpanning =
1689
                wall[searchwall].xpanning =
1690
                    getnumber(tempbuf, wall[searchwall].xpanning, 65536L, 0);
1690
                    getnumber(tempbuf, wall[searchwall].xpanning, 65536L, 0);
1691
                break;
1691
                break;
1692
            case 1:
1692
            case 1:
1693
            case 2:
1693
            case 2:
1694
                strcpy(tempbuf, "Sector tag 3 (ceilingxpanning): ");
1694
                strcpy(tempbuf, "Sector tag 3 (ceilingxpanning): ");
1695
                sector[searchsector].ceilingxpanning =
1695
                sector[searchsector].ceilingxpanning =
1696
                    getnumber(tempbuf, sector[searchsector].ceilingxpanning, 65536L, 0);
1696
                    getnumber(tempbuf, sector[searchsector].ceilingxpanning, 65536L, 0);
1697
                break;
1697
                break;
1698
            case 3:
1698
            case 3:
1699
                strcpy(tempbuf, "Sprite tag 3 (clipdist) : ");
1699
                strcpy(tempbuf, "Sprite tag 3 (clipdist) : ");
1700
                SPRITE_TAG3(searchwall) =
1700
                SPRITE_TAG3(searchwall) =
1701
                    getnumber(tempbuf, SPRITE_TAG3(searchwall), 65536L, 0);
1701
                    getnumber(tempbuf, SPRITE_TAG3(searchwall), 65536L, 0);
1702
1702
1703
                break;
1703
                break;
1704
            }
1704
            }
1705
            printmessage(" ");
1705
            printmessage(" ");
1706
        }
1706
        }
1707
1707
1708
        if (keystatus[KEYSC_4])
1708
        if (keystatus[KEYSC_4])
1709
        {
1709
        {
1710
            keystatus[KEYSC_4] = 0;
1710
            keystatus[KEYSC_4] = 0;
1711
1711
1712
            switch (searchstat)
1712
            switch (searchstat)
1713
            {
1713
            {
1714
            case 0:
1714
            case 0:
1715
            case 4:
1715
            case 4:
1716
                strcpy(tempbuf, "Wall tag 4 (ypanning): ");
1716
                strcpy(tempbuf, "Wall tag 4 (ypanning): ");
1717
                wall[searchwall].ypanning =
1717
                wall[searchwall].ypanning =
1718
                    getnumber(tempbuf, wall[searchwall].ypanning, 65536L, 0);
1718
                    getnumber(tempbuf, wall[searchwall].ypanning, 65536L, 0);
1719
                break;
1719
                break;
1720
            case 1:
1720
            case 1:
1721
            case 2:
1721
            case 2:
1722
                strcpy(tempbuf, "Sector tag 4 (ceilingypanning): ");
1722
                strcpy(tempbuf, "Sector tag 4 (ceilingypanning): ");
1723
                sector[searchsector].ceilingypanning =
1723
                sector[searchsector].ceilingypanning =
1724
                    getnumber(tempbuf, sector[searchsector].ceilingypanning, 65536L, 0);
1724
                    getnumber(tempbuf, sector[searchsector].ceilingypanning, 65536L, 0);
1725
                break;
1725
                break;
1726
            case 3:
1726
            case 3:
1727
                strcpy(tempbuf, "Sprite tag 4 (ang) : ");
1727
                strcpy(tempbuf, "Sprite tag 4 (ang) : ");
1728
                SPRITE_TAG4(searchwall) =
1728
                SPRITE_TAG4(searchwall) =
1729
                    getnumber(tempbuf, SPRITE_TAG4(searchwall), 65536L, 0);
1729
                    getnumber(tempbuf, SPRITE_TAG4(searchwall), 65536L, 0);
1730
                break;
1730
                break;
1731
            }
1731
            }
1732
            printmessage(" ");
1732
            printmessage(" ");
1733
        }
1733
        }
1734
1734
1735
        if (keystatus[KEYSC_5])
1735
        if (keystatus[KEYSC_5])
1736
        {
1736
        {
1737
            keystatus[KEYSC_5] = 0;
1737
            keystatus[KEYSC_5] = 0;
1738
1738
1739
            switch (searchstat)
1739
            switch (searchstat)
1740
            {
1740
            {
1741
            case 0:
1741
            case 0:
1742
            case 4:
1742
            case 4:
1743
                break;
1743
                break;
1744
            case 1:
1744
            case 1:
1745
            case 2:
1745
            case 2:
1746
                strcpy(tempbuf, "Sector tag 5 (floorxpanning): ");
1746
                strcpy(tempbuf, "Sector tag 5 (floorxpanning): ");
1747
                sector[searchsector].floorxpanning =
1747
                sector[searchsector].floorxpanning =
1748
                    getnumber(tempbuf, sector[searchsector].floorxpanning, 65536L, 0);
1748
                    getnumber(tempbuf, sector[searchsector].floorxpanning, 65536L, 0);
1749
                break;
1749
                break;
1750
            case 3:
1750
            case 3:
1751
                strcpy(tempbuf, "Sprite tag 5 (xvel) : ");
1751
                strcpy(tempbuf, "Sprite tag 5 (xvel) : ");
1752
                SPRITE_TAG5(searchwall) =
1752
                SPRITE_TAG5(searchwall) =
1753
                    getnumber(tempbuf, SPRITE_TAG5(searchwall), 65536L, 0);
1753
                    getnumber(tempbuf, SPRITE_TAG5(searchwall), 65536L, 0);
1754
                break;
1754
                break;
1755
            }
1755
            }
1756
            printmessage(" ");
1756
            printmessage(" ");
1757
        }
1757
        }
1758
1758
1759
        if (keystatus[KEYSC_6])
1759
        if (keystatus[KEYSC_6])
1760
        {
1760
        {
1761
            keystatus[KEYSC_6] = 0;
1761
            keystatus[KEYSC_6] = 0;
1762
1762
1763
            switch (searchstat)
1763
            switch (searchstat)
1764
            {
1764
            {
1765
            case 0:
1765
            case 0:
1766
            case 4:
1766
            case 4:
1767
                break;
1767
                break;
1768
            case 1:
1768
            case 1:
1769
            case 2:
1769
            case 2:
1770
                strcpy(tempbuf, "Sector tag 6 (floorypanning): ");
1770
                strcpy(tempbuf, "Sector tag 6 (floorypanning): ");
1771
                sector[searchsector].floorypanning =
1771
                sector[searchsector].floorypanning =
1772
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1772
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1773
                break;
1773
                break;
1774
            case 3:
1774
            case 3:
1775
                strcpy(tempbuf, "Sprite tag 6 (yvel) : ");
1775
                strcpy(tempbuf, "Sprite tag 6 (yvel) : ");
1776
                SPRITE_TAG6(searchwall) =
1776
                SPRITE_TAG6(searchwall) =
1777
                    getnumber(tempbuf, SPRITE_TAG6(searchwall), 65536L, 0);
1777
                    getnumber(tempbuf, SPRITE_TAG6(searchwall), 65536L, 0);
1778
                break;
1778
                break;
1779
            }
1779
            }
1780
            printmessage(" ");
1780
            printmessage(" ");
1781
        }
1781
        }
1782
1782
1783
        if (keystatus[KEYSC_7])
1783
        if (keystatus[KEYSC_7])
1784
        {
1784
        {
1785
            keystatus[KEYSC_7] = 0;
1785
            keystatus[KEYSC_7] = 0;
1786
1786
1787
            switch (searchstat)
1787
            switch (searchstat)
1788
            {
1788
            {
1789
            case 0:
1789
            case 0:
1790
            case 4:
1790
            case 4:
1791
                break;
1791
                break;
1792
            case 1:
1792
            case 1:
1793
            case 2:
1793
            case 2:
1794
                strcpy(tempbuf, "Sector tag 7 (floorypanning): ");
1794
                strcpy(tempbuf, "Sector tag 7 (floorypanning): ");
1795
                sector[searchsector].floorypanning =
1795
                sector[searchsector].floorypanning =
1796
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1796
                    getnumber(tempbuf, sector[searchsector].floorypanning, 65536L, 0);
1797
                break;
1797
                break;
1798
            case 3:
1798
            case 3:
1799
                strcpy(tempbuf, "Sprite tag 7 (zvel 1) <0-255> : ");
1799
                strcpy(tempbuf, "Sprite tag 7 (zvel 1) <0-255> : ");
1800
                SPRITE_TAG7(searchwall) =
1800
                SPRITE_TAG7(searchwall) =
1801
                    getnumber(tempbuf, SPRITE_TAG7(searchwall), 65536L, 0);
1801
                    getnumber(tempbuf, SPRITE_TAG7(searchwall), 65536L, 0);
1802
                break;
1802
                break;
1803
            }
1803
            }
1804
            printmessage(" ");
1804
            printmessage(" ");
1805
        }
1805
        }
1806
1806
1807
        if (keystatus[KEYSC_8])
1807
        if (keystatus[KEYSC_8])
1808
        {
1808
        {
1809
            keystatus[KEYSC_8] = 0;
1809
            keystatus[KEYSC_8] = 0;
1810
1810
1811
            switch (searchstat)
1811
            switch (searchstat)
1812
            {
1812
            {
1813
            case 0:
1813
            case 0:
1814
            case 4:
1814
            case 4:
1815
                break;
1815
                break;
1816
            case 1:
1816
            case 1:
1817
            case 2:
1817
            case 2:
1818
                break;
1818
                break;
1819
            case 3:
1819
            case 3:
1820
                strcpy(tempbuf, "Sprite tag 8 (zvel 2) <0-255> : ");
1820
                strcpy(tempbuf, "Sprite tag 8 (zvel 2) <0-255> : ");
1821
                SPRITE_TAG8(searchwall) =
1821
                SPRITE_TAG8(searchwall) =
1822
                    getnumber(tempbuf, SPRITE_TAG8(searchwall), 65536L, 0);
1822
                    getnumber(tempbuf, SPRITE_TAG8(searchwall), 65536L, 0);
1823
                break;
1823
                break;
1824
            }
1824
            }
1825
            printmessage(" ");
1825
            printmessage(" ");
1826
        }
1826
        }
1827
1827
1828
        if (keystatus[KEYSC_9])
1828
        if (keystatus[KEYSC_9])
1829
        {
1829
        {
1830
            keystatus[KEYSC_9] = 0;
1830
            keystatus[KEYSC_9] = 0;
1831
1831
1832
            switch (searchstat)
1832
            switch (searchstat)
1833
            {
1833
            {
1834
            case 0:
1834
            case 0:
1835
            case 4:
1835
            case 4:
1836
                break;
1836
                break;
1837
            case 1:
1837
            case 1:
1838
            case 2:
1838
            case 2:
1839
                break;
1839
                break;
1840
            case 3:
1840
            case 3:
1841
                strcpy(tempbuf, "Sprite tag 9 (owner 1) <0-255> : ");
1841
                strcpy(tempbuf, "Sprite tag 9 (owner 1) <0-255> : ");
1842
                SPRITE_TAG9(searchwall) =
1842
                SPRITE_TAG9(searchwall) =
1843
                    getnumber(tempbuf, SPRITE_TAG9(searchwall), 65536L, 0);
1843
                    getnumber(tempbuf, SPRITE_TAG9(searchwall), 65536L, 0);
1844
                break;
1844
                break;
1845
            }
1845
            }
1846
            printmessage(" ");
1846
            printmessage(" ");
1847
        }
1847
        }
1848
1848
1849
        if (keystatus[KEYSC_0])
1849
        if (keystatus[KEYSC_0])
1850
        {
1850
        {
1851
            keystatus[KEYSC_0] = 0;
1851
            keystatus[KEYSC_0] = 0;
1852
1852
1853
            switch (searchstat)
1853
            switch (searchstat)
1854
            {
1854
            {
1855
            case 0:
1855
            case 0:
1856
            case 4:
1856
            case 4:
1857
                break;
1857
                break;
1858
            case 1:
1858
            case 1:
1859
            case 2:
1859
            case 2:
1860
                break;
1860
                break;
1861
            case 3:
1861
            case 3:
1862
                strcpy(tempbuf, "Sprite tag 10 (owner 2) <0-255> : ");
1862
                strcpy(tempbuf, "Sprite tag 10 (owner 2) <0-255> : ");
1863
                SPRITE_TAG10(searchwall) =
1863
                SPRITE_TAG10(searchwall) =
1864
                    getnumber(tempbuf, SPRITE_TAG10(searchwall), 65536L, 0);
1864
                    getnumber(tempbuf, SPRITE_TAG10(searchwall), 65536L, 0);
1865
                break;
1865
                break;
1866
            }
1866
            }
1867
            printmessage(" ");
1867
            printmessage(" ");
1868
        }
1868
        }
1869
1869
1870
    }
1870
    }
1871
1871
1872
    if (!keystatus[KEYSC_SEMI])
1872
    if (!keystatus[KEYSC_SEMI])
1873
        return;
1873
        return;
1874
1874
1875
    if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1875
    if (keystatus[KEYSC_RSHIFT] || keystatus[KEYSC_LSHIFT])
1876
    {
1876
    {
1877
        if (keystatus[KEYSC_1])
1877
        if (keystatus[KEYSC_1])
1878
        {
1878
        {
1879
            keystatus[KEYSC_1] = 0;
1879
            keystatus[KEYSC_1] = 0;
1880
1880
1881
            switch (searchstat)
1881
            switch (searchstat)
1882
            {
1882
            {
1883
            case 3:
1883
            case 3:
1884
                strcpy(tempbuf, "Boolean Sprite tag 11 (0 or 1): ");
1884
                strcpy(tempbuf, "Boolean Sprite tag 11 (0 or 1): ");
1885
                value = !!TEST_BOOL11(sp);
1885
                value = !!TEST_BOOL11(sp);
1886
                value = getnumber(tempbuf, value, 65536L, 0);
1886
                value = getnumber(tempbuf, value, 65536L, 0);
1887
1887
1888
                if (value)
1888
                if (value)
1889
                    SET_BOOL11(sp);
1889
                    SET_BOOL11(sp);
1890
                else
1890
                else
1891
                    RESET_BOOL11(sp);
1891
                    RESET_BOOL11(sp);
1892
1892
1893
                break;
1893
                break;
1894
            }
1894
            }
1895
1895
1896
            printmessage(" ");
1896
            printmessage(" ");
1897
        }
1897
        }
1898
    }
1898
    }
1899
    else
1899
    else
1900
    {
1900
    {
1901
        if (keystatus[KEYSC_1])
1901
        if (keystatus[KEYSC_1])
1902
        {
1902
        {
1903
            keystatus[KEYSC_1] = 0;
1903
            keystatus[KEYSC_1] = 0;
1904
1904
1905
            switch (searchstat)
1905
            switch (searchstat)
1906
            {
1906
            {
1907
            case 3:
1907
            case 3:
1908
                strcpy(tempbuf, "Boolean Sprite tag 1 (0 or 1): ");
1908
                strcpy(tempbuf, "Boolean Sprite tag 1 (0 or 1): ");
1909
                value = !!TEST_BOOL1(sp);
1909
                value = !!TEST_BOOL1(sp);
1910
                value = getnumber(tempbuf, value, 65536L, 0);
1910
                value = getnumber(tempbuf, value, 65536L, 0);
1911
1911
1912
                if (value)
1912
                if (value)
1913
                    SET_BOOL1(sp);
1913
                    SET_BOOL1(sp);
1914
                else
1914
                else
1915
                    RESET_BOOL1(sp);
1915
                    RESET_BOOL1(sp);
1916
1916
1917
                break;
1917
                break;
1918
            }
1918
            }
1919
1919
1920
            printmessage(" ");
1920
            printmessage(" ");
1921
        }
1921
        }
1922
1922
1923
        if (keystatus[KEYSC_2])
1923
        if (keystatus[KEYSC_2])
1924
        {
1924
        {
1925
            keystatus[KEYSC_2] = 0;
1925
            keystatus[KEYSC_2] = 0;
1926
1926
1927
            switch (searchstat)
1927
            switch (searchstat)
1928
            {
1928
            {
1929
            case 3:
1929
            case 3:
1930
                strcpy(tempbuf, "Boolean Sprite tag 2 (0 or 1): ");
1930
                strcpy(tempbuf, "Boolean Sprite tag 2 (0 or 1): ");
1931
                value = !!TEST_BOOL2(sp);
1931
                value = !!TEST_BOOL2(sp);
1932
                value = getnumber(tempbuf, value, 65536L, 0);
1932
                value = getnumber(tempbuf, value, 65536L, 0);
1933
1933
1934
                if (value)
1934
                if (value)
1935
                    SET_BOOL2(sp);
1935
                    SET_BOOL2(sp);
1936
                else
1936
                else
1937
                    RESET_BOOL2(sp);
1937
                    RESET_BOOL2(sp);
1938
1938
1939
                break;
1939
                break;
1940
            }
1940
            }
1941
1941
1942
            printmessage(" ");
1942
            printmessage(" ");
1943
        }
1943
        }
1944
1944
1945
1945
1946
        if (keystatus[KEYSC_3])
1946
        if (keystatus[KEYSC_3])
1947
        {
1947
        {
1948
            keystatus[KEYSC_3] = 0;
1948
            keystatus[KEYSC_3] = 0;
1949
1949
1950
            switch (searchstat)
1950
            switch (searchstat)
1951
            {
1951
            {
1952
            case 3:
1952
            case 3:
1953
                strcpy(tempbuf, "Boolean Sprite tag 3 (0 or 1): ");
1953
                strcpy(tempbuf, "Boolean Sprite tag 3 (0 or 1): ");
1954
                value = !!TEST_BOOL3(sp);
1954
                value = !!TEST_BOOL3(sp);
1955
                value = getnumber(tempbuf, value, 65536L, 0);
1955
                value = getnumber(tempbuf, value, 65536L, 0);
1956
1956
1957
                if (value)
1957
                if (value)
1958
                    SET_BOOL3(sp);
1958
                    SET_BOOL3(sp);
1959
                else
1959
                else
1960
                    RESET_BOOL3(sp);
1960
                    RESET_BOOL3(sp);
1961
1961
1962
                break;
1962
                break;
1963
            }
1963
            }
1964
1964
1965
            printmessage(" ");
1965
            printmessage(" ");
1966
        }
1966
        }
1967
1967
1968
        if (keystatus[KEYSC_4])
1968
        if (keystatus[KEYSC_4])
1969
        {
1969
        {
1970
            keystatus[KEYSC_4] = 0;
1970
            keystatus[KEYSC_4] = 0;
1971
1971
1972
            switch (searchstat)
1972
            switch (searchstat)
1973
            {
1973
            {
1974
            case 3:
1974
            case 3:
1975
                strcpy(tempbuf, "Boolean Sprite tag 4 (0 or 1): ");
1975
                strcpy(tempbuf, "Boolean Sprite tag 4 (0 or 1): ");
1976
                value = !!TEST_BOOL4(sp);
1976
                value = !!TEST_BOOL4(sp);
1977
                value = getnumber(tempbuf, value, 65536L, 0);
1977
                value = getnumber(tempbuf, value, 65536L, 0);
1978
1978
1979
                if (value)
1979
                if (value)
1980
                    SET_BOOL4(sp);
1980
                    SET_BOOL4(sp);
1981
                else
1981
                else
1982
                    RESET_BOOL4(sp);
1982
                    RESET_BOOL4(sp);
1983
1983
1984
                break;
1984
                break;
1985
            }
1985
            }
1986
1986
1987
            printmessage(" ");
1987
            printmessage(" ");
1988
        }
1988
        }
1989
1989
1990
        if (keystatus[KEYSC_5])
1990
        if (keystatus[KEYSC_5])
1991
        {
1991
        {
1992
            keystatus[KEYSC_5] = 0;
1992
            keystatus[KEYSC_5] = 0;
1993
1993
1994
            switch (searchstat)
1994
            switch (searchstat)
1995
            {
1995
            {
1996
            case 3:
1996
            case 3:
1997
                strcpy(tempbuf, "Boolean Sprite tag 5 (0 or 1): ");
1997
                strcpy(tempbuf, "Boolean Sprite tag 5 (0 or 1): ");
1998
                value = !!TEST_BOOL5(sp);
1998
                value = !!TEST_BOOL5(sp);
1999
                value = getnumber(tempbuf, value, 65536L, 0);
1999
                value = getnumber(tempbuf, value, 65536L, 0);
2000
2000
2001
                if (value)
2001
                if (value)
2002
                    SET_BOOL5(sp);
2002
                    SET_BOOL5(sp);
2003
                else
2003
                else
2004
                    RESET_BOOL5(sp);
2004
                    RESET_BOOL5(sp);
2005
2005
2006
                break;
2006
                break;
2007
            }
2007