Subversion Repositories eduke32

Rev

Rev 558 | Rev 561 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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