Subversion Repositories eduke32

Rev

Rev 217 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5 Plagman 1
//-------------------------------------------------------------------------
2
/*
3
Copyright (C) 2005 - EDuke32 team
4
 
5
This file is part of EDuke32
6
 
7
EDuke32 is free software; you can redistribute it and/or
8
modify it under the terms of the GNU General Public License version 2
9
as published by the Free Software Foundation.
10
 
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
 
15
See the GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20
*/
21
//-------------------------------------------------------------------------
22
 
23
#include "duke3d.h"
24
#include "gamedef.h"
25
 
26
#include "osd.h"
27
 
28
int conversion = 13;
29
 
30
static char compilefile[BMAX_PATH] = "(none)";  // file we're currently compiling
31
static char parsing_item_name[MAXVARLABEL] = "(none)", previous_item_name[MAXVARLABEL] = "NULL";
32
 
33
static short total_lines,line_number;
34
static char checking_ifelse,parsing_state;
35
char g_szBuf[1024];
36
 
37
long *casescriptptr=NULL;      // the pointer to the start of the case table in a switch statement
38
// first entry is 'default' code.
39
int casecount = 0;
40
signed char checking_switch = 0, current_event = -1;
41
char labelsonly = 0, nokeywordcheck = 0, dynamicremap = 0;
42
static short num_braces = 0;    // init to some sensible defaults
43
 
92 terminx 44
int redefined_quote_count = 0;
5 Plagman 45
 
46
long *aplWeaponClip[MAX_WEAPONS];       // number of items in magazine
47
long *aplWeaponReload[MAX_WEAPONS];     // delay to reload (include fire)
48
long *aplWeaponFireDelay[MAX_WEAPONS];      // delay to fire
49
long *aplWeaponHoldDelay[MAX_WEAPONS];      // delay after release fire button to fire (0 for none)
50
long *aplWeaponTotalTime[MAX_WEAPONS];      // The total time the weapon is cycling before next fire.
51
long *aplWeaponFlags[MAX_WEAPONS];      // Flags for weapon
52
long *aplWeaponShoots[MAX_WEAPONS];     // what the weapon shoots
53
long *aplWeaponSpawnTime[MAX_WEAPONS];      // the frame at which to spawn an item
54
long *aplWeaponSpawn[MAX_WEAPONS];      // the item to spawn
55
long *aplWeaponShotsPerBurst[MAX_WEAPONS];  // number of shots per 'burst' (one ammo per 'burst'
56
long *aplWeaponWorksLike[MAX_WEAPONS];      // What original the weapon works like
57
long *aplWeaponInitialSound[MAX_WEAPONS];   // Sound made when initialy firing. zero for no sound
58
long *aplWeaponFireSound[MAX_WEAPONS];      // Sound made when firing (each time for automatic)
59
long *aplWeaponSound2Time[MAX_WEAPONS];     // Alternate sound time
60
long *aplWeaponSound2Sound[MAX_WEAPONS];    // Alternate sound sound ID
61
long *aplWeaponReloadSound1[MAX_WEAPONS];    // Sound of magazine being removed
62
long *aplWeaponReloadSound2[MAX_WEAPONS];    // Sound of magazine being inserted
63
 
64
int g_iReturnVarID=-1;      // var ID of "RETURN"
65
int g_iWeaponVarID=-1;      // var ID of "WEAPON"
66
int g_iWorksLikeVarID=-1;   // var ID of "WORKSLIKE"
67
int g_iZRangeVarID=-1;      // var ID of "ZRANGE"
68
int g_iAngRangeVarID=-1;    // var ID of "ANGRANGE"
69
int g_iAimAngleVarID=-1;    // var ID of "AUTOAIMANGLE"
70
int g_iLoTagID=-1;          // var ID of "LOTAG"
71
int g_iHiTagID=-1;          // var ID of "HITAG"
72
int g_iTextureID=-1;        // var ID of "TEXTURE"
73
int g_iThisActorID=-1;      // var ID of "THISACTOR"
74
 
75
long *actorLoadEventScrptr[MAXTILES];
76
 
77
long *apScriptGameEvent[MAXGAMEEVENTS];
78
long *parsing_event=NULL;
79
 
80
MATTGAMEVAR aGameVars[MAXGAMEVARS];
81
int iGameVarCount=0;
82
 
83
MATTGAMEVAR aDefaultGameVars[MAXGAMEVARS];  // the 'original' values
84
 
85
void ReportError(int iError);
86
void FreeGameVars(void);
87
 
88
extern long qsetmode;
89
 
90
enum errors {
91
    ERROR_CLOSEBRACKET,
92
    ERROR_EVENTONLY,
93
    ERROR_EXCEEDSMAXTILES,
94
    ERROR_EXPECTEDKEYWORD,
95
    ERROR_FOUNDWITHIN,
96
    ERROR_ISAKEYWORD,
97
    ERROR_NOENDSWITCH,
98
    ERROR_NOTAGAMEDEF,
99
    ERROR_NOTAGAMEVAR,
100
    ERROR_OPENBRACKET,
101
    ERROR_PARAMUNDEFINED,
102
    ERROR_SYMBOLNOTRECOGNIZED,
103
    ERROR_SYNTAXERROR,
104
    ERROR_VARREADONLY,
105
    ERROR_VARTYPEMISMATCH,
106
    WARNING_DUPLICATEDEFINITION,
107
    WARNING_EVENTSYNC,
108
    WARNING_LABELSONLY,
109
};
110
 
111
enum labeltypes {
112
    LABEL_ANY       = -1,
113
    LABEL_ACTION    = 1,
114
    LABEL_AI        = 2,
115
    LABEL_DEFINE    = 4,
116
    LABEL_MOVE      = 8,
117
    LABEL_STATE     = 16,
118
};
119
 
120
static char *labeltypenames[] = {
121
                                    "define",
122
                                    "state",
123
                                    "actor",
124
                                    "action",
125
                                    "ai",
126
                                    "move"
127
                                };
128
 
129
static char *translatelabeltype(long type)
130
{
131
    int i;
132
    char x[64];
133
 
134
    x[0] = 0;
135
    for (i=0;i<6;i++) {
136
        if (!(type & (1<<i))) continue;
137
        if (x[0]) Bstrcat(x, " or ");
138
        Bstrcat(x, labeltypenames[i]);
139
    }
140
    return strdup(x);
141
}
142
 
143
#define NUMKEYWORDS (signed int)(sizeof(keyw)/sizeof(keyw[0]))
144
 
145
char *keyw[] = {
146
                   "definelevelname",          // 0  defines level name
147
                   "actor",                    // 1  defines an actor
148
                   "addammo",                  // 2  adds ammo to a weapon
149
                   "ifrnd",                    // 3  checks against a randomizer
150
                   "enda",                     // 4  ends an actor definition
151
                   "ifcansee",                 // 5  checks if the player can see an object
152
                   "ifhitweapon",              // 6  checks if an object was hit by a weapon
153
                   "action",                   // 7  defines an action if used outside a state or actor, otherwise triggers actor to perform action
154
                   "ifpdistl",                 // 8  checks if player distance is less than value
155
                   "ifpdistg",                 // 9  checks if player distance is more than value
156
                   "else",                     // 10 used with if checks
157
                   "strength",                 // 11 sets health
158
                   "break",                    // 12 stops processing
159
                   "shoot",                    // 13 shoots a projectile
160
                   "palfrom",                  // 14 used for player screen shading effect, sets p->pals_time and p->pals[0-2]
161
                   "sound",                    // 15 plays a sound that was defined with definesound
162
                   "fall",                     // 16 causes actor to fall to sector floor height
163
                   "state",                    // 17 begins defining a state if used outside a state or actor, otherwise calls a state
164
                   "ends",                     // 18 ends defining a state
165
                   "define",                   // 19 defines a value
166
                   "<null>",                   // 20 was previously used to define a comment
167
                   "ifai",                     // 21 checks if actor is currently performing a specific ai function
168
                   "killit",                   // 22 kills an actor
169
                   "addweapon",                // 23 adds a weapon to the closest player
170
                   "ai",                       // 24 sets an ai function to be used by an actor
171
                   "addphealth",               // 25 adds health to the player
172
                   "ifdead",                   // 26 checks if actor is dead
173
                   "ifsquished",               // 27 checks if actor has been squished
174
                   "sizeto",                   // 28 gradually increases actor size until it matches parameters given
175
                   "{",                        // 29 used to indicate segments of code
176
                   "}",                        // 30 used to indicate segments of code
177
                   "spawn",                    // 31 spawns an actor
178
                   "move",                     // 32
179
                   "ifwasweapon",              // 33
180
                   "ifaction",                 // 34
181
                   "ifactioncount",            // 35
182
                   "resetactioncount",         // 36
183
                   "debris",                   // 37
184
                   "pstomp",                   // 38
185
                   "<null>",                   // 39 was previously used to define the start of a comment block
186
                   "cstat",                    // 40
187
                   "ifmove",                   // 41
188
                   "resetplayer",              // 42
189
                   "ifonwater",                // 43
190
                   "ifinwater",                // 44
191
                   "ifcanshoottarget",         // 45
192
                   "ifcount",                  // 46
193
                   "resetcount",               // 47
194
                   "addinventory",             // 48
195
                   "ifactornotstayput",        // 49
196
                   "hitradius",                // 50
197
                   "ifp",                      // 51
198
                   "count",                    // 52
199
                   "ifactor",                  // 53
200
                   "music",                    // 54
201
                   "include",                  // 55
202
                   "ifstrength",               // 56
203
                   "definesound",              // 57
204
                   "guts",                     // 58
205
                   "ifspawnedby",              // 59
206
                   "gamestartup",              // 60
207
                   "wackplayer",               // 61
208
                   "ifgapzl",                  // 62
209
                   "ifhitspace",               // 63
210
                   "ifoutside",                // 64
211
                   "ifmultiplayer",            // 65
212
                   "operate",                  // 66
213
                   "ifinspace",                // 67
214
                   "debug",                    // 68
215
                   "endofgame",                // 69
216
                   "ifbulletnear",             // 70
217
                   "ifrespawn",                // 71
218
                   "iffloordistl",             // 72
219
                   "ifceilingdistl",           // 73
220
                   "spritepal",                // 74
221
                   "ifpinventory",             // 75
222
                   "betaname",                 // 76
223
                   "cactor",                   // 77
224
                   "ifphealthl",               // 78
225
                   "definequote",              // 79
226
                   "quote",                    // 80
227
                   "ifinouterspace",           // 81
228
                   "ifnotmoving",              // 82
229
                   "respawnhitag",             // 83
230
                   "tip",                      // 84
231
                   "ifspritepal",              // 85
232
                   "money",                    // 86
233
                   "soundonce",                // 87
234
                   "addkills",                 // 88
235
                   "stopsound",                // 89
236
                   "ifawayfromwall",           // 90
237
                   "ifcanseetarget",           // 91
238
                   "globalsound",              // 92
239
                   "lotsofglass",              // 93
240
                   "ifgotweaponce",            // 94
241
                   "getlastpal",               // 95
242
                   "pkick",                    // 96
243
                   "mikesnd",                  // 97
244
                   "useractor",                // 98
245
                   "sizeat",                   // 99
246
                   "addstrength",              // 100  [#]
247
                   "cstator",                  // 101
248
                   "mail",                     // 102
249
                   "paper",                    // 103
250
                   "tossweapon",               // 104
251
                   "sleeptime",                // 105
252
                   "nullop",                   // 106
253
                   "definevolumename",         // 107
254
                   "defineskillname",          // 108
255
                   "ifnosounds",               // 109
256
                   "clipdist",                 // 110
257
                   "ifangdiffl",               // 111
258
                   "gamevar",                  // 112
259
                   "ifvarl",                   // 113
260
                   "ifvarg",                   // 114
261
                   "setvarvar",                // 115
262
                   "setvar",                   // 116
263
                   "addvarvar",                // 117
264
                   "addvar",                   // 118
265
                   "ifvarvarl",                // 119
266
                   "ifvarvarg",                // 120
267
                   "addlogvar",                // 121
268
                   "addlog",                   // 122
269
                   "onevent",                  // 123
270
                   "endevent",                 // 124
271
                   "ifvare",                   // 125
272
                   "ifvarvare",                // 126
273
                   "spgetlotag",               // 127
274
                   "spgethitag",               // 128
275
                   "sectgetlotag",             // 129
276
                   "sectgethitag",             // 130
277
                   "ifsound",                  // 131
278
                   "gettexturefloor",          // 132
279
                   "gettextureceiling",        // 133
280
                   "inittimer",                // 134
281
                   "starttrack",               // 135
282
                   "randvar",                  // 136
283
                   "enhanced",                 // 137
284
                   "getangletotarget",         // 138
285
                   "getactorangle",            // 139
286
                   "setactorangle",            // 140
287
                   "mulvar",                   // 141
288
                   "mulvarvar",                // 142
289
                   "divvar",                   // 143
290
                   "divvarvar",                // 144
291
                   "modvar",                   // 145
292
                   "modvarvar",                // 146
293
                   "andvar",                   // 147
294
                   "andvarvar",                // 148
295
                   "orvar",                    // 149
296
                   "orvarvar",                 // 150
297
                   "getplayerangle",           // 151
298
                   "setplayerangle",           // 152
299
                   "lockplayer",               // 153
300
                   "setsector",                // 154
301
                   "getsector",                // 155
302
                   "setactor",                 // 156
303
                   "getactor",                 // 157
304
                   "setwall",                  // 158
305
                   "getwall",                  // 159
306
                   "findnearactor",            // 160
307
                   "findnearactorvar",         // 161
308
                   "setactorvar",              // 162
309
                   "getactorvar",              // 163
310
                   "espawn",                   // 164
311
                   "getplayer",                // 165
312
                   "setplayer",                // 166
313
                   "sqrt",                     // 167
314
                   "eventloadactor",           // 168
315
                   "espawnvar",                // 169
316
                   "getuserdef",               // 170
317
                   "setuserdef",               // 171
318
                   "subvarvar",                // 172
319
                   "subvar",                   // 173
320
                   "ifvarn",                   // 174
321
                   "ifvarvarn",                // 175
322
                   "ifvarand",                 // 176
323
                   "ifvarvarand",              // 177
324
                   "myos",                     // 178
325
                   "myospal",                  // 179
326
                   "displayrand",              // 180
327
                   "sin",                      // 181
328
                   "xorvarvar",                // 182
329
                   "xorvar",                   // 183
330
                   "randvarvar",               // 184
331
                   "myosx",                    // 185
332
                   "myospalx",                 // 186
333
                   "gmaxammo",                 // 187
334
                   "smaxammo",                 // 188
335
                   "startlevel",               // 189
336
                   "eshoot",                   // 190
337
                   "qspawn",                   // 191
338
                   "rotatesprite",             // 192
339
                   "defineprojectile",         // 193
340
                   "spriteshadow",             // 194
341
                   "cos",                      // 195
342
                   "eshootvar",                // 196
343
                   "findnearactor3d",          // 197
344
                   "findnearactor3dvar",       // 198
345
                   "flash",                    // 199
346
                   "qspawnvar",                // 200
347
                   "eqspawn",                  // 201
348
                   "eqspawnvar",               // 202
349
                   "minitext",                 // 203
350
                   "gametext",                 // 204
351
                   "digitalnumber",            // 205
352
                   "addweaponvar",             // 206
353
                   "setprojectile",            // 207
354
                   "angoff",                   // 208
355
                   "updatesector",             // 209
356
                   "insertspriteq",            // 210
357
                   "angoffvar",                // 211
358
                   "whilevarn",                // 212
359
                   "switch",                   // 213
360
                   "case",                     // 214
361
                   "default",                  // 215
362
                   "endswitch",                // 216
363
                   "shootvar",                 // 217
364
                   "soundvar",                 // 218
365
                   "findplayer",               // 219
366
                   "findotherplayer",          // 220
367
                   "activatebysector",         // 221 sectnum, spriteid
368
                   "operatesectors",           // 222 sectnum, spriteid
369
                   "operaterespawns",          // 223 lotag
370
                   "operateactivators",        // 224 lotag, player index
371
                   "operatemasterswitches",    // 225 lotag
372
                   "checkactivatormotion",     // 226 lotag
373
                   "zshoot",                   // 227 zvar projnum
374
                   "dist",                     // 228 sprite1 sprite2
375
                   "ldist",                    // 229 sprite1 sprite2
376
                   "shiftvarl",                // 230
377
                   "shiftvarr",                // 231
378
                   "spritenvg",                // 232
379
                   "getangle",                 // 233
380
                   "whilevarvarn",             // 234
381
                   "hitscan",                  // 235
382
                   "time",                     // 236
383
                   "getplayervar",             // 237
384
                   "setplayervar",             // 238
385
                   "mulscale",                 // 239
386
                   "setaspect",                // 240
387
                   "txdist",                   // 241
388
                   "spritenoshade",            // 242
389
                   "movesprite",               // 243
390
                   "checkavailweapon",         // 244
391
                   "soundoncevar",             // 245
392
                   "updatesectorz",            // 246
393
                   "stopallsounds",            // 247
394
                   "ssp",                      // 248
395
                   "stopsoundvar",             // 249
396
                   "displayrandvar",           // 250
397
                   "displayrandvarvar",        // 251
398
                   "checkavailinven",          // 252
399
                   "globalsoundvar",           // 253
400
                   "guniqhudid",               // 254
401
                   "getprojectile",            // 255
402
                   "getthisprojectile",        // 256
403
                   "setthisprojectile",        // 257
404
                   "definecheat",              // 258
405
                   "cheatkeys",                // 259
406
                   "userquote",                // 260
407
                   "precache",                 // 261
121 terminx 408
                   "definegamefuncname",       // 262
5 Plagman 409
                   "redefinequote",            // 263
410
                   "dynquote",                 // 264
411
                   "getpname",                 // 265
412
                   "qstrcat",                  // 266
413
                   "qstrcpy",                  // 267
414
                   "setsprite",                // 268
415
                   "rotatepoint",              // 269
416
                   "dragpoint",                // 270
417
                   "getzrange",                // 271
418
                   "changespritestat",         // 272
419
                   "getceilzofslope",          // 273
420
                   "getflorzofslope",          // 274
421
                   "neartag",                  // 275
422
                   "definegametype",           // 276
423
                   "changespritesect",         // 277
424
                   "spriteflags",              // 278
425
                   "savegamevar",              // 279
426
                   "readgamevar",              // 280
427
                   "findnearsprite",           // 281
428
                   "findnearspritevar",        // 282
429
                   "findnearsprite3d",         // 283
430
                   "findnearsprite3dvar",      // 284
431
                   "dynamicremap",             // 285
432
                   "setinput",                 // 286
433
                   "getinput",                 // 287
29 terminx 434
                   "save",                                         // 288
97 terminx 435
                   "cansee",                   // 289
106 terminx 436
                   "canseespr",                // 290
169 terminx 437
                   "findnearactorz",           // 291
438
                   "findnearactorzvar",        // 292
439
                   "findnearspritez",          // 293
440
                   "findnearspritezvar",       // 294
199 terminx 441
                   "ezshoot",                  // 295
5 Plagman 442
                   "<null>"
443
               };
444
 
445
LABELS sectorlabels[]= {
446
                           { "wallptr", SECTOR_WALLPTR, 0, 0 },
447
                           { "wallnum", SECTOR_WALLNUM, 0, 0 },
448
                           { "ceilingz", SECTOR_CEILINGZ, 0, 0 },
449
                           { "floorz", SECTOR_FLOORZ, 0, 0 },
450
                           { "ceilingstat", SECTOR_CEILINGSTAT, 0, 0 },
451
                           { "floorstat", SECTOR_FLOORSTAT, 0, 0 },
452
                           { "ceilingpicnum", SECTOR_CEILINGPICNUM, 0, 0 },
453
                           { "ceilingslope", SECTOR_CEILINGSLOPE, 0, 0 },
454
                           { "ceilingshade", SECTOR_CEILINGSHADE, 0, 0 },
455
                           { "ceilingpal", SECTOR_CEILINGPAL, 0, 0 },
456
                           { "ceilingxpanning", SECTOR_CEILINGXPANNING, 0, 0 },
457
                           { "ceilingypanning", SECTOR_CEILINGYPANNING, 0, 0 },
458
                           { "floorpicnum", SECTOR_FLOORPICNUM, 0, 0 },
459
                           { "floorslope", SECTOR_FLOORSLOPE, 0, 0 },
460
                           { "floorshade", SECTOR_FLOORSHADE, 0, 0 },
461
                           { "floorpal", SECTOR_FLOORPAL, 0, 0 },
462
                           { "floorxpanning", SECTOR_FLOORXPANNING, 0, 0 },
463
                           { "floorypanning", SECTOR_FLOORYPANNING, 0, 0 },
464
                           { "visibility", SECTOR_VISIBILITY, 0, 0 },
465
                           { "alignto", SECTOR_ALIGNTO, 0, 0 },
466
                           { "lotag", SECTOR_LOTAG, 0, 0 },
467
                           { "hitag", SECTOR_HITAG, 0, 0 },
468
                           { "extra", SECTOR_EXTRA, 0, 0 },
469
                           { "", -1, 0, 0  }     // END OF LIST
470
                       };
471
 
472
LABELS walllabels[]= {
473
                         { "x", WALL_X, 0, 0 },
474
                         { "y", WALL_Y, 0, 0 },
475
                         { "point2", WALL_POINT2, 0, 0 },
476
                         { "nextwall", WALL_NEXTWALL, 0, 0 },
477
                         { "nextsector", WALL_NEXTSECTOR, 0, 0 },
478
                         { "cstat", WALL_CSTAT, 0, 0 },
479
                         { "picnum", WALL_PICNUM, 0, 0 },
480
                         { "overpicnum", WALL_OVERPICNUM, 0, 0 },
481
                         { "shade", WALL_SHADE, 0, 0 },
482
                         { "pal", WALL_PAL, 0, 0 },
483
                         { "xrepeat", WALL_XREPEAT, 0, 0 },
484
                         { "yrepeat", WALL_YREPEAT, 0, 0 },
485
                         { "xpanning", WALL_XPANNING, 0, 0 },
486
                         { "ypanning", WALL_YPANNING, 0, 0 },
487
                         { "lotag", WALL_LOTAG, 0, 0 },
488
                         { "hitag", WALL_HITAG, 0, 0 },
489
                         { "extra", WALL_EXTRA, 0, 0 },
490
                         { "", -1, 0, 0  }     // END OF LIST
491
                     };
492
 
493
LABELS actorlabels[]= {
494
                          { "x", ACTOR_X, 0, 0 },
495
                          { "y", ACTOR_Y, 0, 0 },
496
                          { "z", ACTOR_Z, 0, 0 },
497
                          { "cstat", ACTOR_CSTAT, 0, 0 },
498
                          { "picnum", ACTOR_PICNUM, 0, 0 },
499
                          { "shade", ACTOR_SHADE, 0, 0 },
500
                          { "pal", ACTOR_PAL, 0, 0 },
501
                          { "clipdist", ACTOR_CLIPDIST, 0, 0 },
502
                          { "detail", ACTOR_DETAIL, 0, 0 },
503
                          { "xrepeat", ACTOR_XREPEAT, 0, 0 },
504
                          { "yrepeat", ACTOR_YREPEAT, 0, 0 },
505
                          { "xoffset", ACTOR_XOFFSET, 0, 0 },
506
                          { "yoffset", ACTOR_YOFFSET, 0, 0 },
507
                          { "sectnum", ACTOR_SECTNUM, 0, 0 },
508
                          { "statnum", ACTOR_STATNUM, 0, 0 },
509
                          { "ang", ACTOR_ANG, 0, 0 },
510
                          { "owner", ACTOR_OWNER, 0, 0 },
511
                          { "xvel", ACTOR_XVEL, 0, 0 },
512
                          { "yvel", ACTOR_YVEL, 0, 0 },
513
                          { "zvel", ACTOR_ZVEL, 0, 0 },
514
                          { "lotag", ACTOR_LOTAG, 0, 0 },
515
                          { "hitag", ACTOR_HITAG, 0, 0 },
516
                          { "extra", ACTOR_EXTRA, 0, 0 },
517
 
518
                          // hittype labels...
519
                          { "htcgg", ACTOR_HTCGG, 0, 0 },
520
                          { "htpicnum", ACTOR_HTPICNUM, 0, 0 },
521
                          { "htang", ACTOR_HTANG, 0, 0 },
522
                          { "htextra", ACTOR_HTEXTRA, 0, 0 },
523
                          { "htowner", ACTOR_HTOWNER, 0, 0 },
524
                          { "htmovflag", ACTOR_HTMOVFLAG, 0, 0 },
525
                          { "httempang", ACTOR_HTTEMPANG, 0, 0 },
526
                          { "htactorstayput", ACTOR_HTACTORSTAYPUT, 0, 0 },
527
                          { "htdispicnum", ACTOR_HTDISPICNUM, 0, 0 },
528
                          { "httimetosleep", ACTOR_HTTIMETOSLEEP, 0, 0 },
529
                          { "htfloorz", ACTOR_HTFLOORZ, 0, 0 },
530
                          { "htceilingz", ACTOR_HTCEILINGZ, 0, 0 },
531
                          { "htlastvx", ACTOR_HTLASTVX, 0, 0 },
532
                          { "htlastvy", ACTOR_HTLASTVY, 0, 0 },
533
                          { "htbposx", ACTOR_HTBPOSX, 0, 0 },
534
                          { "htbposy", ACTOR_HTBPOSY, 0, 0 },
535
                          { "htbposz", ACTOR_HTBPOSZ, 0, 0 },
536
                          { "htg_t", ACTOR_HTG_T, LABEL_HASPARM2, 8 },
537
 
538
                          // model flags
539
 
540
                          { "angoff", ACTOR_ANGOFF, 0, 0 },
541
                          { "pitch", ACTOR_PITCH, 0, 0 },
542
                          { "roll", ACTOR_ROLL, 0, 0 },
543
                          { "mdxoff", ACTOR_MDXOFF, 0, 0 },
544
                          { "mdyoff", ACTOR_MDYOFF, 0, 0 },
545
                          { "mdzoff", ACTOR_MDZOFF, 0, 0 },
546
                          { "", -1, 0, 0  }     // END OF LIST
547
                      };
548
 
549
LABELS playerlabels[]= {
550
                           { "zoom", PLAYER_ZOOM, 0, 0 },
551
                           { "exitx", PLAYER_EXITX, 0, 0 },
552
                           { "exity", PLAYER_EXITY, 0, 0 },
553
                           { "loogiex", PLAYER_LOOGIEX, LABEL_HASPARM2, 64 },
554
                           { "loogiey", PLAYER_LOOGIEY, LABEL_HASPARM2, 64 },
555
                           { "numloogs", PLAYER_NUMLOOGS, 0, 0 },
556
                           { "loogcnt", PLAYER_LOOGCNT, 0, 0 },
557
                           { "posx", PLAYER_POSX, 0, 0 },
558
                           { "posy", PLAYER_POSY, 0, 0 },
559
                           { "posz", PLAYER_POSZ, 0, 0 },
560
                           { "horiz", PLAYER_HORIZ, 0, 0 },
561
                           { "ohoriz", PLAYER_OHORIZ, 0, 0 },
562
                           { "ohorizoff", PLAYER_OHORIZOFF, 0, 0 },
563
                           { "invdisptime", PLAYER_INVDISPTIME, 0, 0 },
564
                           { "bobposx", PLAYER_BOBPOSX, 0, 0 },
565
                           { "bobposy", PLAYER_BOBPOSY, 0, 0 },
566
                           { "oposx", PLAYER_OPOSX, 0, 0 },
567
                           { "oposy", PLAYER_OPOSY, 0, 0 },
568
                           { "oposz", PLAYER_OPOSZ, 0, 0 },
569
                           { "pyoff", PLAYER_PYOFF, 0, 0 },
570
                           { "opyoff", PLAYER_OPYOFF, 0, 0 },
571
                           { "posxv", PLAYER_POSXV, 0, 0 },
572
                           { "posyv", PLAYER_POSYV, 0, 0 },
573
                           { "poszv", PLAYER_POSZV, 0, 0 },
574
                           { "last_pissed_time", PLAYER_LAST_PISSED_TIME, 0, 0 },
575
                           { "truefz", PLAYER_TRUEFZ, 0, 0 },
576
                           { "truecz", PLAYER_TRUECZ, 0, 0 },
577
                           { "player_par", PLAYER_PLAYER_PAR, 0, 0 },
578
                           { "visibility", PLAYER_VISIBILITY, 0, 0 },
579
                           { "bobcounter", PLAYER_BOBCOUNTER, 0, 0 },
580
                           { "weapon_sway", PLAYER_WEAPON_SWAY, 0, 0 },
581
                           { "pals_time", PLAYER_PALS_TIME, 0, 0 },
582
                           { "randomflamex", PLAYER_RANDOMFLAMEX, 0, 0 },
583
                           { "crack_time", PLAYER_CRACK_TIME, 0, 0 },
584
                           { "aim_mode", PLAYER_AIM_MODE, 0, 0 },
585
                           { "ang", PLAYER_ANG, 0, 0 },
586
                           { "oang", PLAYER_OANG, 0, 0 },
587
                           { "angvel", PLAYER_ANGVEL, 0, 0 },
588
                           { "cursectnum", PLAYER_CURSECTNUM, 0, 0 },
589
                           { "look_ang", PLAYER_LOOK_ANG, 0, 0 },
590
                           { "last_extra", PLAYER_LAST_EXTRA, 0, 0 },
591
                           { "subweapon", PLAYER_SUBWEAPON, 0, 0 },
592
                           { "ammo_amount", PLAYER_AMMO_AMOUNT, LABEL_HASPARM2, MAX_WEAPONS },
593
                           { "wackedbyactor", PLAYER_WACKEDBYACTOR, 0, 0 },
594
                           { "frag", PLAYER_FRAG, 0, 0 },
595
                           { "fraggedself", PLAYER_FRAGGEDSELF, 0, 0 },
596
                           { "curr_weapon", PLAYER_CURR_WEAPON, 0, 0 },
597
                           { "last_weapon", PLAYER_LAST_WEAPON, 0, 0 },
598
                           { "tipincs", PLAYER_TIPINCS, 0, 0 },
599
                           { "horizoff", PLAYER_HORIZOFF, 0, 0 },
600
                           { "wantweaponfire", PLAYER_WANTWEAPONFIRE, 0, 0 },
601
                           { "holoduke_amount", PLAYER_HOLODUKE_AMOUNT, 0, 0 },
602
                           { "newowner", PLAYER_NEWOWNER, 0, 0 },
603
                           { "hurt_delay", PLAYER_HURT_DELAY, 0, 0 },
604
                           { "hbomb_hold_delay", PLAYER_HBOMB_HOLD_DELAY, 0, 0 },
605
                           { "jumping_counter", PLAYER_JUMPING_COUNTER, 0, 0 },
606
                           { "airleft", PLAYER_AIRLEFT, 0, 0 },
607
                           { "knee_incs", PLAYER_KNEE_INCS, 0, 0 },
608
                           { "access_incs", PLAYER_ACCESS_INCS, 0, 0 },
609
                           { "fta", PLAYER_FTA, 0, 0 },
610
                           { "ftq", PLAYER_FTQ, 0, 0 },
611
                           { "access_wallnum", PLAYER_ACCESS_WALLNUM, 0, 0 },
612
                           { "access_spritenum", PLAYER_ACCESS_SPRITENUM, 0, 0 },
613
                           { "kickback_pic", PLAYER_KICKBACK_PIC, 0, 0 },
614
                           { "got_access", PLAYER_GOT_ACCESS, 0, 0 },
615
                           { "weapon_ang", PLAYER_WEAPON_ANG, 0, 0 },
616
                           { "firstaid_amount", PLAYER_FIRSTAID_AMOUNT, 0, 0 },
617
                           { "somethingonplayer", PLAYER_SOMETHINGONPLAYER, 0, 0 },
618
                           { "on_crane", PLAYER_ON_CRANE, 0, 0 },
619
                           { "i", PLAYER_I, 0, 0 },
620
                           { "one_parallax_sectnum", PLAYER_ONE_PARALLAX_SECTNUM, 0, 0 },
621
                           { "over_shoulder_on", PLAYER_OVER_SHOULDER_ON, 0, 0 },
622
                           { "random_club_frame", PLAYER_RANDOM_CLUB_FRAME, 0, 0 },
623
                           { "fist_incs", PLAYER_FIST_INCS, 0, 0 },
624
                           { "one_eighty_count", PLAYER_ONE_EIGHTY_COUNT, 0, 0 },
625
                           { "cheat_phase", PLAYER_CHEAT_PHASE, 0, 0 },
626
                           { "dummyplayersprite", PLAYER_DUMMYPLAYERSPRITE, 0, 0 },
627
                           { "extra_extra8", PLAYER_EXTRA_EXTRA8, 0, 0 },
628
                           { "quick_kick", PLAYER_QUICK_KICK, 0, 0 },
629
                           { "heat_amount", PLAYER_HEAT_AMOUNT, 0, 0 },
630
                           { "actorsqu", PLAYER_ACTORSQU, 0, 0 },
631
                           { "timebeforeexit", PLAYER_TIMEBEFOREEXIT, 0, 0 },
632
                           { "customexitsound", PLAYER_CUSTOMEXITSOUND, 0, 0 },
633
                           { "weaprecs[16]", PLAYER_WEAPRECS, 0, 0 },
634
                           { "weapreccnt", PLAYER_WEAPRECCNT, 0, 0 },
635
                           { "interface_toggle_flag", PLAYER_INTERFACE_TOGGLE_FLAG, 0, 0 },
636
                           { "rotscrnang", PLAYER_ROTSCRNANG, 0, 0 },
637
                           { "dead_flag", PLAYER_DEAD_FLAG, 0, 0 },
638
                           { "show_empty_weapon", PLAYER_SHOW_EMPTY_WEAPON, 0, 0 },
639
                           { "scuba_amount", PLAYER_SCUBA_AMOUNT, 0, 0 },
640
                           { "jetpack_amount", PLAYER_JETPACK_AMOUNT, 0, 0 },
641
                           { "steroids_amount", PLAYER_STEROIDS_AMOUNT, 0, 0 },
642
                           { "shield_amount", PLAYER_SHIELD_AMOUNT, 0, 0 },
643
                           { "holoduke_on", PLAYER_HOLODUKE_ON, 0, 0 },
644
                           { "pycount", PLAYER_PYCOUNT, 0, 0 },
645
                           { "weapon_pos", PLAYER_WEAPON_POS, 0, 0 },
646
                           { "frag_ps", PLAYER_FRAG_PS, 0, 0 },
647
                           { "transporter_hold", PLAYER_TRANSPORTER_HOLD, 0, 0 },
648
                           { "last_full_weapon", PLAYER_LAST_FULL_WEAPON, 0, 0 },
649
                           { "footprintshade", PLAYER_FOOTPRINTSHADE, 0, 0 },
650
                           { "boot_amount", PLAYER_BOOT_AMOUNT, 0, 0 },
651
                           { "scream_voice", PLAYER_SCREAM_VOICE, 0, 0 },
652
                           { "gm", PLAYER_GM, 0, 0 },
653
                           { "on_warping_sector", PLAYER_ON_WARPING_SECTOR, 0, 0 },
654
                           { "footprintcount", PLAYER_FOOTPRINTCOUNT, 0, 0 },
655
                           { "hbomb_on", PLAYER_HBOMB_ON, 0, 0 },
656
                           { "jumping_toggle", PLAYER_JUMPING_TOGGLE, 0, 0 },
657
                           { "rapid_fire_hold", PLAYER_RAPID_FIRE_HOLD, 0, 0 },
658
                           { "on_ground", PLAYER_ON_GROUND, 0, 0 },
659
                           { "name", PLAYER_NAME,  LABEL_ISSTRING, 32 },
660
                           { "inven_icon", PLAYER_INVEN_ICON, 0, 0 },
661
                           { "buttonpalette", PLAYER_BUTTONPALETTE, 0, 0 },
662
                           { "jetpack_on", PLAYER_JETPACK_ON, 0, 0 },
663
                           { "spritebridge", PLAYER_SPRITEBRIDGE, 0, 0 },
664
                           { "lastrandomspot", PLAYER_LASTRANDOMSPOT, 0, 0 },
665
                           { "scuba_on", PLAYER_SCUBA_ON, 0, 0 },
666
                           { "footprintpal", PLAYER_FOOTPRINTPAL, 0, 0 },
667
                           { "heat_on", PLAYER_HEAT_ON, 0, 0 },
668
                           { "holster_weapon", PLAYER_HOLSTER_WEAPON, 0, 0 },
669
                           { "falling_counter", PLAYER_FALLING_COUNTER, 0, 0 },
670
                           { "gotweapon", PLAYER_GOTWEAPON, LABEL_HASPARM2, MAX_WEAPONS },
671
                           { "refresh_inventory", PLAYER_REFRESH_INVENTORY, 0, 0 },
672
                           { "palette", PLAYER_PALETTE, 0, 0 },
673
                           { "toggle_key_flag", PLAYER_TOGGLE_KEY_FLAG, 0, 0 },
674
                           { "knuckle_incs", PLAYER_KNUCKLE_INCS, 0, 0 },
675
                           { "walking_snd_toggle", PLAYER_WALKING_SND_TOGGLE, 0, 0 },
676
                           { "palookup", PLAYER_PALOOKUP, 0, 0 },
677
                           { "hard_landing", PLAYER_HARD_LANDING, 0, 0 },
678
                           { "max_+_rooms", PLAYER_MAX_SECRET_ROOMS, 0, 0 },
679
                           { "secret_rooms", PLAYER_SECRET_ROOMS, 0, 0 },
680
                           { "pals", PLAYER_PALS, LABEL_HASPARM2, 2 },
681
                           { "max_actors_killed", PLAYER_MAX_ACTORS_KILLED, 0, 0 },
682
                           { "actors_killed", PLAYER_ACTORS_KILLED, 0, 0 },
683
                           { "return_to_center", PLAYER_RETURN_TO_CENTER, 0, 0 },
684
                           { "runspeed", PLAYER_RUNSPEED, 0, 0 },
685
                           { "sbs", PLAYER_SBS, 0, 0 },
686
                           { "reloading", PLAYER_RELOADING, 0, 0 },
687
                           { "auto_aim", PLAYER_AUTO_AIM, 0, 0 },
172 terminx 688
                           { "movement_lock", PLAYER_MOVEMENT_LOCK, 0, 0 },
5 Plagman 689
                           { "sound_pitch", PLAYER_SOUND_PITCH, 0, 0 },
690
                           { "weaponswitch", PLAYER_WEAPONSWITCH, 0, 0 },
691
                           { "", -1, 0, 0  }     // END OF LIST
692
                       };
693
 
694
LABELS projectilelabels[]= {
695
                               { "workslike", PROJ_WORKSLIKE, 0, 0 },
696
                               { "spawns", PROJ_SPAWNS, 0, 0 },
697
                               { "sxrepeat", PROJ_SXREPEAT, 0, 0 },
698
                               { "syrepeat", PROJ_SYREPEAT, 0, 0 },
699
                               { "sound", PROJ_SOUND, 0, 0 },
700
                               { "isound", PROJ_ISOUND, 0, 0 },
701
                               { "vel", PROJ_VEL, 0, 0 },
702
                               { "extra", PROJ_EXTRA, 0, 0 },
703
                               { "decal", PROJ_DECAL, 0, 0 },
704
                               { "trail", PROJ_TRAIL, 0, 0 },
705
                               { "txrepeat", PROJ_TXREPEAT, 0, 0 },
706
                               { "tyrepeat", PROJ_TYREPEAT, 0, 0 },
707
                               { "toffset", PROJ_TOFFSET, 0, 0 },
708
                               { "tnum", PROJ_TNUM, 0, 0 },
709
                               { "drop", PROJ_DROP, 0, 0 },
710
                               { "cstat", PROJ_CSTAT, 0, 0 },
711
                               { "clipdist", PROJ_CLIPDIST, 0, 0 },
712
                               { "shade", PROJ_SHADE, 0, 0 },
713
                               { "xrepeat", PROJ_XREPEAT, 0, 0 },
714
                               { "yrepeat", PROJ_YREPEAT, 0, 0 },
715
                               { "pal", PROJ_PAL, 0, 0 },
716
                               { "extra_rand", PROJ_EXTRA_RAND, 0, 0 },
717
                               { "hitradius", PROJ_HITRADIUS, 0, 0 },
718
                               { "velmult", PROJ_VEL_MULT, 0, 0 },
719
                               { "offset", PROJ_OFFSET, 0, 0 },
720
                               { "bounces", PROJ_BOUNCES, 0, 0 },
721
                               { "bsound", PROJ_BSOUND, 0, 0 },
722
                               { "range", PROJ_RANGE, 0, 0 },
723
                               { "", -1, 0, 0  }     // END OF LIST
724
                           };
725
 
726
LABELS userdefslabels[]= {
727
                             //        { "<null>", 1, 0, 0 },
728
                             { "god", USERDEFS_GOD, 0, 0 },
729
                             { "warp_on", USERDEFS_WARP_ON, 0, 0 },
730
                             { "cashman", USERDEFS_CASHMAN, 0, 0 },
731
                             { "eog", USERDEFS_EOG, 0, 0 },
732
                             { "showallmap", USERDEFS_SHOWALLMAP, 0, 0 },
733
                             { "show_help", USERDEFS_SHOW_HELP, 0, 0 },
734
                             { "scrollmode", USERDEFS_SCROLLMODE, 0, 0 },
735
                             { "clipping", USERDEFS_CLIPPING, 0, 0 },
736
                             { "user_name", USERDEFS_USER_NAME, LABEL_HASPARM2, MAXPLAYERS },
737
                             { "ridecule", USERDEFS_RIDECULE, LABEL_HASPARM2 | LABEL_ISSTRING, 10 },
738
                             { "savegame", USERDEFS_SAVEGAME, LABEL_HASPARM2 | LABEL_ISSTRING, 10 },
739
                             { "pwlockout", USERDEFS_PWLOCKOUT, LABEL_ISSTRING, 128 },
740
                             { "rtsname;", USERDEFS_RTSNAME,  LABEL_ISSTRING, 128 },
741
                             { "overhead_on", USERDEFS_OVERHEAD_ON, 0, 0 },
742
                             { "last_overhead", USERDEFS_LAST_OVERHEAD, 0, 0 },
743
                             { "showweapons", USERDEFS_SHOWWEAPONS, 0, 0 },
744
 
745
                             { "pause_on", USERDEFS_PAUSE_ON, 0, 0 },
746
                             { "from_bonus", USERDEFS_FROM_BONUS, 0, 0 },
747
                             { "camerasprite", USERDEFS_CAMERASPRITE, 0, 0 },
748
                             { "last_camsprite", USERDEFS_LAST_CAMSPRITE, 0, 0 },
749
                             { "last_level", USERDEFS_LAST_LEVEL, 0, 0 },
750
                             { "secretlevel", USERDEFS_SECRETLEVEL, 0, 0 },
751
 
752
                             { "const_visibility", USERDEFS_CONST_VISIBILITY, 0, 0 },
753
                             { "uw_framerate", USERDEFS_UW_FRAMERATE, 0, 0 },
754
                             { "camera_time", USERDEFS_CAMERA_TIME, 0, 0 },
755
                             { "folfvel", USERDEFS_FOLFVEL, 0, 0 },
756
                             { "folavel", USERDEFS_FOLAVEL, 0, 0 },
757
                             { "folx", USERDEFS_FOLX, 0, 0 },
758
                             { "foly", USERDEFS_FOLY, 0, 0 },
759
                             { "fola", USERDEFS_FOLA, 0, 0 },
760
                             { "reccnt", USERDEFS_RECCNT, 0, 0 },
761
 
762
                             { "entered_name", USERDEFS_ENTERED_NAME, 0, 0 },
763
                             { "screen_tilting", USERDEFS_SCREEN_TILTING, 0, 0 },
764
                             { "shadows", USERDEFS_SHADOWS, 0, 0 },
765
                             { "fta_on", USERDEFS_FTA_ON, 0, 0 },
766
                             { "executions", USERDEFS_EXECUTIONS, 0, 0 },
767
                             { "auto_run", USERDEFS_AUTO_RUN, 0, 0 },
768
                             { "coords", USERDEFS_COORDS, 0, 0 },
769
                             { "tickrate", USERDEFS_TICKRATE, 0, 0 },
770
                             { "m_coop", USERDEFS_M_COOP, 0, 0 },
771
                             { "coop", USERDEFS_COOP, 0, 0 },
772
                             { "screen_size", USERDEFS_SCREEN_SIZE, 0, 0 },
773
                             { "lockout", USERDEFS_LOCKOUT, 0, 0 },
774
                             { "crosshair", USERDEFS_CROSSHAIR, 0, 0 },
775
                             { "wchoice[MAXPLAYERS][MAX_WEAPONS]", USERDEFS_WCHOICE, 0, 0 },
776
                             { "playerai", USERDEFS_PLAYERAI, 0, 0 },
777
                             { "respawn_monsters", USERDEFS_RESPAWN_MONSTERS, 0, 0 },
778
                             { "respawn_items", USERDEFS_RESPAWN_ITEMS, 0, 0 },
779
                             { "respawn_inventory", USERDEFS_RESPAWN_INVENTORY, 0, 0 },
780
                             { "recstat", USERDEFS_RECSTAT, 0, 0 },
781
                             { "monsters_off", USERDEFS_MONSTERS_OFF, 0, 0 },
782
                             { "brightness", USERDEFS_BRIGHTNESS, 0, 0 },
783
                             { "m_respawn_items", USERDEFS_M_RESPAWN_ITEMS, 0, 0 },
784
                             { "m_respawn_monsters", USERDEFS_M_RESPAWN_MONSTERS, 0, 0 },
785
                             { "m_respawn_inventory", USERDEFS_M_RESPAWN_INVENTORY, 0, 0 },
786
                             { "m_recstat", USERDEFS_M_RECSTAT, 0, 0 },
787
                             { "m_monsters_off", USERDEFS_M_MONSTERS_OFF, 0, 0 },
788
                             { "detail", USERDEFS_DETAIL, 0, 0 },
789
                             { "m_ffire", USERDEFS_M_FFIRE, 0, 0 },
790
                             { "ffire", USERDEFS_FFIRE, 0, 0 },
791
                             { "m_player_skill", USERDEFS_M_PLAYER_SKILL, 0, 0 },
792
                             { "m_level_number", USERDEFS_M_LEVEL_NUMBER, 0, 0 },
793
                             { "m_volume_number", USERDEFS_M_VOLUME_NUMBER, 0, 0 },
794
                             { "multimode", USERDEFS_MULTIMODE, 0, 0 },
795
                             { "player_skill", USERDEFS_PLAYER_SKILL, 0, 0 },
796
                             { "level_number", USERDEFS_LEVEL_NUMBER, 0, 0 },
797
                             { "volume_number", USERDEFS_VOLUME_NUMBER, 0, 0 },
798
                             { "m_marker", USERDEFS_M_MARKER, 0, 0 },
799
                             { "marker", USERDEFS_MARKER, 0, 0 },
800
                             { "mouseflip", USERDEFS_MOUSEFLIP, 0, 0 },
801
                             { "statusbarscale", USERDEFS_STATUSBARSCALE, 0, 0 },
802
                             { "drawweapon", USERDEFS_DRAWWEAPON, 0, 0 },
803
                             { "mouseaiming", USERDEFS_MOUSEAIMING, 0, 0 },
804
                             { "weaponswitch", USERDEFS_WEAPONSWITCH, 0, 0 },
38 terminx 805
                             { "democams", USERDEFS_DEMOCAMS, 0, 0 },
53 terminx 806
                             { "color", USERDEFS_COLOR, 0, 0 },
89 terminx 807
                             { "msgdisptime", USERDEFS_MSGDISPTIME, 0, 0 },
128 terminx 808
                             { "statusbarmode", USERDEFS_STATUSBARMODE, 0, 0 },
147 terminx 809
                             { "m_noexits", USERDEFS_M_NOEXITS, 0, 0 },
810
                             { "noexits", USERDEFS_NOEXITS, 0, 0 },
148 terminx 811
                             { "autovote", USERDEFS_AUTOVOTE, 0, 0 },
150 terminx 812
                             { "automsg", USERDEFS_AUTOMSG, 0, 0 },
152 terminx 813
                             { "idplayers", USERDEFS_IDPLAYERS, 0, 0 },
5 Plagman 814
                             { "", -1, 0, 0  }     // END OF LIST
815
                         };
816
 
817
LABELS inputlabels[]= {
29 terminx 818
                          { "avel", INPUT_AVEL, 0, 0 },
819
                          { "horz", INPUT_HORZ, 0, 0 },
820
                          { "fvel", INPUT_FVEL, 0, 0 },
821
                          { "svel", INPUT_SVEL, 0, 0 },
822
                          { "bits", INPUT_BITS, 0, 0 },
823
                          { "bits2", INPUT_BITS2, 0, 0 },
824
                          { "", -1, 0, 0  }     // END OF LIST
825
                      };
5 Plagman 826
 
827
void skipcomments(void)
828
{
829
    char c;
830
    while ((c = *textptr))
831
    {
832
        if (c == ' ' || c == '\t' || c == '\r')
833
            textptr++;
834
        else if (c == '\n') {
835
            line_number++;
836
            textptr++;
837
        }
838
        else if (c == '/' && textptr[1] == '/')
839
        {
840
            if (!(error || warning) && condebug > 1)
841
                initprintf("%s:%ld: debug: got comment.\n",compilefile,line_number);
842
            while( *textptr != 0x0a && *textptr != 0x0d && *textptr != 0 )
843
                textptr++;
844
        }
845
        else if (c == '/' && textptr[1] == '*')
846
        {
847
            if (!(error || warning) && condebug > 1)
848
                initprintf("%s:%ld: debug: got start of comment block.\n",compilefile,line_number);
849
            while (*textptr && !(textptr[0] == '*' && textptr[1] == '/'))
850
            {
851
                if (*textptr == '\n')
852
                    line_number++;
853
                textptr++;
854
            }
855
            if ((!(error || warning) && condebug > 1) && (textptr[0] == '*' && textptr[1] == '/'))
856
                initprintf("%s:%ld: debug: got end of comment block.\n",compilefile,line_number);
857
            if (!*textptr)
858
            {
859
                if(!(error || warning) && condebug)
860
                    initprintf("%s:%ld: debug: EOF in comment!\n",compilefile,line_number);
861
                ReportError(-1);
862
                initprintf("%s:%ld: error: found `/*' with no `*/'.\n",compilefile,line_number);
863
                parsing_state = num_braces = 0;
864
                parsing_actor = 0;
865
                error++;
866
                break;
867
            }
868
            else textptr+=2;
869
        }
870
        else break;
871
    }
872
}
873
 
874
void DefineProjectile(long lVar1, long lLabelID, long lVar2)
875
{
876
    switch(lLabelID)
877
    {
878
    case PROJ_WORKSLIKE:
879
        projectile[lVar1].workslike=lVar2;
880
        break;
881
 
882
    case PROJ_SPAWNS:
883
        projectile[lVar1].spawns=lVar2;
884
        break;
885
 
886
    case PROJ_SXREPEAT:
887
        projectile[lVar1].sxrepeat=lVar2;
888
        break;
889
 
890
    case PROJ_SYREPEAT:
891
        projectile[lVar1].syrepeat=lVar2;
892
        break;
893
 
894
    case PROJ_SOUND:
895
        projectile[lVar1].sound=lVar2;
896
        break;
897
 
898
    case PROJ_ISOUND:
899
        projectile[lVar1].isound=lVar2;
900
        break;
901
 
902
    case PROJ_VEL:
903
        projectile[lVar1].vel=lVar2;
904
        break;
905
 
906
    case PROJ_EXTRA:
907
        projectile[lVar1].extra=lVar2;
908
        break;
909
 
910
    case PROJ_DECAL:
911
        projectile[lVar1].decal=lVar2;
912
        break;
913
 
914
    case PROJ_TRAIL:
915
        projectile[lVar1].trail=lVar2;
916
        break;
917
 
918
    case PROJ_TXREPEAT:
919
        projectile[lVar1].txrepeat=lVar2;
920
        break;
921
 
922
    case PROJ_TYREPEAT:
923
        projectile[lVar1].tyrepeat=lVar2;
924
        break;
925
 
926
    case PROJ_TOFFSET:
927
        projectile[lVar1].toffset=lVar2;
928
        break;
929
 
930
    case PROJ_TNUM:
931
        projectile[lVar1].tnum=lVar2;
932
        break;
933
 
934
    case PROJ_DROP:
935
        projectile[lVar1].drop=lVar2;
936
        break;
937
 
938
    case PROJ_CSTAT:
939
        projectile[lVar1].cstat=lVar2;
940
        break;
941
 
942
    case PROJ_CLIPDIST:
943
        projectile[lVar1].clipdist=lVar2;
944
        break;
945
 
946
    case PROJ_SHADE:
947
        projectile[lVar1].shade=lVar2;
948
        break;
949
 
950
    case PROJ_XREPEAT:
951
        projectile[lVar1].xrepeat=lVar2;
952
        break;
953
 
954
    case PROJ_YREPEAT:
955
        projectile[lVar1].yrepeat=lVar2;
956
        break;
957
 
958
    case PROJ_PAL:
959
        projectile[lVar1].pal=lVar2;
960
        break;
961
 
962
    case PROJ_EXTRA_RAND:
963
        projectile[lVar1].extra_rand=lVar2;
964
        break;
965
 
966
    case PROJ_HITRADIUS:
967
        projectile[lVar1].hitradius=lVar2;
968
        break;
969
 
970
    case PROJ_VEL_MULT:
971
        projectile[lVar1].velmult=lVar2;
972
        break;
973
 
974
    case PROJ_OFFSET:
975
        projectile[lVar1].offset=lVar2;
976
        break;
977
 
978
    case PROJ_BOUNCES:
979
        projectile[lVar1].bounces=lVar2;
980
        break;
981
 
982
    case PROJ_BSOUND:
983
        projectile[lVar1].bsound=lVar2;
984
        break;
985
 
986
    case PROJ_RANGE:
987
        projectile[lVar1].range=lVar2;
988
        break;
989
 
990
    default:
991
        break;
992
    }
993
 
994
    //  defaultprojectile[lVar1] = projectile[lVar1];
995
    Bmemcpy(&defaultprojectile[lVar1], &projectile[lVar1], sizeof(projectile[lVar1]));
996
 
997
    return;
998
}
999
 
1000
char CheckEventSync(int iEventID)
1001
{
1002
    if(parsing_event || parsing_actor)
1003
    {
1004
        switch(iEventID)
1005
        {
1006
        case EVENT_CHEATGETSTEROIDS:
1007
        case EVENT_CHEATGETHEAT:
1008
        case EVENT_CHEATGETBOOT:
1009
        case EVENT_CHEATGETSHIELD:
1010
        case EVENT_CHEATGETSCUBA:
1011
        case EVENT_CHEATGETHOLODUKE:
1012
        case EVENT_CHEATGETJETPACK:
1013
        case EVENT_CHEATGETFIRSTAID:
1014
        case EVENT_DISPLAYWEAPON:
1015
        case EVENT_DRAWWEAPON:
1016
        case EVENT_DISPLAYCROSSHAIR:
1017
        case EVENT_DISPLAYREST:
1018
        case EVENT_ENTERLEVEL:
1019
        case EVENT_GETLOADTILE:
1020
        case EVENT_GETMENUTILE:
1021
        case EVENT_INIT:
1022
        case EVENT_LOGO:
1023
            return 0;
1024
        default:
1025
            return 1;
1026
        }
1027
    }
1028
    return 1;
1029
}
1030
 
1031
void AddLog(char *psz)
1032
{
1033
    Bstrcpy(tempbuf,psz);
1034
    if(tempbuf[Bstrlen(psz)] != '\n')
1035
        Bstrcat(tempbuf,"\n");
1036
    if (qsetmode == 200) OSD_Printf(tempbuf);
1037
    else initprintf(tempbuf);
1038
}
1039
 
1040
char AddGameVar(char *pszLabel, long lValue, unsigned long dwFlags);
1041
 
120 terminx 1042
int ReadGameVars(long fil)
5 Plagman 1043
{
1044
    int i;
1045
    long l;
1046
 
1047
    //     AddLog("Reading gamevars from savegame");
1048
 
1049
    FreeGameVars(); // nuke 'em from orbit, it's the only way to be sure...
1050
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1051
    //  AddLog(g_szBuf);
1052
 
120 terminx 1053
    if(kdfread(&iGameVarCount,sizeof(iGameVarCount),1,fil) != 1) goto corrupt;
5 Plagman 1054
    for(i=0;i<iGameVarCount;i++)
1055
    {
120 terminx 1056
        if(kdfread(&(aGameVars[i]),sizeof(MATTGAMEVAR),1,fil) != 1) goto corrupt;
104 terminx 1057
        aGameVars[i].szLabel=Bcalloc(MAXVARLABEL,sizeof(char));
120 terminx 1058
        if(kdfread(aGameVars[i].szLabel,sizeof(char) * MAXVARLABEL, 1, fil) != 1) goto corrupt;
5 Plagman 1059
    }
1060
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1061
    //  AddLog(g_szBuf);
1062
    for(i=0;i<iGameVarCount;i++)
1063
    {
1064
        if(aGameVars[i].dwFlags & GAMEVAR_FLAG_PERPLAYER)
104 terminx 1065
            aGameVars[i].plValues=Bcalloc(MAXPLAYERS,sizeof(long));
5 Plagman 1066
        else if( aGameVars[i].dwFlags & GAMEVAR_FLAG_PERACTOR)
104 terminx 1067
            aGameVars[i].plValues=Bcalloc(MAXSPRITES,sizeof(long));
5 Plagman 1068
        else
1069
            // else nothing 'extra...'
1070
            aGameVars[i].plValues=NULL;
1071
    }
1072
 
1073
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1074
    //  AddLog(g_szBuf);
1075
    InitGameVarPointers();
1076
 
1077
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1078
    //  AddLog(g_szBuf);
1079
    for(i=0;i<iGameVarCount;i++)
1080
    {
1081
        if(aGameVars[i].dwFlags & GAMEVAR_FLAG_PERPLAYER)
1082
        {
1083
            //Bsprintf(g_szBuf,"Reading value array for %s (%d)",aGameVars[i].szLabel,sizeof(long) * MAXPLAYERS);
1084
            //AddLog(g_szBuf);
120 terminx 1085
            if(kdfread(aGameVars[i].plValues,sizeof(long) * MAXPLAYERS, 1, fil) != 1) goto corrupt;
5 Plagman 1086
        }
1087
        else if( aGameVars[i].dwFlags & GAMEVAR_FLAG_PERACTOR)
1088
        {
1089
            //Bsprintf(g_szBuf,"Reading value array for %s (%d)",aGameVars[i].szLabel,sizeof(long) * MAXSPRITES);
1090
            //AddLog(g_szBuf);
126 terminx 1091
            if(kdfread(&aGameVars[i].plValues[0],sizeof(long), MAXSPRITES, fil) != MAXSPRITES) goto corrupt;
5 Plagman 1092
        }
1093
        // else nothing 'extra...'
1094
    }
1095
 
1096
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1097
    //  AddLog(g_szBuf);
120 terminx 1098
    if(kdfread(apScriptGameEvent,sizeof(apScriptGameEvent),1,fil) != 1) goto corrupt;
5 Plagman 1099
    for(i=0;i<MAXGAMEEVENTS;i++)
1100
        if(apScriptGameEvent[i])
1101
        {
1102
            l = (long)apScriptGameEvent[i]+(long)&script[0];
1103
            apScriptGameEvent[i] = (long *)l;
1104
        }
1105
 
1106
    //  Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1107
    //  AddLog(g_szBuf);
120 terminx 1108
    if(kdfread(&l,sizeof(l),1,fil) != 1) goto corrupt;
1109
    if(kdfread(g_szBuf,l,1,fil) != 1) goto corrupt;
5 Plagman 1110
    g_szBuf[l]=0;
1111
    AddLog(g_szBuf);
1112
 
1113
#if 0
1114
    {
1115
        FILE *fp;
1116
        AddLog("Dumping Vars...");
1117
        fp=fopen("xxx.txt","w");
1118
        if(fp)
1119
        {
1120
            DumpGameVars(fp);
1121
            fclose(fp);
1122
        }
1123
        AddLog("Done Dumping...");
1124
    }
1125
#endif
120 terminx 1126
    return(0);
1127
corrupt:
1128
    return(1);
5 Plagman 1129
}
1130
 
1131
void SaveGameVars(FILE *fil)
1132
{
1133
    int i;
1134
    long l;
1135
 
1136
    //   AddLog("Saving Game Vars to File");
1137
    dfwrite(&iGameVarCount,sizeof(iGameVarCount),1,fil);
1138
 
1139
    for(i=0;i<iGameVarCount;i++)
1140
    {
1141
        dfwrite(&(aGameVars[i]),sizeof(MATTGAMEVAR),1,fil);
102 terminx 1142
        dfwrite(aGameVars[i].szLabel,sizeof(char) * MAXVARLABEL, 1, fil);
5 Plagman 1143
    }
1144
 
1145
    //     dfwrite(&aGameVars,sizeof(aGameVars),1,fil);
1146
 
1147
    for(i=0;i<iGameVarCount;i++)
1148
    {
1149
        if(aGameVars[i].dwFlags & GAMEVAR_FLAG_PERPLAYER)
1150
        {
1151
            //Bsprintf(g_szBuf,"Writing value array for %s (%d)",aGameVars[i].szLabel,sizeof(long) * MAXPLAYERS);
1152
            //AddLog(g_szBuf);
1153
            dfwrite(aGameVars[i].plValues,sizeof(long) * MAXPLAYERS, 1, fil);
1154
        }
1155
        else if( aGameVars[i].dwFlags & GAMEVAR_FLAG_PERACTOR)
1156
        {
1157
            //Bsprintf(g_szBuf,"Writing value array for %s (%d)",aGameVars[i].szLabel,sizeof(long) * MAXSPRITES);
1158
            //AddLog(g_szBuf);
126 terminx 1159
            dfwrite(&aGameVars[i].plValues[0],sizeof(long), MAXSPRITES, fil);
5 Plagman 1160
        }
1161
        // else nothing 'extra...'
1162
    }
1163
 
1164
    for(i=0;i<MAXGAMEEVENTS;i++)
1165
        if(apScriptGameEvent[i])
1166
        {
1167
            l = (long)apScriptGameEvent[i]-(long)&script[0];
1168
            apScriptGameEvent[i] = (long *)l;
1169
        }
1170
    dfwrite(apScriptGameEvent,sizeof(apScriptGameEvent),1,fil);
1171
    for(i=0;i<MAXGAMEEVENTS;i++)
1172
        if(apScriptGameEvent[i])
1173
        {
1174
            l = (long)apScriptGameEvent[i]+(long)&script[0];
1175
            apScriptGameEvent[i] = (long *)l;
1176
        }
1177
 
1178
    Bsprintf(g_szBuf,"EOF: EDuke32");
1179
    l=strlen(g_szBuf);
1180
    dfwrite(&l,sizeof(l),1,fil);
1181
    dfwrite(g_szBuf,l,1,fil);
1182
}
1183
 
1184
void DumpGameVars(FILE *fp)
1185
{
1186
    int i;
1187
    if(!fp)
1188
    {
1189
        return;
1190
    }
1191
    fprintf(fp,"// Current Game Definitions\n\n");
1192
    for(i=0;i<iGameVarCount;i++)
1193
    {
1194
        if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_SECRET) )
1195
        {
1196
            continue; // do nothing...
1197
        }
1198
        else
1199
        {
1200
            fprintf(fp,"gamevar %s ",aGameVars[i].szLabel);
1201
 
1202
            if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_PLONG) )
1203
                fprintf(fp,"%ld",*((long*)aGameVars[i].lValue));
1204
            else
1205
                fprintf(fp,"%ld",aGameVars[i].lValue);
1206
            if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_PERPLAYER) )
1207
                fprintf(fp," GAMEVAR_FLAG_PERPLAYER");
1208
            else if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_PERACTOR) )
1209
                fprintf(fp," GAMEVAR_FLAG_PERACTOR");
1210
            else
1211
                fprintf(fp," %ld",aGameVars[i].dwFlags & (GAMEVAR_FLAG_USER_MASK));
1212
            fprintf(fp," // ");
1213
            if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_SYSTEM))
1214
                fprintf(fp," (system)");
1215
            if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_PLONG))
1216
                fprintf(fp," (pointer)");
1217
            if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_READONLY) )
1218
                fprintf(fp," (read only)");
1219
            fprintf(fp,"\n");
1220
        }
1221
    }
1222
    fprintf(fp,"\n// end of game definitions\n");
1223
}
1224
 
1225
void ResetGameVars(void)
1226
{
1227
    int i;
1228
 
1229
    //AddLog("Reset Game Vars");
1230
    FreeGameVars();
1231
 
193 terminx 1232
    for(i=0;i<MAXGAMEVARS;i++)
5 Plagman 1233
    {
1234
        //Bsprintf(g_szBuf,"Resetting %d: '%s' to %ld",i,aDefaultGameVars[i].szLabel,
1235
        //      aDefaultGameVars[i].lValue
1236
        //      );
1237
        //AddLog(g_szBuf);
193 terminx 1238
        if(aDefaultGameVars[i].szLabel != NULL)
1239
            AddGameVar(aDefaultGameVars[i].szLabel,aDefaultGameVars[i].lValue,aDefaultGameVars[i].dwFlags);
5 Plagman 1240
    }
1241
}
1242
 
1243
char AddGameVar(char *pszLabel, long lValue, unsigned long dwFlags)
1244
{
1245
    int i;
1246
    int j;
1247
 
1248
    //Bsprintf(g_szBuf,"AddGameVar(%s, %d, %X)",pszLabel, lValue, dwFlags);
1249
    //AddLog(g_szBuf);
1250
 
1251
    if(Bstrlen(pszLabel) > (MAXVARLABEL-1) )
1252
    {
1253
        error++;
1254
        initprintf("%s:%ld: error: variable name `%s' exceeds limit of %d characters.\n",compilefile,line_number,pszLabel, MAXVARLABEL);
1255
        return 0;
1256
    }
1257
    for(i=0;i<iGameVarCount;i++)
1258
    {
102 terminx 1259
        if(aGameVars[i].szLabel != NULL)
5 Plagman 1260
        {
102 terminx 1261
            if( Bstrcmp(pszLabel,aGameVars[i].szLabel) == 0 )
5 Plagman 1262
            {
102 terminx 1263
                // found it...
1264
                if(aGameVars[i].dwFlags & GAMEVAR_FLAG_PLONG)
1265
                {
1266
                    //                 warning++;
1267
                    //                 initprintf("%s:%ld: warning: Internal gamevar '%s' cannot be redefined.\n",compilefile,line_number,label+(labelcnt<<6));
1268
                    ReportError(-1);
1269
                    initprintf("%s:%ld: warning: cannot redefine internal gamevar `%s'.\n",compilefile,line_number,label+(labelcnt<<6));
1270
                    return 0;
1271
                }
1272
                else if((aGameVars[i].dwFlags & GAMEVAR_FLAG_DEFAULT) || (aGameVars[i].dwFlags & GAMEVAR_FLAG_SYSTEM))
1273
                {
1274
                    //Bsprintf(g_szBuf,"Replacing %s at %d",pszLabel,i);
1275
                    //AddLog(g_szBuf);
1276
                    //b=1;
1277
                    // it's OK to replace
1278
                    break;
1279
                }
1280
                else
1281
                {
1282
                    // it's a duplicate in error
1283
                    warning++;
1284
                    ReportError(WARNING_DUPLICATEDEFINITION);
1285
                    return 0;
1286
                }
5 Plagman 1287
            }
1288
        }
1289
    }
1290
    if( i < MAXGAMEVARS)
1291
    {
1292
        // Set values
1293
        if(aGameVars[i].dwFlags & GAMEVAR_FLAG_SYSTEM)
1294
        {
1295
            //if(b)
1296
            //{
1297
            //Bsprintf(g_szBuf,"CP:%s %d",__FILE__,__LINE__);
1298
            //AddLog(g_szBuf);
1299
            //}
1300
            // if existing is system, they only get to change default value....
1301
            aGameVars[i].lValue=lValue;
193 terminx 1302
            aDefaultGameVars[i].lValue=lValue;
5 Plagman 1303
        }
1304
        else
1305
        {
102 terminx 1306
            if(aGameVars[i].szLabel == NULL)
104 terminx 1307
                aGameVars[i].szLabel=Bcalloc(MAXVARLABEL,sizeof(char));
5 Plagman 1308
            Bstrcpy(aGameVars[i].szLabel,pszLabel);
1309
            aGameVars[i].dwFlags=dwFlags;
1310
            aGameVars[i].lValue=lValue;
193 terminx 1311
            if(aDefaultGameVars[i].szLabel == NULL)
217 terminx 1312
            {
193 terminx 1313
                aDefaultGameVars[i].szLabel=Bcalloc(MAXVARLABEL,sizeof(char));
217 terminx 1314
                Bstrcpy(aDefaultGameVars[i].szLabel,pszLabel);
1315
            }
193 terminx 1316
            aDefaultGameVars[i].dwFlags=dwFlags;
1317
            aDefaultGameVars[i].lValue=lValue;
5 Plagman 1318
        }
1319
 
1320
        if(i==iGameVarCount)
1321
        {
1322
            // we're adding a new one.
1323
            iGameVarCount++;
1324
        }
1325
        if(aGameVars[i].plValues && !(aGameVars[i].dwFlags & GAMEVAR_FLAG_SYSTEM))
1326
        {
1327
            // only free if not system
1328
            Bfree(aGameVars[i].plValues);
1329
            aGameVars[i].plValues=NULL;
1330
        }
1331
        if(aGameVars[i].dwFlags & GAMEVAR_FLAG_PERPLAYER)
1332
        {
1333
            if(!aGameVars[i].plValues)
104 terminx 1334
                aGameVars[i].plValues=Bcalloc(MAXPLAYERS,sizeof(long));
5 Plagman 1335
            for(j=0;j<MAXPLAYERS;j++)
1336
                aGameVars[i].plValues[j]=lValue;
1337
        }
1338
        else if( aGameVars[i].dwFlags & GAMEVAR_FLAG_PERACTOR)
1339
        {
1340
            if(!aGameVars[i].plValues)
104 terminx 1341
                aGameVars[i].plValues=Bcalloc(MAXSPRITES,sizeof(long));
5 Plagman 1342
            for(j=0;j<MAXSPRITES;j++)
1343
                aGameVars[i].plValues[j]=lValue;
1344
        }
1345
        return 1;
1346
    }
1347
    else
1348
    {
1349
        // no room to add...
1350
        return 0;
1351
    }
1352
}
1353
 
1354
void ResetActorGameVars(short sActor)
1355
{
1356
    int i;
193 terminx 1357
    //    OSD_Printf("resetting vars for actor %d\n",sActor);
172 terminx 1358
    for(i=0;i<MAXGAMEVARS;i++)
193 terminx 1359
        if((aGameVars[i].dwFlags & GAMEVAR_FLAG_PERACTOR) && !(aGameVars[i].dwFlags & GAMEVAR_FLAG_NODEFAULT))
1360
        {
1361
            //            OSD_Printf("reset %s (%d) to %s (%d)\n",aGameVars[i].szLabel,aGameVars[i].plValues[sActor],aDefaultGameVars[i].szLabel,aDefaultGameVars[i].lValue);
172 terminx 1362
            aGameVars[i].plValues[sActor]=aDefaultGameVars[i].lValue;
193 terminx 1363
        }
5 Plagman 1364
}
1365
 
1366
int GetGameID(char *szGameLabel)
1367
{
1368
    int i;
1369
 
1370
    for(i=0;i<iGameVarCount;i++)
1371
    {
102 terminx 1372
        if(aGameVars[i].szLabel != NULL)
5 Plagman 1373
        {
102 terminx 1374
            if( Bstrcmp(szGameLabel, aGameVars[i].szLabel) == 0 )
1375
            {
1376
                return i;
1377
            }
5 Plagman 1378
        }
1379
    }
1380
    return -1;
1381
}
1382
 
1383
long GetGameVarID(int id, short sActor, short sPlayer)
1384
{
1385
    int m=0;
1386
    if(id<0 || id >= iGameVarCount)
1387
    {
1388
        if(id==MAXGAMEVARS)
1389
            return(*insptr++);
1390
        else if(id&(MAXGAMEVARS<<1))
1391
        {
1392
            m=1;
1393
            id ^= (MAXGAMEVARS<<1);
1394
        }
1395
        else
1396
        {
1397
            AddLog("GetGameVarID: Invalid Game ID");
1398
            return -1;
1399
        }
1400
    }
1401
    if( id == g_iThisActorID )
1402
    {
1403
        return sActor;
1404
    }
1405
    if( aGameVars[id].dwFlags & GAMEVAR_FLAG_PERPLAYER )
1406
    {
1407
        // for the current player
1408
        if(sPlayer >=0 && sPlayer < MAXPLAYERS)
1409
        {
1410
            //Bsprintf(g_szBuf,"GetGameVarID( %d, %d, %d) returns %ld\n",id,sActor,sPlayer, aGameVars[id].plValues[sPlayer]);
1411
            //AddLog(g_szBuf);
1412
            if(m) return -aGameVars[id].plValues[sPlayer];
1413
            else return aGameVars[id].plValues[sPlayer];
1414
        }
1415
        else
1416
        {
1417
            if(m) return -aGameVars[id].lValue;
1418
            else return aGameVars[id].lValue;
1419
        }
1420
    }
1421
    else if( aGameVars[id].dwFlags & GAMEVAR_FLAG_PERACTOR )
1422
    {
1423
        // for the current actor
1424
        if(sActor >= 0 && sActor <=MAXSPRITES)
1425
        {
1426
            if(m) return -aGameVars[id].plValues[sActor];
1427
            else return aGameVars[id].plValues[sActor];
1428
        }
1429
        else
1430
        {
1431
            if(m) return -aGameVars[id].lValue;
1432
            else return aGameVars[id].lValue;
1433
        }
1434
    }
1435
    else if( aGameVars[id].dwFlags & GAMEVAR_FLAG_PLONG )
1436
    {
1437
        if(m) return -(*((long*)aGameVars[id].lValue));
1438
        else return (*((long*)aGameVars[id].lValue));
1439
    }
1440
    else
1441
    {
1442
        if(m) return -aGameVars[id].lValue;
1443
        else return aGameVars[id].lValue;
1444
    }
1445
}
1446
 
1447
void SetGameVarID(int id, long lValue, short sActor, short sPlayer)
1448
{
1449
    if(id<0 || id >= iGameVarCount)
1450
    {
1451
        AddLog("Invalid Game ID");
1452
        return;
1453
    }
1454
    //Bsprintf(g_szBuf,"SGVI: %d ('%s') to %ld for %d %d",id,aGameVars[id].szLabel,lValue,sActor,sPlayer);
1455
    //AddLog(g_szBuf);
1456
    if((aGameVars[id].dwFlags & GAMEVAR_FLAG_PERPLAYER) && (sPlayer != -1))
1457
    {
1458
        // for the current player
1459
        aGameVars[id].plValues[sPlayer]=lValue;
1460
    }
1461
    else if((aGameVars[id].dwFlags & GAMEVAR_FLAG_PERACTOR) && (sActor != -1))
1462
    {
1463
        // for the current actor
1464
        aGameVars[id].plValues[sActor]=lValue;
1465
    }
1466
    else if( aGameVars[id].dwFlags & GAMEVAR_FLAG_PLONG )
1467
    {
1468
        // set the value at pointer
1469
        *((long*)aGameVars[id].lValue)=lValue;
1470
    }
1471
    else
1472
    {
1473
        aGameVars[id].lValue=lValue;
1474
    }
1475
}
1476
 
1477
long GetGameVar(char *szGameLabel, long lDefault, short sActor, short sPlayer)
1478
{
1479
    int i;
1480
    for(i=0;i<iGameVarCount;i++)
1481
    {
102 terminx 1482
        if(aGameVars[i].szLabel != NULL)
5 Plagman 1483
        {
102 terminx 1484
            if( Bstrcmp(szGameLabel, aGameVars[i].szLabel) == 0 )
1485
            {
1486
                return GetGameVarID(i, sActor, sPlayer);
1487
            }
5 Plagman 1488
        }
1489
    }
1490
    return lDefault;
1491
}
1492
 
1493
long *GetGameValuePtr(char *szGameLabel)
1494
{
1495
    int i;
1496
    for(i=0;i<iGameVarCount;i++)
1497
    {
102 terminx 1498
        if(aGameVars[i].szLabel != NULL)
5 Plagman 1499
        {
102 terminx 1500
            if( Bstrcmp(szGameLabel, aGameVars[i].szLabel) == 0 )
5 Plagman 1501
            {
102 terminx 1502
                if(aGameVars[i].dwFlags & (GAMEVAR_FLAG_PERACTOR | GAMEVAR_FLAG_PERPLAYER))
5 Plagman 1503
                {
102 terminx 1504
                    if(!aGameVars[i].plValues)
1505
                    {
1506
                        AddLog("INTERNAL ERROR: NULL array !!!");
1507
                    }
1508
                    return aGameVars[i].plValues;
5 Plagman 1509
                }
102 terminx 1510
                return &(aGameVars[i].lValue);
5 Plagman 1511
            }
1512
        }
1513
    }
1514
    //Bsprintf(g_szBuf,"Could not find value '%s'\n",szGameLabel);
1515
    //AddLog(g_szBuf);
1516
    return NULL;
1517
}
1518
 
1519
long GetDefID(char *szGameLabel)
1520
{
1521
    int i;
1522
    for(i=0;i<iGameVarCount;i++)
1523
    {
102 terminx 1524
        if(aGameVars[i].szLabel != NULL)
5 Plagman 1525
        {
102 terminx 1526
            if( Bstrcmp(szGameLabel, aGameVars[i].szLabel) == 0 )
1527
            {
1528
                return i;
1529
            }
5 Plagman 1530
        }
1531
    }
1532
    return -1;
1533
}
1534
 
1535
char ispecial(char c)
1536
{
1537
    if(c == 0x0a)
1538
    {
1539
        line_number++;
1540
        return 1;
1541
    }
1542
 
1543
    if(c == ' ' || c == 0x0d)
1544
        return 1;
1545
 
1546
    return 0;
1547
}
1548
 
1549
char isaltok(char c)
1550
{
1551
    return ( isalnum(c) || c == '{' || c == '}' || c == '/' || c == '*' || c == '-' || c == '_' || c == '.');
1552
}
1553
 
1554
long getlabelid(LABELS *pLabel, char *psz)
1555
{
1556
    // find the label psz in the table pLabel.
1557
    // returns the ID for the label, or -1
1558
 
1559
    long l=-1;
1560
    int i;
1561
 
1562
    for(i=0;pLabel[i].lId >=0 ; i++)
1563
    {
1564
        if(!Bstrcasecmp(pLabel[i].name,psz))
1565
        {
1566
            l= pLabel[i].lId;
1567
            break;  // stop for loop
1568
        }
1569
    }
1570
    return l;
1571
}
1572
 
1573
long getlabeloffset(LABELS *pLabel, char *psz)
1574
{
1575
    // find the label psz in the table pLabel.
1576
    // returns the offset in the array for the label, or -1
1577
    int i;
1578
 
1579
    for(i=0;pLabel[i].lId >=0 ; i++)
1580
    {
1581
        if(!Bstrcasecmp(pLabel[i].name,psz))
1582
        {
1583
            //    printf("Label has flags of %02X\n",pLabel[i].flags);
1584
            return i;
1585
        }
1586
    }
1587
    return -1;
1588
}
1589
 
1590
void getlabel(void)
1591
{
1592
    long i;
1593
 
1594
    skipcomments();
1595
 
1596
    while( isalnum(*textptr) == 0 )
1597
    {
1598
        if(*textptr == 0x0a) line_number++;
1599
        textptr++;
1600
        if( *textptr == 0)
1601
            return;
1602
    }
1603
 
1604
    i = 0;
107 terminx 1605
    while( ispecial(*textptr) == 0 && *textptr!=']' && *textptr!='\t' && *textptr!='\n' && *textptr!='\r')
5 Plagman 1606
        label[(labelcnt<<6)+i++] = *(textptr++);
1607
 
1608
    label[(labelcnt<<6)+i] = 0;
1609
    if (!(error || warning) && condebug > 1)
1610
        initprintf("%s:%ld: debug: got label `%s'.\n",compilefile,line_number,label+(labelcnt<<6));
1611
}
1612
 
1613
long keyword(void)
1614
{
1615
    long i;
1616
    char *temptextptr;
1617
 
1618
    skipcomments();
1619
 
1620
    temptextptr = textptr;
1621
 
1622
    while( isaltok(*temptextptr) == 0 )
1623
    {
1624
        temptextptr++;
1625
        if( *temptextptr == 0 )
1626
            return 0;
1627
    }
1628
 
1629
    i = 0;
1630
    while( isaltok(*temptextptr) )
1631
    {
1632
        tempbuf[i] = *(temptextptr++);
1633
        i++;
1634
    }
1635
    tempbuf[i] = 0;
1636
    for(i=0;i<NUMKEYWORDS;i++)
1637
        if( Bstrcmp( tempbuf,keyw[i]) == 0 )
1638
            return i;
1639
 
1640
    return -1;
1641
}
1642
 
1643
long transword(void) //Returns its code #
1644
{
1645
    long i, l;
1646
 
1647
    skipcomments();
1648
 
1649
    while( isaltok(*textptr) == 0 )
1650
    {
1651
        if(*textptr == 0x0a) line_number++;
1652
        if( *textptr == 0 )
1653
            return -1;
1654
        textptr++;
1655
    }
1656
 
1657
    l = 0;
1658
    while( isaltok(*(textptr+l)) && !(*(textptr + l) == '.') )
1659
    {
1660
        tempbuf[l] = textptr[l];
1661
        l++;
1662
    }
1663
    while( isaltok(*(textptr+l)) )
1664
    {
1665
        tempbuf[l] = textptr[l];
1666
        l++;
1667
    }
1668
    tempbuf[l] = 0;
1669
 
1670
    for(i=0;i<NUMKEYWORDS;i++)
1671
    {
1672
        if( Bstrcmp( tempbuf,keyw[i]) == 0 )
1673
        {
1674
            *scriptptr = i;
1675
            textptr += l;
1676
            scriptptr++;
1677
            if (!(error || warning) && condebug)
1678
                initprintf("%s:%ld: debug: translating keyword `%s'.\n",compilefile,line_number,keyw[i]);
1679
            return i;
1680
        }
1681
    }
1682
 
1683
    textptr += l;
1684
 
1685
    if( tempbuf[0] == '{' && tempbuf[1] != 0)
1686
    {
1687
        ReportError(-1);
1688
        initprintf("%s:%ld: error: expected a SPACE or CR between `{' and `%s'.\n",compilefile,line_number,tempbuf+1);
1689
    }
1690
    else if( tempbuf[0] == '}' && tempbuf[1] != 0)
1691
    {
1692
        ReportError(-1);
1693
        initprintf("%s:%ld: error: expected a SPACE or CR between `}' and `%s'.\n",compilefile,line_number,tempbuf+1);
1694
    }
1695
    else ReportError(ERROR_EXPECTEDKEYWORD);
1696
    error++;
1697
    return -1;
1698
}
1699
 
1700
void transvartype(int type)
1701
{
91 terminx 1702
    int i=0,f=0;
5 Plagman 1703
 
1704
    skipcomments();
1705
    if(!type && !labelsonly && (isdigit(*textptr) || ((*textptr == '-') && (isdigit(*(textptr+1))))))
1706
    {
1707
        if (!(error || warning) && condebug)
1708
            initprintf("%s:%ld: debug: accepted constant %ld in place of gamevar.\n",compilefile,line_number,atol(textptr));
1709
        *scriptptr++=MAXGAMEVARS;
1710
        *scriptptr++=atol(textptr);
1711
        getlabel();
1712
        return;
1713
    }
1714
    else if((*textptr == '-') && !isdigit(*(textptr+1)))
1715
    {
1716
        if(!type)
1717
        {
1718
            if (!(error || warning) && condebug)
1719
                initprintf("%s:%ld: debug: flagging gamevar as negative.\n",compilefile,line_number,atol(textptr));
1720
            f = (MAXGAMEVARS<<1);
1721
        }
1722
        else
1723
        {
1724
            error++;
1725
            ReportError(ERROR_SYNTAXERROR);
1726
            getlabel();
1727
            return;
1728
        }
1729
    }
1730
    getlabel();
1731
    if(!nokeywordcheck)
1732
        for(i=0;i<NUMKEYWORDS;i++)
1733
            if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
1734
            {
1735
                error++;
1736
                ReportError(ERROR_ISAKEYWORD);
1737
                return;
1738
            }
1739
    i=GetDefID(label+(labelcnt<<6));
1740
    if(i<0)
1741
    {
1742
        if(!type && !labelsonly)
1743
        {
1744
            Bstrcpy(tempbuf,label+(labelcnt<<6));
1745
            for(i=0;i<labelcnt;i++)
1746
            {
1747
                if( Bstrcmp(tempbuf,label+(i<<6)) == 0 && (labeltype[i] & LABEL_DEFINE))
1748
                {
1749
                    if (!(error || warning) && condebug)
1750
                        initprintf("%s:%ld: debug: accepted defined label `%s' instead of gamevar.\n",compilefile,line_number,label+(i<<6));
1751
                    *scriptptr++=MAXGAMEVARS;
1752
                    *scriptptr++=labelcode[i];
1753
                    textptr++;
1754
                    return;
1755
                }
1756
            }
1757
            error++;
1758
            ReportError(ERROR_NOTAGAMEVAR);
1759
            textptr++;
1760
            return;
1761
        }
1762
        else
1763
        {
1764
            error++;
1765
            ReportError(ERROR_NOTAGAMEVAR);
1766
            textptr++;
1767
            return;
1768
        }
1769
    }
1770
    if(type == GAMEVAR_FLAG_READONLY && aGameVars[i].dwFlags & GAMEVAR_FLAG_READONLY)
1771
    {
1772
        error++;
1773
        ReportError(ERROR_VARREADONLY);
1774
        return;
1775
    }
1776
    else if(aGameVars[i].dwFlags & type)
1777
    {
1778
        error++;
1779
        ReportError(ERROR_VARTYPEMISMATCH);
1780
        return;
1781
    }
1782
    if((aGameVars[i].dwFlags & GAMEVAR_FLAG_SYNCCHECK) && parsing_actor && CheckEventSync(current_event))
1783
    {
1784
        ReportError(-1);
1785
        initprintf("%s:%ld: warning: found local gamevar `%s' used within %s.\n",compilefile,line_number,label+(labelcnt<<6),parsing_event?"a synced event":"an actor");
1786
    }
1787
    if (!(error || warning) && condebug > 1)
1788
        initprintf("%s:%ld: debug: accepted gamevar `%s'.\n",compilefile,line_number,label+(labelcnt<<6));
1789
    i |= f;
1790
    *scriptptr++=i;
1791
}
1792
 
1793
inline void transvar(void)
1794
{
1795
    transvartype(0);
1796
}
1797
 
1798
inline void transmultvarstype(int type, char num)
1799
{
1800
    char i;
1801
    for(i=0;i<num;i++)
1802
        transvartype(type);
1803
}
1804
 
1805
inline void transmultvars(char num)
1806
{
1807
    transmultvarstype(0,num);
1808
}
1809
 
1810
long transnum(long type)
1811
{
1812
    long i, l;
1813
 
1814
    skipcomments();
1815
 
1816
    while( isaltok(*textptr) == 0 )
1817
    {
1818
        if(*textptr == 0x0a) line_number++;
1819
        textptr++;
1820
        if( *textptr == 0 )
1821
            return -1; // eof
1822
    }
1823
 
1824
    l = 0;
1825
    while( isaltok(*(textptr+l)) )
1826
    {
1827
        tempbuf[l] = textptr[l];
1828
        l++;
1829
    }
1830
    tempbuf[l] = 0;
1831
 
1832
    if(!nokeywordcheck)
1833
        for(i=0;i<NUMKEYWORDS;i++)
1834
            if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0)
1835
            {
1836
                error++;
1837
                ReportError(ERROR_ISAKEYWORD);
1838
                textptr+=l;
1839
            }
121 terminx 1840
 
5 Plagman 1841
    for(i=0;i<labelcnt;i++)
1842
    {
1843
        if( !Bstrcmp(tempbuf,label+(i<<6)) )
1844
        {
1845
            char *el,*gl;
1846
 
1847
            if (labeltype[i] & type)
1848
            {
1849
                if (!(error || warning) && condebug > 1)
1850
                {
1851
                    gl = translatelabeltype(labeltype[i]);
1852
                    initprintf("%s:%ld: debug: accepted %s label `%s'.\n",compilefile,line_number,gl,label+(i<<6));
1853
                    Bfree(gl);
1854
                }
1855
                *(scriptptr++) = labelcode[i];
1856
                textptr += l;
1857
                return labeltype[i];
1858
            }
1859
            *(scriptptr++) = 0;
1860
            textptr += l;
1861
            el = translatelabeltype(type);
1862
            gl = translatelabeltype(labeltype[i]);
1863
            ReportError(-1);
1864
            initprintf("%s:%ld: warning: expected a %s, found a %s.\n",compilefile,line_number,el,gl);
1865
            Bfree(el);
1866
            Bfree(gl);
1867
            return -1;  // valid label name, but wrong type
1868
        }
1869
    }
1870
 
1871
    if( isdigit(*textptr) == 0 && *textptr != '-')
1872
    {
1873
        ReportError(ERROR_PARAMUNDEFINED);
1874
        error++;
1875
        textptr+=l;
1876
        return -1; // error!
1877
    }
1878
 
1879
    if( isdigit(*textptr) && labelsonly )
1880
    {
1881
        ReportError(WARNING_LABELSONLY);
1882
        //         warning++;
1883
    }
1884
    if (!(error || warning) && condebug > 1)
1885
        initprintf("%s:%ld: debug: accepted constant %ld.\n",compilefile,line_number,atol(textptr));
1886
    *scriptptr = atol(textptr);
1887
    scriptptr++;
1888
 
1889
    textptr += l;
1890
 
1891
    return 0;   // literal value
1892
}
1893
 
1894
long CountCaseStatements()
1895
{
1896
    long lCount;
1897
    char *temptextptr;
1898
    long *savescript;
1899
    long *savecase;
1900
    short temp_line_number;
1901
 
1902
    temp_line_number=line_number;
1903
 
1904
    casecount=0;
1905
    temptextptr=textptr;
1906
    savescript=scriptptr;
1907
    savecase=casescriptptr;
1908
    casescriptptr=NULL;
1909
    //Bsprintf(g_szBuf,"CSS: %.12s",textptr);
1910
    //AddLog(g_szBuf);
1911
    while(parsecommand() == 0)
1912
    {
1913
        //Bsprintf(g_szBuf,"CSSL: %.20s",textptr);
1914
        //AddLog(g_szBuf);
1915
        ;
1916
    }
1917
    // since we processed the endswitch, we need to re-increment checking_switch
1918
    checking_switch++;
1919
 
1920
    textptr=temptextptr;
1921
    scriptptr=savescript;
1922
 
1923
    line_number = temp_line_number;
1924
 
1925
    lCount=casecount;
1926
    casecount=0;
1927
    casescriptptr=savecase;
1928
    return lCount;
1929
}
1930
 
1931
char parsecommand(void)
1932
{
1933
    long i, j=0, k=0, *tempscrptr;
1934
    char done, *temptextptr;
1935
 
1936
    long tw;
1937
 
1938
    if (((unsigned)(scriptptr-script) > MAXSCRIPTSIZE) && error == 0) {
1939
        /* Bsprintf(tempbuf,"fatal error: Size of compiled CON code exceeds maximum size! (%ud, %d)\n",(unsigned)(scriptptr-script),MAXSCRIPTSIZE); */
1940
        ReportError(-1);
1941
        initprintf("%s:%ld: internal compiler error: Aborted (%ud)\n",compilefile,line_number,(unsigned)(scriptptr-script));
1942
        initprintf(tempbuf);
1943
        error++;
1944
    }
1945
 
1946
    if( (error+warning) > 63 || ( *textptr == '\0' ) || ( *(textptr+1) == '\0' ) ) return 1;
1947
 
1948
    if (checking_switch > 0 )
1949
    {
1950
        //Bsprintf(g_szBuf,"PC(): '%.25s'",textptr);
1951
        //AddLog(g_szBuf);
1952
    }
1953
    tw = transword();
1954
    //    Bsprintf(tempbuf,"%s",keyw[tw]);
1955
    //    AddLog(tempbuf);
1956
 
1957
    skipcomments(); // yes?  no?
1958
 
1959
    switch(tw)
1960
    {
1961
    default:
1962
    case -1:
1963
        return 0; //End
1964
    case CON_STATE:
1965
        if( parsing_actor == 0 && parsing_state == 0 )
1966
        {
1967
            getlabel();
1968
            scriptptr--;
1969
            labelcode[labelcnt] = (long) scriptptr;
1970
            labeltype[labelcnt] = LABEL_STATE;
1971
 
1972
            parsing_state = 1;
1973
            Bsprintf(parsing_item_name,"%s",label+(labelcnt<<6));
1974
            labelcnt++;
1975
            return 0;
1976
        }
1977
 
1978
        getlabel();
1979
 
1980
        for(i=0;i<NUMKEYWORDS;i++)
1981
            if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
1982
            {
1983
                error++;
1984
                ReportError(ERROR_ISAKEYWORD);
1985
                return 0;
1986
            }
1987
        for(j=0;j<labelcnt;j++)
1988
        {
1989
            if( Bstrcmp(label+(j<<6),label+(labelcnt<<6)) == 0)
1990
            {
1991
                if (labeltype[j] & LABEL_STATE)
1992
                {
1993
                    if (!(error || warning) && condebug > 1)
1994
                        initprintf("%s:%ld: debug: accepted state label `%s'.\n",compilefile,line_number,label+(j<<6));
1995
                    *scriptptr = labelcode[j];
1996
                    break;
1997
                }
1998
                else
1999
                {
2000
                    char *gl;
2001
                    gl = translatelabeltype(labeltype[j]);
2002
                    ReportError(-1);
2003
                    initprintf("%s:%ld: warning: expected a state, found a %s.\n",compilefile,line_number,gl);
2004
                    Bfree(gl);
2005
                    *(scriptptr-1) = CON_NULLOP; // get rid of the state, leaving a nullop to satisfy if conditions
2006
                    return 0;  // valid label name, but wrong type
2007
                }
2008
            }
2009
        }
2010
        if(j==labelcnt)
2011
        {
2012
            ReportError(-1);
2013
            initprintf("%s:%ld: error: state `%s' not found.\n",compilefile,line_number,label+(labelcnt<<6));
2014
            error++;
2015
        }
2016
        scriptptr++;
2017
        return 0;
2018
 
2019
    case CON_ENDS:
2020
        if( parsing_state == 0 )
2021
        {
2022
            ReportError(-1);
2023
            initprintf("%s:%ld: error: found `ends' without open `state'.\n",compilefile,line_number);
2024
            error++;
2025
        }
2026
        //            else
2027
        {
2028
            if( num_braces > 0 )
2029
            {
2030
                ReportError(ERROR_OPENBRACKET);
2031
                error++;
2032
            }
2033
            if( num_braces < 0 )
2034
            {
2035
                ReportError(ERROR_CLOSEBRACKET);
2036
                error++;
2037
            }
2038
            if( checking_switch > 0  )
2039
            {
2040
                ReportError(ERROR_NOENDSWITCH);
2041
                error++;
2042
 
2043
                checking_switch = 0; // can't be checking anymore...
2044
            }
2045
 
2046
            parsing_state = 0;
2047
            Bsprintf(parsing_item_name,"(none)");
2048
        }
2049
        return 0;
2050
 
2051
    case CON_SETTHISPROJECTILE:
2052
    case CON_SETPROJECTILE:
2053
        if(!CheckEventSync(current_event))
2054
            ReportError(WARNING_EVENTSYNC);
2055
    case CON_GETTHISPROJECTILE:
2056
    case CON_GETPROJECTILE:
2057
        {
2058
            long lLabelID;
2059
 
2060
            // syntax getwall[<var>].x <VAR>
2061
            // gets the value of wall[<var>].xxx into <VAR>
2062
 
2063
            // now get name of .xxx
2064
            while((*textptr != '['))
2065
            {
2066
                textptr++;
2067
            }
2068
            if(*textptr == '[')
2069
                textptr++;
2070
 
2071
            // get the ID of the DEF
2072
            if(tw == CON_SETTHISPROJECTILE)
2073
                labelsonly = 1;
2074
            transvar();
2075
            labelsonly = 0;
2076
            // now get name of .xxx
2077
            while(*textptr != '.')
2078
            {
2079
                if(*textptr == 0xa)
2080
                    break;
2081
                if(!*textptr)
2082
                    break;
2083
 
2084
                textptr++;
2085
            }
2086
            if(*textptr!='.')
2087
            {
2088
                error++;
2089
                ReportError(ERROR_SYNTAXERROR);
2090
                return 0;
2091
            }
2092
            textptr++;
2093
            /// now pointing at 'xxx'
2094
            getlabel();
2095
            //printf("found xxx label of '%s'\n",   label+(labelcnt<<6));
2096
 
2097
            lLabelID=getlabeloffset(projectilelabels,label+(labelcnt<<6));
2098
            //printf("LabelID is %ld\n",lLabelID);
2099
            if(lLabelID == -1 )
2100
            {
2101
                error++;
2102
                ReportError(ERROR_SYMBOLNOTRECOGNIZED);
2103
                return 0;
2104
            }
2105
 
2106
            *scriptptr++=projectilelabels[lLabelID].lId;
2107
 
2108
            //printf("member's flags are: %02Xh\n",playerlabels[lLabelID].flags);
2109
 
2110
            // now at target VAR...
2111
 
2112
            // get the ID of the DEF
2113
            switch(tw)
2114
            {
2115
            case CON_SETPROJECTILE:
2116
            case CON_SETTHISPROJECTILE:
2117
                transvar();
2118
                break;
2119
            default:
2120
                transvartype(GAMEVAR_FLAG_READONLY);
2121
                break;
2122
            }
2123
            break;
2124
        }
2125
 
2126
    case CON_GAMEVAR:
2127
        // syntax: gamevar <var1> <initial value> <flags>
2128
        // defines var1 and sets initial value.
2129
        // flags are used to define usage
2130
        // (see top of this files for flags)
2131
        //printf("Got gamedef. Getting Label. '%.20s'\n",textptr);
2132
 
2133
        if(isdigit(*textptr) || (*textptr == '-'))
2134
        {
2135
            getlabel();
2136
            error++;
2137
            ReportError(ERROR_SYNTAXERROR);
2138
            transnum(LABEL_DEFINE);
2139
            transnum(LABEL_DEFINE);
2140
            scriptptr -= 3; // we complete the process anyways just to skip past the fucked up section
2141
            return 0;
2142
        }
2143
 
2144
        getlabel();
2145
        //printf("Got Label '%.20s'\n",textptr);
2146
        // Check to see it's already defined
2147
 
2148
        for(i=0;i<NUMKEYWORDS;i++)
2149
            if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
2150
            {
2151
                error++;
2152
                ReportError(ERROR_ISAKEYWORD);
2153
                return 0;
2154
            }
2155
#if 0
2156
        for(i=0;i<iGameVarCount;i++)
2157
        {
102 terminx 2158
            if(aGameVars[i].szLabel != NULL)
5 Plagman 2159
            {
102 terminx 2160
                if( Bstrcmp(label+(labelcnt<<6),aGameVars[i].szLabel) == 0 )
2161
                {
2162
                    warning++;
2163
                    initprintf("  * WARNING.(L%ld) duplicate Game definition `%s' ignored.\n",line_number,label+(labelcnt<<6));
2164
                    break;
2165
                }
5 Plagman 2166
            }
2167
        }
2168
#endif
2169
 
2170
        //printf("Translating number  '%.20s'\n",textptr);
2171
        transnum(LABEL_DEFINE); // get initial value
2172
        //printf("Done Translating number.  '%.20s'\n",textptr);
2173
 
2174
        transnum(LABEL_DEFINE); // get flags
2175
        //Bsprintf(g_szBuf,"Adding GameVar='%s', val=%l, flags=%lX",label+(labelcnt<<6),
2176
        //      *(scriptptr-2), *(scriptptr-1));
2177
        //AddLog(g_szBuf);
2178
 
2179
        AddGameVar(label+(labelcnt<<6),*(scriptptr-2),
2180
                   (*(scriptptr-1))
2181
                   // can't define default or secret
2182
                   & (~( GAMEVAR_FLAG_DEFAULT | GAMEVAR_FLAG_SECRET))
2183
                  );
2184
        //AddLog("Added gamevar");
2185
        scriptptr -= 3; // no need to save in script...
2186
        return 0;
2187
 
2188
    case CON_DEFINE:
2189
        {
2190
            //printf("Got definition. Getting Label. '%.20s'\n",textptr);
2191
            getlabel();
2192
            //printf("Got label. '%.20s'\n",textptr);
2193
            // Check to see it's already defined
2194
 
2195
            for(i=0;i<NUMKEYWORDS;i++)
2196
                if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
2197
                {
2198
                    error++;
2199
                    ReportError(ERROR_ISAKEYWORD);
2200
                    return 0;
2201
                }
2202
 
2203
            for(i=0;i<labelcnt;i++)
2204
            {
2205
                if(Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 && (labeltype[i] & LABEL_DEFINE))
2206
                {
2207
                    if (i >= defaultlabelcnt)
2208
                    {
2209
                        warning++;
2210
                        ReportError(WARNING_DUPLICATEDEFINITION);
2211
                    }
2212
                    break;
2213
                }
2214
            }
2215
            //printf("Translating. '%.20s'\n",textptr);
2216
            transnum(LABEL_DEFINE);
2217
            //printf("Translated. '%.20s'\n",textptr);
2218
            if(i == labelcnt)
2219
            {
2220
                //              printf("Defining Definition '%s' to be '%d'\n",label+(labelcnt<<6),*(scriptptr-1));
2221
                labeltype[labelcnt] = LABEL_DEFINE;
2222
                labelcode[labelcnt++] = *(scriptptr-1);
2223
                if (*(scriptptr-1) >= 0 && *(scriptptr-1) < MAXTILES && dynamicremap)
2224
                    processnames(label+(i<<6),*(scriptptr-1));
2225
            }
2226
            scriptptr -= 2;
2227
            return 0;
2228
        }
2229
 
2230
    case CON_PALFROM:
2231
        for(j=0;j<4;j++)
2232
        {
2233
            if( keyword() == -1 )
2234
                transnum(LABEL_DEFINE);
2235
            else break;
2236
        }
2237
 
2238
        while(j<4)
2239
        {
2240
            *scriptptr = 0;
2241
            scriptptr++;
2242
            j++;
2243
        }
2244
        return 0;
2245
 
2246
    case CON_MOVE:
2247
        if( parsing_actor || parsing_state )
2248
        {
2249
            if(!CheckEventSync(current_event))
2250
                ReportError(WARNING_EVENTSYNC);
2251
            transnum(LABEL_MOVE);
2252
 
2253
            j = 0;
2254
            while(keyword() == -1)
2255
            {
2256
                transnum(LABEL_DEFINE);
2257
                scriptptr--;
2258
                j |= *scriptptr;
2259
            }
2260
            *scriptptr = j;
2261
 
2262
            scriptptr++;
2263
        }
2264
        else
2265
        {
2266
            scriptptr--;
2267
            getlabel();
2268
            // Check to see it's already defined
2269
 
2270
            for(i=0;i<NUMKEYWORDS;i++)
2271
                if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
2272
                {
2273
                    error++;
2274
                    ReportError(ERROR_ISAKEYWORD);
2275
                    return 0;
2276
                }
2277
 
2278
            for(i=0;i<labelcnt;i++)
2279
                if( Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 && (labeltype[i] & LABEL_MOVE))
2280
                {
2281
                    warning++;
2282
                    initprintf("%s:%ld: warning: duplicate move `%s' ignored.\n",compilefile,line_number,label+(labelcnt<<6));
2283
                    break;
2284
                }
2285
            if(i == labelcnt)
2286
            {
2287
                labeltype[labelcnt] = LABEL_MOVE;
2288
                labelcode[labelcnt++] = (long) scriptptr;
2289
            }
2290
            for(j=0;j<2;j++)
2291
            {
2292
                if(keyword() >= 0) break;
2293
                transnum(LABEL_DEFINE);
2294
            }
2295
            for(k=j;k<2;k++)
2296
            {
2297
                *scriptptr = 0;
2298
                scriptptr++;
2299
            }
2300
        }
2301
        return 0;
2302
 
2303
    case CON_MUSIC:
2304
        {
2305
            // NOTE: this doesn't get stored in the PCode...
2306
 
2307
            // music 1 stalker.mid dethtoll.mid streets.mid watrwld1.mid snake1.mid
2308
            //    thecall.mid ahgeez.mid dethtoll.mid streets.mid watrwld1.mid snake1.mid
2309
            scriptptr--;
2310
            transnum(LABEL_DEFINE); // Volume Number (0/4)
2311
            scriptptr--;
2312
 
2313
            k = *scriptptr-1;
2314
 
2315
            if(k >= 0) // if it's background music
2316
            {
2317
                i = 0;
2318
                // get the file name...
2319
                while(keyword() == -1)
2320
                {
2321
                    while( isaltok(*textptr) == 0 )
2322
                    {
2323
                        if(*textptr == 0x0a) line_number++;
2324
                        textptr++;
2325
                        if( *textptr == 0 ) break;
2326
                    }
2327
                    j = 0;
2328
                    while( isaltok(*(textptr+j)) )
2329
                    {
2330
                        music_fn[k][i][j] = textptr[j];
2331
                        j++;
2332
                    }
2333
                    music_fn[k][i][j] = '\0';
2334
                    textptr += j;
2335
                    if(i > 9) break;
2336
                    i++;
2337
                }
2338
            }
2339
            else
2340
            {
2341
                i = 0;
2342
                while(keyword() == -1)
2343
                {
2344
                    while( isaltok(*textptr) == 0 )
2345
                    {
2346
                        if(*textptr == 0x0a) line_number++;
2347
                        textptr++;
2348
                        if( *textptr == 0 ) break;
2349
                    }
2350
                    j = 0;
2351
                    while( isaltok(*(textptr+j)) )
2352
                    {
2353
                        env_music_fn[i][j] = textptr[j];
2354
                        j++;
2355
                    }
2356
                    env_music_fn[i][j] = '\0';
2357
 
2358
                    textptr += j;
2359
                    if(i > 9) break;
2360
                    i++;
2361
                }
2362
            }
2363
        }
2364
        return 0;
2365
 
2366
    case CON_INCLUDE:
2367
        scriptptr--;
2368
        while( isaltok(*textptr) == 0 )
2369
        {
2370
            if(*textptr == 0x0a) line_number++;
2371
            textptr++;
2372
            if( *textptr == 0 ) break;
2373
        }
2374
        j = 0;
2375
        while( isaltok(*textptr) )
2376
        {
2377
            tempbuf[j] = *(textptr++);
2378
            j++;
2379
        }
2380
        tempbuf[j] = '\0';
2381
 
2382
        {
2383
            short temp_line_number;
2384
            char  temp_ifelse_check;
2385
            char *origtptr, *mptr;
2386
            char parentcompilefile[255];
2387
            int fp;
2388
 
2389
            fp = kopen4load(tempbuf,loadfromgrouponly);
2390
            if(fp < 0)
2391
            {
2392
                error++;
2393
                initprintf("%s:%ld: error: could not find file `%s'.\n",compilefile,line_number,tempbuf);
2394
                return 0;
2395
            }
2396
 
2397
            j = kfilelength(fp);
2398
 
2399
            mptr = (char *)Bmalloc(j+1);
2400
            if (!mptr)
2401
            {
2402
                kclose(fp);
2403
                error++;
2404
                initprintf("%s:%ld: error: could not allocate %ld bytes to include `%s'.\n",
2405
                           line_number,compilefile,j,tempbuf);
2406
                return 0;
2407
            }
2408
 
2409
            initprintf("Including: %s (%ld bytes)\n",tempbuf, j);
2410
            kread(fp, mptr, j);
2411
            kclose(fp);
2412
            mptr[j] = 0;
2413
 
2414
            if (*textptr == '"') // skip past the closing quote if it's there so we don't screw up the next line
2415
                textptr++;
2416
            origtptr = textptr;
2417
 
2418
            Bstrcpy(parentcompilefile, compilefile);
2419
            Bstrcpy(compilefile, tempbuf);
2420
            temp_line_number = line_number;
2421
            line_number = 1;
2422
            temp_ifelse_check = checking_ifelse;
2423
            checking_ifelse = 0;
2424
 
2425
            textptr = mptr;
2426
            do done = parsecommand(); while (!done);
2427
 
2428
            Bstrcpy(compilefile, parentcompilefile);
2429
            total_lines += line_number;
2430
            line_number = temp_line_number;
2431
            checking_ifelse = temp_ifelse_check;
2432
 
2433
            textptr = origtptr;
2434
 
2435
            Bfree(mptr);
2436
        }
2437
        return 0;
2438
 
2439
    case CON_AI:
2440
        if( parsing_actor || parsing_state )
2441
        {
2442
            if(!CheckEventSync(current_event))
2443
                ReportError(WARNING_EVENTSYNC);
2444
            transnum(LABEL_AI);
2445
        }
2446
        else
2447
        {
2448
            scriptptr--;
2449
            getlabel();
2450
 
2451
            for(i=0;i<NUMKEYWORDS;i++)
2452
                if( Bstrcmp( label+(labelcnt<<6),keyw[i]) == 0 )
2453
                {
2454
                    error++;
2455
                    ReportError(ERROR_ISAKEYWORD);
2456
                    return 0;
2457
                }
2458
 
2459
            for(i=0;i<labelcnt;i++)
2460
                if( Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 && (labeltype[i] & LABEL_AI))
2461
                {
2462
                    warning++;
2463
                    initprintf("%s:%ld: warning: duplicate ai `%s' ignored.\n",compilefile,line_number,label+(labelcnt<<6));
2464
                    break;
2465
                }
2466
 
2467
            if(i == labelcnt)
2468
            {
2469
                labeltype[labelcnt] = LABEL_AI;
2470
                labelcode[labelcnt++] = (long) scriptptr;
2471
            }
2472
 
2473
            for(j=0;j<3;j++)
2474