mirror of
https://github.com/ZDoom/raze-gles.git
synced 2024-11-18 18:21:38 +00:00
c1c01f0e0b
DONT_BUILD. git-svn-id: https://svn.eduke32.com/eduke32@4541 1a8010ca-5511-0410-912e-c29ae57300e0
5809 lines
187 KiB
C
5809 lines
187 KiB
C
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2010 EDuke32 developers and contributors
|
|
|
|
This file is part of EDuke32.
|
|
|
|
EDuke32 is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License version 2
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <math.h> // sqrt
|
|
|
|
#include "compat.h"
|
|
|
|
#include "duke3d.h"
|
|
#include "gamedef.h"
|
|
#include "gameexec.h"
|
|
#include "scriplib.h"
|
|
#include "savegame.h"
|
|
#include "premap.h"
|
|
#include "osdcmds.h"
|
|
#include "osd.h"
|
|
#include "menus.h"
|
|
#include "input.h"
|
|
|
|
#ifdef LUNATIC
|
|
# include "lunatic_game.h"
|
|
#endif
|
|
|
|
#if KRANDDEBUG
|
|
# define GAMEEXEC_INLINE
|
|
# define GAMEEXEC_STATIC
|
|
#else
|
|
# define GAMEEXEC_INLINE inline
|
|
# define GAMEEXEC_STATIC static
|
|
#endif
|
|
|
|
vmstate_t vm;
|
|
|
|
#if !defined LUNATIC
|
|
enum vmflags_t {
|
|
VM_RETURN = 0x00000001,
|
|
VM_KILL = 0x00000002,
|
|
VM_NOEXECUTE = 0x00000004,
|
|
};
|
|
|
|
int32_t g_tw;
|
|
int32_t g_errorLineNum;
|
|
int32_t g_currentEventExec = -1;
|
|
|
|
GAMEEXEC_STATIC void VM_Execute(int32_t loop);
|
|
|
|
# include "gamestructures.c"
|
|
#endif
|
|
|
|
#define VM_CONDITIONAL(xxx) { if ((xxx) || ((insptr = (intptr_t *)*(insptr+1)) && (((*insptr) & 0xfff) == CON_ELSE))) \
|
|
{ insptr += 2; VM_Execute(0); } }
|
|
|
|
void VM_ScriptInfo(void)
|
|
{
|
|
#if !defined LUNATIC
|
|
intptr_t *p;
|
|
|
|
if (!script)
|
|
return;
|
|
|
|
if (insptr)
|
|
{
|
|
initprintf("\n");
|
|
|
|
for (p=insptr-20; p<insptr+20; p++)
|
|
{
|
|
initprintf("%5d: %3d: ",(int32_t)(p - script),(int32_t)(p - insptr));
|
|
|
|
if (*p>>12&&(*p&0xFFF)<CON_END)
|
|
initprintf("%5d %s",(int32_t)(*p>>12),keyw[*p&0xFFF]);
|
|
else
|
|
initprintf("%d",(int32_t)*p);
|
|
|
|
initprintf("\n");
|
|
}
|
|
|
|
initprintf("\n");
|
|
}
|
|
|
|
if (vm.g_i)
|
|
initprintf_nowarn("current actor: %d (%d)\n",vm.g_i,TrackerCast(vm.g_sp->picnum));
|
|
|
|
initprintf("g_errorLineNum: %d, g_tw: %d\n",g_errorLineNum,g_tw);
|
|
#endif
|
|
}
|
|
|
|
static void VM_KillIt(int32_t iActor, int32_t iPlayer)
|
|
{
|
|
if ((unsigned) iActor >= MAXSPRITES)
|
|
return;
|
|
|
|
// if player was set to squish, first stop that...
|
|
if (iPlayer >= 0 && g_player[iPlayer].ps->actorsqu == iActor)
|
|
g_player[iPlayer].ps->actorsqu = -1;
|
|
|
|
A_DeleteSprite(iActor);
|
|
}
|
|
|
|
// May recurse, e.g. through EVENT_XXX -> ... -> EVENT_KILLIT
|
|
int32_t VM_OnEvent(int32_t iEventID, int32_t iActor, int32_t iPlayer, int32_t lDist, int32_t iReturn)
|
|
{
|
|
#ifdef LUNATIC
|
|
if (L_IsInitialized(&g_ElState) && El_HaveEvent(iEventID))
|
|
{
|
|
const double t = gethiticks();
|
|
int32_t ret = El_CallEvent(&g_ElState, iEventID, iActor, iPlayer, lDist, &iReturn);
|
|
|
|
// NOTE: the run times are those of the called event plus any events
|
|
// called by it, *not* "self" time.
|
|
g_eventTotalMs[iEventID] += gethiticks()-t;
|
|
g_eventCalls[iEventID]++;
|
|
|
|
if (ret == 1)
|
|
VM_KillIt(iActor, iPlayer);
|
|
}
|
|
#else
|
|
|
|
if (apScriptGameEvent[iEventID])
|
|
{
|
|
intptr_t *oinsptr=insptr;
|
|
vmstate_t vm_backup;
|
|
|
|
vmstate_t tempvm = { iActor, iPlayer, lDist,
|
|
iActor >= 0 ? &actor[iActor].t_data[0] : NULL,
|
|
iActor >= 0 ? &sprite[iActor] : NULL,
|
|
0 };
|
|
|
|
int32_t backupReturnVar = aGameVars[g_iReturnVarID].val.lValue;
|
|
int32_t backupEventExec = g_currentEventExec;
|
|
|
|
aGameVars[g_iReturnVarID].val.lValue = iReturn;
|
|
g_currentEventExec = iEventID;
|
|
insptr = apScriptGameEvent[iEventID];
|
|
|
|
Bmemcpy(&vm_backup, &vm, sizeof(vmstate_t));
|
|
Bmemcpy(&vm, &tempvm, sizeof(vmstate_t));
|
|
|
|
VM_Execute(1);
|
|
|
|
if (vm.g_flags & VM_KILL)
|
|
VM_KillIt(iActor, iPlayer);
|
|
|
|
Bmemcpy(&vm, &vm_backup, sizeof(vmstate_t));
|
|
insptr = oinsptr;
|
|
|
|
g_currentEventExec = backupEventExec;
|
|
iReturn = aGameVars[g_iReturnVarID].val.lValue;
|
|
aGameVars[g_iReturnVarID].val.lValue = backupReturnVar;
|
|
}
|
|
#endif
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
static inline int32_t VM_CheckSquished(void)
|
|
{
|
|
const sectortype *sc = §or[vm.g_sp->sectnum];
|
|
|
|
if ((vm.g_sp->picnum == APLAYER && ud.noclip) || sc->lotag == ST_23_SWINGING_DOOR)
|
|
return 0;
|
|
|
|
{
|
|
int32_t fz=sc->floorz, cz=sc->ceilingz;
|
|
#ifdef YAX_ENABLE
|
|
int16_t cb, fb;
|
|
|
|
yax_getbunches(vm.g_sp->sectnum, &cb, &fb);
|
|
if (cb >= 0 && (sc->ceilingstat&512)==0) // if ceiling non-blocking...
|
|
cz -= (32<<8); // unconditionally don't squish... yax_getneighborsect is slowish :/
|
|
if (fb >= 0 && (sc->floorstat&512)==0)
|
|
fz += (32<<8);
|
|
#endif
|
|
|
|
if (vm.g_sp->pal == 1 ?
|
|
(fz - cz >= (32<<8) || (sc->lotag&32768)) :
|
|
(fz - cz >= (12<<8)))
|
|
return 0;
|
|
}
|
|
|
|
P_DoQuote(QUOTE_SQUISHED, g_player[vm.g_p].ps);
|
|
|
|
if (A_CheckEnemySprite(vm.g_sp))
|
|
vm.g_sp->xvel = 0;
|
|
|
|
if (vm.g_sp->pal == 1) // frozen
|
|
{
|
|
actor[vm.g_i].picnum = SHOTSPARK1;
|
|
actor[vm.g_i].extra = 1;
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if !defined LUNATIC
|
|
GAMEEXEC_STATIC GAMEEXEC_INLINE void P_ForceAngle(DukePlayer_t *p)
|
|
{
|
|
int32_t n = 128-(krand()&255);
|
|
|
|
p->horiz += 64;
|
|
p->return_to_center = 9;
|
|
p->look_ang = p->rotscrnang = n>>1;
|
|
}
|
|
#endif
|
|
|
|
int32_t A_Dodge(spritetype *s)
|
|
{
|
|
int32_t bx,by,bxvect,byvect,i;
|
|
int32_t mx = s->x, my = s->y;
|
|
int32_t mxvect = sintable[(s->ang+512)&2047];
|
|
int32_t myvect = sintable[s->ang&2047];
|
|
|
|
if (A_CheckEnemySprite(s) && s->extra <= 0) // hack
|
|
return 0;
|
|
|
|
for (i=headspritestat[STAT_PROJECTILE]; i>=0; i=nextspritestat[i]) //weapons list
|
|
{
|
|
if (OW == i)
|
|
continue;
|
|
|
|
bx = SX-mx;
|
|
by = SY-my;
|
|
bxvect = sintable[(SA+512)&2047];
|
|
byvect = sintable[SA&2047];
|
|
|
|
if ((mxvect * bx) + (myvect * by) >= 0 && (bxvect * bx) + (byvect * by) < 0)
|
|
{
|
|
if (klabs((bxvect * by) - (byvect * bx)) < 65536<<6)
|
|
{
|
|
s->ang -= 512+(krand()&1024);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t A_GetFurthestAngle(int32_t iActor, int32_t angs)
|
|
{
|
|
spritetype *s = &sprite[iActor];
|
|
|
|
if (s->picnum != APLAYER && (AC_COUNT(actor[iActor].t_data)&63) > 2)
|
|
return s->ang + 1024;
|
|
|
|
{
|
|
int32_t furthest_angle=0;
|
|
int32_t d, j;
|
|
int32_t greatestd = INT32_MIN;
|
|
int32_t angincs=2048/angs;
|
|
hitdata_t hit;
|
|
|
|
for (j=s->ang; j<(2048+s->ang); j+=angincs)
|
|
{
|
|
s->z -= (8<<8);
|
|
hitscan((const vec3_t *)s, s->sectnum,
|
|
sintable[(j+512)&2047],
|
|
sintable[j&2047],0,
|
|
&hit,CLIPMASK1);
|
|
s->z += (8<<8);
|
|
d = klabs(hit.pos.x-s->x) + klabs(hit.pos.y-s->y);
|
|
|
|
if (d > greatestd)
|
|
{
|
|
greatestd = d;
|
|
furthest_angle = j;
|
|
}
|
|
}
|
|
|
|
return furthest_angle&2047;
|
|
}
|
|
}
|
|
|
|
int32_t A_FurthestVisiblePoint(int32_t iActor, spritetype *ts, int32_t *dax, int32_t *day)
|
|
{
|
|
if (AC_COUNT(actor[iActor].t_data)&63)
|
|
return -1;
|
|
|
|
{
|
|
int32_t d, da;//, d, cd, ca,tempx,tempy,cx,cy;
|
|
int32_t j, angincs;
|
|
spritetype *s = &sprite[iActor];
|
|
hitdata_t hit;
|
|
|
|
if ((!g_netServer && ud.multimode < 2) && ud.player_skill < 3)
|
|
angincs = 2048/2;
|
|
else angincs = 2048/(1+(krand()&1));
|
|
|
|
for (j=ts->ang; j<(2048+ts->ang); j+=(angincs-(krand()&511)))
|
|
{
|
|
ts->z -= (16<<8);
|
|
hitscan((const vec3_t *)ts, ts->sectnum,
|
|
sintable[(j+512)&2047],
|
|
sintable[j&2047],16384-(krand()&32767),
|
|
&hit,CLIPMASK1);
|
|
|
|
ts->z += (16<<8);
|
|
|
|
d = klabs(hit.pos.x-ts->x)+klabs(hit.pos.y-ts->y);
|
|
da = klabs(hit.pos.x-s->x)+klabs(hit.pos.y-s->y);
|
|
|
|
if (d < da && hit.sect > -1)
|
|
if (cansee(hit.pos.x,hit.pos.y,hit.pos.z,
|
|
hit.sect,s->x,s->y,s->z-(16<<8),s->sectnum))
|
|
{
|
|
*dax = hit.pos.x;
|
|
*day = hit.pos.y;
|
|
return hit.sect;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void A_GetZLimits(int32_t iActor)
|
|
{
|
|
spritetype *s = &sprite[iActor];
|
|
|
|
// if (s->statnum == STAT_PLAYER || s->statnum == STAT_STANDABLE || s->statnum == STAT_ZOMBIEACTOR || s->statnum == STAT_ACTOR || s->statnum == STAT_PROJECTILE)
|
|
{
|
|
int32_t hz,lz,zr = 127;
|
|
int32_t cstat = s->cstat;
|
|
|
|
s->cstat = 0;
|
|
|
|
if (s->statnum == STAT_PROJECTILE)
|
|
zr = 4;
|
|
|
|
s->z -= ZOFFSET;
|
|
getzrange((vec3_t *)s,s->sectnum,&actor[iActor].ceilingz,&hz,&actor[iActor].floorz,&lz,zr,CLIPMASK0);
|
|
s->z += ZOFFSET;
|
|
|
|
s->cstat = cstat;
|
|
|
|
actor[iActor].flags &= ~SFLAG_NOFLOORSHADOW;
|
|
|
|
if ((lz&49152) == 49152 && (sprite[lz&(MAXSPRITES-1)].cstat&48) == 0)
|
|
{
|
|
const spritetype *hitspr = &sprite[lz&(MAXSPRITES-1)];
|
|
|
|
lz &= (MAXSPRITES-1);
|
|
|
|
if ((A_CheckEnemySprite(hitspr) && hitspr->pal != 1 && s->statnum != STAT_PROJECTILE)
|
|
|| (hitspr->picnum == APLAYER && A_CheckEnemySprite(s)))
|
|
{
|
|
actor[iActor].flags |= SFLAG_NOFLOORSHADOW; // No shadows on actors
|
|
s->xvel = -256;
|
|
A_SetSprite(iActor,CLIPMASK0);
|
|
}
|
|
else if (s->statnum == STAT_PROJECTILE && hitspr->picnum == APLAYER && s->owner==lz)
|
|
{
|
|
actor[iActor].ceilingz = sector[s->sectnum].ceilingz;
|
|
actor[iActor].floorz = sector[s->sectnum].floorz;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
else
|
|
{
|
|
actor[iActor].ceilingz = sector[s->sectnum].ceilingz;
|
|
actor[iActor].floorz = sector[s->sectnum].floorz;
|
|
}
|
|
*/
|
|
}
|
|
|
|
void A_Fall(int32_t iActor)
|
|
{
|
|
spritetype *s = &sprite[iActor];
|
|
int32_t hz,lz,c = g_spriteGravity;
|
|
#ifdef YAX_ENABLE
|
|
int16_t fbunch;
|
|
#endif
|
|
if (G_CheckForSpaceFloor(s->sectnum))
|
|
c = 0;
|
|
else
|
|
{
|
|
if (G_CheckForSpaceCeiling(s->sectnum) || sector[s->sectnum].lotag == ST_2_UNDERWATER)
|
|
c = g_spriteGravity/6;
|
|
}
|
|
|
|
if (s->statnum == STAT_ACTOR || s->statnum == STAT_PLAYER || s->statnum == STAT_ZOMBIEACTOR || s->statnum == STAT_STANDABLE)
|
|
{
|
|
int32_t cstat = s->cstat;
|
|
s->cstat = 0;
|
|
s->z -= ZOFFSET;
|
|
getzrange((vec3_t *)s,s->sectnum,&actor[iActor].ceilingz,&hz,&actor[iActor].floorz,&lz,127L,CLIPMASK0);
|
|
s->z += ZOFFSET;
|
|
s->cstat = cstat;
|
|
}
|
|
else
|
|
{
|
|
actor[iActor].ceilingz = sector[s->sectnum].ceilingz;
|
|
actor[iActor].floorz = sector[s->sectnum].floorz;
|
|
}
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (sector[s->sectnum].floorstat&512)
|
|
fbunch = -1;
|
|
else
|
|
fbunch = yax_getbunch(s->sectnum, YAX_FLOOR);
|
|
#endif
|
|
|
|
if (s->z < actor[iActor].floorz-ZOFFSET
|
|
#ifdef YAX_ENABLE
|
|
|| fbunch >= 0
|
|
#endif
|
|
)
|
|
{
|
|
if (sector[s->sectnum].lotag == ST_2_UNDERWATER && s->zvel > 3122)
|
|
s->zvel = 3144;
|
|
s->z += s->zvel = min(6144, s->zvel+c);
|
|
}
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (fbunch >= 0)
|
|
setspritez(iActor, (vec3_t *)s);
|
|
else
|
|
#endif
|
|
if (s->z >= actor[iActor].floorz-ZOFFSET)
|
|
{
|
|
s->z = actor[iActor].floorz-ZOFFSET;
|
|
s->zvel = 0;
|
|
}
|
|
}
|
|
|
|
int32_t G_GetAngleDelta(int32_t a,int32_t na)
|
|
{
|
|
a &= 2047;
|
|
na &= 2047;
|
|
|
|
if (klabs(a-na) < 1024)
|
|
{
|
|
// OSD_Printf("G_GetAngleDelta() returning %d\n",na-a);
|
|
return (na-a);
|
|
}
|
|
|
|
if (na > 1024) na -= 2048;
|
|
if (a > 1024) a -= 2048;
|
|
|
|
// OSD_Printf("G_GetAngleDelta() returning %d\n",na-a);
|
|
return (na-a);
|
|
}
|
|
|
|
GAMEEXEC_STATIC void VM_AlterAng(int32_t movflags)
|
|
{
|
|
const int32_t ticselapsed = (AC_COUNT(vm.g_t))&31;
|
|
|
|
#if !defined LUNATIC
|
|
const intptr_t *moveptr;
|
|
if ((unsigned)AC_MOVE_ID(vm.g_t) >= (unsigned)g_scriptSize-1)
|
|
|
|
{
|
|
AC_MOVE_ID(vm.g_t) = 0;
|
|
OSD_Printf_nowarn(OSD_ERROR "bad moveptr for actor %d (%d)!\n", vm.g_i, TrackerCast(vm.g_sp->picnum));
|
|
return;
|
|
}
|
|
|
|
moveptr = script + AC_MOVE_ID(vm.g_t);
|
|
|
|
vm.g_sp->xvel += (moveptr[0] - vm.g_sp->xvel)/5;
|
|
if (vm.g_sp->zvel < 648)
|
|
vm.g_sp->zvel += ((moveptr[1]<<4) - vm.g_sp->zvel)/5;
|
|
#else
|
|
vm.g_sp->xvel += (actor[vm.g_i].mv.hvel - vm.g_sp->xvel)/5;
|
|
if (vm.g_sp->zvel < 648)
|
|
vm.g_sp->zvel += ((actor[vm.g_i].mv.vvel<<4) - vm.g_sp->zvel)/5;
|
|
#endif
|
|
|
|
if (A_CheckEnemySprite(vm.g_sp) && vm.g_sp->extra <= 0) // hack
|
|
return;
|
|
|
|
if (movflags&seekplayer)
|
|
{
|
|
int32_t aang = vm.g_sp->ang, angdif, goalang;
|
|
int32_t j = g_player[vm.g_p].ps->holoduke_on;
|
|
|
|
// NOTE: looks like 'owner' is set to target sprite ID...
|
|
|
|
if (j >= 0 && cansee(sprite[j].x,sprite[j].y,sprite[j].z,sprite[j].sectnum,vm.g_sp->x,vm.g_sp->y,vm.g_sp->z,vm.g_sp->sectnum))
|
|
vm.g_sp->owner = j;
|
|
else vm.g_sp->owner = g_player[vm.g_p].ps->i;
|
|
|
|
if (sprite[vm.g_sp->owner].picnum == APLAYER)
|
|
goalang = getangle(actor[vm.g_i].lastvx-vm.g_sp->x,actor[vm.g_i].lastvy-vm.g_sp->y);
|
|
else
|
|
goalang = getangle(sprite[vm.g_sp->owner].x-vm.g_sp->x,sprite[vm.g_sp->owner].y-vm.g_sp->y);
|
|
|
|
if (vm.g_sp->xvel && vm.g_sp->picnum != DRONE)
|
|
{
|
|
angdif = G_GetAngleDelta(aang,goalang);
|
|
|
|
if (ticselapsed < 2)
|
|
{
|
|
if (klabs(angdif) < 256)
|
|
{
|
|
j = 128-(krand()&256);
|
|
vm.g_sp->ang += j;
|
|
if (A_GetHitscanRange(vm.g_i) < 844)
|
|
vm.g_sp->ang -= j;
|
|
}
|
|
}
|
|
else if (ticselapsed > 18 && ticselapsed < GAMETICSPERSEC) // choose
|
|
{
|
|
if (klabs(angdif>>2) < 128) vm.g_sp->ang = goalang;
|
|
else vm.g_sp->ang += angdif>>2;
|
|
}
|
|
}
|
|
else vm.g_sp->ang = goalang;
|
|
}
|
|
|
|
if (ticselapsed < 1)
|
|
{
|
|
if (movflags&furthestdir)
|
|
{
|
|
vm.g_sp->ang = A_GetFurthestAngle(vm.g_i, 2);
|
|
vm.g_sp->owner = g_player[vm.g_p].ps->i;
|
|
}
|
|
|
|
if (movflags&fleeenemy)
|
|
vm.g_sp->ang = A_GetFurthestAngle(vm.g_i, 2);
|
|
}
|
|
}
|
|
|
|
static void VM_AddAngle(int32_t shr, int32_t goalang)
|
|
{
|
|
int32_t angdif = G_GetAngleDelta(vm.g_sp->ang,goalang)>>shr;
|
|
|
|
if ((angdif > -8 && angdif < 0) || (angdif < 8 && angdif > 0))
|
|
angdif *= 2;
|
|
|
|
vm.g_sp->ang += angdif;
|
|
}
|
|
|
|
static void VM_FacePlayer(int32_t shr)
|
|
{
|
|
int32_t goalang;
|
|
const DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
if (g_player[vm.g_p].ps->newowner >= 0)
|
|
goalang = getangle(ps->opos.x-vm.g_sp->x, ps->opos.y-vm.g_sp->y);
|
|
else
|
|
goalang = getangle(ps->pos.x-vm.g_sp->x, ps->pos.y-vm.g_sp->y);
|
|
|
|
VM_AddAngle(shr, goalang);
|
|
}
|
|
|
|
////////// TROR get*zofslope //////////
|
|
// These rather belong into the engine.
|
|
|
|
static int32_t yax_getceilzofslope(int16_t sectnum, int32_t dax, int32_t day)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if ((sector[sectnum].ceilingstat&512)==0)
|
|
{
|
|
int32_t nsect = yax_getneighborsect(dax, day, sectnum, YAX_CEILING);
|
|
if (nsect >= 0)
|
|
return getceilzofslope(nsect, dax, day);
|
|
}
|
|
#endif
|
|
return getceilzofslope(sectnum, dax, day);
|
|
}
|
|
|
|
static int32_t yax_getflorzofslope(int16_t sectnum, int32_t dax, int32_t day)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if ((sector[sectnum].floorstat&512)==0)
|
|
{
|
|
int32_t nsect = yax_getneighborsect(dax, day, sectnum, YAX_FLOOR);
|
|
if (nsect >= 0)
|
|
return getflorzofslope(nsect, dax, day);
|
|
}
|
|
#endif
|
|
return getflorzofslope(sectnum, dax, day);
|
|
}
|
|
|
|
////////////////////
|
|
|
|
GAMEEXEC_STATIC void VM_Move(void)
|
|
{
|
|
#if !defined LUNATIC
|
|
const intptr_t *moveptr;
|
|
#endif
|
|
// NOTE: commented out condition is dead since r3159 (making hi/lotag unsigned).
|
|
// XXX: Does it break anything? Where are movflags with all bits set created?
|
|
const uint16_t *movflagsptr = &AC_MOVFLAGS(vm.g_sp, &actor[vm.g_i]);
|
|
const int32_t movflags = /*(*movflagsptr==-1) ? 0 :*/ *movflagsptr;
|
|
const int32_t deadflag = (A_CheckEnemySprite(vm.g_sp) && vm.g_sp->extra <= 0);
|
|
int32_t badguyp, angdif;
|
|
|
|
AC_COUNT(vm.g_t)++;
|
|
|
|
// If the move ID is zero, or the movflags are 0
|
|
if (AC_MOVE_ID(vm.g_t) == 0 || movflags == 0)
|
|
{
|
|
if (deadflag || (actor[vm.g_i].bpos.x != vm.g_sp->x) || (actor[vm.g_i].bpos.y != vm.g_sp->y))
|
|
{
|
|
actor[vm.g_i].bpos.x = vm.g_sp->x;
|
|
actor[vm.g_i].bpos.y = vm.g_sp->y;
|
|
setsprite(vm.g_i, (vec3_t *)vm.g_sp);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (deadflag)
|
|
goto dead;
|
|
|
|
if (movflags&face_player)
|
|
VM_FacePlayer(2);
|
|
|
|
if (movflags&spin)
|
|
vm.g_sp->ang += sintable[((AC_COUNT(vm.g_t)<<3)&2047)]>>6;
|
|
|
|
if (movflags&face_player_slow)
|
|
VM_FacePlayer(4);
|
|
|
|
if ((movflags&jumptoplayer_bits) == jumptoplayer_bits)
|
|
{
|
|
if (AC_COUNT(vm.g_t) < 16)
|
|
vm.g_sp->zvel -= (sintable[(512+(AC_COUNT(vm.g_t)<<4))&2047]>>5);
|
|
}
|
|
|
|
if (movflags&face_player_smart)
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
int32_t newx = ps->pos.x + (ps->vel.x/768);
|
|
int32_t newy = ps->pos.y + (ps->vel.y/768);
|
|
|
|
int32_t goalang = getangle(newx-vm.g_sp->x,newy-vm.g_sp->y);
|
|
VM_AddAngle(2, goalang);
|
|
}
|
|
|
|
dead:
|
|
#if !defined LUNATIC
|
|
if ((unsigned)AC_MOVE_ID(vm.g_t) >= (unsigned)g_scriptSize-1)
|
|
{
|
|
AC_MOVE_ID(vm.g_t) = 0;
|
|
OSD_Printf_nowarn(OSD_ERROR "clearing bad moveptr for actor %d (%d)\n", vm.g_i, TrackerCast(vm.g_sp->picnum));
|
|
return;
|
|
}
|
|
|
|
moveptr = script + AC_MOVE_ID(vm.g_t);
|
|
|
|
if (movflags&geth) vm.g_sp->xvel += ((moveptr[0])-vm.g_sp->xvel)>>1;
|
|
if (movflags&getv) vm.g_sp->zvel += ((moveptr[1]<<4)-vm.g_sp->zvel)>>1;
|
|
#else
|
|
if (movflags&geth) vm.g_sp->xvel += (actor[vm.g_i].mv.hvel - vm.g_sp->xvel)>>1;
|
|
if (movflags&getv) vm.g_sp->zvel += (16*actor[vm.g_i].mv.vvel - vm.g_sp->zvel)>>1;
|
|
#endif
|
|
|
|
if (movflags&dodgebullet && !deadflag)
|
|
A_Dodge(vm.g_sp);
|
|
|
|
if (vm.g_sp->picnum != APLAYER)
|
|
VM_AlterAng(movflags);
|
|
|
|
if (vm.g_sp->xvel > -6 && vm.g_sp->xvel < 6)
|
|
vm.g_sp->xvel = 0;
|
|
|
|
badguyp = A_CheckEnemySprite(vm.g_sp);
|
|
|
|
if (vm.g_sp->xvel || vm.g_sp->zvel)
|
|
{
|
|
int32_t daxvel;
|
|
|
|
if (badguyp && vm.g_sp->picnum != ROTATEGUN)
|
|
{
|
|
if ((vm.g_sp->picnum == DRONE || vm.g_sp->picnum == COMMANDER) && vm.g_sp->extra > 0)
|
|
{
|
|
if (vm.g_sp->picnum == COMMANDER)
|
|
{
|
|
int32_t l;
|
|
// NOTE: COMMANDER updates both actor[].floorz and
|
|
// .ceilingz regardless of its zvel.
|
|
actor[vm.g_i].floorz = l = yax_getflorzofslope(vm.g_sp->sectnum,vm.g_sp->x,vm.g_sp->y);
|
|
if (vm.g_sp->z > l-(8<<8))
|
|
{
|
|
vm.g_sp->z = l-(8<<8);
|
|
vm.g_sp->zvel = 0;
|
|
}
|
|
|
|
actor[vm.g_i].ceilingz = l = yax_getceilzofslope(vm.g_sp->sectnum,vm.g_sp->x,vm.g_sp->y);
|
|
if (vm.g_sp->z < l+(80<<8))
|
|
{
|
|
vm.g_sp->z = l+(80<<8);
|
|
vm.g_sp->zvel = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int32_t l;
|
|
// The DRONE updates either .floorz or .ceilingz, not both.
|
|
if (vm.g_sp->zvel > 0)
|
|
{
|
|
actor[vm.g_i].floorz = l = yax_getflorzofslope(vm.g_sp->sectnum,vm.g_sp->x,vm.g_sp->y);
|
|
if (vm.g_sp->z > l-(30<<8))
|
|
vm.g_sp->z = l-(30<<8);
|
|
}
|
|
else
|
|
{
|
|
actor[vm.g_i].ceilingz = l = yax_getceilzofslope(vm.g_sp->sectnum,vm.g_sp->x,vm.g_sp->y);
|
|
if (vm.g_sp->z < l+(50<<8))
|
|
{
|
|
vm.g_sp->z = l+(50<<8);
|
|
vm.g_sp->zvel = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (vm.g_sp->picnum != ORGANTIC)
|
|
{
|
|
// All other actors besides ORGANTIC don't update .floorz or
|
|
// .ceilingz here.
|
|
if (vm.g_sp->zvel > 0 && actor[vm.g_i].floorz < vm.g_sp->z)
|
|
vm.g_sp->z = actor[vm.g_i].floorz;
|
|
if (vm.g_sp->zvel < 0)
|
|
{
|
|
const int32_t l = yax_getceilzofslope(vm.g_sp->sectnum,vm.g_sp->x,vm.g_sp->y);
|
|
|
|
if (vm.g_sp->z < l+(66<<8))
|
|
{
|
|
vm.g_sp->z = l+(66<<8);
|
|
vm.g_sp->zvel >>= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (vm.g_sp->picnum == APLAYER)
|
|
if (vm.g_sp->z < actor[vm.g_i].ceilingz+(32<<8))
|
|
vm.g_sp->z = actor[vm.g_i].ceilingz+(32<<8);
|
|
|
|
daxvel = vm.g_sp->xvel;
|
|
angdif = vm.g_sp->ang;
|
|
|
|
if (badguyp && vm.g_sp->picnum != ROTATEGUN)
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
if (vm.g_x < 960 && vm.g_sp->xrepeat > 16)
|
|
{
|
|
daxvel = -(1024-vm.g_x);
|
|
angdif = getangle(ps->pos.x-vm.g_sp->x, ps->pos.y-vm.g_sp->y);
|
|
|
|
if (vm.g_x < 512)
|
|
{
|
|
ps->vel.x = 0;
|
|
ps->vel.y = 0;
|
|
}
|
|
else
|
|
{
|
|
ps->vel.x = mulscale16(ps->vel.x, ps->runspeed-0x2000);
|
|
ps->vel.y = mulscale16(ps->vel.y, ps->runspeed-0x2000);
|
|
}
|
|
}
|
|
else if (vm.g_sp->picnum != DRONE && vm.g_sp->picnum != SHARK && vm.g_sp->picnum != COMMANDER)
|
|
{
|
|
if (ps->actorsqu == vm.g_i)
|
|
return;
|
|
|
|
if (!A_CheckSpriteFlags(vm.g_i, SFLAG_SMOOTHMOVE))
|
|
{
|
|
if (AC_COUNT(vm.g_t)&1)
|
|
return;
|
|
daxvel <<= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
vec3_t tmpvect = { (daxvel*(sintable[(angdif+512)&2047]))>>14,
|
|
(daxvel*(sintable[angdif&2047]))>>14,
|
|
vm.g_sp->zvel
|
|
};
|
|
|
|
actor[vm.g_i].movflag = A_MoveSprite(
|
|
vm.g_i,&tmpvect, (A_CheckSpriteFlags(vm.g_i, SFLAG_NOCLIP) ? 0 : CLIPMASK0));
|
|
}
|
|
}
|
|
|
|
if (!badguyp)
|
|
return;
|
|
|
|
if (sector[vm.g_sp->sectnum].ceilingstat&1)
|
|
vm.g_sp->shade += (sector[vm.g_sp->sectnum].ceilingshade-vm.g_sp->shade)>>1;
|
|
else vm.g_sp->shade += (sector[vm.g_sp->sectnum].floorshade-vm.g_sp->shade)>>1;
|
|
}
|
|
|
|
static void P_AddWeaponMaybeSwitch(DukePlayer_t *ps, int32_t weap)
|
|
{
|
|
if ((ps->weaponswitch & 1) && (ps->weaponswitch & 4))
|
|
{
|
|
const int32_t snum = P_Get(ps->i);
|
|
int32_t i, new_wchoice = -1, curr_wchoice = -1;
|
|
|
|
for (i=0; i<=FREEZE_WEAPON && (new_wchoice < 0 || curr_wchoice < 0); i++)
|
|
{
|
|
int32_t w = g_player[snum].wchoice[i];
|
|
|
|
if (w == KNEE_WEAPON)
|
|
w = FREEZE_WEAPON;
|
|
else w--;
|
|
|
|
if (w == ps->curr_weapon)
|
|
curr_wchoice = i;
|
|
if (w == weap)
|
|
new_wchoice = i;
|
|
}
|
|
|
|
P_AddWeapon(ps, weap, (new_wchoice < curr_wchoice));
|
|
}
|
|
else
|
|
{
|
|
P_AddWeapon(ps, weap, (ps->weaponswitch & 1));
|
|
}
|
|
}
|
|
|
|
#if defined LUNATIC
|
|
void P_AddWeaponMaybeSwitchI(int32_t snum, int32_t weap)
|
|
{
|
|
P_AddWeaponMaybeSwitch(g_player[snum].ps, weap);
|
|
}
|
|
#else
|
|
static void P_AddWeaponAmmoCommon(DukePlayer_t *ps, int32_t weap, int32_t amount)
|
|
{
|
|
P_AddAmmo(weap, ps, amount);
|
|
|
|
if (ps->curr_weapon == KNEE_WEAPON && (ps->gotweapon & (1 << weap)))
|
|
P_AddWeaponMaybeSwitch(ps, weap);
|
|
}
|
|
|
|
static int32_t VM_AddWeapon(int32_t weap, int32_t amount, DukePlayer_t *ps)
|
|
{
|
|
if ((unsigned)weap >= MAX_WEAPONS)
|
|
{
|
|
CON_ERRPRINTF("Invalid weapon ID %d\n", weap);
|
|
return 1;
|
|
}
|
|
|
|
if ((ps->gotweapon & (1 << weap)) == 0)
|
|
{
|
|
P_AddWeaponMaybeSwitch(ps, weap);
|
|
}
|
|
else if (ps->ammo_amount[weap] >= ps->max_ammo_amount[weap])
|
|
{
|
|
vm.g_flags |= VM_NOEXECUTE;
|
|
return 2;
|
|
}
|
|
|
|
P_AddWeaponAmmoCommon(ps, weap, amount);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static void VM_Fall(int32_t g_i, spritetype *g_sp)
|
|
{
|
|
int32_t grav = g_spriteGravity;
|
|
|
|
g_sp->xoffset = g_sp->yoffset = 0;
|
|
|
|
if (G_CheckForSpaceCeiling(g_sp->sectnum) || sector[g_sp->sectnum].lotag == ST_2_UNDERWATER)
|
|
grav = g_spriteGravity/6;
|
|
else if (G_CheckForSpaceFloor(g_sp->sectnum))
|
|
grav = 0;
|
|
|
|
if (!actor[g_i].cgg-- || (sector[g_sp->sectnum].floorstat&2))
|
|
{
|
|
A_GetZLimits(g_i);
|
|
actor[g_i].cgg = 3;
|
|
}
|
|
|
|
if (g_sp->z < actor[g_i].floorz-ZOFFSET)
|
|
{
|
|
// Free fall.
|
|
g_sp->zvel = min(g_sp->zvel+grav, ACTOR_MAXFALLINGZVEL);
|
|
g_sp->z += g_sp->zvel;
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(g_sp->sectnum, YAX_FLOOR) >= 0 &&
|
|
(sector[g_sp->sectnum].floorstat&512)==0)
|
|
setspritez(g_i, (vec3_t *)g_sp);
|
|
else
|
|
#endif
|
|
if (g_sp->z > actor[g_i].floorz - ZOFFSET)
|
|
g_sp->z = actor[g_i].floorz - ZOFFSET;
|
|
return;
|
|
}
|
|
|
|
// SET_SPRITE_Z
|
|
g_sp->z = actor[g_i].floorz - ZOFFSET;
|
|
|
|
if (A_CheckEnemySprite(g_sp) || (g_sp->picnum == APLAYER && g_sp->owner >= 0))
|
|
{
|
|
if (g_sp->zvel > 3084 && g_sp->extra <= 1)
|
|
{
|
|
// I'm guessing this DRONE check is from a beta version of the game
|
|
// where they crashed into the ground when killed
|
|
if (!(g_sp->picnum == APLAYER && g_sp->extra > 0) && g_sp->pal != 1 && g_sp->picnum != DRONE)
|
|
{
|
|
A_DoGuts(g_i,JIBS6,15);
|
|
A_PlaySound(SQUISHED,g_i);
|
|
A_Spawn(g_i,BLOODPOOL);
|
|
}
|
|
|
|
actor[g_i].picnum = SHOTSPARK1;
|
|
actor[g_i].extra = 1;
|
|
g_sp->zvel = 0;
|
|
}
|
|
else if (g_sp->zvel > 2048 && sector[g_sp->sectnum].lotag != ST_1_ABOVE_WATER)
|
|
{
|
|
int16_t newsect = g_sp->sectnum;
|
|
|
|
pushmove((vec3_t *)g_sp, &newsect, 128, 4<<8, 4<<8, CLIPMASK0);
|
|
if ((unsigned)newsect < MAXSECTORS)
|
|
changespritesect(g_i, newsect);
|
|
|
|
A_PlaySound(THUD, g_i);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
if (g_sp->z > actor[g_i].floorz - ZOFFSET)
|
|
{
|
|
// Unreachable because of SET_SPRITE_Z.
|
|
A_GetZLimits(g_i);
|
|
if (actor[g_i].floorz != sector[g_sp->sectnum].floorz)
|
|
g_sp->z = (actor[g_i].floorz - ZOFFSET);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (sector[g_sp->sectnum].lotag == ST_1_ABOVE_WATER)
|
|
{
|
|
switch (DYNAMICTILEMAP(g_sp->picnum))
|
|
{
|
|
case OCTABRAIN__STATIC:
|
|
case COMMANDER__STATIC:
|
|
case DRONE__STATIC:
|
|
break;
|
|
|
|
default:
|
|
{
|
|
#if !defined LUNATIC
|
|
int32_t moveScriptOfs = AC_MOVE_ID(vm.g_t);
|
|
#endif
|
|
// fix for flying/jumping monsters getting stuck in water
|
|
if ((AC_MOVFLAGS(g_sp, &actor[vm.g_i]) & jumptoplayer_bits) == jumptoplayer_only ||
|
|
(G_HaveActor(g_sp->picnum) &&
|
|
#if !defined LUNATIC
|
|
(unsigned)moveScriptOfs < (unsigned)g_scriptSize-1 && script[moveScriptOfs + 1]
|
|
#else
|
|
actor[g_i].mv.vvel != 0
|
|
#endif
|
|
))
|
|
{
|
|
// OSD_Printf("%d\n", script[moveScriptOfs + 1]);
|
|
break;
|
|
}
|
|
|
|
// OSD_Printf("hitag: %d\n",g_sp->hitag);
|
|
g_sp->z += ACTOR_ONWATER_ADDZ;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
g_sp->zvel = 0;
|
|
}
|
|
|
|
static int32_t VM_ResetPlayer(int32_t g_p, int32_t g_flags)
|
|
{
|
|
//AddLog("resetplayer");
|
|
if (!g_netServer && ud.multimode < 2)
|
|
{
|
|
if (g_lastSaveSlot >= 0 && ud.recstat != 2)
|
|
{
|
|
g_player[g_p].ps->gm |= MODE_MENU;
|
|
KB_ClearKeyDown(sc_Space);
|
|
I_AdvanceTriggerClear();
|
|
M_ChangeMenu(MENU_RESETPLAYER);
|
|
}
|
|
else g_player[g_p].ps->gm = MODE_RESTART;
|
|
#if !defined LUNATIC
|
|
g_flags |= VM_NOEXECUTE;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
if (g_p == myconnectindex)
|
|
{
|
|
CAMERADIST = 0;
|
|
CAMERACLOCK = totalclock;
|
|
}
|
|
|
|
if (g_fakeMultiMode)
|
|
P_ResetPlayer(g_p);
|
|
#ifndef NETCODE_DISABLE
|
|
if (g_netServer)
|
|
{
|
|
P_ResetPlayer(g_p);
|
|
Net_SpawnPlayer(g_p);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
P_UpdateScreenPal(g_player[g_p].ps);
|
|
//AddLog("EOF: resetplayer");
|
|
|
|
return g_flags;
|
|
}
|
|
|
|
void G_GetTimeDate(int32_t *vals)
|
|
{
|
|
time_t rawtime;
|
|
struct tm *ti;
|
|
|
|
time(&rawtime);
|
|
ti=localtime(&rawtime);
|
|
// initprintf("Time&date: %s\n",asctime (ti));
|
|
|
|
vals[0] = ti->tm_sec;
|
|
vals[1] = ti->tm_min;
|
|
vals[2] = ti->tm_hour;
|
|
vals[3] = ti->tm_mday;
|
|
vals[4] = ti->tm_mon;
|
|
vals[5] = ti->tm_year+1900;
|
|
vals[6] = ti->tm_wday;
|
|
vals[7] = ti->tm_yday;
|
|
}
|
|
|
|
int32_t G_StartTrack(int32_t level)
|
|
{
|
|
if ((unsigned)level < MAXLEVELS)
|
|
{
|
|
int32_t musicIndex = MAXLEVELS*ud.volume_number + level;
|
|
|
|
if (MapInfo[musicIndex].musicfn != NULL)
|
|
{
|
|
// Only set g_musicIndex on success.
|
|
g_musicIndex = musicIndex;
|
|
S_PlayMusic(MapInfo[musicIndex].musicfn, g_musicIndex);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
LUNATIC_EXTERN void G_ShowView(int32_t x, int32_t y, int32_t z, int32_t a, int32_t horiz, int32_t sect,
|
|
int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t unbiasedp)
|
|
{
|
|
int32_t smoothratio = calc_smoothratio(totalclock, ototalclock);
|
|
#ifdef USE_OPENGL
|
|
int32_t oprojhacks;
|
|
#endif
|
|
|
|
if (g_screenCapture)
|
|
return;
|
|
|
|
if (offscreenrendering)
|
|
{
|
|
clearview(0);
|
|
return;
|
|
}
|
|
|
|
if (x1 > x2) swaplong(&x1,&x2);
|
|
if (y1 > y2) swaplong(&y1,&y2);
|
|
|
|
if (!unbiasedp)
|
|
{
|
|
// The showview command has a rounding bias towards zero,
|
|
// e.g. floor((319*1680)/320) == 1674
|
|
x1 = scale(x1,xdim,320);
|
|
y1 = scale(y1,ydim,200);
|
|
x2 = scale(x2,xdim,320);
|
|
y2 = scale(y2,ydim,200);
|
|
}
|
|
else
|
|
{
|
|
// This will map the maximum 320-based coordinate to the
|
|
// maximum real screen coordinate:
|
|
// floor((319*1679)/319) == 1679
|
|
x1 = scale(x1,xdim-1,319);
|
|
y1 = scale(y1,ydim-1,199);
|
|
x2 = scale(x2,xdim-1,319);
|
|
y2 = scale(y2,ydim-1,199);
|
|
}
|
|
|
|
horiz = clamp(horiz, HORIZ_MIN, HORIZ_MAX);
|
|
|
|
#ifdef USE_OPENGL
|
|
oprojhacks = glprojectionhacks;
|
|
glprojectionhacks = 0;
|
|
#endif
|
|
{
|
|
int32_t o = newaspect_enable;
|
|
newaspect_enable = r_usenewaspect;
|
|
setaspect_new_use_dimen = 1;
|
|
|
|
setview(x1,y1,x2,y2);
|
|
|
|
setaspect_new_use_dimen = 0;
|
|
newaspect_enable = o;
|
|
}
|
|
|
|
G_DoInterpolations(smoothratio);
|
|
|
|
G_HandleMirror(x, y, z, a, horiz, smoothratio);
|
|
#ifdef POLYMER
|
|
if (getrendermode() == REND_POLYMER)
|
|
polymer_setanimatesprites(G_DoSpriteAnimations, x,y,a,smoothratio);
|
|
#endif
|
|
yax_preparedrawrooms();
|
|
drawrooms(x,y,z,a,horiz,sect);
|
|
yax_drawrooms(G_DoSpriteAnimations, sect, 0, smoothratio);
|
|
|
|
display_mirror = 2;
|
|
G_DoSpriteAnimations(x,y,a,smoothratio);
|
|
display_mirror = 0;
|
|
drawmasks();
|
|
G_RestoreInterpolations();
|
|
G_UpdateScreenArea();
|
|
#ifdef USE_OPENGL
|
|
glprojectionhacks = oprojhacks;
|
|
#endif
|
|
}
|
|
|
|
#if !defined LUNATIC
|
|
GAMEEXEC_STATIC void VM_Execute(int32_t loop)
|
|
{
|
|
register int32_t tw = *insptr;
|
|
|
|
// jump directly into the loop, saving us from the checks during the first iteration
|
|
goto skip_check;
|
|
|
|
while (loop)
|
|
{
|
|
if (vm.g_flags & (VM_RETURN|VM_KILL|VM_NOEXECUTE))
|
|
return;
|
|
|
|
tw = *insptr;
|
|
|
|
skip_check:
|
|
// Bsprintf(g_szBuf,"Parsing: %d",*insptr);
|
|
// AddLog(g_szBuf);
|
|
|
|
g_errorLineNum = tw>>12;
|
|
g_tw = tw &= 0xFFF;
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_REDEFINEQUOTE:
|
|
insptr++;
|
|
{
|
|
int32_t q = *insptr++, i = *insptr++;
|
|
if ((ScriptQuotes[q] == NULL || ScriptQuoteRedefinitions[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("%d %d null quote\n", q,i);
|
|
break;
|
|
}
|
|
Bstrcpy(ScriptQuotes[q],ScriptQuoteRedefinitions[i]);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETTHISPROJECTILE:
|
|
case CON_SETTHISPROJECTILE:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etplayer[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessActiveProjectile(tw==CON_SETTHISPROJECTILE,lVar1,lLabelID,lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_IFRND:
|
|
VM_CONDITIONAL(rnd(*(++insptr)));
|
|
continue;
|
|
|
|
case CON_IFCANSHOOTTARGET:
|
|
{
|
|
int32_t j;
|
|
|
|
if (vm.g_x > 1024)
|
|
{
|
|
int16_t temphit;
|
|
|
|
if ((j = A_CheckHitSprite(vm.g_i,&temphit)) == (1<<30))
|
|
{
|
|
VM_CONDITIONAL(1);
|
|
continue;
|
|
}
|
|
|
|
{
|
|
int32_t sclip = 768, angdif = 16;
|
|
|
|
if (A_CheckEnemySprite(vm.g_sp) && vm.g_sp->xrepeat > 56)
|
|
{
|
|
sclip = 3084;
|
|
angdif = 48;
|
|
}
|
|
|
|
if (j > sclip)
|
|
{
|
|
if (temphit >= 0 && sprite[temphit].picnum == vm.g_sp->picnum)
|
|
{
|
|
VM_CONDITIONAL(0);
|
|
continue;
|
|
}
|
|
|
|
vm.g_sp->ang += angdif;
|
|
j = A_CheckHitSprite(vm.g_i,&temphit);
|
|
vm.g_sp->ang -= angdif;
|
|
|
|
if (j > sclip)
|
|
{
|
|
if (temphit >= 0 && sprite[temphit].picnum == vm.g_sp->picnum)
|
|
{
|
|
VM_CONDITIONAL(0);
|
|
continue;
|
|
}
|
|
|
|
vm.g_sp->ang -= angdif;
|
|
j = A_CheckHitSprite(vm.g_i,&temphit);
|
|
vm.g_sp->ang += angdif;
|
|
|
|
if (j > 768)
|
|
{
|
|
if (temphit >= 0 && sprite[temphit].picnum == vm.g_sp->picnum)
|
|
{
|
|
VM_CONDITIONAL(0);
|
|
continue;
|
|
}
|
|
|
|
VM_CONDITIONAL(1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
VM_CONDITIONAL(1);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFCANSEETARGET:
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
int32_t j = cansee(vm.g_sp->x, vm.g_sp->y, vm.g_sp->z-((krand()&41)<<8),
|
|
vm.g_sp->sectnum, ps->pos.x, ps->pos.y,
|
|
ps->pos.z/*-((krand()&41)<<8)*/, sprite[ps->i].sectnum);
|
|
VM_CONDITIONAL(j);
|
|
if (j) actor[vm.g_i].timetosleep = SLEEPTIME;
|
|
}
|
|
continue;
|
|
|
|
case CON_IFACTORNOTSTAYPUT:
|
|
VM_CONDITIONAL(actor[vm.g_i].actorstayput == -1);
|
|
continue;
|
|
|
|
case CON_IFCANSEE:
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
spritetype *s = &sprite[ps->i];
|
|
int32_t j;
|
|
|
|
// select sprite for monster to target
|
|
// if holoduke is on, let them target holoduke first.
|
|
//
|
|
if (ps->holoduke_on >= 0)
|
|
{
|
|
s = &sprite[ps->holoduke_on];
|
|
j = cansee(vm.g_sp->x,vm.g_sp->y,vm.g_sp->z-(krand()&((32<<8)-1)),vm.g_sp->sectnum,
|
|
s->x,s->y,s->z,s->sectnum);
|
|
|
|
if (j == 0)
|
|
{
|
|
// they can't see player's holoduke
|
|
// check for player...
|
|
s = &sprite[ps->i];
|
|
}
|
|
}
|
|
|
|
// can they see player, (or player's holoduke)
|
|
j = cansee(vm.g_sp->x,vm.g_sp->y,vm.g_sp->z-(krand()&((47<<8))),vm.g_sp->sectnum,
|
|
s->x,s->y,s->z-(24<<8),s->sectnum);
|
|
|
|
if (j == 0)
|
|
{
|
|
// search around for target player
|
|
|
|
// also modifies 'target' x&y if found..
|
|
|
|
j = 1;
|
|
if (A_FurthestVisiblePoint(vm.g_i,s,&actor[vm.g_i].lastvx,&actor[vm.g_i].lastvy) == -1)
|
|
j = 0;
|
|
}
|
|
else
|
|
{
|
|
// else, they did see it.
|
|
// save where we were looking...
|
|
actor[vm.g_i].lastvx = s->x;
|
|
actor[vm.g_i].lastvy = s->y;
|
|
}
|
|
|
|
if (j && (vm.g_sp->statnum == STAT_ACTOR || vm.g_sp->statnum == STAT_STANDABLE))
|
|
actor[vm.g_i].timetosleep = SLEEPTIME;
|
|
|
|
VM_CONDITIONAL(j);
|
|
continue;
|
|
}
|
|
|
|
case CON_IFHITWEAPON:
|
|
VM_CONDITIONAL(A_IncurDamage(vm.g_i) >= 0);
|
|
continue;
|
|
|
|
case CON_IFSQUISHED:
|
|
VM_CONDITIONAL(VM_CheckSquished());
|
|
continue;
|
|
|
|
case CON_IFDEAD:
|
|
// j = vm.g_sp->extra;
|
|
// if (vm.g_sp->picnum == APLAYER)
|
|
// j--;
|
|
VM_CONDITIONAL(vm.g_sp->extra <= 0);
|
|
continue;
|
|
|
|
case CON_AI:
|
|
insptr++;
|
|
//Following changed to use pointersizes
|
|
AC_AI_ID(vm.g_t) = *insptr++; // Ai
|
|
|
|
AC_ACTION_ID(vm.g_t) = *(script + AC_AI_ID(vm.g_t)); // Action
|
|
|
|
// NOTE: "if" check added in r1155. It used to be a pointer though.
|
|
if (AC_AI_ID(vm.g_t))
|
|
AC_MOVE_ID(vm.g_t) = *(script + AC_AI_ID(vm.g_t) + 1); // move
|
|
|
|
vm.g_sp->hitag = *(script + AC_AI_ID(vm.g_t) + 2); // move flags
|
|
|
|
AC_COUNT(vm.g_t) = AC_ACTION_COUNT(vm.g_t) = AC_CURFRAME(vm.g_t) = 0;
|
|
|
|
if (!A_CheckEnemySprite(vm.g_sp) || vm.g_sp->extra > 0) // hack
|
|
if (vm.g_sp->hitag&random_angle)
|
|
vm.g_sp->ang = krand()&2047;
|
|
continue;
|
|
|
|
case CON_ACTION:
|
|
insptr++;
|
|
AC_ACTION_COUNT(vm.g_t) = AC_CURFRAME(vm.g_t) = 0;
|
|
AC_ACTION_ID(vm.g_t) = *insptr++;
|
|
continue;
|
|
|
|
case CON_IFPLAYERSL:
|
|
VM_CONDITIONAL(numplayers < *(++insptr));
|
|
continue;
|
|
|
|
case CON_IFPDISTL:
|
|
VM_CONDITIONAL(vm.g_x < *(++insptr));
|
|
if (vm.g_x > MAXSLEEPDIST && actor[vm.g_i].timetosleep == 0)
|
|
actor[vm.g_i].timetosleep = SLEEPTIME;
|
|
continue;
|
|
|
|
case CON_IFPDISTG:
|
|
VM_CONDITIONAL(vm.g_x > *(++insptr));
|
|
if (vm.g_x > MAXSLEEPDIST && actor[vm.g_i].timetosleep == 0)
|
|
actor[vm.g_i].timetosleep = SLEEPTIME;
|
|
continue;
|
|
|
|
case CON_ELSE:
|
|
insptr = (intptr_t *) *(insptr+1);
|
|
continue;
|
|
|
|
case CON_ADDSTRENGTH:
|
|
insptr++;
|
|
vm.g_sp->extra += *insptr++;
|
|
continue;
|
|
|
|
case CON_STRENGTH:
|
|
insptr++;
|
|
vm.g_sp->extra = *insptr++;
|
|
continue;
|
|
|
|
case CON_IFGOTWEAPONCE:
|
|
insptr++;
|
|
|
|
if ((GametypeFlags[ud.coop]&GAMETYPE_WEAPSTAY) && (g_netServer || ud.multimode > 1))
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
if (*insptr == 0)
|
|
{
|
|
int32_t j = 0;
|
|
for (; j < ps->weapreccnt; j++)
|
|
if (ps->weaprecs[j] == vm.g_sp->picnum)
|
|
break;
|
|
|
|
VM_CONDITIONAL(j < ps->weapreccnt && vm.g_sp->owner == vm.g_i);
|
|
continue;
|
|
}
|
|
else if (ps->weapreccnt < MAX_WEAPONS)
|
|
{
|
|
ps->weaprecs[ps->weapreccnt++] = vm.g_sp->picnum;
|
|
VM_CONDITIONAL(vm.g_sp->owner == vm.g_i);
|
|
continue;
|
|
}
|
|
}
|
|
VM_CONDITIONAL(0);
|
|
continue;
|
|
|
|
case CON_GETLASTPAL:
|
|
insptr++;
|
|
if (vm.g_sp->picnum == APLAYER)
|
|
vm.g_sp->pal = g_player[P_GetP(vm.g_sp)].ps->palookup;
|
|
else
|
|
{
|
|
if (vm.g_sp->pal == 1 && vm.g_sp->extra == 0) // hack for frozen
|
|
vm.g_sp->extra++;
|
|
vm.g_sp->pal = actor[vm.g_i].tempang;
|
|
}
|
|
actor[vm.g_i].tempang = 0;
|
|
continue;
|
|
|
|
case CON_TOSSWEAPON:
|
|
insptr++;
|
|
// NOTE: assumes that current actor is APLAYER
|
|
P_DropWeapon(P_GetP(vm.g_sp));
|
|
continue;
|
|
|
|
case CON_NULLOP:
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_MIKESND:
|
|
insptr++;
|
|
if (((unsigned)vm.g_sp->yvel >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", TrackerCast(vm.g_sp->yvel));
|
|
continue;
|
|
}
|
|
if (!S_CheckSoundPlaying(vm.g_i,vm.g_sp->yvel))
|
|
A_PlaySound(vm.g_sp->yvel,vm.g_i);
|
|
continue;
|
|
|
|
case CON_PKICK:
|
|
insptr++;
|
|
|
|
if ((g_netServer || ud.multimode > 1) && vm.g_sp->picnum == APLAYER)
|
|
{
|
|
if (g_player[otherp].ps->quick_kick == 0)
|
|
g_player[otherp].ps->quick_kick = 14;
|
|
}
|
|
else if (vm.g_sp->picnum != APLAYER && g_player[vm.g_p].ps->quick_kick == 0)
|
|
g_player[vm.g_p].ps->quick_kick = 14;
|
|
continue;
|
|
|
|
case CON_SIZETO:
|
|
insptr++;
|
|
|
|
{
|
|
int32_t j = (*insptr++ - vm.g_sp->xrepeat)<<1;
|
|
vm.g_sp->xrepeat += ksgn(j);
|
|
|
|
if ((vm.g_sp->picnum == APLAYER && vm.g_sp->yrepeat < 36) || *insptr < vm.g_sp->yrepeat ||
|
|
((vm.g_sp->yrepeat*(tilesizy[vm.g_sp->picnum]+8))<<2) < (actor[vm.g_i].floorz - actor[vm.g_i].ceilingz))
|
|
{
|
|
j = ((*insptr)-vm.g_sp->yrepeat)<<1;
|
|
if (klabs(j)) vm.g_sp->yrepeat += ksgn(j);
|
|
}
|
|
}
|
|
insptr++;
|
|
|
|
continue;
|
|
|
|
case CON_SIZEAT:
|
|
insptr++;
|
|
vm.g_sp->xrepeat = (uint8_t) *insptr++;
|
|
vm.g_sp->yrepeat = (uint8_t) *insptr++;
|
|
continue;
|
|
|
|
case CON_SHOOT:
|
|
insptr++;
|
|
A_Shoot(vm.g_i,*insptr++);
|
|
continue;
|
|
|
|
case CON_SOUNDONCE:
|
|
if (((unsigned)*(++insptr) >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", (int32_t)*insptr++);
|
|
continue;
|
|
}
|
|
if (!S_CheckSoundPlaying(vm.g_i,*insptr++))
|
|
A_PlaySound(*(insptr-1),vm.g_i);
|
|
continue;
|
|
|
|
case CON_IFACTORSOUND:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++), j = Gv_GetVarX(*insptr++);
|
|
|
|
if (((unsigned)j >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", j);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
insptr--;
|
|
VM_CONDITIONAL(A_CheckSoundPlaying(i,j));
|
|
}
|
|
continue;
|
|
|
|
case CON_IFSOUND:
|
|
if (((unsigned)*(++insptr) >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", (int32_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
VM_CONDITIONAL(S_CheckSoundPlaying(vm.g_i,*insptr));
|
|
// VM_DoConditional(SoundOwner[*insptr][0].ow == vm.g_i);
|
|
continue;
|
|
|
|
case CON_STOPSOUND:
|
|
if (((unsigned)*(++insptr) >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", (int32_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
if (S_CheckSoundPlaying(vm.g_i,*insptr))
|
|
S_StopSound((int16_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_STOPACTORSOUND:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++), j = Gv_GetVarX(*insptr++);
|
|
|
|
if ((j<0 || j>=MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
if (A_CheckSoundPlaying(i,j))
|
|
S_StopEnvSound(j,i);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_SETACTORSOUNDPITCH:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++), j = Gv_GetVarX(*insptr++), pitchoffset = Gv_GetVarX(*insptr++);
|
|
|
|
if ((j<0 || j>=MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
S_ChangeSoundPitch(j,i,pitchoffset);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_GLOBALSOUND:
|
|
if (((unsigned)*(++insptr) >= MAXSOUNDS))
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", (int32_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
if (vm.g_p == screenpeek || (GametypeFlags[ud.coop]&GAMETYPE_COOPSOUND)
|
|
#ifdef SPLITSCREEN_MOD_HACKS
|
|
|| (g_fakeMultiMode==2)
|
|
#endif
|
|
)
|
|
A_PlaySound(*insptr,g_player[screenpeek].ps->i);
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_SOUND:
|
|
if ((unsigned)*(++insptr) >= MAXSOUNDS)
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", (int32_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
A_PlaySound(*insptr++,vm.g_i);
|
|
continue;
|
|
|
|
case CON_TIP:
|
|
insptr++;
|
|
g_player[vm.g_p].ps->tipincs = GAMETICSPERSEC;
|
|
continue;
|
|
|
|
case CON_FALL:
|
|
insptr++;
|
|
VM_Fall(vm.g_i, vm.g_sp);
|
|
continue;
|
|
|
|
case CON_RETURN:
|
|
vm.g_flags |= VM_RETURN;
|
|
case CON_ENDA:
|
|
case CON_BREAK:
|
|
case CON_ENDS:
|
|
return;
|
|
case CON_RIGHTBRACE:
|
|
insptr++;
|
|
return;
|
|
|
|
case CON_ADDAMMO:
|
|
insptr++;
|
|
{
|
|
int32_t weap=*insptr++, amount=*insptr++;
|
|
DukePlayer_t *ps = g_player[vm.g_p].ps;
|
|
|
|
if ((unsigned)weap >= MAX_WEAPONS)
|
|
{
|
|
CON_ERRPRINTF("Invalid weapon ID %d\n", weap);
|
|
break;
|
|
}
|
|
|
|
if (ps->ammo_amount[weap] >= ps->max_ammo_amount[weap])
|
|
{
|
|
vm.g_flags |= VM_NOEXECUTE;
|
|
break;
|
|
}
|
|
|
|
P_AddWeaponAmmoCommon(ps, weap, amount);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_MONEY:
|
|
insptr++;
|
|
A_SpawnMultiple(vm.g_i, MONEY, *insptr++);
|
|
continue;
|
|
|
|
case CON_MAIL:
|
|
insptr++;
|
|
A_SpawnMultiple(vm.g_i, MAIL, *insptr++);
|
|
continue;
|
|
|
|
case CON_SLEEPTIME:
|
|
insptr++;
|
|
actor[vm.g_i].timetosleep = (int16_t)*insptr++;
|
|
continue;
|
|
|
|
case CON_PAPER:
|
|
insptr++;
|
|
A_SpawnMultiple(vm.g_i, PAPER, *insptr++);
|
|
continue;
|
|
|
|
case CON_ADDKILLS:
|
|
insptr++;
|
|
g_player[vm.g_p].ps->actors_killed += *insptr++;
|
|
actor[vm.g_i].actorstayput = -1;
|
|
continue;
|
|
|
|
case CON_LOTSOFGLASS:
|
|
insptr++;
|
|
A_SpawnGlass(vm.g_i,*insptr++);
|
|
continue;
|
|
|
|
case CON_KILLIT:
|
|
insptr++;
|
|
vm.g_flags |= VM_KILL;
|
|
continue;
|
|
|
|
case CON_ADDWEAPON:
|
|
insptr++;
|
|
{
|
|
int32_t weap=*insptr++, amount=*insptr++;
|
|
VM_AddWeapon(weap, amount, g_player[vm.g_p].ps);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_DEBUG:
|
|
insptr++;
|
|
initprintf("%" PRIdPTR "\n",*insptr++);
|
|
continue;
|
|
|
|
case CON_ENDOFGAME:
|
|
case CON_ENDOFLEVEL:
|
|
insptr++;
|
|
g_player[vm.g_p].ps->timebeforeexit = *insptr++;
|
|
g_player[vm.g_p].ps->customexitsound = -1;
|
|
ud.eog = 1;
|
|
continue;
|
|
|
|
case CON_ADDPHEALTH:
|
|
insptr++;
|
|
|
|
{
|
|
int32_t j;
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
if (ps->newowner >= 0)
|
|
G_ClearCameraView(ps);
|
|
|
|
j = sprite[ps->i].extra;
|
|
|
|
if (vm.g_sp->picnum != ATOMICHEALTH)
|
|
{
|
|
if (j > ps->max_player_health && *insptr > 0)
|
|
{
|
|
insptr++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (j > 0)
|
|
j += *insptr;
|
|
if (j > ps->max_player_health && *insptr > 0)
|
|
j = ps->max_player_health;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (j > 0)
|
|
j += *insptr;
|
|
if (j > (ps->max_player_health<<1))
|
|
j = (ps->max_player_health<<1);
|
|
}
|
|
|
|
if (j < 0) j = 0;
|
|
|
|
if (ud.god == 0)
|
|
{
|
|
if (*insptr > 0)
|
|
{
|
|
if ((j - *insptr) < (ps->max_player_health>>2) &&
|
|
j >= (ps->max_player_health>>2))
|
|
A_PlaySound(DUKE_GOTHEALTHATLOW,ps->i);
|
|
|
|
ps->last_extra = j;
|
|
}
|
|
|
|
sprite[ps->i].extra = j;
|
|
}
|
|
}
|
|
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_STATE:
|
|
{
|
|
intptr_t *tempscrptr=insptr+2;
|
|
|
|
insptr = (intptr_t *) *(insptr+1);
|
|
VM_Execute(1);
|
|
insptr = tempscrptr;
|
|
}
|
|
continue;
|
|
|
|
case CON_LEFTBRACE:
|
|
insptr++;
|
|
VM_Execute(1);
|
|
continue;
|
|
|
|
case CON_MOVE:
|
|
insptr++;
|
|
AC_COUNT(vm.g_t) = 0;
|
|
AC_MOVE_ID(vm.g_t) = *insptr++;
|
|
vm.g_sp->hitag = *insptr++;
|
|
if (A_CheckEnemySprite(vm.g_sp) && vm.g_sp->extra <= 0) // hack
|
|
continue;
|
|
if (vm.g_sp->hitag&random_angle)
|
|
vm.g_sp->ang = krand()&2047;
|
|
continue;
|
|
|
|
case CON_ADDWEAPONVAR:
|
|
insptr++;
|
|
{
|
|
int32_t weap=Gv_GetVarX(*insptr++), amount=Gv_GetVarX(*insptr++);
|
|
VM_AddWeapon(weap, amount, g_player[vm.g_p].ps);
|
|
continue;
|
|
}
|
|
|
|
case CON_ACTIVATEBYSECTOR:
|
|
case CON_OPERATESECTORS:
|
|
case CON_OPERATEACTIVATORS:
|
|
case CON_SETASPECT:
|
|
case CON_SSP:
|
|
insptr++;
|
|
{
|
|
int32_t var1 = Gv_GetVarX(*insptr++), var2;
|
|
if (tw == CON_OPERATEACTIVATORS && *insptr == g_iThisActorID)
|
|
{
|
|
var2 = vm.g_p;
|
|
insptr++;
|
|
}
|
|
else var2 = Gv_GetVarX(*insptr++);
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_ACTIVATEBYSECTOR:
|
|
if ((unsigned)var1 >= (unsigned)numsectors) {CON_ERRPRINTF("Invalid sector %d\n", var1); break;}
|
|
G_ActivateBySector(var1, var2);
|
|
break;
|
|
case CON_OPERATESECTORS:
|
|
if ((unsigned)var1 >= (unsigned)numsectors) {CON_ERRPRINTF("Invalid sector %d\n", var1); break;}
|
|
G_OperateSectors(var1, var2);
|
|
break;
|
|
case CON_OPERATEACTIVATORS:
|
|
if ((unsigned)var2>=(unsigned)playerswhenstarted) {CON_ERRPRINTF("Invalid player %d\n", var2); break;}
|
|
G_OperateActivators(var1, var2);
|
|
break;
|
|
case CON_SETASPECT:
|
|
setaspect(var1, var2);
|
|
break;
|
|
case CON_SSP:
|
|
if ((unsigned)var1 >= MAXSPRITES) { CON_ERRPRINTF("Invalid sprite %d\n", var1); break;}
|
|
A_SetSprite(var1, var2);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_CANSEESPR:
|
|
insptr++;
|
|
{
|
|
int32_t lVar1 = Gv_GetVarX(*insptr++), lVar2 = Gv_GetVarX(*insptr++), res;
|
|
|
|
if ((unsigned)lVar1 >= MAXSPRITES || (unsigned)lVar2 >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("Invalid sprite %d\n", (unsigned)lVar1 >= MAXSPRITES ? lVar1 : lVar2);
|
|
res=0;
|
|
}
|
|
else res=cansee(sprite[lVar1].x,sprite[lVar1].y,sprite[lVar1].z,sprite[lVar1].sectnum,
|
|
sprite[lVar2].x,sprite[lVar2].y,sprite[lVar2].z,sprite[lVar2].sectnum);
|
|
|
|
Gv_SetVarX(*insptr++, res);
|
|
continue;
|
|
}
|
|
|
|
case CON_OPERATERESPAWNS:
|
|
insptr++;
|
|
G_OperateRespawns(Gv_GetVarX(*insptr++));
|
|
continue;
|
|
|
|
case CON_OPERATEMASTERSWITCHES:
|
|
insptr++;
|
|
G_OperateMasterSwitches(Gv_GetVarX(*insptr++));
|
|
continue;
|
|
|
|
case CON_CHECKACTIVATORMOTION:
|
|
insptr++;
|
|
aGameVars[g_iReturnVarID].val.lValue = G_CheckActivatorMotion(Gv_GetVarX(*insptr++));
|
|
continue;
|
|
|
|
case CON_INSERTSPRITEQ:
|
|
insptr++;
|
|
A_AddToDeleteQueue(vm.g_i);
|
|
continue;
|
|
|
|
case CON_QSTRLEN:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((ScriptQuotes[j] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", j);
|
|
Gv_SetVarX(i,-1);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,Bstrlen(ScriptQuotes[j]));
|
|
continue;
|
|
}
|
|
|
|
case CON_QSTRDIM:
|
|
insptr++;
|
|
{
|
|
vec2_t dim = { 0, 0, };
|
|
|
|
int32_t w=*insptr++;
|
|
int32_t h=*insptr++;
|
|
|
|
int32_t tilenum = Gv_GetVarX(*insptr++);
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), z = Gv_GetVarX(*insptr++);
|
|
int32_t blockangle=Gv_GetVarX(*insptr++);
|
|
int32_t q=Gv_GetVarX(*insptr++);
|
|
int32_t orientation=Gv_GetVarX(*insptr++);
|
|
int32_t xspace=Gv_GetVarX(*insptr++), yline=Gv_GetVarX(*insptr++);
|
|
int32_t xbetween=Gv_GetVarX(*insptr++), ybetween=Gv_GetVarX(*insptr++);
|
|
int32_t f=Gv_GetVarX(*insptr++);
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++);
|
|
|
|
orientation &= (ROTATESPRITE_MAX-1);
|
|
|
|
if (tilenum < 0 || tilenum+255 >= MAXTILES)
|
|
CON_ERRPRINTF("invalid base tilenum %d\n", tilenum);
|
|
else if ((unsigned)q >= MAXQUOTES)
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q);
|
|
else if ((ScriptQuotes[q] == NULL))
|
|
CON_ERRPRINTF("null quote %d\n", q);
|
|
else
|
|
dim = G_ScreenTextSize(tilenum,x,y,z,blockangle,ScriptQuotes[q],2|orientation,xspace,yline,xbetween,ybetween,f,x1,y1,x2,y2);
|
|
|
|
Gv_SetVarX(w,dim.x);
|
|
Gv_SetVarX(h,dim.y);
|
|
continue;
|
|
}
|
|
|
|
case CON_HEADSPRITESTAT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j > MAXSTATUS)
|
|
{
|
|
CON_ERRPRINTF("invalid status list %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,headspritestat[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_PREVSPRITESTAT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,prevspritestat[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_NEXTSPRITESTAT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,nextspritestat[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_HEADSPRITESECT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("invalid sector %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,headspritesect[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_PREVSPRITESECT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,prevspritesect[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_NEXTSPRITESECT:
|
|
insptr++;
|
|
{
|
|
int32_t i=*insptr++;
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", j);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(i,nextspritesect[j]);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETKEYNAME:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++),
|
|
f = Gv_GetVarX(*insptr++);
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)i >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", i);
|
|
continue;
|
|
}
|
|
else if ((ScriptQuotes[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", i);
|
|
continue;
|
|
}
|
|
else if ((unsigned)f >= NUMGAMEFUNCTIONS)
|
|
{
|
|
CON_ERRPRINTF("invalid function %d\n", f);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (j < 2)
|
|
Bstrcpy(tempbuf,KB_ScanCodeToString(ud.config.KeyboardKeys[f][j]));
|
|
else
|
|
{
|
|
Bstrcpy(tempbuf,KB_ScanCodeToString(ud.config.KeyboardKeys[f][0]));
|
|
|
|
if (!*tempbuf)
|
|
Bstrcpy(tempbuf,KB_ScanCodeToString(ud.config.KeyboardKeys[f][1]));
|
|
}
|
|
}
|
|
|
|
if (*tempbuf)
|
|
Bstrcpy(ScriptQuotes[i],tempbuf);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_QSUBSTR:
|
|
insptr++;
|
|
{
|
|
int32_t q1 = Gv_GetVarX(*insptr++);
|
|
int32_t q2 = Gv_GetVarX(*insptr++);
|
|
int32_t st = Gv_GetVarX(*insptr++);
|
|
int32_t ln = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)q1>=MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q1);
|
|
continue;
|
|
}
|
|
if ((ScriptQuotes[q1] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q1);
|
|
continue;
|
|
}
|
|
if ((unsigned)q2>=MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q2);
|
|
continue;
|
|
}
|
|
if ((ScriptQuotes[q2] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q2);
|
|
continue;
|
|
}
|
|
|
|
{
|
|
char *s1 = ScriptQuotes[q1];
|
|
char *s2 = ScriptQuotes[q2];
|
|
|
|
while (*s2 && st--) s2++;
|
|
while ((*s1 = *s2) && ln--)
|
|
{
|
|
s1++;
|
|
s2++;
|
|
}
|
|
*s1=0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_GETPNAME:
|
|
case CON_QSTRNCAT:
|
|
case CON_QSTRCAT:
|
|
case CON_QSTRCPY:
|
|
case CON_QGETSYSSTR:
|
|
case CON_CHANGESPRITESECT:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++), j;
|
|
if (tw == CON_GETPNAME && *insptr == g_iThisActorID)
|
|
{
|
|
j = vm.g_p;
|
|
insptr++;
|
|
}
|
|
else j = Gv_GetVarX(*insptr++);
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_GETPNAME:
|
|
if ((ScriptQuotes[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", i);
|
|
break;
|
|
}
|
|
if (g_player[j].user_name[0])
|
|
Bstrcpy(ScriptQuotes[i],g_player[j].user_name);
|
|
else Bsprintf(ScriptQuotes[i],"%d",j);
|
|
break;
|
|
case CON_QGETSYSSTR:
|
|
if ((ScriptQuotes[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d %d\n", i,j);
|
|
break;
|
|
}
|
|
switch (j)
|
|
{
|
|
case STR_MAPNAME:
|
|
case STR_MAPFILENAME:
|
|
{
|
|
int32_t idx = ud.volume_number*MAXLEVELS + ud.level_number;
|
|
const char *src;
|
|
|
|
if ((unsigned)idx >= ARRAY_SIZE(MapInfo))
|
|
{
|
|
CON_ERRPRINTF("out of bounds map number (vol=%d, lev=%d)\n",
|
|
ud.volume_number, ud.level_number);
|
|
break;
|
|
}
|
|
|
|
src = j==STR_MAPNAME ? MapInfo[idx].name : MapInfo[idx].filename;
|
|
if (src == NULL)
|
|
{
|
|
CON_ERRPRINTF("attempted access to %s of non-existent map (vol=%d, lev=%d)",
|
|
j==STR_MAPNAME ? "name" : "file name",
|
|
ud.volume_number, ud.level_number);
|
|
break;
|
|
}
|
|
|
|
Bstrcpy(ScriptQuotes[i], j==STR_MAPNAME ? MapInfo[idx].name : MapInfo[idx].filename);
|
|
break;
|
|
}
|
|
case STR_PLAYERNAME:
|
|
if ((unsigned)vm.g_p >= (unsigned)playerswhenstarted)
|
|
{
|
|
CON_ERRPRINTF("Invalid player ID %d\n", vm.g_p);
|
|
break;
|
|
}
|
|
Bstrcpy(ScriptQuotes[i],g_player[vm.g_p].user_name);
|
|
break;
|
|
case STR_VERSION:
|
|
Bsprintf(tempbuf,HEAD2 " %s",s_buildRev);
|
|
Bstrcpy(ScriptQuotes[i],tempbuf);
|
|
break;
|
|
case STR_GAMETYPE:
|
|
Bstrcpy(ScriptQuotes[i],GametypeNames[ud.coop]);
|
|
break;
|
|
case STR_VOLUMENAME:
|
|
if ((unsigned)ud.volume_number >= MAXVOLUMES)
|
|
{
|
|
CON_ERRPRINTF("invalid volume (%d)\n", ud.volume_number);
|
|
break;
|
|
}
|
|
Bstrcpy(ScriptQuotes[i],EpisodeNames[ud.volume_number]);
|
|
break;
|
|
default:
|
|
CON_ERRPRINTF("unknown str ID %d %d\n", i,j);
|
|
}
|
|
break;
|
|
case CON_QSTRCAT:
|
|
if ((ScriptQuotes[i] == NULL || ScriptQuotes[j] == NULL)) goto nullquote;
|
|
Bstrncat(ScriptQuotes[i],ScriptQuotes[j],(MAXQUOTELEN-1)-Bstrlen(ScriptQuotes[i]));
|
|
break;
|
|
case CON_QSTRNCAT:
|
|
if ((ScriptQuotes[i] == NULL || ScriptQuotes[j] == NULL)) goto nullquote;
|
|
Bstrncat(ScriptQuotes[i],ScriptQuotes[j],Gv_GetVarX(*insptr++));
|
|
break;
|
|
case CON_QSTRCPY:
|
|
if ((ScriptQuotes[i] == NULL || ScriptQuotes[j] == NULL)) goto nullquote;
|
|
if (i != j)
|
|
Bstrcpy(ScriptQuotes[i],ScriptQuotes[j]);
|
|
break;
|
|
case CON_CHANGESPRITESECT:
|
|
if ((unsigned)i >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("Invalid sprite %d\n", i);
|
|
break;
|
|
}
|
|
if ((unsigned)j >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", j);
|
|
break;
|
|
}
|
|
changespritesect(i,j);
|
|
break;
|
|
default:
|
|
nullquote:
|
|
CON_ERRPRINTF("null quote %d\n", ScriptQuotes[i] ? j : i);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_CHANGESPRITESTAT:
|
|
insptr++;
|
|
{
|
|
int32_t i = Gv_GetVarX(*insptr++);
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)i >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("Invalid sprite: %d\n", i);
|
|
continue;
|
|
}
|
|
if ((unsigned)j >= MAXSTATUS)
|
|
{
|
|
CON_ERRPRINTF("Invalid statnum: %d\n", j);
|
|
continue;
|
|
}
|
|
if (sprite[i].statnum == j)
|
|
continue;
|
|
|
|
/* initialize actor data when changing to an actor statnum because there's usually
|
|
garbage left over from being handled as a hard coded object */
|
|
|
|
if (sprite[i].statnum > STAT_ZOMBIEACTOR && (j == STAT_ACTOR || j == STAT_ZOMBIEACTOR))
|
|
{
|
|
actor_t *a = &actor[i];
|
|
|
|
a->lastvx = 0;
|
|
a->lastvy = 0;
|
|
a->timetosleep = 0;
|
|
a->cgg = 0;
|
|
a->movflag = 0;
|
|
a->tempang = 0;
|
|
a->dispicnum = 0;
|
|
T1=T2=T3=T4=T5=T6=T7=T8=T9=0;
|
|
a->flags = 0;
|
|
sprite[i].hitag = 0;
|
|
|
|
if (G_HaveActor(sprite[i].picnum))
|
|
{
|
|
const intptr_t *actorptr = g_tile[sprite[i].picnum].execPtr;
|
|
// offsets
|
|
AC_ACTION_ID(a->t_data) = actorptr[1];
|
|
AC_MOVE_ID(a->t_data) = actorptr[2];
|
|
AC_MOVFLAGS(&sprite[i], &actor[i]) = actorptr[3]; // ai bits (movflags)
|
|
}
|
|
}
|
|
|
|
changespritestat(i,j);
|
|
continue;
|
|
}
|
|
|
|
case CON_STARTLEVEL:
|
|
insptr++; // skip command
|
|
{
|
|
// from 'level' cheat in game.c (about line 6250)
|
|
int32_t volnume=Gv_GetVarX(*insptr++), levnume=Gv_GetVarX(*insptr++);
|
|
|
|
if ((volnume > MAXVOLUMES-1 || volnume < 0))
|
|
{
|
|
CON_ERRPRINTF("invalid volume (%d)\n", volnume);
|
|
continue;
|
|
}
|
|
|
|
if ((levnume > MAXLEVELS-1 || levnume < 0))
|
|
{
|
|
CON_ERRPRINTF("invalid level (%d)\n", levnume);
|
|
continue;
|
|
}
|
|
|
|
ud.m_volume_number = ud.volume_number = volnume;
|
|
ud.m_level_number = ud.level_number = levnume;
|
|
//if (numplayers > 1 && g_netServer)
|
|
// Net_NewGame(volnume,levnume);
|
|
//else
|
|
{
|
|
g_player[myconnectindex].ps->gm |= MODE_EOL;
|
|
ud.display_bonus_screen = 0;
|
|
} // MODE_RESTART;
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_MYOSX:
|
|
case CON_MYOSPALX:
|
|
case CON_MYOS:
|
|
case CON_MYOSPAL:
|
|
insptr++;
|
|
{
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), tilenum=Gv_GetVarX(*insptr++);
|
|
int32_t shade=Gv_GetVarX(*insptr++), orientation=Gv_GetVarX(*insptr++);
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_MYOS:
|
|
G_DrawTile(x,y,tilenum,shade,orientation);
|
|
break;
|
|
case CON_MYOSPAL:
|
|
{
|
|
int32_t pal=Gv_GetVarX(*insptr++);
|
|
G_DrawTilePal(x,y,tilenum,shade,orientation,pal);
|
|
break;
|
|
}
|
|
case CON_MYOSX:
|
|
G_DrawTileSmall(x,y,tilenum,shade,orientation);
|
|
break;
|
|
case CON_MYOSPALX:
|
|
{
|
|
int32_t pal=Gv_GetVarX(*insptr++);
|
|
G_DrawTilePalSmall(x,y,tilenum,shade,orientation,pal);
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_SWITCH:
|
|
insptr++; // p-code
|
|
{
|
|
// command format:
|
|
// variable ID to check
|
|
// script offset to 'end'
|
|
// count of case statements
|
|
// script offset to default case (null if none)
|
|
// For each case: value, ptr to code
|
|
//AddLog("Processing Switch...");
|
|
int32_t lValue=Gv_GetVarX(*insptr++), lEnd=*insptr++, lCases=*insptr++;
|
|
intptr_t *lpDefault=insptr++, *lpCases=insptr;
|
|
int32_t bMatched=0, lCheckCase;
|
|
int32_t left,right;
|
|
insptr += lCases*2;
|
|
//Bsprintf(g_szBuf,"lEnd= %d *lpDefault=%d",lEnd,*lpDefault);
|
|
//AddLog(g_szBuf);
|
|
|
|
//Bsprintf(g_szBuf,"Checking %d cases for %d",lCases, lValue);
|
|
//AddLog(g_szBuf);
|
|
left=0; right=lCases-1;
|
|
while (!bMatched)
|
|
{
|
|
//Bsprintf(g_szBuf,"Checking #%d Value= %d",lCheckCase, lpCases[lCheckCase*2]);
|
|
//AddLog(g_szBuf);
|
|
lCheckCase=(left+right)/2;
|
|
// initprintf("(%2d..%2d..%2d) [%2d..%2d..%2d]==%2d\n",left,lCheckCase,right,lpCases[left*2],lpCases[lCheckCase*2],lpCases[right*2],lValue);
|
|
if (lpCases[lCheckCase*2] > lValue)
|
|
right=lCheckCase-1;
|
|
else if (lpCases[lCheckCase*2] < lValue)
|
|
left =lCheckCase+1;
|
|
else if (lpCases[lCheckCase*2] == lValue)
|
|
{
|
|
//AddLog("Found Case Match");
|
|
//Bsprintf(g_szBuf,"insptr=%d. lCheckCase=%d, offset=%d, &script[0]=%d",
|
|
// (int32_t)insptr,(int32_t)lCheckCase,lpCases[lCheckCase*2+1],(int32_t)&script[0]);
|
|
//AddLog(g_szBuf);
|
|
// fake a 2-d Array
|
|
insptr=(intptr_t *)(lpCases[lCheckCase*2+1] + &script[0]);
|
|
//Bsprintf(g_szBuf,"insptr=%d. ", (int32_t)insptr);
|
|
//AddLog(g_szBuf);
|
|
VM_Execute(1);
|
|
//AddLog("Done Executing Case");
|
|
bMatched=1;
|
|
}
|
|
if (right-left < 0)
|
|
break;
|
|
}
|
|
if (!bMatched)
|
|
{
|
|
if (*lpDefault)
|
|
{
|
|
//AddLog("No Matching Case: Using Default");
|
|
insptr=(intptr_t *)(*lpDefault + &script[0]);
|
|
VM_Execute(1);
|
|
}
|
|
else
|
|
{
|
|
//AddLog("No Matching Case: No Default to use");
|
|
}
|
|
}
|
|
insptr=(intptr_t *)(lEnd + (intptr_t)&script[0]);
|
|
//Bsprintf(g_szBuf,"insptr=%d. ", (int32_t)insptr);
|
|
//AddLog(g_szBuf);
|
|
//AddLog("Done Processing Switch");
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_ENDSWITCH:
|
|
case CON_ENDEVENT:
|
|
insptr++;
|
|
return;
|
|
|
|
case CON_DISPLAYRAND:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr++, system_15bit_rand());
|
|
continue;
|
|
|
|
case CON_DRAGPOINT:
|
|
insptr++;
|
|
{
|
|
int32_t wallnum = Gv_GetVarX(*insptr++), newx = Gv_GetVarX(*insptr++), newy = Gv_GetVarX(*insptr++);
|
|
|
|
if ((wallnum<0 || wallnum>=numwalls))
|
|
{
|
|
CON_ERRPRINTF("Invalid wall %d\n", wallnum);
|
|
continue;
|
|
}
|
|
dragpoint(wallnum,newx,newy,0);
|
|
continue;
|
|
}
|
|
|
|
case CON_LDIST:
|
|
insptr++;
|
|
{
|
|
int32_t distvar = *insptr++, xvar = Gv_GetVarX(*insptr++), yvar = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)xvar >= MAXSPRITES || (unsigned)yvar >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite\n");
|
|
continue;
|
|
}
|
|
|
|
Gv_SetVarX(distvar, ldist(&sprite[xvar],&sprite[yvar]));
|
|
continue;
|
|
}
|
|
|
|
case CON_DIST:
|
|
insptr++;
|
|
{
|
|
int32_t distvar = *insptr++, xvar = Gv_GetVarX(*insptr++), yvar = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)xvar >= MAXSPRITES || (unsigned)yvar >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite\n");
|
|
continue;
|
|
}
|
|
|
|
Gv_SetVarX(distvar, dist(&sprite[xvar],&sprite[yvar]));
|
|
continue;
|
|
}
|
|
|
|
case CON_GETANGLE:
|
|
insptr++;
|
|
{
|
|
int32_t angvar = *insptr++;
|
|
int32_t xvar = Gv_GetVarX(*insptr++);
|
|
int32_t yvar = Gv_GetVarX(*insptr++);
|
|
|
|
Gv_SetVarX(angvar, getangle(xvar,yvar));
|
|
continue;
|
|
}
|
|
|
|
case CON_GETINCANGLE:
|
|
insptr++;
|
|
{
|
|
int32_t angvar = *insptr++;
|
|
int32_t xvar = Gv_GetVarX(*insptr++);
|
|
int32_t yvar = Gv_GetVarX(*insptr++);
|
|
|
|
Gv_SetVarX(angvar, G_GetAngleDelta(xvar,yvar));
|
|
continue;
|
|
}
|
|
|
|
case CON_MULSCALE:
|
|
insptr++;
|
|
{
|
|
int32_t var1 = *insptr++, var2 = Gv_GetVarX(*insptr++);
|
|
int32_t var3 = Gv_GetVarX(*insptr++), var4 = Gv_GetVarX(*insptr++);
|
|
|
|
Gv_SetVarX(var1, mulscale(var2, var3, var4));
|
|
continue;
|
|
}
|
|
|
|
case CON_INITTIMER:
|
|
insptr++;
|
|
G_InitTimer(Gv_GetVarX(*insptr++));
|
|
continue;
|
|
|
|
case CON_TIME:
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_ESPAWNVAR:
|
|
case CON_EQSPAWNVAR:
|
|
case CON_QSPAWNVAR:
|
|
insptr++;
|
|
{
|
|
int32_t lIn=Gv_GetVarX(*insptr++);
|
|
int32_t j;
|
|
if ((unsigned)vm.g_sp->sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", TrackerCast(vm.g_sp->sectnum));
|
|
continue;
|
|
}
|
|
j = A_Spawn(vm.g_i, lIn);
|
|
switch (tw)
|
|
{
|
|
case CON_EQSPAWNVAR:
|
|
if (j != -1)
|
|
A_AddToDeleteQueue(j);
|
|
case CON_ESPAWNVAR:
|
|
aGameVars[g_iReturnVarID].val.lValue = j;
|
|
break;
|
|
case CON_QSPAWNVAR:
|
|
if (j != -1)
|
|
A_AddToDeleteQueue(j);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_ESPAWN:
|
|
case CON_EQSPAWN:
|
|
case CON_QSPAWN:
|
|
insptr++;
|
|
|
|
{
|
|
int32_t j;
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", TrackerCast(vm.g_sp->sectnum));
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
j = A_Spawn(vm.g_i,*insptr++);
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_EQSPAWN:
|
|
if (j != -1)
|
|
A_AddToDeleteQueue(j);
|
|
case CON_ESPAWN:
|
|
aGameVars[g_iReturnVarID].val.lValue = j;
|
|
break;
|
|
case CON_QSPAWN:
|
|
if (j != -1)
|
|
A_AddToDeleteQueue(j);
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
case CON_ESHOOT:
|
|
case CON_EZSHOOT:
|
|
case CON_ZSHOOT:
|
|
insptr++;
|
|
{
|
|
int32_t j;
|
|
// NOTE: (int16_t) cast because we want to exclude that
|
|
// SHOOT_HARDCODED_ZVEL is passed.
|
|
const int32_t zvel = (tw == CON_ESHOOT) ?
|
|
SHOOT_HARDCODED_ZVEL : (int16_t)Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", TrackerCast(vm.g_sp->sectnum));
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
j = A_ShootWithZvel(vm.g_i,*insptr++,zvel);
|
|
|
|
if (tw != CON_ZSHOOT)
|
|
aGameVars[g_iReturnVarID].val.lValue = j;
|
|
}
|
|
continue;
|
|
|
|
case CON_SHOOTVAR:
|
|
case CON_ESHOOTVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", TrackerCast(vm.g_sp->sectnum));
|
|
continue;
|
|
}
|
|
|
|
j = A_Shoot(vm.g_i, j);
|
|
if (tw == CON_ESHOOTVAR)
|
|
aGameVars[g_iReturnVarID].val.lValue = j;
|
|
continue;
|
|
}
|
|
|
|
case CON_EZSHOOTVAR:
|
|
case CON_ZSHOOTVAR:
|
|
insptr++;
|
|
{
|
|
const int32_t zvel = (int16_t)Gv_GetVarX(*insptr++);
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", TrackerCast(vm.g_sp->sectnum));
|
|
continue;
|
|
}
|
|
|
|
j = A_ShootWithZvel(vm.g_i, j, zvel);
|
|
if (tw == CON_EZSHOOTVAR)
|
|
aGameVars[g_iReturnVarID].val.lValue = j;
|
|
continue;
|
|
}
|
|
|
|
case CON_CMENU:
|
|
insptr++;
|
|
M_ChangeMenu(Gv_GetVarX(*insptr++));
|
|
continue;
|
|
|
|
case CON_SOUNDVAR:
|
|
case CON_STOPSOUNDVAR:
|
|
case CON_SOUNDONCEVAR:
|
|
case CON_GLOBALSOUNDVAR:
|
|
case CON_SCREENSOUND:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
|
|
if (j<0 || j>=MAXSOUNDS)
|
|
{
|
|
CON_ERRPRINTF("Invalid sound %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
switch (tw)
|
|
{
|
|
case CON_SOUNDONCEVAR:
|
|
if (!S_CheckSoundPlaying(vm.g_i,j))
|
|
A_PlaySound((int16_t)j,vm.g_i);
|
|
continue;
|
|
case CON_GLOBALSOUNDVAR:
|
|
A_PlaySound((int16_t)j,g_player[screenpeek].ps->i);
|
|
continue;
|
|
case CON_STOPSOUNDVAR:
|
|
if (S_CheckSoundPlaying(vm.g_i,j))
|
|
S_StopSound((int16_t)j);
|
|
continue;
|
|
case CON_SOUNDVAR:
|
|
A_PlaySound((int16_t)j,vm.g_i);
|
|
continue;
|
|
case CON_SCREENSOUND:
|
|
A_PlaySound(j, -1);
|
|
continue;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
case CON_GUNIQHUDID:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if (j >= 0 && j < MAXUNIQHUDID-1)
|
|
guniqhudid = j;
|
|
else
|
|
CON_ERRPRINTF("Invalid ID %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
case CON_SAVEGAMEVAR:
|
|
case CON_READGAMEVAR:
|
|
{
|
|
int32_t i=0;
|
|
insptr++;
|
|
if (ud.config.scripthandle < 0)
|
|
{
|
|
insptr++;
|
|
continue;
|
|
}
|
|
switch (tw)
|
|
{
|
|
case CON_SAVEGAMEVAR:
|
|
i=Gv_GetVarX(*insptr);
|
|
SCRIPT_PutNumber(ud.config.scripthandle, "Gamevars",aGameVars[*insptr++].szLabel,i,FALSE,FALSE);
|
|
break;
|
|
case CON_READGAMEVAR:
|
|
SCRIPT_GetNumber(ud.config.scripthandle, "Gamevars",aGameVars[*insptr].szLabel,&i);
|
|
Gv_SetVarX(*insptr++, i);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_SHOWVIEW:
|
|
case CON_SHOWVIEWUNBIASED:
|
|
insptr++;
|
|
{
|
|
int32_t x=Gv_GetVarX(*insptr++);
|
|
int32_t y=Gv_GetVarX(*insptr++);
|
|
int32_t z=Gv_GetVarX(*insptr++);
|
|
int32_t a=Gv_GetVarX(*insptr++);
|
|
int32_t horiz=Gv_GetVarX(*insptr++);
|
|
int32_t sect=Gv_GetVarX(*insptr++);
|
|
int32_t x1=Gv_GetVarX(*insptr++);
|
|
int32_t y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++);
|
|
int32_t y2=Gv_GetVarX(*insptr++);
|
|
|
|
if (x1 < 0 || y1 < 0 || x2 >= 320 || y2 >= 200)
|
|
{
|
|
CON_ERRPRINTF("incorrect coordinates\n");
|
|
continue;
|
|
}
|
|
|
|
if ((unsigned)sect >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sect);
|
|
continue;
|
|
}
|
|
|
|
G_ShowView(x, y, z, a, horiz, sect, x1, y1, x2, y2, (tw != CON_SHOWVIEW));
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_ROTATESPRITEA:
|
|
case CON_ROTATESPRITE16:
|
|
case CON_ROTATESPRITE:
|
|
insptr++;
|
|
{
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), z=Gv_GetVarX(*insptr++);
|
|
int32_t a=Gv_GetVarX(*insptr++), tilenum=Gv_GetVarX(*insptr++), shade=Gv_GetVarX(*insptr++);
|
|
int32_t pal=Gv_GetVarX(*insptr++), orientation=Gv_GetVarX(*insptr++);
|
|
int32_t alpha = (tw == CON_ROTATESPRITEA) ? Gv_GetVarX(*insptr++) : 0;
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++);
|
|
|
|
int32_t blendidx = 0;
|
|
|
|
if (tw != CON_ROTATESPRITE16 && !(orientation&ROTATESPRITE_FULL16))
|
|
{
|
|
x<<=16;
|
|
y<<=16;
|
|
}
|
|
|
|
if ((unsigned)tilenum >= MAXTILES)
|
|
{
|
|
CON_ERRPRINTF("invalid tilenum %d\n", tilenum);
|
|
continue;
|
|
}
|
|
|
|
if (x < -(320<<16) || x >= (640<<16) || y < -(200<<16) || y >= (400<<16))
|
|
{
|
|
CON_ERRPRINTF("invalid coordinates: %d, %d\n", x, y);
|
|
continue;
|
|
}
|
|
|
|
orientation &= (ROTATESPRITE_MAX-1);
|
|
|
|
NEG_ALPHA_TO_BLEND(alpha, blendidx, orientation);
|
|
|
|
rotatesprite_(x,y,z,a,tilenum,shade,pal,2|orientation,alpha,blendidx,x1,y1,x2,y2);
|
|
continue;
|
|
}
|
|
|
|
case CON_GAMETEXT:
|
|
case CON_GAMETEXTZ:
|
|
insptr++;
|
|
{
|
|
int32_t tilenum = Gv_GetVarX(*insptr++);
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), q=Gv_GetVarX(*insptr++);
|
|
int32_t shade=Gv_GetVarX(*insptr++), pal=Gv_GetVarX(*insptr++);
|
|
int32_t orientation=Gv_GetVarX(*insptr++);
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++);
|
|
int32_t z = (tw == CON_GAMETEXTZ) ? Gv_GetVarX(*insptr++) : 65536;
|
|
|
|
if (tilenum < 0 || tilenum+255 >= MAXTILES)
|
|
{
|
|
CON_ERRPRINTF("invalid base tilenum %d\n", tilenum);
|
|
continue;
|
|
}
|
|
|
|
if ((unsigned)q >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[q] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
orientation &= (ROTATESPRITE_MAX-1);
|
|
|
|
G_PrintGameText(0,tilenum,x>>1,y,ScriptQuotes[q],shade,pal,orientation,x1,y1,x2,y2,z);
|
|
continue;
|
|
}
|
|
|
|
case CON_DIGITALNUMBER:
|
|
case CON_DIGITALNUMBERZ:
|
|
insptr++;
|
|
{
|
|
int32_t tilenum = Gv_GetVarX(*insptr++);
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), q=Gv_GetVarX(*insptr++);
|
|
int32_t shade=Gv_GetVarX(*insptr++), pal=Gv_GetVarX(*insptr++);
|
|
int32_t orientation=Gv_GetVarX(*insptr++);
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++);
|
|
int32_t z = (tw == CON_DIGITALNUMBERZ) ? Gv_GetVarX(*insptr++) : 65536;
|
|
|
|
// NOTE: '-' not taken into account, but we have rotatesprite() bound check now anyway
|
|
if (tilenum < 0 || tilenum+9 >= MAXTILES)
|
|
{
|
|
CON_ERRPRINTF("invalid base tilenum %d\n", tilenum);
|
|
continue;
|
|
}
|
|
|
|
G_DrawTXDigiNumZ(tilenum,x,y,q,shade,pal,orientation,x1,y1,x2,y2,z);
|
|
continue;
|
|
}
|
|
|
|
case CON_MINITEXT:
|
|
insptr++;
|
|
{
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), q=Gv_GetVarX(*insptr++);
|
|
int32_t shade=Gv_GetVarX(*insptr++), pal=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)q >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[q] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q);
|
|
continue;
|
|
}
|
|
minitextshade(x,y,ScriptQuotes[q],shade,pal, 2+8+16);
|
|
continue;
|
|
}
|
|
|
|
case CON_SCREENTEXT:
|
|
insptr++;
|
|
{
|
|
int32_t tilenum = Gv_GetVarX(*insptr++);
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), z = Gv_GetVarX(*insptr++);
|
|
int32_t blockangle=Gv_GetVarX(*insptr++), charangle=Gv_GetVarX(*insptr++);
|
|
int32_t q=Gv_GetVarX(*insptr++);
|
|
int32_t shade=Gv_GetVarX(*insptr++), pal=Gv_GetVarX(*insptr++);
|
|
int32_t orientation=Gv_GetVarX(*insptr++);
|
|
int32_t alpha=Gv_GetVarX(*insptr++);
|
|
int32_t xspace=Gv_GetVarX(*insptr++), yline=Gv_GetVarX(*insptr++);
|
|
int32_t xbetween=Gv_GetVarX(*insptr++), ybetween=Gv_GetVarX(*insptr++);
|
|
int32_t f=Gv_GetVarX(*insptr++);
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++);
|
|
|
|
if (tilenum < 0 || tilenum+255 >= MAXTILES)
|
|
{
|
|
CON_ERRPRINTF("invalid base tilenum %d\n", tilenum);
|
|
continue;
|
|
}
|
|
|
|
if ((unsigned)q >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[q] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
orientation &= (ROTATESPRITE_MAX-1);
|
|
|
|
G_ScreenText(tilenum,x,y,z,blockangle,charangle,ScriptQuotes[q],shade,pal,2|orientation,alpha,xspace,yline,xbetween,ybetween,f,x1,y1,x2,y2);
|
|
continue;
|
|
}
|
|
|
|
case CON_ANGOFF:
|
|
insptr++;
|
|
spriteext[vm.g_i].angoff=*insptr++;
|
|
continue;
|
|
|
|
case CON_GETZRANGE:
|
|
insptr++;
|
|
{
|
|
vec3_t vect;
|
|
|
|
vect.x = Gv_GetVarX(*insptr++);
|
|
vect.y = Gv_GetVarX(*insptr++);
|
|
vect.z = Gv_GetVarX(*insptr++);
|
|
|
|
{
|
|
int32_t sectnum=Gv_GetVarX(*insptr++);
|
|
int32_t ceilzvar=*insptr++, ceilhitvar=*insptr++, florzvar=*insptr++, florhitvar=*insptr++;
|
|
int32_t walldist=Gv_GetVarX(*insptr++), clipmask=Gv_GetVarX(*insptr++);
|
|
int32_t ceilz, ceilhit, florz, florhit;
|
|
|
|
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
continue;
|
|
}
|
|
getzrange(&vect, sectnum, &ceilz, &ceilhit, &florz, &florhit, walldist, clipmask);
|
|
Gv_SetVarX(ceilzvar, ceilz);
|
|
Gv_SetVarX(ceilhitvar, ceilhit);
|
|
Gv_SetVarX(florzvar, florz);
|
|
Gv_SetVarX(florhitvar, florhit);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_SECTSETINTERPOLATION:
|
|
case CON_SECTCLEARINTERPOLATION:
|
|
insptr++;
|
|
{
|
|
int32_t sectnum = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
continue;
|
|
}
|
|
|
|
if (tw==CON_SECTSETINTERPOLATION)
|
|
Sect_SetInterpolation(sectnum);
|
|
else
|
|
Sect_ClearInterpolation(sectnum);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_CALCHYPOTENUSE:
|
|
insptr++;
|
|
{
|
|
int32_t retvar=*insptr++;
|
|
int64_t dax=Gv_GetVarX(*insptr++), day=Gv_GetVarX(*insptr++);
|
|
int64_t hypsq = dax*dax + day*day;
|
|
|
|
if (hypsq > (int64_t)INT32_MAX)
|
|
Gv_SetVarX(retvar, (int32_t)sqrt((double)hypsq));
|
|
else
|
|
Gv_SetVarX(retvar, ksqrt((uint32_t)hypsq));
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_LINEINTERSECT:
|
|
case CON_RAYINTERSECT:
|
|
insptr++;
|
|
{
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++), z1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++), z2=Gv_GetVarX(*insptr++);
|
|
int32_t x3=Gv_GetVarX(*insptr++), y3=Gv_GetVarX(*insptr++), x4=Gv_GetVarX(*insptr++), y4=Gv_GetVarX(*insptr++);
|
|
int32_t intxvar=*insptr++, intyvar=*insptr++, intzvar=*insptr++, retvar=*insptr++;
|
|
int32_t intx, inty, intz, ret;
|
|
|
|
if (tw==CON_LINEINTERSECT)
|
|
ret = lineintersect(x1, y1, z1, x2, y2, z2, x3, y3, x4, y4, &intx, &inty, &intz);
|
|
else
|
|
ret = rayintersect(x1, y1, z1, x2, y2, z2, x3, y3, x4, y4, &intx, &inty, &intz);
|
|
|
|
Gv_SetVarX(retvar, ret);
|
|
if (ret)
|
|
{
|
|
Gv_SetVarX(intxvar, intx);
|
|
Gv_SetVarX(intyvar, inty);
|
|
Gv_SetVarX(intzvar, intz);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_CLIPMOVE:
|
|
case CON_CLIPMOVENOSLIDE:
|
|
insptr++;
|
|
{
|
|
vec3_t vect;
|
|
int32_t retvar=*insptr++, xvar=*insptr++, yvar=*insptr++, z=Gv_GetVarX(*insptr++), sectnumvar=*insptr++;
|
|
int32_t xvect=Gv_GetVarX(*insptr++), yvect=Gv_GetVarX(*insptr++);
|
|
int32_t walldist=Gv_GetVarX(*insptr++), floordist=Gv_GetVarX(*insptr++), ceildist=Gv_GetVarX(*insptr++);
|
|
int32_t clipmask=Gv_GetVarX(*insptr++);
|
|
int16_t sectnum;
|
|
|
|
vect.x = Gv_GetVarX(xvar);
|
|
vect.y = Gv_GetVarX(yvar);
|
|
vect.z = z;
|
|
sectnum = Gv_GetVarX(sectnumvar);
|
|
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
Gv_SetVarX(retvar, 0);
|
|
continue;
|
|
}
|
|
|
|
Gv_SetVarX(retvar, clipmovex(&vect, §num, xvect, yvect, walldist, floordist, ceildist,
|
|
clipmask, (tw==CON_CLIPMOVENOSLIDE)));
|
|
Gv_SetVarX(sectnumvar, sectnum);
|
|
Gv_SetVarX(xvar, vect.x);
|
|
Gv_SetVarX(yvar, vect.y);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_HITSCAN:
|
|
insptr++;
|
|
{
|
|
vec3_t vect;
|
|
hitdata_t hit;
|
|
|
|
vect.x = Gv_GetVarX(*insptr++);
|
|
vect.y = Gv_GetVarX(*insptr++);
|
|
vect.z = Gv_GetVarX(*insptr++);
|
|
|
|
{
|
|
int32_t sectnum=Gv_GetVarX(*insptr++);
|
|
int32_t vx=Gv_GetVarX(*insptr++), vy=Gv_GetVarX(*insptr++), vz=Gv_GetVarX(*insptr++);
|
|
int32_t hitsectvar=*insptr++, hitwallvar=*insptr++, hitspritevar=*insptr++;
|
|
int32_t hitxvar=*insptr++, hityvar=*insptr++, hitzvar=*insptr++, cliptype=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
continue;
|
|
}
|
|
hitscan((const vec3_t *)&vect, sectnum, vx, vy, vz, &hit, cliptype);
|
|
Gv_SetVarX(hitsectvar, hit.sect);
|
|
Gv_SetVarX(hitwallvar, hit.wall);
|
|
Gv_SetVarX(hitspritevar, hit.sprite);
|
|
Gv_SetVarX(hitxvar, hit.pos.x);
|
|
Gv_SetVarX(hityvar, hit.pos.y);
|
|
Gv_SetVarX(hitzvar, hit.pos.z);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_CANSEE:
|
|
insptr++;
|
|
{
|
|
int32_t x1=Gv_GetVarX(*insptr++), y1=Gv_GetVarX(*insptr++), z1=Gv_GetVarX(*insptr++);
|
|
int32_t sect1=Gv_GetVarX(*insptr++);
|
|
int32_t x2=Gv_GetVarX(*insptr++), y2=Gv_GetVarX(*insptr++), z2=Gv_GetVarX(*insptr++);
|
|
int32_t sect2=Gv_GetVarX(*insptr++), rvar=*insptr++;
|
|
|
|
if ((unsigned)sect1 >= (unsigned)numsectors || (unsigned)sect2 >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector\n");
|
|
Gv_SetVarX(rvar, 0);
|
|
}
|
|
|
|
Gv_SetVarX(rvar, cansee(x1,y1,z1,sect1,x2,y2,z2,sect2));
|
|
continue;
|
|
}
|
|
|
|
case CON_ROTATEPOINT:
|
|
insptr++;
|
|
{
|
|
int32_t xpivot=Gv_GetVarX(*insptr++), ypivot=Gv_GetVarX(*insptr++);
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), daang=Gv_GetVarX(*insptr++);
|
|
int32_t x2var=*insptr++, y2var=*insptr++;
|
|
int32_t x2, y2;
|
|
|
|
rotatepoint(xpivot,ypivot,x,y,daang,&x2,&y2);
|
|
Gv_SetVarX(x2var, x2);
|
|
Gv_SetVarX(y2var, y2);
|
|
continue;
|
|
}
|
|
|
|
case CON_NEARTAG:
|
|
insptr++;
|
|
{
|
|
// neartag(int32_t x, int32_t y, int32_t z, short sectnum, short ang, //Starting position & angle
|
|
// short *neartagsector, //Returns near sector if sector[].tag != 0
|
|
// short *neartagwall, //Returns near wall if wall[].tag != 0
|
|
// short *neartagsprite, //Returns near sprite if sprite[].tag != 0
|
|
// int32_t *neartaghitdist, //Returns actual distance to object (scale: 1024=largest grid size)
|
|
// int32_t neartagrange, //Choose maximum distance to scan (scale: 1024=largest grid size)
|
|
// char tagsearch) //1-lotag only, 2-hitag only, 3-lotag&hitag
|
|
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++), z=Gv_GetVarX(*insptr++);
|
|
int32_t sectnum=Gv_GetVarX(*insptr++), ang=Gv_GetVarX(*insptr++);
|
|
int32_t neartagsectorvar=*insptr++, neartagwallvar=*insptr++, neartagspritevar=*insptr++, neartaghitdistvar=*insptr++;
|
|
int32_t neartagrange=Gv_GetVarX(*insptr++), tagsearch=Gv_GetVarX(*insptr++);
|
|
|
|
int16_t neartagsector, neartagwall, neartagsprite;
|
|
int32_t neartaghitdist;
|
|
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
continue;
|
|
}
|
|
neartag(x, y, z, sectnum, ang, &neartagsector, &neartagwall, &neartagsprite,
|
|
&neartaghitdist, neartagrange, tagsearch, NULL);
|
|
|
|
Gv_SetVarX(neartagsectorvar, neartagsector);
|
|
Gv_SetVarX(neartagwallvar, neartagwall);
|
|
Gv_SetVarX(neartagspritevar, neartagsprite);
|
|
Gv_SetVarX(neartaghitdistvar, neartaghitdist);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETTIMEDATE:
|
|
insptr++;
|
|
{
|
|
int32_t i, vals[8];
|
|
|
|
G_GetTimeDate(vals);
|
|
|
|
for (i=0; i<8; i++)
|
|
Gv_SetVarX(*insptr++, vals[i]);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_MOVESPRITE:
|
|
case CON_SETSPRITE:
|
|
insptr++;
|
|
{
|
|
int32_t spritenum = Gv_GetVarX(*insptr++);
|
|
vec3_t davector;
|
|
|
|
davector.x = Gv_GetVarX(*insptr++);
|
|
davector.y = Gv_GetVarX(*insptr++);
|
|
davector.z = Gv_GetVarX(*insptr++);
|
|
|
|
if (tw == CON_SETSPRITE)
|
|
{
|
|
if ((unsigned)spritenum >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", spritenum);
|
|
continue;
|
|
}
|
|
setsprite(spritenum, &davector);
|
|
continue;
|
|
}
|
|
|
|
{
|
|
int32_t cliptype = Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)spritenum >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", spritenum);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr++, A_MoveSprite(spritenum, &davector, cliptype));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
case CON_GETFLORZOFSLOPE:
|
|
case CON_GETCEILZOFSLOPE:
|
|
insptr++;
|
|
{
|
|
int32_t sectnum = Gv_GetVarX(*insptr++), x = Gv_GetVarX(*insptr++), y = Gv_GetVarX(*insptr++);
|
|
if ((unsigned)sectnum >= (unsigned)numsectors)
|
|
{
|
|
CON_ERRPRINTF("Invalid sector %d\n", sectnum);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
if (tw == CON_GETFLORZOFSLOPE)
|
|
{
|
|
Gv_SetVarX(*insptr++, getflorzofslope(sectnum,x,y));
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr++, getceilzofslope(sectnum,x,y));
|
|
continue;
|
|
}
|
|
|
|
case CON_UPDATESECTOR:
|
|
case CON_UPDATESECTORZ:
|
|
insptr++;
|
|
{
|
|
int32_t x=Gv_GetVarX(*insptr++), y=Gv_GetVarX(*insptr++);
|
|
int32_t z=(tw==CON_UPDATESECTORZ)?Gv_GetVarX(*insptr++):0;
|
|
int32_t var=*insptr++;
|
|
int16_t w=sprite[vm.g_i].sectnum;
|
|
|
|
if (tw==CON_UPDATESECTOR) updatesector(x,y,&w);
|
|
else updatesectorz(x,y,z,&w);
|
|
|
|
Gv_SetVarX(var, w);
|
|
continue;
|
|
}
|
|
|
|
case CON_SPAWN:
|
|
insptr++;
|
|
if ((unsigned)vm.g_sp->sectnum >= MAXSECTORS)
|
|
{
|
|
insptr++;
|
|
continue;
|
|
}
|
|
A_Spawn(vm.g_i,*insptr++);
|
|
continue;
|
|
|
|
case CON_IFWASWEAPON:
|
|
insptr++;
|
|
VM_CONDITIONAL(actor[vm.g_i].picnum == *insptr);
|
|
continue;
|
|
|
|
case CON_IFAI:
|
|
insptr++;
|
|
VM_CONDITIONAL(AC_AI_ID(vm.g_t) == *insptr);
|
|
continue;
|
|
|
|
case CON_IFACTION:
|
|
insptr++;
|
|
VM_CONDITIONAL(AC_ACTION_ID(vm.g_t) == *insptr);
|
|
continue;
|
|
|
|
case CON_IFACTIONCOUNT:
|
|
insptr++;
|
|
VM_CONDITIONAL(AC_ACTION_COUNT(vm.g_t) >= *insptr);
|
|
continue;
|
|
|
|
case CON_RESETACTIONCOUNT:
|
|
insptr++;
|
|
AC_ACTION_COUNT(vm.g_t) = 0;
|
|
continue;
|
|
|
|
case CON_DEBRIS:
|
|
insptr++;
|
|
{
|
|
int32_t dnum = *insptr++;
|
|
int32_t s, l, j;
|
|
|
|
if ((unsigned)vm.g_sp->sectnum < MAXSECTORS)
|
|
for (j=(*insptr)-1; j>=0; j--)
|
|
{
|
|
if (vm.g_sp->picnum == BLIMP && dnum == SCRAP1)
|
|
s = 0;
|
|
else s = (krand()%3);
|
|
|
|
l = A_InsertSprite(vm.g_sp->sectnum,
|
|
vm.g_sp->x+(krand()&255)-128,vm.g_sp->y+(krand()&255)-128,vm.g_sp->z-(8<<8)-(krand()&8191),
|
|
dnum+s,vm.g_sp->shade,32+(krand()&15),32+(krand()&15),
|
|
krand()&2047,(krand()&127)+32,
|
|
-(krand()&2047),vm.g_i,5);
|
|
if (vm.g_sp->picnum == BLIMP && dnum == SCRAP1)
|
|
sprite[l].yvel = BlimpSpawnSprites[j%14];
|
|
else sprite[l].yvel = -1;
|
|
sprite[l].pal = vm.g_sp->pal;
|
|
}
|
|
insptr++;
|
|
}
|
|
continue;
|
|
|
|
case CON_COUNT:
|
|
insptr++;
|
|
AC_COUNT(vm.g_t) = (int16_t) *insptr++;
|
|
continue;
|
|
|
|
case CON_CSTATOR:
|
|
insptr++;
|
|
vm.g_sp->cstat |= (int16_t) *insptr++;
|
|
continue;
|
|
|
|
case CON_CLIPDIST:
|
|
insptr++;
|
|
vm.g_sp->clipdist = (int16_t) *insptr++;
|
|
continue;
|
|
|
|
case CON_CSTAT:
|
|
insptr++;
|
|
vm.g_sp->cstat = (int16_t) *insptr++;
|
|
continue;
|
|
|
|
case CON_SAVENN:
|
|
case CON_SAVE:
|
|
insptr++;
|
|
{
|
|
g_lastSaveSlot = *insptr++;
|
|
|
|
if ((unsigned)g_lastSaveSlot >= MAXSAVEGAMES)
|
|
continue;
|
|
|
|
if (tw == CON_SAVE || ud.savegame[g_lastSaveSlot][0] == 0)
|
|
{
|
|
time_t curtime = time(NULL);
|
|
struct tm *timeptr = localtime(&curtime);
|
|
Bsnprintf(ud.savegame[g_lastSaveSlot], sizeof(ud.savegame[g_lastSaveSlot]), "Auto %.4d%.2d%.2d %.2d%.2d%.2d\n",
|
|
timeptr->tm_year + 1900, timeptr->tm_mon, timeptr->tm_mday,
|
|
timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec);
|
|
}
|
|
|
|
OSD_Printf("Saving to slot %d\n",g_lastSaveSlot);
|
|
|
|
KB_FlushKeyboardQueue();
|
|
|
|
g_screenCapture = 1;
|
|
G_DrawRooms(myconnectindex,65536);
|
|
g_screenCapture = 0;
|
|
|
|
G_SavePlayerMaybeMulti(g_lastSaveSlot);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_QUAKE:
|
|
insptr++;
|
|
g_earthquakeTime = Gv_GetVarX(*insptr++);
|
|
A_PlaySound(EARTHQUAKE,g_player[screenpeek].ps->i);
|
|
continue;
|
|
|
|
case CON_IFMOVE:
|
|
insptr++;
|
|
VM_CONDITIONAL(AC_MOVE_ID(vm.g_t) == *insptr);
|
|
continue;
|
|
|
|
case CON_RESETPLAYER:
|
|
{
|
|
insptr++;
|
|
vm.g_flags = VM_ResetPlayer(vm.g_p, vm.g_flags);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFONWATER:
|
|
VM_CONDITIONAL(sector[vm.g_sp->sectnum].lotag == ST_1_ABOVE_WATER && klabs(vm.g_sp->z-sector[vm.g_sp->sectnum].floorz) < (32<<8));
|
|
continue;
|
|
|
|
case CON_IFINWATER:
|
|
VM_CONDITIONAL(sector[vm.g_sp->sectnum].lotag == ST_2_UNDERWATER);
|
|
continue;
|
|
|
|
case CON_IFCOUNT:
|
|
insptr++;
|
|
VM_CONDITIONAL(AC_COUNT(vm.g_t) >= *insptr);
|
|
continue;
|
|
|
|
case CON_IFACTOR:
|
|
insptr++;
|
|
VM_CONDITIONAL(vm.g_sp->picnum == *insptr);
|
|
continue;
|
|
|
|
case CON_RESETCOUNT:
|
|
insptr++;
|
|
AC_COUNT(vm.g_t) = 0;
|
|
continue;
|
|
|
|
case CON_ADDINVENTORY:
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
insptr += 2;
|
|
switch (*(insptr-1))
|
|
{
|
|
case GET_STEROIDS:
|
|
ps->inv_amount[GET_STEROIDS] = *insptr;
|
|
ps->inven_icon = ICON_STEROIDS;
|
|
break;
|
|
|
|
case GET_SHIELD:
|
|
ps->inv_amount[GET_SHIELD] += *insptr;// 100;
|
|
if (ps->inv_amount[GET_SHIELD] > ps->max_shield_amount)
|
|
ps->inv_amount[GET_SHIELD] = ps->max_shield_amount;
|
|
break;
|
|
|
|
case GET_SCUBA:
|
|
ps->inv_amount[GET_SCUBA] = *insptr;// 1600;
|
|
ps->inven_icon = ICON_SCUBA;
|
|
break;
|
|
|
|
case GET_HOLODUKE:
|
|
ps->inv_amount[GET_HOLODUKE] = *insptr;// 1600;
|
|
ps->inven_icon = ICON_HOLODUKE;
|
|
break;
|
|
|
|
case GET_JETPACK:
|
|
ps->inv_amount[GET_JETPACK] = *insptr;// 1600;
|
|
ps->inven_icon = ICON_JETPACK;
|
|
break;
|
|
|
|
case GET_ACCESS:
|
|
switch (vm.g_sp->pal)
|
|
{
|
|
case 0:
|
|
ps->got_access |= 1;
|
|
break;
|
|
case 21:
|
|
ps->got_access |= 2;
|
|
break;
|
|
case 23:
|
|
ps->got_access |= 4;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GET_HEATS:
|
|
ps->inv_amount[GET_HEATS] = *insptr;
|
|
ps->inven_icon = ICON_HEATS;
|
|
break;
|
|
|
|
case GET_FIRSTAID:
|
|
ps->inven_icon = ICON_FIRSTAID;
|
|
ps->inv_amount[GET_FIRSTAID] = *insptr;
|
|
break;
|
|
|
|
case GET_BOOTS:
|
|
ps->inven_icon = ICON_BOOTS;
|
|
ps->inv_amount[GET_BOOTS] = *insptr;
|
|
break;
|
|
default:
|
|
CON_ERRPRINTF("Invalid inventory ID %d\n", (int32_t)*(insptr-1));
|
|
break;
|
|
}
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
case CON_HITRADIUSVAR:
|
|
insptr++;
|
|
{
|
|
int32_t v1=Gv_GetVarX(*insptr++),v2=Gv_GetVarX(*insptr++),v3=Gv_GetVarX(*insptr++);
|
|
int32_t v4=Gv_GetVarX(*insptr++),v5=Gv_GetVarX(*insptr++);
|
|
A_RadiusDamage(vm.g_i,v1,v2,v3,v4,v5);
|
|
}
|
|
continue;
|
|
|
|
case CON_HITRADIUS:
|
|
A_RadiusDamage(vm.g_i,*(insptr+1),*(insptr+2),*(insptr+3),*(insptr+4),*(insptr+5));
|
|
insptr += 6;
|
|
continue;
|
|
|
|
case CON_IFP:
|
|
{
|
|
int32_t l = *(++insptr);
|
|
int32_t j = 0;
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
int32_t s = sprite[ps->i].xvel;
|
|
|
|
if ((l&8) && ps->on_ground && TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_CROUCH))
|
|
j = 1;
|
|
else if ((l&16) && ps->jumping_counter == 0 && !ps->on_ground &&
|
|
ps->vel.z > 2048)
|
|
j = 1;
|
|
else if ((l&32) && ps->jumping_counter > 348)
|
|
j = 1;
|
|
else if ((l&1) && s >= 0 && s < 8)
|
|
j = 1;
|
|
else if ((l&2) && s >= 8 && !TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_RUN))
|
|
j = 1;
|
|
else if ((l&4) && s >= 8 && TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_RUN))
|
|
j = 1;
|
|
else if ((l&64) && ps->pos.z < (vm.g_sp->z-(48<<8)))
|
|
j = 1;
|
|
else if ((l&128) && s <= -8 && !TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_RUN))
|
|
j = 1;
|
|
else if ((l&256) && s <= -8 && TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_RUN))
|
|
j = 1;
|
|
else if ((l&512) && (ps->quick_kick > 0 || (ps->curr_weapon == KNEE_WEAPON && ps->kickback_pic > 0)))
|
|
j = 1;
|
|
else if ((l&1024) && sprite[ps->i].xrepeat < 32)
|
|
j = 1;
|
|
else if ((l&2048) && ps->jetpack_on)
|
|
j = 1;
|
|
else if ((l&4096) && ps->inv_amount[GET_STEROIDS] > 0 && ps->inv_amount[GET_STEROIDS] < 400)
|
|
j = 1;
|
|
else if ((l&8192) && ps->on_ground)
|
|
j = 1;
|
|
else if ((l&16384) && sprite[ps->i].xrepeat > 32 && sprite[ps->i].extra > 0 && ps->timebeforeexit == 0)
|
|
j = 1;
|
|
else if ((l&32768) && sprite[ps->i].extra <= 0)
|
|
j = 1;
|
|
else if ((l&65536L))
|
|
{
|
|
if (vm.g_sp->picnum == APLAYER && (g_netServer || ud.multimode > 1))
|
|
j = G_GetAngleDelta(g_player[otherp].ps->ang,getangle(ps->pos.x-g_player[otherp].ps->pos.x,ps->pos.y-g_player[otherp].ps->pos.y));
|
|
else
|
|
j = G_GetAngleDelta(ps->ang,getangle(vm.g_sp->x-ps->pos.x,vm.g_sp->y-ps->pos.y));
|
|
|
|
if (j > -128 && j < 128)
|
|
j = 1;
|
|
else
|
|
j = 0;
|
|
}
|
|
VM_CONDITIONAL((intptr_t) j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFSTRENGTH:
|
|
insptr++;
|
|
VM_CONDITIONAL(vm.g_sp->extra <= *insptr);
|
|
continue;
|
|
|
|
case CON_GUTS:
|
|
A_DoGuts(vm.g_i,*(insptr+1),*(insptr+2));
|
|
insptr += 3;
|
|
continue;
|
|
|
|
case CON_IFSPAWNEDBY:
|
|
insptr++;
|
|
VM_CONDITIONAL(actor[vm.g_i].picnum == *insptr);
|
|
continue;
|
|
|
|
case CON_WACKPLAYER:
|
|
insptr++;
|
|
P_ForceAngle(g_player[vm.g_p].ps);
|
|
continue;
|
|
|
|
case CON_FLASH:
|
|
insptr++;
|
|
sprite[vm.g_i].shade = -127;
|
|
g_player[vm.g_p].ps->visibility = -127;
|
|
continue;
|
|
|
|
case CON_SAVEMAPSTATE:
|
|
G_SaveMapState();
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_LOADMAPSTATE:
|
|
G_RestoreMapState();
|
|
insptr++;
|
|
continue;
|
|
|
|
case CON_CLEARMAPSTATE:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j >= MAXVOLUMES*MAXLEVELS)
|
|
{
|
|
CON_ERRPRINTF("Invalid map number: %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
G_FreeMapState(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_STOPALLSOUNDS:
|
|
insptr++;
|
|
if (screenpeek == vm.g_p)
|
|
FX_StopAllSounds();
|
|
continue;
|
|
|
|
case CON_IFGAPZL:
|
|
insptr++;
|
|
VM_CONDITIONAL(((actor[vm.g_i].floorz - actor[vm.g_i].ceilingz) >> 8) < *insptr);
|
|
continue;
|
|
|
|
case CON_IFHITSPACE:
|
|
VM_CONDITIONAL(TEST_SYNC_KEY(g_player[vm.g_p].sync->bits, SK_OPEN));
|
|
continue;
|
|
|
|
case CON_IFOUTSIDE:
|
|
VM_CONDITIONAL(sector[vm.g_sp->sectnum].ceilingstat&1);
|
|
continue;
|
|
|
|
case CON_IFMULTIPLAYER:
|
|
VM_CONDITIONAL((g_netServer || g_netClient || ud.multimode > 1));
|
|
continue;
|
|
|
|
case CON_IFCLIENT:
|
|
VM_CONDITIONAL(g_netClient != NULL);
|
|
continue;
|
|
|
|
case CON_IFSERVER:
|
|
VM_CONDITIONAL(g_netServer != NULL);
|
|
continue;
|
|
|
|
case CON_OPERATE:
|
|
insptr++;
|
|
if (sector[vm.g_sp->sectnum].lotag == 0)
|
|
{
|
|
int16_t neartagsector, neartagwall, neartagsprite;
|
|
int32_t neartaghitdist;
|
|
|
|
neartag(vm.g_sp->x,vm.g_sp->y,vm.g_sp->z-(32<<8),vm.g_sp->sectnum,vm.g_sp->ang,
|
|
&neartagsector,&neartagwall,&neartagsprite,&neartaghitdist, 768, 4+1, NULL);
|
|
|
|
if (neartagsector >= 0 && isanearoperator(sector[neartagsector].lotag))
|
|
if ((sector[neartagsector].lotag&0xff) == ST_23_SWINGING_DOOR || sector[neartagsector].floorz == sector[neartagsector].ceilingz)
|
|
if ((sector[neartagsector].lotag&(16384|32768)) == 0)
|
|
{
|
|
int32_t j;
|
|
|
|
for (SPRITES_OF_SECT(neartagsector, j))
|
|
if (sprite[j].picnum == ACTIVATOR)
|
|
break;
|
|
|
|
if (j == -1)
|
|
G_OperateSectors(neartagsector,vm.g_i);
|
|
}
|
|
}
|
|
continue;
|
|
|
|
case CON_IFINSPACE:
|
|
VM_CONDITIONAL(G_CheckForSpaceCeiling(vm.g_sp->sectnum));
|
|
continue;
|
|
|
|
case CON_SPRITEPAL:
|
|
insptr++;
|
|
if (vm.g_sp->picnum != APLAYER)
|
|
actor[vm.g_i].tempang = vm.g_sp->pal;
|
|
vm.g_sp->pal = *insptr++;
|
|
continue;
|
|
|
|
case CON_CACTOR:
|
|
insptr++;
|
|
vm.g_sp->picnum = *insptr++;
|
|
continue;
|
|
|
|
case CON_IFBULLETNEAR:
|
|
VM_CONDITIONAL(A_Dodge(vm.g_sp) == 1);
|
|
continue;
|
|
|
|
case CON_IFRESPAWN:
|
|
if (A_CheckEnemySprite(vm.g_sp)) VM_CONDITIONAL(ud.respawn_monsters)
|
|
else if (A_CheckInventorySprite(vm.g_sp)) VM_CONDITIONAL(ud.respawn_inventory)
|
|
else VM_CONDITIONAL(ud.respawn_items)
|
|
continue;
|
|
|
|
case CON_IFFLOORDISTL:
|
|
insptr++;
|
|
VM_CONDITIONAL((actor[vm.g_i].floorz - vm.g_sp->z) <= ((*insptr)<<8));
|
|
continue;
|
|
|
|
case CON_IFCEILINGDISTL:
|
|
insptr++;
|
|
VM_CONDITIONAL((vm.g_sp->z - actor[vm.g_i].ceilingz) <= ((*insptr)<<8));
|
|
continue;
|
|
|
|
case CON_PALFROM:
|
|
insptr++;
|
|
if ((unsigned)vm.g_p >= (unsigned)playerswhenstarted)
|
|
{
|
|
CON_ERRPRINTF("invalid player ID %d\n", vm.g_p);
|
|
insptr += 4;
|
|
}
|
|
else
|
|
{
|
|
uint8_t f=*insptr++, r=*insptr++, g=*insptr++, b=*insptr++;
|
|
|
|
P_PalFrom(g_player[vm.g_p].ps, f, r,g,b);
|
|
}
|
|
continue;
|
|
|
|
case CON_SECTOROFWALL:
|
|
insptr++;
|
|
{
|
|
int32_t j = *insptr++;
|
|
|
|
Gv_SetVarX(j, sectorofwall(Gv_GetVarX(*insptr++)));
|
|
}
|
|
continue;
|
|
|
|
case CON_QSPRINTF:
|
|
insptr++;
|
|
{
|
|
int32_t dq = Gv_GetVarX(*insptr++), sq = Gv_GetVarX(*insptr++);
|
|
if ((ScriptQuotes[sq] == NULL || ScriptQuotes[dq] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", ScriptQuotes[sq] ? dq : sq);
|
|
|
|
while ((*insptr & 0xFFF) != CON_NULLOP)
|
|
Gv_GetVarX(*insptr++);
|
|
|
|
insptr++; // skip the NOP
|
|
continue;
|
|
}
|
|
|
|
{
|
|
int32_t arg[32], i = 0, j = 0, k = 0, numargs;
|
|
int32_t len = Bstrlen(ScriptQuotes[sq]);
|
|
char tempbuf[MAXQUOTELEN];
|
|
|
|
while ((*insptr & 0xFFF) != CON_NULLOP && i < 32)
|
|
arg[i++] = Gv_GetVarX(*insptr++);
|
|
numargs = i;
|
|
|
|
insptr++; // skip the NOP
|
|
|
|
i = 0;
|
|
|
|
do
|
|
{
|
|
while (k < len && j < MAXQUOTELEN && ScriptQuotes[sq][k] != '%')
|
|
tempbuf[j++] = ScriptQuotes[sq][k++];
|
|
|
|
if (ScriptQuotes[sq][k] == '%')
|
|
{
|
|
k++;
|
|
switch (ScriptQuotes[sq][k])
|
|
{
|
|
case 'l':
|
|
if (ScriptQuotes[sq][k+1] != 'd')
|
|
{
|
|
// write the % and l
|
|
tempbuf[j++] = ScriptQuotes[sq][k-1];
|
|
tempbuf[j++] = ScriptQuotes[sq][k++];
|
|
break;
|
|
}
|
|
k++;
|
|
case 'd':
|
|
{
|
|
char buf[16];
|
|
int32_t ii;
|
|
|
|
if (i >= numargs)
|
|
goto finish_qsprintf;
|
|
Bsprintf(buf, "%d", arg[i++]);
|
|
|
|
ii = Bstrlen(buf);
|
|
Bmemcpy(&tempbuf[j], buf, ii);
|
|
j += ii;
|
|
k++;
|
|
}
|
|
break;
|
|
|
|
case 's':
|
|
{
|
|
int32_t ii;
|
|
|
|
if (i >= numargs)
|
|
goto finish_qsprintf;
|
|
ii = Bstrlen(ScriptQuotes[arg[i]]);
|
|
|
|
Bmemcpy(&tempbuf[j], ScriptQuotes[arg[i]], ii);
|
|
j += ii;
|
|
i++;
|
|
k++;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
tempbuf[j++] = ScriptQuotes[sq][k-1];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while (k < len && j < MAXQUOTELEN);
|
|
finish_qsprintf:
|
|
tempbuf[j] = '\0';
|
|
Bstrncpyz(ScriptQuotes[dq], tempbuf, MAXQUOTELEN);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
case CON_ADDLOG:
|
|
{
|
|
insptr++;
|
|
|
|
OSD_Printf(OSDTEXT_GREEN "CONLOG: L=%d\n",g_errorLineNum);
|
|
continue;
|
|
}
|
|
|
|
case CON_ADDLOGVAR:
|
|
insptr++;
|
|
{
|
|
int32_t m=1;
|
|
char szBuf[256];
|
|
int32_t lVarID = *insptr;
|
|
|
|
if ((lVarID >= g_gameVarCount) || lVarID < 0)
|
|
{
|
|
if (*insptr==MAXGAMEVARS) // addlogvar for a constant? Har.
|
|
insptr++;
|
|
// else if (*insptr > g_gameVarCount && (*insptr < (MAXGAMEVARS<<1)+MAXGAMEVARS+1+MAXGAMEARRAYS))
|
|
else if (*insptr&(MAXGAMEVARS<<2))
|
|
{
|
|
int32_t index;
|
|
|
|
lVarID ^= (MAXGAMEVARS<<2);
|
|
|
|
if (lVarID&(MAXGAMEVARS<<1))
|
|
{
|
|
m = -m;
|
|
lVarID ^= (MAXGAMEVARS<<1);
|
|
}
|
|
|
|
insptr++;
|
|
|
|
index=Gv_GetVarX(*insptr++);
|
|
if (index>=0 && index < aGameArrays[lVarID].size)
|
|
{
|
|
OSD_Printf(OSDTEXT_GREEN "%s: L=%d %s[%d] =%d\n", keyw[g_tw], g_errorLineNum,
|
|
aGameArrays[lVarID].szLabel, index,
|
|
(int32_t)(m*aGameArrays[lVarID].plValues[index]));
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
CON_ERRPRINTF("invalid array index\n");
|
|
continue;
|
|
}
|
|
}
|
|
else if (*insptr&(MAXGAMEVARS<<3))
|
|
{
|
|
// FIXME FIXME FIXME
|
|
if ((lVarID & (MAXGAMEVARS-1)) == g_iActorVarID)
|
|
{
|
|
intptr_t *oinsptr = insptr++;
|
|
int32_t index = Gv_GetVarX(*insptr++);
|
|
insptr = oinsptr;
|
|
if ((unsigned)index >= MAXSPRITES-1)
|
|
{
|
|
CON_ERRPRINTF("invalid array index\n");
|
|
Gv_GetVarX(*insptr++);
|
|
continue;
|
|
}
|
|
OSD_Printf(OSDTEXT_GREEN "%s: L=%d %d %d\n",keyw[g_tw],g_errorLineNum,index,Gv_GetVar(*insptr++,index,vm.g_p));
|
|
continue;
|
|
}
|
|
}
|
|
else if (*insptr&(MAXGAMEVARS<<1))
|
|
{
|
|
m = -m;
|
|
lVarID ^= (MAXGAMEVARS<<1);
|
|
}
|
|
else
|
|
{
|
|
// invalid varID
|
|
insptr++;
|
|
CON_ERRPRINTF("invalid variable\n");
|
|
continue; // out of switch
|
|
}
|
|
}
|
|
Bsprintf(szBuf,"CONLOGVAR: L=%d %s ",g_errorLineNum, aGameVars[lVarID].szLabel);
|
|
strcpy(g_szBuf,szBuf);
|
|
|
|
if (aGameVars[lVarID].dwFlags & GAMEVAR_READONLY)
|
|
{
|
|
Bsprintf(szBuf," (read-only)");
|
|
strcat(g_szBuf,szBuf);
|
|
}
|
|
if (aGameVars[lVarID].dwFlags & GAMEVAR_PERPLAYER)
|
|
{
|
|
Bsprintf(szBuf," (Per Player. Player=%d)",vm.g_p);
|
|
}
|
|
else if (aGameVars[lVarID].dwFlags & GAMEVAR_PERACTOR)
|
|
{
|
|
Bsprintf(szBuf," (Per Actor. Actor=%d)",vm.g_i);
|
|
}
|
|
else
|
|
{
|
|
Bsprintf(szBuf," (Global)");
|
|
}
|
|
Bstrcat(g_szBuf,szBuf);
|
|
Bsprintf(szBuf," =%d\n", Gv_GetVarX(lVarID)*m);
|
|
Bstrcat(g_szBuf,szBuf);
|
|
OSD_Printf(OSDTEXT_GREEN "%s",g_szBuf);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
case CON_SETSECTOR:
|
|
case CON_GETSECTOR:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etsector[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessSector(tw==CON_SETSECTOR, lVar1, lLabelID, lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_SQRT:
|
|
insptr++;
|
|
{
|
|
// syntax sqrt <invar> <outvar>
|
|
int32_t lInVarID=*insptr++, lOutVarID=*insptr++;
|
|
|
|
Gv_SetVarX(lOutVarID, ksqrt((uint32_t)Gv_GetVarX(lInVarID)));
|
|
continue;
|
|
}
|
|
|
|
case CON_FINDNEARACTOR:
|
|
case CON_FINDNEARSPRITE:
|
|
case CON_FINDNEARACTOR3D:
|
|
case CON_FINDNEARSPRITE3D:
|
|
insptr++;
|
|
{
|
|
// syntax findnearactorvar <type> <maxdist> <getvar>
|
|
// gets the sprite ID of the nearest actor within max dist
|
|
// that is of <type> into <getvar>
|
|
// -1 for none found
|
|
// <type> <maxdist> <varid>
|
|
int32_t lType=*insptr++, lMaxDist=*insptr++, lVarID=*insptr++;
|
|
int32_t lFound=-1, j, k = MAXSTATUS-1;
|
|
|
|
if (tw == CON_FINDNEARACTOR || tw == CON_FINDNEARACTOR3D)
|
|
k = 1;
|
|
|
|
if (tw==CON_FINDNEARSPRITE3D || tw==CON_FINDNEARACTOR3D)
|
|
{
|
|
do
|
|
{
|
|
j=headspritestat[k]; // all sprites
|
|
while (j>=0)
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i && dist(&sprite[vm.g_i], &sprite[j]) < lMaxDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
if (j == MAXSPRITES || tw == CON_FINDNEARACTOR3D)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
continue;
|
|
}
|
|
|
|
do
|
|
{
|
|
j=headspritestat[k]; // all sprites
|
|
while (j>=0)
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i && ldist(&sprite[vm.g_i], &sprite[j]) < lMaxDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
|
|
if (j == MAXSPRITES || tw == CON_FINDNEARACTOR)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
continue;
|
|
}
|
|
|
|
case CON_FINDNEARACTORVAR:
|
|
case CON_FINDNEARSPRITEVAR:
|
|
case CON_FINDNEARACTOR3DVAR:
|
|
case CON_FINDNEARSPRITE3DVAR:
|
|
insptr++;
|
|
{
|
|
// syntax findnearactorvar <type> <maxdistvar> <getvar>
|
|
// gets the sprite ID of the nearest actor within max dist
|
|
// that is of <type> into <getvar>
|
|
// -1 for none found
|
|
// <type> <maxdistvarid> <varid>
|
|
int32_t lType=*insptr++, lMaxDist=Gv_GetVarX(*insptr++), lVarID=*insptr++;
|
|
int32_t lFound=-1, j, k = 1;
|
|
|
|
if (tw == CON_FINDNEARSPRITEVAR || tw == CON_FINDNEARSPRITE3DVAR)
|
|
k = MAXSTATUS-1;
|
|
|
|
if (tw==CON_FINDNEARACTOR3DVAR || tw==CON_FINDNEARSPRITE3DVAR)
|
|
{
|
|
do
|
|
{
|
|
j=headspritestat[k]; // all sprites
|
|
|
|
while (j >= 0)
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i && dist(&sprite[vm.g_i], &sprite[j]) < lMaxDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
if (j == MAXSPRITES || tw==CON_FINDNEARACTOR3DVAR)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
continue;
|
|
}
|
|
|
|
do
|
|
{
|
|
j=headspritestat[k]; // all sprites
|
|
|
|
while (j >= 0)
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i && ldist(&sprite[vm.g_i], &sprite[j]) < lMaxDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
|
|
if (j == MAXSPRITES || tw==CON_FINDNEARACTORVAR)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
continue;
|
|
}
|
|
|
|
case CON_FINDNEARACTORZVAR:
|
|
case CON_FINDNEARSPRITEZVAR:
|
|
insptr++;
|
|
{
|
|
// syntax findnearactorvar <type> <maxdistvar> <getvar>
|
|
// gets the sprite ID of the nearest actor within max dist
|
|
// that is of <type> into <getvar>
|
|
// -1 for none found
|
|
// <type> <maxdistvarid> <varid>
|
|
int32_t lType=*insptr++, lMaxDist=Gv_GetVarX(*insptr++);
|
|
int32_t lMaxZDist=Gv_GetVarX(*insptr++);
|
|
int32_t lVarID=*insptr++, lFound=-1, lTemp, lTemp2, j, k=MAXSTATUS-1;
|
|
do
|
|
{
|
|
j=headspritestat[tw==CON_FINDNEARACTORZVAR?1:k]; // all sprites
|
|
if (j == -1) continue;
|
|
do
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i)
|
|
{
|
|
lTemp=ldist(&sprite[vm.g_i], &sprite[j]);
|
|
if (lTemp < lMaxDist)
|
|
{
|
|
lTemp2=klabs(sprite[vm.g_i].z-sprite[j].z);
|
|
if (lTemp2 < lMaxZDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
while (j>=0);
|
|
if (tw==CON_FINDNEARACTORZVAR || j == MAXSPRITES)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_FINDNEARACTORZ:
|
|
case CON_FINDNEARSPRITEZ:
|
|
insptr++;
|
|
{
|
|
// syntax findnearactorvar <type> <maxdist> <getvar>
|
|
// gets the sprite ID of the nearest actor within max dist
|
|
// that is of <type> into <getvar>
|
|
// -1 for none found
|
|
// <type> <maxdist> <varid>
|
|
int32_t lType=*insptr++, lMaxDist=*insptr++, lMaxZDist=*insptr++, lVarID=*insptr++;
|
|
int32_t lTemp, lTemp2, lFound=-1, j, k=MAXSTATUS-1;
|
|
do
|
|
{
|
|
j=headspritestat[tw==CON_FINDNEARACTORZ?1:k]; // all sprites
|
|
if (j == -1) continue;
|
|
do
|
|
{
|
|
if (sprite[j].picnum == lType && j != vm.g_i)
|
|
{
|
|
lTemp=ldist(&sprite[vm.g_i], &sprite[j]);
|
|
if (lTemp < lMaxDist)
|
|
{
|
|
lTemp2=klabs(sprite[vm.g_i].z-sprite[j].z);
|
|
if (lTemp2 < lMaxZDist)
|
|
{
|
|
lFound=j;
|
|
j = MAXSPRITES;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
j = nextspritestat[j];
|
|
}
|
|
while (j>=0);
|
|
|
|
if (tw==CON_FINDNEARACTORZ || j == MAXSPRITES)
|
|
break;
|
|
}
|
|
while (k--);
|
|
Gv_SetVarX(lVarID, lFound);
|
|
continue;
|
|
}
|
|
|
|
case CON_FINDPLAYER:
|
|
insptr++;
|
|
{
|
|
int32_t j;
|
|
aGameVars[g_iReturnVarID].val.lValue = A_FindPlayer(&sprite[vm.g_i],&j);
|
|
Gv_SetVarX(*insptr++, j);
|
|
}
|
|
continue;
|
|
|
|
case CON_FINDOTHERPLAYER:
|
|
insptr++;
|
|
{
|
|
int32_t j;
|
|
// Gv_SetVarX(g_iReturnVarID, P_FindOtherPlayer(vm.g_p,&j));
|
|
aGameVars[g_iReturnVarID].val.lValue = P_FindOtherPlayer(vm.g_p,&j);
|
|
Gv_SetVarX(*insptr++, j);
|
|
}
|
|
continue;
|
|
|
|
case CON_SETPLAYER:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etplayer[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lParm2 = 0, lVar2;
|
|
// HACK: need to have access to labels structure at run-time...
|
|
|
|
if (PlayerLabels[lLabelID].flags & LABEL_HASPARM2)
|
|
lParm2=Gv_GetVarX(*insptr++);
|
|
lVar2=*insptr++;
|
|
|
|
VM_SetPlayer(lVar1, lLabelID, lVar2, lParm2);
|
|
continue;
|
|
}
|
|
|
|
|
|
case CON_GETPLAYER:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etplayer[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lParm2 = 0, lVar2;
|
|
// HACK: need to have access to labels structure at run-time...
|
|
|
|
if (PlayerLabels[lLabelID].flags & LABEL_HASPARM2)
|
|
lParm2=Gv_GetVarX(*insptr++);
|
|
lVar2=*insptr++;
|
|
|
|
VM_GetPlayer(lVar1, lLabelID, lVar2, lParm2);
|
|
continue;
|
|
}
|
|
|
|
case CON_SETINPUT:
|
|
case CON_GETINPUT:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etplayer[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessPlayerInput(tw==CON_SETINPUT, lVar1, lLabelID, lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETUSERDEF:
|
|
case CON_SETUSERDEF:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etuserdef.xxx <VAR>
|
|
// <xxxid> <varid>
|
|
int32_t lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessUserdef(tw==CON_SETUSERDEF, lLabelID, lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETPROJECTILE:
|
|
case CON_SETPROJECTILE:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etplayer[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=Gv_GetVarX(*insptr++), lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessProjectile(tw==CON_SETPROJECTILE,lVar1,lLabelID,lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_SETWALL:
|
|
case CON_GETWALL:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etwall[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessWall(tw==CON_SETWALL, lVar1, lLabelID, lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_SETACTORVAR:
|
|
case CON_GETACTORVAR:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etactorvar[<var>].<varx> <VAR>
|
|
// gets the value of the per-actor variable varx into VAR
|
|
// <var> <varx> <VAR>
|
|
int32_t lSprite=Gv_GetVarX(*insptr++), lVar1=*insptr++;
|
|
int32_t lVar2=*insptr++;
|
|
|
|
if ((unsigned)lSprite >= MAXSPRITES)
|
|
{
|
|
CON_ERRPRINTF("invalid sprite ID %d\n", lSprite);
|
|
if (lVar1 == MAXGAMEVARS || lVar1 & ((MAXGAMEVARS<<2)|(MAXGAMEVARS<<3))) insptr++;
|
|
if (lVar2 == MAXGAMEVARS || lVar2 & ((MAXGAMEVARS<<2)|(MAXGAMEVARS<<3))) insptr++;
|
|
continue;
|
|
}
|
|
|
|
if (tw == CON_SETACTORVAR)
|
|
{
|
|
Gv_SetVar(lVar1, Gv_GetVarX(lVar2), lSprite, vm.g_p);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(lVar2, Gv_GetVar(lVar1, lSprite, vm.g_p));
|
|
continue;
|
|
}
|
|
|
|
case CON_SETPLAYERVAR:
|
|
case CON_GETPLAYERVAR:
|
|
insptr++;
|
|
{
|
|
int32_t iPlayer = vm.g_p;
|
|
|
|
if (*insptr != g_iThisActorID)
|
|
iPlayer=Gv_GetVarX(*insptr);
|
|
|
|
insptr++;
|
|
{
|
|
int32_t lVar1=*insptr++, lVar2=*insptr++;
|
|
|
|
if ((unsigned)iPlayer >= (unsigned)playerswhenstarted)
|
|
{
|
|
CON_ERRPRINTF("invalid player ID %d\n", iPlayer);
|
|
if (lVar1 == MAXGAMEVARS || lVar1 & ((MAXGAMEVARS<<2)|(MAXGAMEVARS<<3))) insptr++;
|
|
if (lVar2 == MAXGAMEVARS || lVar2 & ((MAXGAMEVARS<<2)|(MAXGAMEVARS<<3))) insptr++;
|
|
continue;
|
|
}
|
|
|
|
if (tw == CON_SETPLAYERVAR)
|
|
{
|
|
Gv_SetVar(lVar1, Gv_GetVarX(lVar2), vm.g_i, iPlayer);
|
|
continue;
|
|
}
|
|
Gv_SetVarX(lVar2, Gv_GetVar(lVar1, vm.g_i, iPlayer));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
case CON_SETACTOR:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etactor[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lParm2 = 0;
|
|
|
|
if (ActorLabels[lLabelID].flags & LABEL_HASPARM2)
|
|
lParm2=Gv_GetVarX(*insptr++);
|
|
|
|
{
|
|
int32_t lVar2=*insptr++;
|
|
|
|
VM_SetSprite(lVar1, lLabelID, lVar2, lParm2);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_GETACTOR:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etactor[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lParm2 = 0;
|
|
|
|
if (ActorLabels[lLabelID].flags & LABEL_HASPARM2)
|
|
lParm2=Gv_GetVarX(*insptr++);
|
|
|
|
{
|
|
int32_t lVar2=*insptr++;
|
|
|
|
VM_GetSprite(lVar1, lLabelID, lVar2, lParm2);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_SETTSPR:
|
|
case CON_GETTSPR:
|
|
insptr++;
|
|
{
|
|
// syntax [gs]etactor[<var>].x <VAR>
|
|
// <varid> <xxxid> <varid>
|
|
|
|
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
|
|
|
|
VM_AccessTsprite(tw==CON_SETTSPR, lVar1, lLabelID, lVar2);
|
|
continue;
|
|
}
|
|
|
|
case CON_GETANGLETOTARGET:
|
|
insptr++;
|
|
// Actor[vm.g_i].lastvx and lastvy are last known location of target.
|
|
Gv_SetVarX(*insptr++, getangle(actor[vm.g_i].lastvx-vm.g_sp->x,actor[vm.g_i].lastvy-vm.g_sp->y));
|
|
continue;
|
|
|
|
case CON_ANGOFFVAR:
|
|
insptr++;
|
|
spriteext[vm.g_i].angoff=Gv_GetVarX(*insptr++);
|
|
continue;
|
|
|
|
case CON_LOCKPLAYER:
|
|
insptr++;
|
|
g_player[vm.g_p].ps->transporter_hold=Gv_GetVarX(*insptr++);
|
|
continue;
|
|
|
|
case CON_CHECKAVAILWEAPON:
|
|
case CON_CHECKAVAILINVEN:
|
|
insptr++;
|
|
{
|
|
int32_t j = vm.g_p;
|
|
|
|
if (*insptr != g_iThisActorID)
|
|
j=Gv_GetVarX(*insptr);
|
|
|
|
insptr++;
|
|
|
|
if ((unsigned)j >= (unsigned)playerswhenstarted)
|
|
{
|
|
CON_ERRPRINTF("Invalid player ID %d\n", j);
|
|
continue;
|
|
}
|
|
|
|
if (tw == CON_CHECKAVAILWEAPON)
|
|
P_CheckWeapon(g_player[j].ps);
|
|
else P_SelectNextInvItem(g_player[j].ps);
|
|
}
|
|
continue;
|
|
|
|
case CON_GETPLAYERANGLE:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr++, g_player[vm.g_p].ps->ang);
|
|
continue;
|
|
|
|
case CON_SETPLAYERANGLE:
|
|
insptr++;
|
|
g_player[vm.g_p].ps->ang=Gv_GetVarX(*insptr++);
|
|
g_player[vm.g_p].ps->ang &= 2047;
|
|
continue;
|
|
|
|
case CON_GETACTORANGLE:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr++, vm.g_sp->ang);
|
|
continue;
|
|
|
|
case CON_SETACTORANGLE:
|
|
insptr++;
|
|
vm.g_sp->ang=Gv_GetVarX(*insptr++);
|
|
vm.g_sp->ang &= 2047;
|
|
continue;
|
|
|
|
case CON_SETVAR:
|
|
insptr++;
|
|
if ((aGameVars[*insptr].dwFlags & (GAMEVAR_USER_MASK|GAMEVAR_PTR_MASK)) == 0)
|
|
{
|
|
aGameVars[*insptr].val.lValue = *(insptr+1);
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr, *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SETARRAY:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
int32_t index = Gv_GetVarX(*insptr++);
|
|
int32_t value = Gv_GetVarX(*insptr++);
|
|
|
|
if (j<0 || j >= g_gameArrayCount || index >= aGameArrays[j].size || index < 0)
|
|
{
|
|
OSD_Printf_nowarn(OSD_ERROR "Gv_SetVar(): tried to set invalid array ID (%d) or index out of bounds from sprite %d (%d), player %d\n",
|
|
j,vm.g_i,TrackerCast(sprite[vm.g_i].picnum),vm.g_p);
|
|
continue;
|
|
}
|
|
if (aGameArrays[j].dwFlags & GAMEARRAY_READONLY)
|
|
{
|
|
OSD_Printf("Tried to set on read-only array `%s'", aGameArrays[j].szLabel);
|
|
continue;
|
|
}
|
|
aGameArrays[j].plValues[index]=value;
|
|
continue;
|
|
}
|
|
case CON_WRITEARRAYTOFILE:
|
|
case CON_READARRAYFROMFILE:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
{
|
|
int q = *insptr++;
|
|
|
|
if (ScriptQuotes[q] == NULL)
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", q);
|
|
continue;
|
|
}
|
|
|
|
if (tw == CON_READARRAYFROMFILE)
|
|
{
|
|
int32_t fil = kopen4loadfrommod(ScriptQuotes[q], 0);
|
|
int32_t asize;
|
|
|
|
if (fil < 0)
|
|
continue;
|
|
|
|
asize = kfilelength(fil);
|
|
|
|
if (asize > 0)
|
|
{
|
|
// NOTE: this is broken on 64-bit, e.g. for LNGA2.
|
|
/*OSD_Printf(OSDTEXT_GREEN "CON_RESIZEARRAY: resizing array %s from %d to %d\n",
|
|
aGameArrays[j].szLabel, aGameArrays[j].size, asize / GAR_ELTSZ);*/
|
|
aGameArrays[j].plValues = (intptr_t *)Xrealloc(aGameArrays[j].plValues, asize);
|
|
aGameArrays[j].size = asize / GAR_ELTSZ;
|
|
kread(fil, aGameArrays[j].plValues, asize);
|
|
}
|
|
|
|
kclose(fil);
|
|
continue;
|
|
}
|
|
|
|
{
|
|
FILE *fil;
|
|
char temp[BMAX_PATH];
|
|
|
|
if (G_ModDirSnprintf(temp, sizeof(temp), "%s", ScriptQuotes[q]))
|
|
{
|
|
CON_ERRPRINTF("file name too long\n");
|
|
continue;
|
|
}
|
|
|
|
fil = fopen(temp,"wb");
|
|
if (fil == NULL)
|
|
{
|
|
CON_ERRPRINTF("couldn't open file");
|
|
continue;
|
|
}
|
|
|
|
fwrite(aGameArrays[j].plValues,1,sizeof(int) * aGameArrays[j].size,fil);
|
|
fclose(fil);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
case CON_GETARRAYSIZE:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_SetVarX(*insptr++, (aGameArrays[j].dwFlags&GAMEARRAY_VARSIZE) ?
|
|
Gv_GetVarX(aGameArrays[j].size) : aGameArrays[j].size);
|
|
}
|
|
continue;
|
|
|
|
case CON_RESIZEARRAY:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
int32_t asize = Gv_GetVarX(*insptr++);
|
|
|
|
if (asize > 0)
|
|
{
|
|
/*OSD_Printf(OSDTEXT_GREEN "CON_RESIZEARRAY: resizing array %s from %d to %d\n", aGameArrays[j].szLabel, aGameArrays[j].size, asize);*/
|
|
aGameArrays[j].plValues = (intptr_t *)Xrealloc(aGameArrays[j].plValues, GAR_ELTSZ * asize);
|
|
aGameArrays[j].size = asize;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_COPY:
|
|
insptr++;
|
|
{
|
|
int32_t si=*insptr++, ssiz = 0;
|
|
int32_t sidx = Gv_GetVarX(*insptr++); //, vm.g_i, vm.g_p);
|
|
int32_t di=*insptr++, dsiz = 0;
|
|
int32_t didx = Gv_GetVarX(*insptr++);
|
|
int32_t numelts = Gv_GetVarX(*insptr++);
|
|
|
|
if (si<0 || si>=g_gameArrayCount)
|
|
{
|
|
CON_ERRPRINTF("Invalid array %d!", si);
|
|
dsiz = 1;
|
|
}
|
|
if (di<0 || di>=g_gameArrayCount)
|
|
{
|
|
CON_ERRPRINTF("Invalid array %d!", di);
|
|
dsiz = 1;
|
|
}
|
|
if (aGameArrays[di].dwFlags & GAMEARRAY_READONLY)
|
|
{
|
|
CON_ERRPRINTF("Array %d is read-only!", di);
|
|
dsiz = 1;
|
|
}
|
|
if (dsiz) continue; // dirty replacement for VMFLAG_ERROR
|
|
|
|
ssiz = (aGameArrays[si].dwFlags&GAMEARRAY_VARSIZE) ?
|
|
Gv_GetVarX(aGameArrays[si].size) : aGameArrays[si].size;
|
|
dsiz = (aGameArrays[di].dwFlags&GAMEARRAY_VARSIZE) ?
|
|
Gv_GetVarX(aGameArrays[si].size) : aGameArrays[di].size;
|
|
|
|
if (sidx > ssiz || didx > dsiz) continue;
|
|
if ((sidx+numelts) > ssiz) numelts = ssiz-sidx;
|
|
if ((didx+numelts) > dsiz) numelts = dsiz-didx;
|
|
|
|
// Switch depending on the source array type.
|
|
switch (aGameArrays[si].dwFlags & GAMEARRAY_TYPE_MASK)
|
|
{
|
|
case 0:
|
|
// CON array to CON array.
|
|
Bmemcpy(aGameArrays[di].plValues+didx, aGameArrays[si].plValues+sidx, numelts*GAR_ELTSZ);
|
|
break;
|
|
case GAMEARRAY_OFINT:
|
|
// From int32-sized array. Note that the CON array element
|
|
// type is intptr_t, so it is different-sized on 64-bit
|
|
// archs, but same-sized on 32-bit ones.
|
|
for (; numelts>0; numelts--)
|
|
(aGameArrays[di].plValues)[didx++] = ((int32_t *)aGameArrays[si].plValues)[sidx++];
|
|
break;
|
|
case GAMEARRAY_OFSHORT:
|
|
// From int16_t array. Always different-sized.
|
|
for (; numelts>0; numelts--)
|
|
(aGameArrays[di].plValues)[didx++] = ((int16_t *)aGameArrays[si].plValues)[sidx++];
|
|
break;
|
|
case GAMEARRAY_OFCHAR:
|
|
// From char array. Always different-sized.
|
|
for (; numelts>0; numelts--)
|
|
(aGameArrays[di].plValues)[didx++] = ((uint8_t *)aGameArrays[si].plValues)[sidx++];
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case CON_RANDVAR:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr, mulscale16(krand(), *(insptr+1)+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_DISPLAYRANDVAR:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr, mulscale15(system_15bit_rand(), *(insptr+1)+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_INV:
|
|
if ((aGameVars[*(insptr+1)].dwFlags & (GAMEVAR_USER_MASK|GAMEVAR_PTR_MASK)) == 0)
|
|
{
|
|
aGameVars[*(insptr+1)].val.lValue = -aGameVars[*(insptr+1)].val.lValue;
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*(insptr+1), -Gv_GetVarX(*(insptr+1)));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_MULVAR:
|
|
insptr++;
|
|
Gv_MulVar(*insptr, *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_DIVVAR:
|
|
insptr++;
|
|
if (*(insptr+1) == 0)
|
|
{
|
|
CON_ERRPRINTF("divide by zero!\n");
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
Gv_DivVar(*insptr, *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_MODVAR:
|
|
insptr++;
|
|
if (*(insptr+1) == 0)
|
|
{
|
|
CON_ERRPRINTF("mod by zero!\n");
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
|
|
Gv_ModVar(*insptr,*(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_ANDVAR:
|
|
insptr++;
|
|
Gv_AndVar(*insptr,*(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_ORVAR:
|
|
insptr++;
|
|
Gv_OrVar(*insptr,*(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_XORVAR:
|
|
insptr++;
|
|
Gv_XorVar(*insptr,*(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SETVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
if ((aGameVars[j].dwFlags & (GAMEVAR_USER_MASK|GAMEVAR_PTR_MASK)) == 0)
|
|
{
|
|
aGameVars[j].val.lValue = Gv_GetVarX(*insptr++);
|
|
continue;
|
|
}
|
|
|
|
Gv_SetVarX(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_RANDVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_SetVarX(j,mulscale16(krand(), Gv_GetVarX(*insptr++)+1));
|
|
}
|
|
continue;
|
|
|
|
case CON_DISPLAYRANDVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_SetVarX(j,mulscale15(system_15bit_rand(), Gv_GetVarX(*insptr++)+1));
|
|
}
|
|
continue;
|
|
|
|
case CON_GMAXAMMO:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j>=MAX_WEAPONS)
|
|
{
|
|
CON_ERRPRINTF("Invalid weapon ID %d\n", j);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr++, g_player[vm.g_p].ps->max_ammo_amount[j]);
|
|
}
|
|
continue;
|
|
|
|
case CON_SMAXAMMO:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
if ((unsigned)j>=MAX_WEAPONS)
|
|
{
|
|
CON_ERRPRINTF("Invalid weapon ID %d\n", j);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
g_player[vm.g_p].ps->max_ammo_amount[j]=Gv_GetVarX(*insptr++);
|
|
}
|
|
continue;
|
|
|
|
case CON_MULVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
|
|
Gv_MulVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_DIVVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
int32_t l2=Gv_GetVarX(*insptr++);
|
|
|
|
if (!l2)
|
|
{
|
|
CON_ERRPRINTF("divide by zero!\n");
|
|
continue;
|
|
}
|
|
|
|
Gv_DivVar(j, l2);
|
|
continue;
|
|
}
|
|
|
|
case CON_MODVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
int32_t l2=Gv_GetVarX(*insptr++);
|
|
|
|
if (!l2)
|
|
{
|
|
CON_ERRPRINTF("mod by zero!\n");
|
|
continue;
|
|
}
|
|
|
|
|
|
Gv_ModVar(j, l2);
|
|
continue;
|
|
}
|
|
|
|
case CON_ANDVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_AndVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_XORVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_XorVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_ORVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_OrVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_SUBVAR:
|
|
insptr++;
|
|
Gv_SubVar(*insptr, *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SUBVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_SubVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_ADDVAR:
|
|
insptr++;
|
|
Gv_AddVar(*insptr, *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SHIFTVARL:
|
|
insptr++;
|
|
if ((aGameVars[*insptr].dwFlags & (GAMEVAR_USER_MASK|GAMEVAR_PTR_MASK)) == 0)
|
|
{
|
|
aGameVars[*insptr].val.lValue <<= *(insptr+1);
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr, Gv_GetVarX(*insptr) << *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SHIFTVARR:
|
|
insptr++;
|
|
if ((aGameVars[*insptr].dwFlags & (GAMEVAR_USER_MASK|GAMEVAR_PTR_MASK)) == 0)
|
|
{
|
|
aGameVars[*insptr].val.lValue >>= *(insptr+1);
|
|
insptr += 2;
|
|
continue;
|
|
}
|
|
Gv_SetVarX(*insptr, Gv_GetVarX(*insptr) >> *(insptr+1));
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_SIN:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr, sintable[Gv_GetVarX(*(insptr+1))&2047]);
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_COS:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr, sintable[(Gv_GetVarX(*(insptr+1))+512)&2047]);
|
|
insptr += 2;
|
|
continue;
|
|
|
|
case CON_ADDVARVAR:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_AddVar(j, Gv_GetVarX(*insptr++));
|
|
}
|
|
continue;
|
|
|
|
case CON_SPGETLOTAG:
|
|
insptr++;
|
|
aGameVars[g_iLoTagID].val.lValue = vm.g_sp->lotag;
|
|
continue;
|
|
|
|
case CON_SPGETHITAG:
|
|
insptr++;
|
|
aGameVars[g_iHiTagID].val.lValue = vm.g_sp->hitag;
|
|
continue;
|
|
|
|
case CON_SECTGETLOTAG:
|
|
insptr++;
|
|
aGameVars[g_iLoTagID].val.lValue = sector[vm.g_sp->sectnum].lotag;
|
|
continue;
|
|
|
|
case CON_SECTGETHITAG:
|
|
insptr++;
|
|
aGameVars[g_iHiTagID].val.lValue = sector[vm.g_sp->sectnum].hitag;
|
|
continue;
|
|
|
|
case CON_GETTEXTUREFLOOR:
|
|
insptr++;
|
|
aGameVars[g_iTextureID].val.lValue = sector[vm.g_sp->sectnum].floorpicnum;
|
|
continue;
|
|
|
|
case CON_STARTTRACK:
|
|
case CON_STARTTRACKVAR:
|
|
insptr++;
|
|
{
|
|
int32_t level = (tw == CON_STARTTRACK) ? *(insptr++) :
|
|
Gv_GetVarX(*(insptr++));
|
|
|
|
if (G_StartTrack(level))
|
|
CON_ERRPRINTF("invalid level %d or null music for volume %d level %d\n",
|
|
level, ud.volume_number, level);
|
|
}
|
|
continue;
|
|
|
|
case CON_ACTIVATECHEAT:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*(insptr++));
|
|
if (numplayers != 1 || !(g_player[myconnectindex].ps->gm & MODE_GAME))
|
|
{
|
|
CON_ERRPRINTF("not in a single-player game.\n");
|
|
continue;
|
|
}
|
|
osdcmd_cheatsinfo_stat.cheatnum = j;
|
|
}
|
|
continue;
|
|
|
|
case CON_SETGAMEPALETTE:
|
|
insptr++;
|
|
P_SetGamePalette(g_player[vm.g_p].ps, Gv_GetVarX(*(insptr++)), 2+16);
|
|
continue;
|
|
|
|
case CON_GETTEXTURECEILING:
|
|
insptr++;
|
|
aGameVars[g_iTextureID].val.lValue = sector[vm.g_sp->sectnum].ceilingpicnum;
|
|
continue;
|
|
|
|
case CON_IFVARVARAND:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j &= Gv_GetVarX(*insptr++);
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVAROR:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j |= Gv_GetVarX(*insptr++);
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVARXOR:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j ^= Gv_GetVarX(*insptr++);
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVAREITHER:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
int32_t l = Gv_GetVarX(*insptr++);
|
|
insptr--;
|
|
VM_CONDITIONAL(j || l);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVARN:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j = (j != Gv_GetVarX(*insptr++));
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVARE:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j = (j == Gv_GetVarX(*insptr++));
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVARG:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j = (j > Gv_GetVarX(*insptr++));
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARVARL:
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
j = (j < Gv_GetVarX(*insptr++));
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARE:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j == *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARN:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j != *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_WHILEVARN:
|
|
{
|
|
intptr_t *savedinsptr=insptr+2;
|
|
int32_t j;
|
|
do
|
|
{
|
|
insptr=savedinsptr;
|
|
j = (Gv_GetVarX(*(insptr-1)) != *insptr);
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
while (j);
|
|
continue;
|
|
}
|
|
|
|
case CON_WHILEVARVARN:
|
|
{
|
|
int32_t j;
|
|
intptr_t *savedinsptr=insptr+2;
|
|
do
|
|
{
|
|
insptr=savedinsptr;
|
|
j = Gv_GetVarX(*(insptr-1));
|
|
j = (j != Gv_GetVarX(*insptr++));
|
|
insptr--;
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
while (j);
|
|
continue;
|
|
}
|
|
|
|
case CON_IFVARAND:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j & *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVAROR:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j | *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARXOR:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j ^ *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVAREITHER:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j || *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARG:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j > *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFVARL:
|
|
insptr++;
|
|
{
|
|
int32_t j=Gv_GetVarX(*insptr++);
|
|
VM_CONDITIONAL(j < *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFPHEALTHL:
|
|
insptr++;
|
|
VM_CONDITIONAL(sprite[g_player[vm.g_p].ps->i].extra < *insptr);
|
|
continue;
|
|
|
|
case CON_IFPINVENTORY:
|
|
insptr++;
|
|
{
|
|
int32_t j = 0;
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
switch (*insptr++)
|
|
{
|
|
case GET_STEROIDS:
|
|
if (ps->inv_amount[GET_STEROIDS] != *insptr)
|
|
j = 1;
|
|
break;
|
|
case GET_SHIELD:
|
|
if (ps->inv_amount[GET_SHIELD] != ps->max_shield_amount)
|
|
j = 1;
|
|
break;
|
|
case GET_SCUBA:
|
|
if (ps->inv_amount[GET_SCUBA] != *insptr) j = 1;
|
|
break;
|
|
case GET_HOLODUKE:
|
|
if (ps->inv_amount[GET_HOLODUKE] != *insptr) j = 1;
|
|
break;
|
|
case GET_JETPACK:
|
|
if (ps->inv_amount[GET_JETPACK] != *insptr) j = 1;
|
|
break;
|
|
case GET_ACCESS:
|
|
switch (vm.g_sp->pal)
|
|
{
|
|
case 0:
|
|
if (ps->got_access&1) j = 1;
|
|
break;
|
|
case 21:
|
|
if (ps->got_access&2) j = 1;
|
|
break;
|
|
case 23:
|
|
if (ps->got_access&4) j = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case GET_HEATS:
|
|
if (ps->inv_amount[GET_HEATS] != *insptr) j = 1;
|
|
break;
|
|
case GET_FIRSTAID:
|
|
if (ps->inv_amount[GET_FIRSTAID] != *insptr) j = 1;
|
|
break;
|
|
case GET_BOOTS:
|
|
if (ps->inv_amount[GET_BOOTS] != *insptr) j = 1;
|
|
break;
|
|
default:
|
|
CON_ERRPRINTF("invalid inventory ID: %d\n", (int32_t)*(insptr-1));
|
|
}
|
|
|
|
VM_CONDITIONAL(j);
|
|
continue;
|
|
}
|
|
|
|
case CON_PSTOMP:
|
|
insptr++;
|
|
{
|
|
DukePlayer_t *const ps = g_player[vm.g_p].ps;
|
|
|
|
if (ps->knee_incs == 0 && sprite[ps->i].xrepeat >= 40)
|
|
if (cansee(vm.g_sp->x,vm.g_sp->y,vm.g_sp->z-(4<<8),vm.g_sp->sectnum,ps->pos.x,
|
|
ps->pos.y,ps->pos.z+(16<<8),sprite[ps->i].sectnum))
|
|
{
|
|
int32_t j = playerswhenstarted-1;
|
|
|
|
for (; j>=0; j--)
|
|
{
|
|
if (g_player[j].ps->actorsqu == vm.g_i)
|
|
break;
|
|
}
|
|
|
|
if (j == -1)
|
|
{
|
|
ps->knee_incs = 1;
|
|
if (ps->weapon_pos == 0)
|
|
ps->weapon_pos = -1;
|
|
ps->actorsqu = vm.g_i;
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
case CON_IFAWAYFROMWALL:
|
|
{
|
|
int16_t s1=vm.g_sp->sectnum;
|
|
int32_t j = 0;
|
|
|
|
updatesector(vm.g_sp->x+108,vm.g_sp->y+108,&s1);
|
|
if (s1 == vm.g_sp->sectnum)
|
|
{
|
|
updatesector(vm.g_sp->x-108,vm.g_sp->y-108,&s1);
|
|
if (s1 == vm.g_sp->sectnum)
|
|
{
|
|
updatesector(vm.g_sp->x+108,vm.g_sp->y-108,&s1);
|
|
if (s1 == vm.g_sp->sectnum)
|
|
{
|
|
updatesector(vm.g_sp->x-108,vm.g_sp->y+108,&s1);
|
|
if (s1 == vm.g_sp->sectnum)
|
|
j = 1;
|
|
}
|
|
}
|
|
}
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_QUOTE:
|
|
insptr++;
|
|
|
|
if ((unsigned)(*insptr) >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", (int32_t)(*insptr));
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[*insptr] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", (int32_t)*insptr);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
if ((unsigned)vm.g_p >= MAXPLAYERS)
|
|
{
|
|
CON_ERRPRINTF("bad player for quote %d: (%d)\n", (int32_t)*insptr,vm.g_p);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
P_DoQuote(*(insptr++)|MAXQUOTES,g_player[vm.g_p].ps);
|
|
continue;
|
|
|
|
case CON_USERQUOTE:
|
|
insptr++;
|
|
{
|
|
int32_t i=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)i >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", i);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", i);
|
|
continue;
|
|
}
|
|
G_AddUserQuote(ScriptQuotes[i]);
|
|
}
|
|
continue;
|
|
|
|
case CON_ECHO:
|
|
insptr++;
|
|
{
|
|
int32_t i=Gv_GetVarX(*insptr++);
|
|
|
|
if ((unsigned)i >= MAXQUOTES)
|
|
{
|
|
CON_ERRPRINTF("invalid quote ID %d\n", i);
|
|
insptr++;
|
|
continue;
|
|
}
|
|
|
|
if ((ScriptQuotes[i] == NULL))
|
|
{
|
|
CON_ERRPRINTF("null quote %d\n", i);
|
|
continue;
|
|
}
|
|
OSD_Printf("%s\n",ScriptQuotes[i]);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFINOUTERSPACE:
|
|
VM_CONDITIONAL(G_CheckForSpaceFloor(vm.g_sp->sectnum));
|
|
continue;
|
|
|
|
case CON_IFNOTMOVING:
|
|
VM_CONDITIONAL((actor[vm.g_i].movflag&49152) > 16384);
|
|
continue;
|
|
|
|
case CON_RESPAWNHITAG:
|
|
insptr++;
|
|
switch (DYNAMICTILEMAP(vm.g_sp->picnum))
|
|
{
|
|
case FEM1__STATIC:
|
|
case FEM2__STATIC:
|
|
case FEM3__STATIC:
|
|
case FEM4__STATIC:
|
|
case FEM5__STATIC:
|
|
case FEM6__STATIC:
|
|
case FEM7__STATIC:
|
|
case FEM8__STATIC:
|
|
case FEM9__STATIC:
|
|
case FEM10__STATIC:
|
|
case PODFEM1__STATIC:
|
|
case NAKED1__STATIC:
|
|
case STATUE__STATIC:
|
|
if (vm.g_sp->yvel)
|
|
G_OperateRespawns(vm.g_sp->yvel);
|
|
break;
|
|
default:
|
|
// if (vm.g_sp->hitag >= 0)
|
|
G_OperateRespawns(vm.g_sp->hitag);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case CON_IFSPRITEPAL:
|
|
insptr++;
|
|
VM_CONDITIONAL(vm.g_sp->pal == *insptr);
|
|
continue;
|
|
|
|
case CON_IFANGDIFFL:
|
|
insptr++;
|
|
{
|
|
int32_t j = klabs(G_GetAngleDelta(g_player[vm.g_p].ps->ang,vm.g_sp->ang));
|
|
VM_CONDITIONAL(j <= *insptr);
|
|
}
|
|
continue;
|
|
|
|
case CON_IFNOSOUNDS:
|
|
{
|
|
int32_t j = !A_CheckAnySoundPlaying(vm.g_i);
|
|
VM_CONDITIONAL(j);
|
|
}
|
|
continue;
|
|
|
|
case CON_SPRITEFLAGS:
|
|
insptr++;
|
|
actor[vm.g_i].flags = Gv_GetVarX(*insptr++);
|
|
continue;
|
|
|
|
case CON_GETTICKS:
|
|
insptr++;
|
|
Gv_SetVarX(*insptr++, getticks());
|
|
continue;
|
|
|
|
case CON_GETCURRADDRESS:
|
|
insptr++;
|
|
{
|
|
int32_t j=*insptr++;
|
|
Gv_SetVarX(j, (intptr_t)(insptr-script));
|
|
}
|
|
continue;
|
|
|
|
case CON_JUMP: // XXX XXX XXX
|
|
insptr++;
|
|
{
|
|
int32_t j = Gv_GetVarX(*insptr++);
|
|
insptr = (intptr_t *)(j+script);
|
|
}
|
|
continue;
|
|
|
|
default:
|
|
VM_ScriptInfo();
|
|
|
|
G_GameExit("An error has occurred in the EDuke32 virtual machine.\n\n"
|
|
"If you are an end user, please e-mail the file eduke32.log\n"
|
|
"along with links to any mods you're using to terminx@gmail.com.\n\n"
|
|
"If you are a mod developer, please attach all of your CON files\n"
|
|
"along with instructions on how to reproduce this error.\n\n"
|
|
"Thank you!");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NORECURSE
|
|
void A_LoadActor(int32_t iActor)
|
|
{
|
|
vm.g_i = iActor; // Sprite ID
|
|
vm.g_p = -1; // iPlayer; // Player ID
|
|
vm.g_x = -1; // lDist; // ?
|
|
vm.g_sp = &sprite[vm.g_i]; // Pointer to sprite structure
|
|
vm.g_t = &actor[vm.g_i].t_data[0]; // Sprite's 'extra' data
|
|
|
|
if (g_tile[vm.g_sp->picnum].loadPtr == NULL)
|
|
return;
|
|
|
|
vm.g_flags &= ~(VM_RETURN|VM_KILL|VM_NOEXECUTE);
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= MAXSECTORS)
|
|
{
|
|
// if(A_CheckEnemySprite(vm.g_sp))
|
|
// g_player[vm.g_p].ps->actors_killed++;
|
|
A_DeleteSprite(vm.g_i);
|
|
return;
|
|
}
|
|
|
|
insptr = g_tile[vm.g_sp->picnum].loadPtr;
|
|
VM_Execute(1);
|
|
insptr = NULL;
|
|
|
|
if (vm.g_flags & VM_KILL)
|
|
A_DeleteSprite(vm.g_i);
|
|
|
|
}
|
|
#endif
|
|
|
|
// NORECURSE
|
|
void A_Execute(int32_t iActor, int32_t iPlayer, int32_t lDist)
|
|
{
|
|
#ifdef LUNATIC
|
|
int32_t killit=0;
|
|
#else
|
|
intptr_t actionofs, *actionptr;
|
|
#endif
|
|
vmstate_t tempvm = { iActor, iPlayer, lDist, &actor[iActor].t_data[0],
|
|
&sprite[iActor], 0
|
|
};
|
|
|
|
/*
|
|
if (g_netClient && A_CheckSpriteFlags(iActor, SFLAG_NULL))
|
|
{
|
|
A_DeleteSprite(iActor);
|
|
return;
|
|
}
|
|
*/
|
|
|
|
if (g_netServer || g_netClient)
|
|
randomseed = ticrandomseed;
|
|
|
|
Bmemcpy(&vm, &tempvm, sizeof(vmstate_t));
|
|
|
|
if ((unsigned)vm.g_sp->sectnum >= MAXSECTORS)
|
|
{
|
|
if (A_CheckEnemySprite(vm.g_sp))
|
|
g_player[vm.g_p].ps->actors_killed++;
|
|
A_DeleteSprite(vm.g_i);
|
|
return;
|
|
}
|
|
|
|
/* Qbix: Changed variables to be aware of the sizeof *insptr
|
|
* (whether it is int32_t vs intptr_t), Although it is specifically cast to intptr_t*
|
|
* which might be corrected if the code is converted to use offsets */
|
|
/* Helixhorned: let's do away with intptr_t's... */
|
|
#if !defined LUNATIC
|
|
actionofs = AC_ACTION_ID(vm.g_t);
|
|
actionptr = (actionofs!=0 && actionofs+4u < (unsigned)g_scriptSize) ?
|
|
&script[actionofs] : NULL;
|
|
|
|
if (actionptr != NULL)
|
|
#endif
|
|
{
|
|
#if !defined LUNATIC
|
|
const int32_t action_frames = actionptr[1];
|
|
const int32_t action_incval = actionptr[3];
|
|
const int32_t action_delay = actionptr[4];
|
|
#else
|
|
const int32_t action_frames = actor[vm.g_i].ac.numframes;
|
|
const int32_t action_incval = actor[vm.g_i].ac.incval;
|
|
const int32_t action_delay = actor[vm.g_i].ac.delay;
|
|
#endif
|
|
uint16_t *actionticsptr = &AC_ACTIONTICS(vm.g_sp, &actor[vm.g_i]);
|
|
*actionticsptr += TICSPERFRAME;
|
|
|
|
if (*actionticsptr > action_delay)
|
|
{
|
|
AC_ACTION_COUNT(vm.g_t)++;
|
|
*actionticsptr = 0;
|
|
|
|
AC_CURFRAME(vm.g_t) += action_incval;
|
|
}
|
|
|
|
if (klabs(AC_CURFRAME(vm.g_t)) >= klabs(action_frames * action_incval))
|
|
AC_CURFRAME(vm.g_t) = 0;
|
|
}
|
|
|
|
#ifdef LUNATIC
|
|
{
|
|
const int32_t picnum = vm.g_sp->picnum;
|
|
|
|
if (L_IsInitialized(&g_ElState) && El_HaveActor(picnum))
|
|
{
|
|
double t = gethiticks();
|
|
|
|
killit = (El_CallActor(&g_ElState, picnum, iActor, iPlayer, lDist)==1);
|
|
|
|
t = gethiticks()-t;
|
|
g_actorTotalMs[picnum] += t;
|
|
g_actorMinMs[picnum] = min(g_actorMinMs[picnum], t);
|
|
g_actorMaxMs[picnum] = max(g_actorMaxMs[picnum], t);
|
|
g_actorCalls[picnum]++;
|
|
}
|
|
}
|
|
#else
|
|
insptr = 4 + (g_tile[vm.g_sp->picnum].execPtr);
|
|
VM_Execute(1);
|
|
insptr = NULL;
|
|
#endif
|
|
|
|
#ifdef LUNATIC
|
|
if (killit)
|
|
#else
|
|
if (vm.g_flags & VM_KILL)
|
|
#endif
|
|
{
|
|
VM_KillIt(iActor, iPlayer);
|
|
return;
|
|
}
|
|
|
|
VM_Move();
|
|
|
|
if (vm.g_sp->statnum == STAT_STANDABLE)
|
|
switch (DYNAMICTILEMAP(vm.g_sp->picnum))
|
|
{
|
|
case RUBBERCAN__STATIC:
|
|
case EXPLODINGBARREL__STATIC:
|
|
case WOODENHORSE__STATIC:
|
|
case HORSEONSIDE__STATIC:
|
|
case CANWITHSOMETHING__STATIC:
|
|
case FIREBARREL__STATIC:
|
|
case NUKEBARREL__STATIC:
|
|
case NUKEBARRELDENTED__STATIC:
|
|
case NUKEBARRELLEAKED__STATIC:
|
|
case TRIPBOMB__STATIC:
|
|
case EGG__STATIC:
|
|
if (actor[vm.g_i].timetosleep > 1)
|
|
actor[vm.g_i].timetosleep--;
|
|
else if (actor[vm.g_i].timetosleep == 1)
|
|
changespritestat(vm.g_i,STAT_ZOMBIEACTOR);
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if (vm.g_sp->statnum != STAT_ACTOR)
|
|
return;
|
|
|
|
if (A_CheckEnemySprite(vm.g_sp))
|
|
{
|
|
if (vm.g_sp->xrepeat > 60) return;
|
|
if (ud.respawn_monsters == 1 && vm.g_sp->extra <= 0) return;
|
|
}
|
|
else if (ud.respawn_items == 1 && (vm.g_sp->cstat&32768)) return;
|
|
|
|
if (A_CheckSpriteFlags(vm.g_i, SFLAG_USEACTIVATOR) && sector[vm.g_sp->sectnum].lotag & 16384)
|
|
changespritestat(vm.g_i, STAT_ZOMBIEACTOR);
|
|
else if (actor[vm.g_i].timetosleep > 1)
|
|
actor[vm.g_i].timetosleep--;
|
|
else if (actor[vm.g_i].timetosleep == 1)
|
|
changespritestat(vm.g_i, STAT_ZOMBIEACTOR);
|
|
}
|
|
|
|
void G_SaveMapState(void)
|
|
{
|
|
int32_t levelnum = ud.volume_number*MAXLEVELS+ud.level_number;
|
|
map_t *mapinfo = &MapInfo[levelnum];
|
|
mapstate_t *save;
|
|
|
|
if (mapinfo->savedstate == NULL)
|
|
mapinfo->savedstate = (mapstate_t *)Xcalloc(1,sizeof(mapstate_t));
|
|
save = mapinfo->savedstate;
|
|
|
|
if (save != NULL)
|
|
{
|
|
#if !defined LUNATIC
|
|
int32_t i;
|
|
#endif
|
|
Bmemcpy(&save->numwalls,&numwalls,sizeof(numwalls));
|
|
Bmemcpy(&save->wall[0],&wall[0],sizeof(walltype)*MAXWALLS);
|
|
Bmemcpy(&save->numsectors,&numsectors,sizeof(numsectors));
|
|
Bmemcpy(&save->sector[0],§or[0],sizeof(sectortype)*MAXSECTORS);
|
|
Bmemcpy(&save->sprite[0],&sprite[0],sizeof(spritetype)*MAXSPRITES);
|
|
|
|
// If we're in EVENT_ANIMATESPRITES, we'll be saving pointer values to disk :-/
|
|
#if !defined LUNATIC
|
|
if (g_currentEventExec == EVENT_ANIMATESPRITES)
|
|
initprintf("Line %d: savemapstate called from EVENT_ANIMATESPRITES. WHY?\n", g_errorLineNum);
|
|
#endif
|
|
Bmemcpy(&save->spriteext[0],&spriteext[0],sizeof(spriteext_t)*MAXSPRITES);
|
|
|
|
save->numsprites = Numsprites;
|
|
save->tailspritefree = tailspritefree;
|
|
Bmemcpy(&save->headspritesect[0],&headspritesect[0],sizeof(headspritesect));
|
|
Bmemcpy(&save->prevspritesect[0],&prevspritesect[0],sizeof(prevspritesect));
|
|
Bmemcpy(&save->nextspritesect[0],&nextspritesect[0],sizeof(nextspritesect));
|
|
Bmemcpy(&save->headspritestat[0],&headspritestat[0],sizeof(headspritestat));
|
|
Bmemcpy(&save->prevspritestat[0],&prevspritestat[0],sizeof(prevspritestat));
|
|
Bmemcpy(&save->nextspritestat[0],&nextspritestat[0],sizeof(nextspritestat));
|
|
#ifdef YAX_ENABLE
|
|
Bmemcpy(&save->numyaxbunches, &numyaxbunches, sizeof(numyaxbunches));
|
|
# if !defined NEW_MAP_FORMAT
|
|
Bmemcpy(save->yax_bunchnum, yax_bunchnum, sizeof(yax_bunchnum));
|
|
Bmemcpy(save->yax_nextwall, yax_nextwall, sizeof(yax_nextwall));
|
|
# endif
|
|
#endif
|
|
Bmemcpy(&save->actor[0],&actor[0],sizeof(actor_t)*MAXSPRITES);
|
|
|
|
Bmemcpy(&save->g_numCyclers,&g_numCyclers,sizeof(g_numCyclers));
|
|
Bmemcpy(&save->cyclers[0],&cyclers[0],sizeof(cyclers));
|
|
Bmemcpy(&save->g_playerSpawnPoints[0],&g_playerSpawnPoints[0],sizeof(g_playerSpawnPoints));
|
|
Bmemcpy(&save->g_numAnimWalls,&g_numAnimWalls,sizeof(g_numAnimWalls));
|
|
Bmemcpy(&save->SpriteDeletionQueue[0],&SpriteDeletionQueue[0],sizeof(SpriteDeletionQueue));
|
|
Bmemcpy(&save->g_spriteDeleteQueuePos,&g_spriteDeleteQueuePos,sizeof(g_spriteDeleteQueuePos));
|
|
Bmemcpy(&save->animwall[0],&animwall[0],sizeof(animwall));
|
|
Bmemcpy(&save->msx[0],&msx[0],sizeof(msx));
|
|
Bmemcpy(&save->msy[0],&msy[0],sizeof(msy));
|
|
Bmemcpy(&save->g_mirrorWall[0],&g_mirrorWall[0],sizeof(g_mirrorWall));
|
|
Bmemcpy(&save->g_mirrorSector[0],&g_mirrorSector[0],sizeof(g_mirrorSector));
|
|
Bmemcpy(&save->g_mirrorCount,&g_mirrorCount,sizeof(g_mirrorCount));
|
|
Bmemcpy(&save->show2dsector[0],&show2dsector[0],sizeof(show2dsector));
|
|
Bmemcpy(&save->g_numClouds,&g_numClouds,sizeof(g_numClouds));
|
|
Bmemcpy(&save->clouds[0],&clouds[0],sizeof(clouds));
|
|
Bmemcpy(&save->cloudx[0],&cloudx[0],sizeof(cloudx));
|
|
Bmemcpy(&save->cloudy[0],&cloudy[0],sizeof(cloudy));
|
|
Bmemcpy(&save->pskyidx,&g_pskyidx,sizeof(g_pskyidx));
|
|
Bmemcpy(&save->animategoal[0],&animategoal[0],sizeof(animategoal));
|
|
Bmemcpy(&save->animatevel[0],&animatevel[0],sizeof(animatevel));
|
|
Bmemcpy(&save->g_animateCount,&g_animateCount,sizeof(g_animateCount));
|
|
Bmemcpy(&save->animatesect[0],&animatesect[0],sizeof(animatesect));
|
|
|
|
G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_FWD);
|
|
Bmemcpy(&save->animateptr[0],&animateptr[0],sizeof(animateptr));
|
|
G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_BACK);
|
|
|
|
{
|
|
EDUKE32_STATIC_ASSERT(sizeof(save->animateptr) == sizeof(animateptr));
|
|
}
|
|
|
|
Bmemcpy(&save->g_numPlayerSprites,&g_numPlayerSprites,sizeof(g_numPlayerSprites));
|
|
Bmemcpy(&save->g_earthquakeTime,&g_earthquakeTime,sizeof(g_earthquakeTime));
|
|
Bmemcpy(&save->lockclock,&lockclock,sizeof(lockclock));
|
|
Bmemcpy(&save->randomseed,&randomseed,sizeof(randomseed));
|
|
Bmemcpy(&save->g_globalRandom,&g_globalRandom,sizeof(g_globalRandom));
|
|
#if !defined LUNATIC
|
|
for (i=g_gameVarCount-1; i>=0; i--)
|
|
{
|
|
if (aGameVars[i].dwFlags & GAMEVAR_NORESET) continue;
|
|
if (aGameVars[i].dwFlags & GAMEVAR_PERPLAYER)
|
|
{
|
|
if (!save->vars[i])
|
|
save->vars[i] = (intptr_t *)Xcalloc(MAXPLAYERS,sizeof(intptr_t));
|
|
Bmemcpy(&save->vars[i][0],&aGameVars[i].val.plValues[0],sizeof(intptr_t) * MAXPLAYERS);
|
|
}
|
|
else if (aGameVars[i].dwFlags & GAMEVAR_PERACTOR)
|
|
{
|
|
if (!save->vars[i])
|
|
save->vars[i] = (intptr_t *)Xcalloc(MAXSPRITES,sizeof(intptr_t));
|
|
Bmemcpy(&save->vars[i][0],&aGameVars[i].val.plValues[0],sizeof(intptr_t) * MAXSPRITES);
|
|
}
|
|
else save->vars[i] = (intptr_t *)aGameVars[i].val.lValue;
|
|
}
|
|
#else
|
|
{
|
|
int32_t slen;
|
|
const char *svcode = El_SerializeGamevars(&slen, levelnum);
|
|
|
|
if (slen < 0)
|
|
{
|
|
El_OnError("ERROR: savemapstate: serialization failed!");
|
|
}
|
|
else
|
|
{
|
|
char *savecode = Xstrdup(svcode);
|
|
Bfree(save->savecode);
|
|
save->savecode = savecode;
|
|
}
|
|
}
|
|
#endif
|
|
ototalclock = totalclock;
|
|
}
|
|
}
|
|
|
|
void G_RestoreMapState(void)
|
|
{
|
|
int32_t levelnum = ud.volume_number*MAXLEVELS+ud.level_number;
|
|
mapstate_t *save = MapInfo[levelnum].savedstate;
|
|
|
|
if (save != NULL)
|
|
{
|
|
int32_t i, x;
|
|
char phealth[MAXPLAYERS];
|
|
|
|
for (i=0; i<playerswhenstarted; i++)
|
|
phealth[i] = sprite[g_player[i].ps->i].extra;
|
|
|
|
pub = NUMPAGES;
|
|
pus = NUMPAGES;
|
|
G_UpdateScreenArea();
|
|
|
|
Bmemcpy(&numwalls,&save->numwalls,sizeof(numwalls));
|
|
Bmemcpy(&wall[0],&save->wall[0],sizeof(walltype)*MAXWALLS);
|
|
Bmemcpy(&numsectors,&save->numsectors,sizeof(numsectors));
|
|
Bmemcpy(§or[0],&save->sector[0],sizeof(sectortype)*MAXSECTORS);
|
|
Bmemcpy(&sprite[0],&save->sprite[0],sizeof(spritetype)*MAXSPRITES);
|
|
Bmemcpy(&spriteext[0],&save->spriteext[0],sizeof(spriteext_t)*MAXSPRITES);
|
|
|
|
// If we're restoring from EVENT_ANIMATESPRITES, all spriteext[].tspr
|
|
// will be overwritten, so NULL them.
|
|
#if !defined LUNATIC
|
|
if (g_currentEventExec == EVENT_ANIMATESPRITES)
|
|
{
|
|
initprintf("Line %d: loadmapstate called from EVENT_ANIMATESPRITES. WHY?\n",g_errorLineNum);
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
spriteext[i].tspr = NULL;
|
|
}
|
|
#endif
|
|
Numsprites = save->numsprites;
|
|
tailspritefree = save->tailspritefree;
|
|
Bmemcpy(&headspritesect[0],&save->headspritesect[0],sizeof(headspritesect));
|
|
Bmemcpy(&prevspritesect[0],&save->prevspritesect[0],sizeof(prevspritesect));
|
|
Bmemcpy(&nextspritesect[0],&save->nextspritesect[0],sizeof(nextspritesect));
|
|
Bmemcpy(&headspritestat[0],&save->headspritestat[0],sizeof(headspritestat));
|
|
Bmemcpy(&prevspritestat[0],&save->prevspritestat[0],sizeof(prevspritestat));
|
|
Bmemcpy(&nextspritestat[0],&save->nextspritestat[0],sizeof(nextspritestat));
|
|
#ifdef YAX_ENABLE
|
|
Bmemcpy(&numyaxbunches, &save->numyaxbunches, sizeof(numyaxbunches));
|
|
# if !defined NEW_MAP_FORMAT
|
|
Bmemcpy(yax_bunchnum, save->yax_bunchnum, sizeof(yax_bunchnum));
|
|
Bmemcpy(yax_nextwall, save->yax_nextwall, sizeof(yax_nextwall));
|
|
# endif
|
|
#endif
|
|
Bmemcpy(&actor[0],&save->actor[0],sizeof(actor_t)*MAXSPRITES);
|
|
|
|
Bmemcpy(&g_numCyclers,&save->g_numCyclers,sizeof(g_numCyclers));
|
|
Bmemcpy(&cyclers[0],&save->cyclers[0],sizeof(cyclers));
|
|
Bmemcpy(&g_playerSpawnPoints[0],&save->g_playerSpawnPoints[0],sizeof(g_playerSpawnPoints));
|
|
Bmemcpy(&g_numAnimWalls,&save->g_numAnimWalls,sizeof(g_numAnimWalls));
|
|
Bmemcpy(&SpriteDeletionQueue[0],&save->SpriteDeletionQueue[0],sizeof(SpriteDeletionQueue));
|
|
Bmemcpy(&g_spriteDeleteQueuePos,&save->g_spriteDeleteQueuePos,sizeof(g_spriteDeleteQueuePos));
|
|
Bmemcpy(&animwall[0],&save->animwall[0],sizeof(animwall));
|
|
Bmemcpy(&msx[0],&save->msx[0],sizeof(msx));
|
|
Bmemcpy(&msy[0],&save->msy[0],sizeof(msy));
|
|
Bmemcpy(&g_mirrorWall[0],&save->g_mirrorWall[0],sizeof(g_mirrorWall));
|
|
Bmemcpy(&g_mirrorSector[0],&save->g_mirrorSector[0],sizeof(g_mirrorSector));
|
|
Bmemcpy(&g_mirrorCount,&save->g_mirrorCount,sizeof(g_mirrorCount));
|
|
Bmemcpy(&show2dsector[0],&save->show2dsector[0],sizeof(show2dsector));
|
|
Bmemcpy(&g_numClouds,&save->g_numClouds,sizeof(g_numClouds));
|
|
Bmemcpy(&clouds[0],&save->clouds[0],sizeof(clouds));
|
|
Bmemcpy(&cloudx[0],&save->cloudx[0],sizeof(cloudx));
|
|
Bmemcpy(&cloudy[0],&save->cloudy[0],sizeof(cloudy));
|
|
Bmemcpy(&g_pskyidx,&save->pskyidx,sizeof(g_pskyidx));
|
|
Bmemcpy(&animategoal[0],&save->animategoal[0],sizeof(animategoal));
|
|
Bmemcpy(&animatevel[0],&save->animatevel[0],sizeof(animatevel));
|
|
Bmemcpy(&g_animateCount,&save->g_animateCount,sizeof(g_animateCount));
|
|
Bmemcpy(&animatesect[0],&save->animatesect[0],sizeof(animatesect));
|
|
|
|
Bmemcpy(&animateptr[0],&save->animateptr[0],sizeof(animateptr));
|
|
G_Util_PtrToIdx(animateptr, g_animateCount, sector, P2I_BACK);
|
|
|
|
Bmemcpy(&g_numPlayerSprites,&save->g_numPlayerSprites,sizeof(g_numPlayerSprites));
|
|
Bmemcpy(&g_earthquakeTime,&save->g_earthquakeTime,sizeof(g_earthquakeTime));
|
|
Bmemcpy(&lockclock,&save->lockclock,sizeof(lockclock));
|
|
Bmemcpy(&randomseed,&save->randomseed,sizeof(randomseed));
|
|
Bmemcpy(&g_globalRandom,&save->g_globalRandom,sizeof(g_globalRandom));
|
|
#if !defined LUNATIC
|
|
for (i=g_gameVarCount-1; i>=0; i--)
|
|
{
|
|
if (aGameVars[i].dwFlags & GAMEVAR_NORESET) continue;
|
|
if (aGameVars[i].dwFlags & GAMEVAR_PERPLAYER)
|
|
{
|
|
if (!save->vars[i]) continue;
|
|
Bmemcpy(&aGameVars[i].val.plValues[0],&save->vars[i][0],sizeof(intptr_t) * MAXPLAYERS);
|
|
}
|
|
else if (aGameVars[i].dwFlags & GAMEVAR_PERACTOR)
|
|
{
|
|
if (!save->vars[i]) continue;
|
|
Bmemcpy(&aGameVars[i].val.plValues[0],&save->vars[i][0],sizeof(intptr_t) * MAXSPRITES);
|
|
}
|
|
else aGameVars[i].val.lValue = (intptr_t)save->vars[i];
|
|
}
|
|
|
|
Gv_RefreshPointers();
|
|
#else
|
|
if (save->savecode)
|
|
{
|
|
El_RestoreGamevars(save->savecode);
|
|
}
|
|
#endif
|
|
// Update g_player[].ps->i (sprite indices of players) to be consistent
|
|
// with just loaded sprites.
|
|
// Otherwise, crashes may ensue: e.g. WGR2 SVN r391, map spiderden:
|
|
// - walk forward (to door leading to other level "Shadowpine Forest")
|
|
// - in new level, walk backward to get back to the Spider Den
|
|
// - walk backward to the door leading to Shadowpine Forest --> crash.
|
|
for (SPRITES_OF(STAT_PLAYER, i))
|
|
{
|
|
int32_t snum = P_Get(i);
|
|
Bassert((unsigned)snum < MAXPLAYERS);
|
|
g_player[snum].ps->i = i;
|
|
}
|
|
|
|
for (i=0; i<playerswhenstarted; i++)
|
|
sprite[g_player[i].ps->i].extra = phealth[i];
|
|
|
|
if (g_player[myconnectindex].ps->over_shoulder_on != 0)
|
|
{
|
|
CAMERADIST = 0;
|
|
CAMERACLOCK = 0;
|
|
g_player[myconnectindex].ps->over_shoulder_on = 1;
|
|
}
|
|
|
|
screenpeek = myconnectindex;
|
|
|
|
if (ud.lockout)
|
|
{
|
|
for (x=g_numAnimWalls-1; x>=0; x--)
|
|
switch (DYNAMICTILEMAP(wall[animwall[x].wallnum].picnum))
|
|
{
|
|
case FEMPIC1__STATIC:
|
|
wall[animwall[x].wallnum].picnum = BLANKSCREEN;
|
|
break;
|
|
case FEMPIC2__STATIC:
|
|
case FEMPIC3__STATIC:
|
|
wall[animwall[x].wallnum].picnum = SCREENBREAK6;
|
|
break;
|
|
}
|
|
}
|
|
#if 0
|
|
else
|
|
{
|
|
for (x=g_numAnimWalls-1; x>=0; x--)
|
|
if (wall[animwall[x].wallnum].extra >= 0)
|
|
wall[animwall[x].wallnum].picnum = wall[animwall[x].wallnum].extra;
|
|
}
|
|
#endif
|
|
#ifdef YAX_ENABLE
|
|
sv_postyaxload();
|
|
#endif
|
|
G_ResetInterpolations();
|
|
|
|
Net_ResetPrediction();
|
|
|
|
G_ClearFIFO();
|
|
G_ResetTimers(0);
|
|
}
|
|
}
|
|
|
|
#ifdef LUNATIC
|
|
void VM_FallSprite(int32_t i)
|
|
{
|
|
VM_Fall(i, &sprite[i]);
|
|
}
|
|
|
|
int32_t VM_ResetPlayer2(int32_t snum)
|
|
{
|
|
return VM_ResetPlayer(snum, 0);
|
|
}
|
|
|
|
int32_t VM_CheckSquished2(int32_t i, int32_t snum)
|
|
{
|
|
vm.g_i = i;
|
|
vm.g_sp = &sprite[i];
|
|
vm.g_p = snum;
|
|
|
|
return VM_CheckSquished();
|
|
}
|
|
#endif
|