Subversion Repositories eduke32

Rev

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