zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2024-12-02 00:53:16 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/source/games/duke/src/gameexec.cpp

3894 lines
93 KiB
C++
Raw Normal View History

- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2000, 2003 - Matt Saettler (EDuke Enhancements)
Copyright (C) 2020 - Christoph Oelckers
This file is part of Enhanced Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
EDuke enhancements integrated: 04/13/2003 - Matt Saettler
Note: EDuke source was in transition. Changes are in-progress in the
source as it is released.
*/
//-------------------------------------------------------------------------
#include "ns.h"
- safety commit
2020-05-14 07:07:07 +00:00
#include "concmd.h"
- removed duplicate header.
2020-06-23 20:01:58 +00:00
#include "duke3d.h"
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
#include "gamevar.h"
- another safety commit.
2020-07-07 15:56:20 +00:00
#include "mapinfo.h"
- WIP level transition refactored to a game independent event system.
2020-09-03 21:10:28 +00:00
#include "gamestate.h"
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
#include "conlabel.h"
#include "automap.h"
- made player.actorsqu a pointer and added the needed infrastructure for that.
2020-10-17 08:30:11 +00:00
#include "dukeactor.h"
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
BEGIN_DUKE_NS
- more header cleanup.
2020-07-06 14:24:22 +00:00
// Player Actions - used by ifp instruction.
enum playeraction_t {
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
pstanding = 0x00000001,
pwalking = 0x00000002,
prunning = 0x00000004,
pducking = 0x00000008,
pfalling = 0x00000010,
pjumping = 0x00000020,
phigher = 0x00000040,
pwalkingback = 0x00000080,
prunningback = 0x00000100,
pkicking = 0x00000200,
pshrunk = 0x00000400,
pjetpack = 0x00000800,
ponsteroids = 0x00001000,
ponground = 0x00002000,
palive = 0x00004000,
pdead = 0x00008000,
pfacing = 0x00010000
- more header cleanup.
2020-07-06 14:24:22 +00:00
};
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
struct ParseState
{
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
int g_p;
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
int g_x;
int* g_t;
uint8_t killit_flag;
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
DDukeActor *g_ac;
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
int* insptr;
- parse - part 3.
2020-10-23 18:18:38 +00:00
Collision coll;
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
int parse(void);
void parseifelse(int condition);
};
- dodge, furthestcanseepoint, furthestangle.
2020-10-21 23:12:16 +00:00
int furthestcanseepoint(DDukeActor* i, DDukeActor* ts, int* dax, int* day);
- ifsquished.
2020-10-22 17:12:48 +00:00
bool ifsquished(DDukeActor* i, int p);
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
void fakebubbaspawn(DDukeActor* actor, int g_p);
- the rest of Duke’s sectnum, except RR's geo hack
2021-11-21 08:08:05 +00:00
void tearitup(sectortype* sect);
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
void destroyit(DDukeActor* actor);
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
void mamaspawn(DDukeActor* actor);
- Blood/Duke/RR/SW: Unify the player's horizon function. * For Duke/SW, we continually apply `SB_CENTERVIEW` only if it was previously a toggled action, similar to Blood. * For SW, we remove two SW-specific bits (`PF_LOCK_HORIZ` and `PF_LOOKING`) that are no longer needed. * For Duke, we remove `return_to_center` and just use the `SB_CENTERVIEW` action bit as required. * For `sethorizon()`, feature set and adjustment speeds are an averaged out accumulation across Duke/SW: ** GameTicRate is factored in for adjustment decisions to provide consistency for SW being the faster game. ** Adjustment amounts are half way between Duke/SW.
2020-09-20 10:01:05 +00:00
void forceplayerangle(int snum);
- safety commit
2020-05-14 07:07:07 +00:00
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
bool killthesprite = false;
- fall command, also some safety work for npt deleting sprites prematurely.
2020-05-14 21:25:53 +00:00
void addspritetodelete(int spnum)
{
- got rid of the old interpreter code.
2020-05-15 06:04:30 +00:00
killthesprite = true;
- fall command, also some safety work for npt deleting sprites prematurely.
2020-05-14 21:25:53 +00:00
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
sectortype* toSect(int index)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
return validSectorIndex(index) ? &sector[index] : nullptr;
}
int fromSect(sectortype* sect)
{
return sect ? sectnum(sect) : -1;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
walltype* toWall(int index)
{
return validWallIndex(index) ? &wall[index] : nullptr;
}
int fromWall(walltype* sect)
{
return sect ? wallnum(sect) : -1;
}
static void DoUserDef(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, int sPlayer, int lParm2)
{
auto vValue = GetGameVarID(lVar2, sActor, sPlayer);
auto lValue = vValue.safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// most settings have been removed because they are either pointless, no longer existent or simply too dangerous to access.
// Others have been made read-only.
switch (lLabelID)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_GOD: // redid this so that the script won't be able to disable user-set god mode.
if (bSet) ud.god = (ud.god & ~2) | (lValue? 2:0);
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, !!ud.god, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_CASHMAN:
if (bSet) ud.cashman = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.cashman, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_EOG:
if (bSet) ud.eog = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.eog, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_SHOWALLMAP:
if (bSet) gFullMap = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, gFullMap, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_SHOWWEAPONS:
- route the shared control CCMDs through the game interface instead of registering local variants for each game.
2020-11-29 11:23:31 +00:00
// Read-only user state.
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, cl_showweapon, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_CAMERASPRITE:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ud.cameraactor = vValue.safeActor();
else SetGameVarID(lVar2, ud.cameraactor, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- another safety commit. # Conflicts: # source/games/duke/src/zz_actors.cpp
2020-05-14 10:52:59 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_LAST_CAMSPRITE:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, -1, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_LAST_LEVEL:
if (bSet) ud.last_level = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.last_level, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_SECRETLEVEL:
if (bSet) ud.secretlevel = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.secretlevel, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_CONST_VISIBILITY:
if (bSet) ud.const_visibility = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.const_visibility, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_SHADOWS:
if (bSet) ud.shadows = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.shadows, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case USERDEFS_M_COOP:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ud.m_coop, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_COOP:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ud.coop, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_RESPAWN_MONSTERS:
if (bSet) ud.respawn_monsters = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.respawn_monsters, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_RESPAWN_ITEMS:
if (bSet) ud.respawn_items = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.respawn_items, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_RESPAWN_INVENTORY:
if (bSet) ud.respawn_inventory = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.respawn_inventory, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_RECSTAT:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ud.recstat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_MONSTERS_OFF:
if (bSet) ud.monsters_off = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.monsters_off, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_BRIGHTNESS:
if (bSet) ud.brightness = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.brightness, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_M_RESPAWN_ITEMS:
if (bSet) ud.m_respawn_items = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.m_respawn_items, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_M_RESPAWN_MONSTERS:
if (bSet) ud.m_respawn_monsters = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.m_respawn_monsters, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_M_RESPAWN_INVENTORY:
if (bSet) ud.m_respawn_inventory = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.m_respawn_inventory, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_M_MONSTERS_OFF:
if (bSet) ud.m_monsters_off = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.m_monsters_off, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_M_FFIRE:
if (bSet) ud.m_ffire = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.m_ffire, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_FFIRE:
if (bSet) ud.ffire = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.ffire, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_MULTIMODE:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ud.multimode, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_PLAYER_SKILL:
if (bSet) ud.player_skill = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.player_skill, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case USERDEFS_MARKER:
if (bSet) ud.marker = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ud.marker, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
default:
// This will also catch all deleted cases.
// make sure that the return value is always defined.
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
return;
}
///////////////////////////////////////////
- CON game access interface done.
2020-10-23 17:07:33 +00:00
void DoPlayer(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, int sPlayer, int lParm2)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto vValue = GetGameVarID(lVar2, sActor, sPlayer);
auto lValue = vValue.safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int iPlayer;
int lTemp;
if (lVar1 == g_iThisActorID)
- safety commit
2020-05-14 07:07:07 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// if they've asked for 'this', then use 'this player'...
iPlayer = sPlayer;
- safety commit
2020-05-14 07:07:07 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
else
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
iPlayer = GetGameVarID(lVar1, sActor, sPlayer).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
if (iPlayer < 0 || iPlayer >= MAXPLAYERS)
return;
switch (lLabelID)
{
case PLAYER_ZOOM:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
SetGameVarID(lVar2, 768, sActor, sPlayer); //return default for AM zoom.
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_EXITX:
if (bSet) ps[iPlayer].exitx = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].exitx, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_EXITY:
if (bSet) ps[iPlayer].exity = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].exity, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LOOGIEX:
if (bSet) ps[iPlayer].loogiex[lParm2] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].loogiex[lParm2], sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LOOGIEY:
- cleanup and minor fixes.
2020-09-22 21:07:11 +00:00
if (bSet) ps[iPlayer].loogiey[lParm2] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].loogiey[lParm2], sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_NUMLOOGS:
if (bSet) ps[iPlayer].numloogs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].numloogs, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LOOGCNT:
if (bSet) ps[iPlayer].loogcnt = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].loogcnt, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSX: // oh, my... :( Writing to these has been disabled until I know how to do it without the engine shitting all over itself.
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].pos.x, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSY:
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].pos.y, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSZ:
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].pos.z, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HORIZ:
- Duke: `DoPlayer()`: Ensure `SB_CENTERVIEW` bit is cleared when setting a horiz target from CON. * Repairs horizon issues raised in https://forum.zdoom.org/viewtopic.php?f=340&p=1185365.
2021-03-31 08:48:38 +00:00
if (bSet)
{
if (ps[iPlayer].sync.actions & SB_CENTERVIEW)
{
ps[iPlayer].sync.actions &= ~SB_CENTERVIEW;
}
ps[iPlayer].horizon.settarget(lValue);
}
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].horizon.horiz.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OHORIZ:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].horizon.ohoriz.asbuild(), sActor, sPlayer);
- gamecontrol: Initial setup of `PlayerHorizon` struct and deployment within Duke. * Started with the most complicated game first. * Struct made up of fixedhoriz class units. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 06:12:37 +00:00
break;
case PLAYER_HORIZOFF:
if (bSet) ps[iPlayer].horizon.horizoff = buildhoriz(lValue);
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].horizon.horizoff.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OHORIZOFF:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].horizon.ohorizoff.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_INVDISPTIME:
if (bSet) ps[iPlayer].invdisptime = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].invdisptime, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_BOBPOSX:
if (bSet) ps[iPlayer].bobposx = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].bobposx, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_BOBPOSY:
if (bSet) ps[iPlayer].bobposy = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].bobposy, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPOSX:
if (bSet) ps[iPlayer].oposx = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].oposx, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPOSY:
if (bSet) ps[iPlayer].oposy = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].oposy, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPOSZ:
if (bSet) ps[iPlayer].oposz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].oposz, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_PYOFF:
if (bSet) ps[iPlayer].pyoff = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].pyoff, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPYOFF:
if (bSet) ps[iPlayer].opyoff = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].opyoff, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSXV:
if (bSet) ps[iPlayer].posxv = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].posxv, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSYV:
if (bSet) ps[iPlayer].posyv = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].posyv, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_POSZV:
if (bSet) ps[iPlayer].poszv = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].poszv, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LAST_PISSED_TIME:
if (bSet) ps[iPlayer].last_pissed_time = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].last_pissed_time, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TRUEFZ:
if (bSet) ps[iPlayer].truefz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].truefz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TRUECZ:
if (bSet) ps[iPlayer].truecz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].truecz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_PLAYER_PAR:
if (bSet) ps[iPlayer].player_par = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].player_par, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_VISIBILITY:
if (bSet) ps[iPlayer].visibility = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].visibility, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_BOBCOUNTER:
if (bSet) ps[iPlayer].bobcounter = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].bobcounter, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WEAPON_SWAY:
- Duke: Ensure all weapon variables used for interpolation have the `o` values set when CON updates them. * Hasn't been an issue to date but could become one should a mod set these. * Can't simply back the variable up and set the main one because unless the mod knows we're interpolating, it could have undesirable effects.
2021-12-10 06:31:51 +00:00
if (bSet) ps[iPlayer].oweapon_sway = ps[iPlayer].weapon_sway = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].weapon_sway, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_PALS_TIME:
if (bSet) ps[iPlayer].pals.a = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].pals.a, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_RANDOMFLAMEX:
if (bSet) ps[iPlayer].randomflamex = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].randomflamex, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_CRACK_TIME:
if (bSet) ps[iPlayer].crack_time = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].crack_time, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_AIM_MODE: // game has no business enforcing this in any way.
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].aim_mode, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ANG:
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
if (bSet) ps[iPlayer].angle.settarget(lValue);
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.ang.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OANG:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].angle.oang.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ANGVEL: // This no longer exists.
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
case PLAYER_CURSECTNUM:
if (bSet) ps[iPlayer].cursector = toSect(lValue);
else SetGameVarID(lVar2, fromSect(ps[iPlayer].cursector), sActor, sPlayer);
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LOOK_ANG:
- binaryangle.h: Remove `lookangle` class and replace use with `binangle`. * Added in fca846272eb3795ddd3dd51ed48e494382c0a389 to deal with signed adjustments but its just not needed. * Made better use of `binangle`/`fixedhoriz` class getters and setters than before as well.
2021-04-11 05:43:11 +00:00
if (bSet) ps[iPlayer].angle.look_ang = buildang(lValue);
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.look_ang.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LAST_EXTRA:
if (bSet) ps[iPlayer].last_extra = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].last_extra, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SUBWEAPON:
if (bSet) ps[iPlayer].subweapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].subweapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_AMMO_AMOUNT:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lTemp = GetGameVarID(lParm2, sActor, sPlayer).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (bSet) ps[iPlayer].ammo_amount[lTemp] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].ammo_amount[lTemp], sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WACKEDBYACTOR:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].wackedbyactor = vValue.safeActor();
else SetGameVarID(lVar2, ps[iPlayer].wackedbyactor, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FRAG:
if (bSet) ps[iPlayer].frag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].frag, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FRAGGEDSELF:
if (bSet) ps[iPlayer].fraggedself = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].fraggedself, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_CURR_WEAPON:
if (bSet) ps[iPlayer].curr_weapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].curr_weapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LAST_WEAPON:
if (bSet) ps[iPlayer].last_weapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].last_weapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TIPINCS:
if (bSet) ps[iPlayer].tipincs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].tipincs, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WANTWEAPONFIRE:
if (bSet) ps[iPlayer].wantweaponfire = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].wantweaponfire, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HOLODUKE_AMOUNT:
if (bSet) ps[iPlayer].holoduke_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].holoduke_amount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_NEWOWNER:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].newOwner = vValue.safeActor();
else SetGameVarID(lVar2, ps[iPlayer].newOwner, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HURT_DELAY:
if (bSet) ps[iPlayer].hurt_delay = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].hurt_delay, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HBOMB_HOLD_DELAY:
if (bSet) ps[iPlayer].hbomb_hold_delay = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].hbomb_hold_delay, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_JUMPING_COUNTER:
if (bSet) ps[iPlayer].jumping_counter = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].jumping_counter, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_AIRLEFT:
if (bSet) ps[iPlayer].airleft = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].airleft, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_KNEE_INCS:
if (bSet) ps[iPlayer].knee_incs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].knee_incs, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ACCESS_INCS:
if (bSet) ps[iPlayer].access_incs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].access_incs, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
case PLAYER_ACCESS_WALLNUM:
if (bSet) ps[iPlayer].access_wall = toWall(lValue);
else SetGameVarID(lVar2, fromWall(ps[iPlayer].access_wall), sActor, sPlayer);
break;
case PLAYER_ACCESS_SPRITENUM:
if (bSet) ps[iPlayer].access_spritenum = vValue.safeActor();
else SetGameVarID(lVar2, ps[iPlayer].access_spritenum, sActor, sPlayer);
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_KICKBACK_PIC:
- Duke: Ensure all weapon variables used for interpolation have the `o` values set when CON updates them. * Hasn't been an issue to date but could become one should a mod set these. * Can't simply back the variable up and set the main one because unless the mod knows we're interpolating, it could have undesirable effects.
2021-12-10 06:31:51 +00:00
if (bSet) ps[iPlayer].okickback_pic = ps[iPlayer].kickback_pic = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].kickback_pic, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_GOT_ACCESS:
if (bSet) ps[iPlayer].got_access = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].got_access, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WEAPON_ANG:
if (bSet) ps[iPlayer].weapon_ang = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].weapon_ang, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FIRSTAID_AMOUNT:
if (bSet) ps[iPlayer].firstaid_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].firstaid_amount, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SOMETHINGONPLAYER:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].somethingonplayer = vValue.safeActor();
else SetGameVarID(lVar2, (ps[iPlayer].somethingonplayer), sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ON_CRANE:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].on_crane = vValue.safeActor();
else SetGameVarID(lVar2, (ps[iPlayer].on_crane), sActor, sPlayer);
break;
case PLAYER_I: // Read only, because this is very dangerous.
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].actor, sActor, sPlayer);
break;
case PLAYER_ONE_PARALLAX_SECTNUM:
if (bSet) ps[iPlayer].one_parallax_sectnum = toSect(lValue);
else SetGameVarID(lVar2, fromSect(ps[iPlayer].one_parallax_sectnum), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OVER_SHOULDER_ON:
if (bSet) ps[iPlayer].over_shoulder_on = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].over_shoulder_on, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_RANDOM_CLUB_FRAME:
- Duke: Ensure all weapon variables used for interpolation have the `o` values set when CON updates them. * Hasn't been an issue to date but could become one should a mod set these. * Can't simply back the variable up and set the main one because unless the mod knows we're interpolating, it could have undesirable effects.
2021-12-10 06:31:51 +00:00
if (bSet) ps[iPlayer].orandom_club_frame = ps[iPlayer].random_club_frame = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].random_club_frame, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FIST_INCS:
if (bSet) ps[iPlayer].fist_incs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].fist_incs, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ONE_EIGHTY_COUNT:
- binaryangle.h: Remove `lookangle` class and replace use with `binangle`. * Added in fca846272eb3795ddd3dd51ed48e494382c0a389 to deal with signed adjustments but its just not needed. * Made better use of `binangle`/`fixedhoriz` class getters and setters than before as well.
2021-04-11 05:43:11 +00:00
if (bSet) ps[iPlayer].angle.spin = lValue;
- fixed the remaining warnings.
2021-05-12 15:57:36 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].angle.spin), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_CHEAT_PHASE:
if (bSet) ps[iPlayer].cheat_phase = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].cheat_phase, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_DUMMYPLAYERSPRITE:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].dummyplayersprite = vValue.safeActor();
else SetGameVarID(lVar2, (ps[iPlayer].dummyplayersprite), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_EXTRA_EXTRA8:
if (bSet) ps[iPlayer].extra_extra8 = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].extra_extra8, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_QUICK_KICK:
if (bSet) ps[iPlayer].quick_kick = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].quick_kick, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HEAT_AMOUNT:
if (bSet) ps[iPlayer].heat_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].heat_amount, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ACTORSQU:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].actorsqu = vValue.safeActor();
else SetGameVarID(lVar2, (ps[iPlayer].actorsqu), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TIMEBEFOREEXIT:
if (bSet) ps[iPlayer].timebeforeexit = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].timebeforeexit, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_CUSTOMEXITSOUND:
if (bSet) ps[iPlayer].customexitsound = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].customexitsound, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WEAPRECS:
if (bSet) ps[iPlayer].weaprecs[lParm2] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].weaprecs[lParm2], sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WEAPRECCNT:
if (bSet) ps[iPlayer].weapreccnt = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].weapreccnt, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_INTERFACE_TOGGLE_FLAG:
if (bSet) ps[iPlayer].interface_toggle_flag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].interface_toggle_flag, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ROTSCRNANG:
- Duke: Back up `rotscrnang` if script sets target to new value so we can interpolate the changes.
2021-11-06 06:57:37 +00:00
if (bSet)
{
ps[iPlayer].angle.orotscrnang = ps[iPlayer].angle.rotscrnang;
ps[iPlayer].angle.rotscrnang = buildang(lValue);
}
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.rotscrnang.asbuild(), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_DEAD_FLAG:
if (bSet) ps[iPlayer].dead_flag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].dead_flag, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SHOW_EMPTY_WEAPON:
if (bSet) ps[iPlayer].show_empty_weapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].show_empty_weapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SCUBA_AMOUNT:
if (bSet) ps[iPlayer].scuba_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].scuba_amount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_JETPACK_AMOUNT:
if (bSet) ps[iPlayer].jetpack_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].jetpack_amount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_STEROIDS_AMOUNT:
if (bSet) ps[iPlayer].steroids_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].steroids_amount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SHIELD_AMOUNT:
if (bSet) ps[iPlayer].shield_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].shield_amount, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HOLODUKE_ON:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (bSet) ps[iPlayer].holoduke_on = vValue.safeActor();
else SetGameVarID(lVar2, (ps[iPlayer].holoduke_on), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_PYCOUNT:
if (bSet) ps[iPlayer].pycount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].pycount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_WEAPON_POS:
- Duke: Ensure all weapon variables used for interpolation have the `o` values set when CON updates them. * Hasn't been an issue to date but could become one should a mod set these. * Can't simply back the variable up and set the main one because unless the mod knows we're interpolating, it could have undesirable effects.
2021-12-10 06:31:51 +00:00
if (bSet) ps[iPlayer].oweapon_pos = ps[iPlayer].weapon_pos = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].weapon_pos, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FRAG_PS:
if (bSet) ps[iPlayer].frag_ps = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].frag_ps, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TRANSPORTER_HOLD:
if (bSet) ps[iPlayer].transporter_hold = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].transporter_hold, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LAST_FULL_WEAPON:
if (bSet) ps[iPlayer].last_full_weapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].last_full_weapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FOOTPRINTSHADE:
if (bSet) ps[iPlayer].footprintshade = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].footprintshade, sActor, sPlayer);
- step 1.
2020-05-14 17:23:36 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_BOOT_AMOUNT:
if (bSet) ps[iPlayer].boot_amount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].boot_amount, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_GM:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, MODE_GAME, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ON_WARPING_SECTOR:
if (bSet) ps[iPlayer].on_warping_sector = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].on_warping_sector, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FOOTPRINTCOUNT:
if (bSet) ps[iPlayer].footprintcount = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].footprintcount, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HBOMB_ON:
if (bSet) ps[iPlayer].hbomb_on = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].hbomb_on, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_JUMPING_TOGGLE:
if (bSet) ps[iPlayer].jumping_toggle = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].jumping_toggle, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_RAPID_FIRE_HOLD:
if (bSet) ps[iPlayer].rapid_fire_hold = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].rapid_fire_hold, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
next...
2020-05-20 22:01:41 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_ON_GROUND:
if (bSet) ps[iPlayer].on_ground = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].on_ground, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_INVEN_ICON:
if (bSet) ps[iPlayer].inven_icon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].inven_icon, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_BUTTONPALETTE:
if (bSet) ps[iPlayer].buttonpalette = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].buttonpalette, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_JETPACK_ON:
if (bSet) ps[iPlayer].jetpack_on = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].jetpack_on, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SPRITEBRIDGE:
if (bSet) ps[iPlayer].spritebridge = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].spritebridge, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_LASTRANDOMSPOT:
if (bSet) ps[iPlayer].lastrandomspot = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].lastrandomspot, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_SCUBA_ON:
if (bSet) ps[iPlayer].scuba_on = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].scuba_on, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FOOTPRINTPAL:
if (bSet) ps[iPlayer].footprintpal = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].footprintpal, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HEAT_ON:
if (bSet) ps[iPlayer].heat_on = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].heat_on, sActor, sPlayer);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
break;
- step 1.
2020-05-14 17:23:36 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_HOLSTER_WEAPON:
if (bSet) ps[iPlayer].holster_weapon = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].holster_weapon, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_FALLING_COUNTER:
if (bSet) ps[iPlayer].falling_counter = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].falling_counter, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_GOTWEAPON:
- addressed most unused/uninitialized variable warnings from MSVC.
2021-11-14 14:03:50 +00:00
if (bSet) ps[iPlayer].gotweapon[lParm2] = !!lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].gotweapon[lParm2], sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_REFRESH_INVENTORY:
if (bSet) ps[iPlayer].refresh_inventory = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].refresh_inventory, sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_TOGGLE_KEY_FLAG:
if (bSet) ps[iPlayer].toggle_key_flag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].toggle_key_flag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_KNUCKLE_INCS:
if (bSet) ps[iPlayer].knuckle_incs = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].knuckle_incs, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_WALKING_SND_TOGGLE:
if (bSet) ps[iPlayer].walking_snd_toggle = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].walking_snd_toggle, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_PALOOKUP:
if (bSet) ps[iPlayer].palookup = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].palookup, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_HARD_LANDING:
- Duke: Ensure all weapon variables used for interpolation have the `o` values set when CON updates them. * Hasn't been an issue to date but could become one should a mod set these. * Can't simply back the variable up and set the main one because unless the mod knows we're interpolating, it could have undesirable effects.
2021-12-10 06:31:51 +00:00
if (bSet) ps[iPlayer].ohard_landing = ps[iPlayer].hard_landing = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].hard_landing, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_MAX_SECRET_ROOMS:
if (bSet) ps[iPlayer].max_secret_rooms = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].max_secret_rooms, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_SECRET_ROOMS:
if (bSet) ps[iPlayer].secret_rooms = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].secret_rooms, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_MAX_ACTORS_KILLED:
if (bSet) ps[iPlayer].max_actors_killed = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].max_actors_killed, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case PLAYER_ACTORS_KILLED:
if (bSet) ps[iPlayer].actors_killed = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, ps[iPlayer].actors_killed, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- Duke: Restore `return_to_center` in gameexec.cpp dropped in 0ab3b33a6c1ee98b8d28369a824be0dfa0950003 and redo based on new code.
2020-10-10 05:59:00 +00:00
case PLAYER_RETURN_TO_CENTER:
if (bSet)
{
ps[iPlayer].sync.actions |= SB_CENTERVIEW;
}
else
{
- Duke: Fix issue where calculated value for old player variable `return_to_center` could have been negative, causing undefined behaviour.
2021-11-07 10:14:29 +00:00
auto center = ps[iPlayer].sync.actions & SB_CENTERVIEW ? abs(xs_CRoundToInt(ps[iPlayer].horizon.horiz.asq16() * (9. / gi->playerHorizMax()))) : 0;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
SetGameVarID(lVar2, center, sActor, sPlayer);
- Duke: Restore `return_to_center` in gameexec.cpp dropped in 0ab3b33a6c1ee98b8d28369a824be0dfa0950003 and redo based on new code.
2020-10-10 05:59:00 +00:00
}
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
default:
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
return;
}
////////////////////
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
void DoWall(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, int sPlayer, int lParm2)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto lValue = GetGameVarID(lVar2, sActor, sPlayer).safeValue();
auto vWall = GetGameVarID(lVar1, sActor, sPlayer);
auto iWall = vWall.safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (iWall < 0 || iWall >= numwalls || vWall.isActor())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return;
}
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
auto wallp = &wall[iWall];
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// All fields affecting map geometry have been made read-only!
switch (lLabelID)
{
case WALL_X:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (!bSet) SetGameVarID(lVar2, wallp->x, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_Y:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) SetGameVarID(lVar2, wallp->y, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_POINT2:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (!bSet) SetGameVarID(lVar2, wallp->point2, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_NEXTWALL:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (!bSet) SetGameVarID(lVar2, wallp->nextwall, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_NEXTSECTOR:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (!bSet) SetGameVarID(lVar2, wallp->nextsector, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_CSTAT:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->cstat = lValue;
else SetGameVarID(lVar2, wallp->cstat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_PICNUM:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->picnum = lValue;
else SetGameVarID(lVar2, wallp->picnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_OVERPICNUM:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->overpicnum = lValue;
else SetGameVarID(lVar2, wallp->overpicnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_SHADE:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->shade = lValue;
else SetGameVarID(lVar2, wallp->shade, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_PAL:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->pal = lValue;
else SetGameVarID(lVar2, wallp->pal, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_XREPEAT:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->xrepeat = lValue;
else SetGameVarID(lVar2, wallp->xrepeat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_YREPEAT:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->yrepeat = lValue;
else SetGameVarID(lVar2, wallp->yrepeat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_XPANNING:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->xpan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, wallp->xpan(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_YPANNING:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->ypan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, wallp->ypan(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_LOTAG:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->lotag = lValue;
else SetGameVarID(lVar2, wallp->lotag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_HITAG:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->hitag = lValue;
else SetGameVarID(lVar2, wallp->hitag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case WALL_EXTRA:
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
if (bSet) wallp->extra = lValue;
else SetGameVarID(lVar2, wallp->extra, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
default:
break;
}
return;
}
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
void DoSector(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, int sPlayer, int lParm2)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
int iSector;
int lValue;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
bool no = false;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (lVar1 == g_iThisActorID)
{
// if they've asked for 'this', then use 'this'...
- use sectno() access function where we really need a sector index.
2021-12-06 16:25:40 +00:00
iSector = sActor->s->sectno();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto vv = GetGameVarID(lVar1, sActor, sPlayer);
no = vv.isActor();
iSector = vv.safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (iSector < 0 || iSector >= numsectors || no)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return;
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lValue = GetGameVarID(lVar2, sActor, sPlayer).safeValue();
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
auto sectp = &sector[iSector];
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// All fields affecting map geometry have been made read-only!
switch (lLabelID)
{
case SECTOR_WALLPTR:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (!bSet) SetGameVarID(lVar2, sectp->wallptr, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_WALLNUM:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (!bSet) SetGameVarID(lVar2, sectp->wallnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGZ:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingz = lValue;
else SetGameVarID(lVar2, sectp->ceilingz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORZ:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorz = lValue;
else SetGameVarID(lVar2, sectp->floorz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGSTAT:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingstat = lValue;
else SetGameVarID(lVar2, sectp->ceilingstat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORSTAT:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorstat = lValue;
else SetGameVarID(lVar2, sectp->floorstat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGPICNUM:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingpicnum = lValue;
else SetGameVarID(lVar2, sectp->ceilingpicnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGSLOPE:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingheinum = lValue;
else SetGameVarID(lVar2, sectp->ceilingheinum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGSHADE:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingshade = lValue;
else SetGameVarID(lVar2, sectp->ceilingshade, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGPAL:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingpal = lValue;
else SetGameVarID(lVar2, sectp->ceilingpal, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_CEILINGXPANNING:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingxpan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, sectp->ceilingxpan(), sActor, sPlayer);
- make sector panning variables floats and added some convenience wrappers.
2020-11-25 19:52:06 +00:00
break;
case SECTOR_CEILINGYPANNING:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->ceilingypan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, sectp->ceilingypan(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORPICNUM:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorpicnum = lValue;
else SetGameVarID(lVar2, sectp->floorpicnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORSLOPE:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorheinum = lValue;
else SetGameVarID(lVar2, sectp->floorheinum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORSHADE:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorshade = lValue;
else SetGameVarID(lVar2, sectp->floorshade, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORPAL:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorpal = lValue;
else SetGameVarID(lVar2, sectp->floorpal, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORXPANNING:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorxpan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, sectp->floorxpan(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_FLOORYPANNING:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->floorypan_ = (float)(lValue & 255);
else SetGameVarID(lVar2, sectp->floorypan(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_VISIBILITY:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->visibility = lValue;
else SetGameVarID(lVar2, sectp->visibility, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_LOTAG:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->lotag = lValue;
else SetGameVarID(lVar2, sectp->lotag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_HITAG:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->hitag = lValue;
else SetGameVarID(lVar2, sectp->hitag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case SECTOR_EXTRA:
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
if (bSet) sectp->extra = lValue;
else SetGameVarID(lVar2, sectp->extra, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
default:
break;
}
return;
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
- CON game access interface done.
2020-10-23 17:07:33 +00:00
void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, int sPlayer, int lParm2)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto vValue = GetGameVarID(lVar2, sActor, sPlayer);
auto lValue = vValue.safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DDukeActor* act;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (lVar1 == g_iThisActorID)
{
// if they've asked for 'this', then use 'this'...
- CON game access interface done.
2020-10-23 17:07:33 +00:00
act = sActor;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
act = GetGameVarID(lVar1, sActor, sPlayer).safeActor();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
auto spr = act->s;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (!act)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
if (!bSet) SetGameVarID(lVar2, 0, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return;
}
switch (lLabelID)
{
case ACTOR_X:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->x = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->x, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_Y:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->y = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->y, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_Z:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->z = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->z, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_CSTAT:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->cstat = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->cstat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_PICNUM:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->picnum = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->picnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_SHADE:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->shade = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->shade, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_PAL:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->pal = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->pal, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_CLIPDIST:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->clipdist = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->clipdist, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_DETAIL:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->spriteextra = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->spriteextra, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_XREPEAT:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->xrepeat = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->xrepeat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_YREPEAT:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->yrepeat = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->yrepeat, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_XOFFSET:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->xoffset = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->xoffset, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_YOFFSET:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->yoffset = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->yoffset, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
case ACTOR_SECTNUM: // made read only because this is not safe.
if (!bSet) /*changespritesect(iActor, lValue);
- use sectno() access function where we really need a sector index.
2021-12-06 16:25:40 +00:00
else*/ SetGameVarID(lVar2, spr->sectno(), sActor, sPlayer);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
break;
case ACTOR_STATNUM:
if (!bSet) /*changespritestat(iActor, lValue);
else*/ SetGameVarID(lVar2, spr->statnum, sActor, sPlayer);
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case ACTOR_ANG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->ang = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->ang, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_OWNER:
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
// there is no way to handle this well because we do not know whether this is an actor or not. Pity.
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->owner = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->owner, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_XVEL:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->xvel = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->xvel, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_YVEL:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->yvel = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->yvel, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_ZVEL:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->zvel = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->zvel, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_LOTAG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->lotag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->lotag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HITAG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->hitag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->hitag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_EXTRA:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) spr->extra = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->extra, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTCGG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->cgg = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->cgg, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTPICNUM:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->picnum = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->picnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTANG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->ang = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->ang, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTEXTRA:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->extra = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->extra, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
case ACTOR_HTOWNER:
if (bSet) act->hitOwnerActor = vValue.safeActor();
else SetGameVarID(lVar2, act->hitOwnerActor, sActor, sPlayer);
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case ACTOR_HTMOVFLAG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->movflag = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->movflag, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTTEMPANG:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->tempang = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->tempang, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
case ACTOR_HTACTORSTAYPUT:
if (bSet) act->actorstayput = toSect(lValue);
else SetGameVarID(lVar2, fromSect(act->actorstayput), sActor, sPlayer);
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case ACTOR_HTDISPICNUM:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->dispicnum = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->dispicnum, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTTIMETOSLEEP:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->timetosleep = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->timetosleep, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTFLOORZ:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->floorz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->floorz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTCEILINGZ:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->ceilingz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->ceilingz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTLASTVX:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->lastvx = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->lastvx, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTLASTVY:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->lastvy = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->lastvy, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTBPOSX:
- Duke: Leverage new `spritetype` methods within Duke, removing `bposx`/`bposy`/`bposz` from hittype.
2021-01-05 19:20:55 +00:00
if (bSet) spr->ox = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->ox, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTBPOSY:
- Duke: Leverage new `spritetype` methods within Duke, removing `bposx`/`bposy`/`bposz` from hittype.
2021-01-05 19:20:55 +00:00
if (bSet) spr->oy = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->oy, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTBPOSZ:
- Duke: Leverage new `spritetype` methods within Duke, removing `bposx`/`bposy`/`bposz` from hittype.
2021-01-05 19:20:55 +00:00
if (bSet) spr->oz = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, spr->oz, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T0:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[0] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[0], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T1:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[1] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[1], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T2:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[2] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[2], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T3:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[3] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[3], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T4:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[4] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[4], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case ACTOR_HTG_T5:
- DoActor cleanup. Using pointers instead of repeated array accesses now.
2020-10-24 05:25:25 +00:00
if (bSet) act->temp_data[5] = lValue;
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
else SetGameVarID(lVar2, act->temp_data[5], sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
default:
break;
}
return;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void ParseState::parseifelse(int condition)
{
if( condition )
{
// skip 'else' pointer.. and...
insptr+=2;
parse();
}
else
{
insptr = &ScriptCode[*(insptr+1)];
if(*insptr == 10)
{
// else...
// skip 'else' and...
insptr+=2;
parse();
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- ifcanshoottarget.
2020-10-23 18:13:35 +00:00
static int ifcanshoottarget(DDukeActor *actor, int g_p, int g_x)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
int j;
if (g_x > 1024)
{
- Duke/RR: checked the rest of the code for shorts and replaced most local ones with ints.
2021-11-07 13:55:28 +00:00
int sclip, angdif;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (badguy(actor) && actor->s->xrepeat > 56)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
sclip = 3084;
angdif = 48;
}
else
{
sclip = 768;
angdif = 16;
}
- ifcanshoottarget.
2020-10-23 18:13:35 +00:00
DDukeActor* hit;
j = hitasprite(actor, &hit);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j == (1 << 30))
{
return 1;
}
if (j > sclip)
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (hit != nullptr && hit->s->picnum == actor->s->picnum)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 0;
else
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
actor->s->ang += angdif; j = hitasprite(actor, &hit); actor->s->ang -= angdif;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j > sclip)
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (hit != nullptr && hit->s->picnum == actor->s->picnum)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 0;
else
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
actor->s->ang -= angdif; j = hitasprite(actor, &hit); actor->s->ang += angdif;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j > 768)
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (hit != nullptr && hit->s->picnum == actor->s->picnum)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 0;
else j = 1;
}
else j = 0;
}
}
else j = 0;
}
}
else j = 0;
}
else j = 1;
return j;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
static bool ifcansee(DDukeActor* actor, int pnum)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
int j;
- ifcansee.
2020-10-23 18:14:50 +00:00
DDukeActor* tosee;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
auto spr = actor->s;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// select sprite for monster to target
// if holoduke is on, let them target holoduke first.
//
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
if (ps[pnum].holoduke_on != nullptr && !isRR())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
tosee = ps[pnum].holoduke_on;
- sectnum removal step
2021-11-21 08:05:58 +00:00
j = cansee(spr->x, spr->y, spr->z - (krand() & ((32 << 8) - 1)), spr->sector(), tosee->s->x, tosee->s->y, tosee->s->z, tosee->sector());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j == 0)
{
// they can't see player's holoduke
- ifcansee.
2020-10-23 18:14:50 +00:00
// check for player..
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
tosee = ps[pnum].GetActor();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
else tosee = ps[pnum].GetActor(); // holoduke not on. look for player
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// can they see player, (or player's holoduke)
- sectnum removal step
2021-11-21 08:05:58 +00:00
j = cansee(spr->x, spr->y, spr->z - (krand() & ((47 << 8))), spr->sector(), tosee->s->x, tosee->s->y, tosee->s->z - ((isRR()? 28 : 24) << 8), tosee->sector());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j == 0)
{
- ifcansee.
2020-10-23 18:14:50 +00:00
// search around for target player
// also modifies 'target' x&y if found.
- changed furthestcanseepoint return value This does not need to return a sector - the caller merely expects success or failure.
2021-11-17 23:07:38 +00:00
j = furthestcanseepoint(actor, tosee, &actor->lastvx, &actor->lastvy);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
{
// else, they did see it.
- ifcansee.
2020-10-23 18:14:50 +00:00
// save where we were looking..
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
actor->lastvx = tosee->s->x;
actor->lastvy = tosee->s->y;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- renamed variables in ifcansee.
2020-11-01 15:26:08 +00:00
if (j == 1 && (spr->statnum == STAT_ACTOR || spr->statnum == STAT_STANDABLE))
- ifcansee.
2020-10-23 18:14:50 +00:00
actor->timetosleep = SLEEPTIME;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return j == 1;
}
// int *it = 0x00589a04;
int ParseState::parse(void)
{
int j, l, s;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
auto g_sp = g_ac? g_ac->s : nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if(killit_flag) return 1;
switch (*insptr)
{
case concmd_ifrnd:
{
insptr++;
// HACK ALERT! The fire animation uses a broken ifrnd setup to delay its start because original CON has no variables.
// But the chosen random value of 16/255 is too low and can cause delays of a second or more.
- parse - part 1.
2020-10-23 18:16:03 +00:00
int spnum = g_sp->picnum;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (spnum == TILE_FIRE && g_t[4] == 0 && *insptr == 16)
{
parseifelse(rnd(64));
break;
}
parseifelse(rnd(*insptr));
break;
}
case concmd_ifcanshoottarget:
- ifcanshoottarget.
2020-10-23 18:13:35 +00:00
parseifelse(ifcanshoottarget(g_ac, g_p, g_x));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifcanseetarget:
- sectnum removal step
2021-11-21 08:05:58 +00:00
j = cansee(g_sp->x, g_sp->y, g_sp->z - ((krand() & 41) << 8), g_sp->sector(), ps[g_p].pos.x, ps[g_p].pos.y, ps[g_p].pos.z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- parse - part 1.
2020-10-23 18:16:03 +00:00
if (j) g_ac->timetosleep = SLEEPTIME;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifnocover:
- sectnum removal step
2021-11-21 08:05:58 +00:00
j = cansee(g_sp->x, g_sp->y, g_sp->z, g_sp->sector(), ps[g_p].pos.x, ps[g_p].pos.y, ps[g_p].pos.z, ps[g_p].GetActor()->sector());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- parse - part 1.
2020-10-23 18:16:03 +00:00
if (j) g_ac->timetosleep = SLEEPTIME;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifactornotstayput:
- actorstayput
2021-11-18 19:55:22 +00:00
parseifelse(g_ac->actorstayput == nullptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifcansee:
- ifcansee.
2020-10-23 18:14:50 +00:00
parseifelse(ifcansee(g_ac, g_p));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifhitweapon:
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
parseifelse(fi.ifhitbyweapon(g_ac) >= 0);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifsquished:
- ifsquished.
2020-10-22 17:12:48 +00:00
parseifelse(ifsquished(g_ac, g_p) == 1);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifdead:
{
j = g_sp->extra;
if (g_sp->picnum == TILE_APLAYER)
j--;
parseifelse(j < 0);
}
break;
case concmd_ai:
insptr++;
g_t[5] = *insptr;
g_t[4] = ScriptCode[g_t[5]]; // Action
g_t[1] = ScriptCode[g_t[5] + 1]; // move
g_sp->hitag = ScriptCode[g_t[5] + 2]; // Ai
g_t[0] = g_t[2] = g_t[3] = 0;
if (g_sp->hitag & random_angle)
g_sp->ang = krand() & 2047;
insptr++;
break;
case concmd_action:
insptr++;
g_t[2] = 0;
g_t[3] = 0;
g_t[4] = *insptr;
insptr++;
break;
case concmd_ifpdistl:
insptr++;
parseifelse(g_x < *insptr);
- parse - part 1.
2020-10-23 18:16:03 +00:00
if (g_x > MAXSLEEPDIST && g_ac->timetosleep == 0)
g_ac->timetosleep = SLEEPTIME;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifpdistg:
insptr++;
parseifelse(g_x > * insptr);
- parse - part 1.
2020-10-23 18:16:03 +00:00
if (g_x > MAXSLEEPDIST && g_ac->timetosleep == 0)
g_ac->timetosleep = SLEEPTIME;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_else:
insptr = &ScriptCode[*(insptr + 1)];
break;
case concmd_addstrength:
insptr++;
g_sp->extra += *insptr;
insptr++;
break;
case concmd_strength:
insptr++;
g_sp->extra = *insptr;
insptr++;
break;
case concmd_smacksprite:
switch (krand() & 1)
{
case 0:
g_sp->ang = (+512 + g_sp->ang + (krand() & 511)) & 2047;
break;
case 1:
g_sp->ang = (-512 + g_sp->ang - (krand() & 511)) & 2047;
break;
}
insptr++;
break;
case concmd_fakebubba:
insptr++;
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
fakebubbaspawn(g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_rndmove:
g_sp->ang = krand() & 2047;
g_sp->xvel = 25;
insptr++;
break;
case concmd_mamatrigger:
- fixed a few bad parameters.
2020-11-02 18:54:20 +00:00
operateactivators(667, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_mamaspawn:
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
mamaspawn(g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_mamaquake:
if (g_sp->pal == 31)
earthquaketime = 4;
else if (g_sp->pal == 32)
earthquaketime = 6;
insptr++;
break;
case concmd_garybanjo:
if (banjosound == 0)
{
- Duke/RR: checked the rest of the code for shorts and replaced most local ones with ints.
2021-11-07 13:55:28 +00:00
int rnum = (krand() & 3) + 1;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (rnum == 4)
{
banjosound = 262;
}
else if (rnum == 1)
{
banjosound = 272;
}
else if (rnum == 2)
{
banjosound = 273;
}
else
{
banjosound = 273;
}
- parse - part 1.
2020-10-23 18:16:03 +00:00
S_PlayActorSound(banjosound, g_ac, CHAN_WEAPON);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- parse - part 1.
2020-10-23 18:16:03 +00:00
else if (!S_CheckActorSoundPlaying(g_ac, banjosound))
S_PlayActorSound(banjosound, g_ac, CHAN_WEAPON);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_motoloopsnd:
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (!S_CheckActorSoundPlaying(g_ac, 411))
S_PlayActorSound(411, g_ac, CHAN_VOICE);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_ifgotweaponce:
insptr++;
if (ud.coop >= 1 && ud.multimode > 1)
{
if (*insptr == 0)
{
for (j = 0; j < ps[g_p].weapreccnt; j++)
if (ps[g_p].weaprecs[j] == g_sp->picnum)
break;
- parse - part 2.
2020-10-23 18:16:57 +00:00
parseifelse(j < ps[g_p].weapreccnt&& g_ac->GetOwner() == g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else if (ps[g_p].weapreccnt < 16)
{
ps[g_p].weaprecs[ps[g_p].weapreccnt++] = g_sp->picnum;
- parse - part 2.
2020-10-23 18:16:57 +00:00
parseifelse(g_ac->GetOwner() == g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
else parseifelse(0);
break;
case concmd_getlastpal:
insptr++;
if (g_sp->picnum == TILE_APLAYER)
g_sp->pal = ps[g_sp->yvel].palookup;
else
{
// Copied from DukeGDX.
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (g_sp->picnum == TILE_EGG && g_ac->temp_data[5] == TILE_EGG + 2 && g_sp->pal == 1)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
ps[connecthead].max_actors_killed++; //revive the egg
- parse - part 2.
2020-10-23 18:16:57 +00:00
g_ac->temp_data[5] = 0;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- fixed the remaining warnings.
2021-05-12 15:57:36 +00:00
g_sp->pal = (uint8_t)g_ac->tempang;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- parse - part 2.
2020-10-23 18:16:57 +00:00
g_ac->tempang = 0;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_tossweapon:
insptr++;
fi.checkweapons(&ps[g_sp->yvel]);
break;
case concmd_nullop:
insptr++;
break;
case concmd_mikesnd:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (!S_CheckActorSoundPlaying(g_ac, g_sp->yvel))
S_PlayActorSound(g_sp->yvel, g_ac, CHAN_VOICE);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_pkick:
insptr++;
if (ud.multimode > 1 && g_sp->picnum == TILE_APLAYER)
{
if (ps[otherp].quick_kick == 0)
ps[otherp].quick_kick = 14;
}
else if (g_sp->picnum != TILE_APLAYER && ps[g_p].quick_kick == 0)
ps[g_p].quick_kick = 14;
break;
case concmd_sizeto:
insptr++;
// JBF 20030805: As I understand it, if xrepeat becomes 0 it basically kills the
// sprite, which is why the "sizeto 0 41" calls in 1.3d became "sizeto 4 41" in
// 1.4, so instead of patching the CONs I'll surruptitiously patch the code here
- Duke: replaced the game type macros with inline functions.
2020-10-11 09:39:51 +00:00
//if (!isPlutoPak() && *insptr == 0) *insptr = 4;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = ((*insptr) - g_sp->xrepeat) << 1;
- Amalgamate ksgn and sgn into Sgn in cmdlib.h, and remove pragmas.h.
2021-01-04 12:35:33 +00:00
g_sp->xrepeat += Sgn(j);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
- replaced all remaining uses of tilesiz[].y
2020-11-23 07:39:49 +00:00
if ((g_sp->picnum == TILE_APLAYER && g_sp->yrepeat < 36) || *insptr < g_sp->yrepeat || ((g_sp->yrepeat * (tileHeight(g_sp->picnum) + 8)) << 2) < (g_ac->floorz - g_ac->ceilingz))
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j = ((*insptr) - g_sp->yrepeat) << 1;
- Amalgamate ksgn and sgn into Sgn in cmdlib.h, and remove pragmas.h.
2021-01-04 12:35:33 +00:00
if (abs(j)) g_sp->yrepeat += Sgn(j);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
insptr++;
break;
case concmd_sizeat:
insptr++;
g_sp->xrepeat = (uint8_t)*insptr;
insptr++;
g_sp->yrepeat = (uint8_t)*insptr;
insptr++;
break;
case concmd_shoot:
insptr++;
- shoot interface transitioned/operateweapon mostly done.
2020-10-24 05:34:39 +00:00
fi.shoot(g_ac, (short)*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_ifsoundid:
insptr++;
parseifelse((short)*insptr == ambientlotag[g_sp->ang]);
break;
case concmd_ifsounddist:
insptr++;
if (*insptr == 0)
parseifelse(ambienthitag[g_sp->ang] > g_x);
else if (*insptr == 1)
parseifelse(ambienthitag[g_sp->ang] < g_x);
break;
case concmd_soundtag:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
S_PlayActorSound(ambientlotag[g_sp->ang], g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_soundtagonce:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (!S_CheckActorSoundPlaying(g_ac, ambientlotag[g_sp->ang]))
S_PlayActorSound(ambientlotag[g_sp->ang], g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_soundonce:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (!S_CheckSoundPlaying(*insptr++))
S_PlayActorSound(*(insptr - 1), g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_stopsound:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (S_CheckSoundPlaying(*insptr))
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
S_StopSound(*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_globalsound:
insptr++;
if (g_p == screenpeek || ud.coop == 1)
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
S_PlayActorSound(*insptr, ps[screenpeek].GetActor());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_smackbubba:
insptr++;
if (!isRRRA() || g_sp->pal != 105)
{
setnextmap(false);
}
break;
case concmd_mamaend:
insptr++;
ps[myconnectindex].MamaEnd = 150;
break;
case concmd_ifactorhealthg:
insptr++;
parseifelse(g_sp->extra > (short)*insptr);
break;
case concmd_ifactorhealthl:
insptr++;
parseifelse(g_sp->extra < (short)*insptr);
break;
case concmd_sound:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
S_PlayActorSound((short) *insptr,g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_tip:
insptr++;
ps[g_p].tipincs = 26;
break;
case concmd_iftipcow:
case concmd_ifhittruck: // both have the same code.
- parse - part 2.
2020-10-23 18:16:57 +00:00
if (g_ac->spriteextra == 1) //
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j = 1;
- parse - part 2.
2020-10-23 18:16:57 +00:00
g_ac->spriteextra++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
j = 0;
parseifelse(j > 0);
break;
case concmd_tearitup:
insptr++;
- the rest of Duke’s sectnum, except RR's geo hack
2021-11-21 08:08:05 +00:00
tearitup(g_sp->sector());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_fall:
insptr++;
g_sp->xoffset = 0;
g_sp->yoffset = 0;
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
fi.fall(g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_enda:
case concmd_break:
case concmd_ends:
case concmd_endevent:
return 1;
case concmd_rightbrace:
insptr++;
return 1;
case concmd_addammo:
insptr++;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if( ps[g_p].ammo_amount[*insptr] >= gs.max_ammo_amount[*insptr] )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
killit_flag = 2;
break;
}
addammo( *insptr, &ps[g_p], *(insptr+1) );
if(ps[g_p].curr_weapon == KNEE_WEAPON)
if( ps[g_p].gotweapon[*insptr] )
fi.addweapon( &ps[g_p], *insptr );
insptr += 2;
break;
case concmd_money:
insptr++;
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
fi.lotsofmoney(g_ac,*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_mail:
insptr++;
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
fi.lotsofmail(g_ac,*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_sleeptime:
insptr++;
- parse - part 2.
2020-10-23 18:16:57 +00:00
g_ac->timetosleep = (short)*insptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_paper:
insptr++;
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
fi.lotsofpaper(g_ac,*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_addkills:
insptr++;
if (isRR())
{
- parse - part 3.
2020-10-23 18:18:38 +00:00
if (g_ac->spriteextra < 1 || g_ac->spriteextra == 128)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- actorflag, actorfella, automap, animateaccess, holoduke spawn, initreactor. # Conflicts: # source/games/duke/src/game_misc.cpp
2020-10-23 17:02:58 +00:00
if (actorfella(g_ac))
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].actors_killed += *insptr;
}
}
else ps[g_p].actors_killed += *insptr;
- actorstayput
2021-11-18 19:55:22 +00:00
g_ac->actorstayput = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_lotsofglass:
insptr++;
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
spriteglass(g_ac, *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_killit:
insptr++;
killit_flag = 1;
break;
case concmd_addweapon:
insptr++;
if( ps[g_p].gotweapon[*insptr] == 0 ) fi.addweapon( &ps[g_p], *insptr );
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
else if( ps[g_p].ammo_amount[*insptr] >= gs.max_ammo_amount[*insptr] )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
killit_flag = 2;
break;
}
addammo( *insptr, &ps[g_p], *(insptr+1) );
if(ps[g_p].curr_weapon == KNEE_WEAPON)
if( ps[g_p].gotweapon[*insptr] )
fi.addweapon( &ps[g_p], *insptr );
insptr+=2;
break;
case concmd_debug:
insptr++;
Printf("%d\n",*insptr);
insptr++;
break;
case concmd_endofgame:
insptr++;
ps[g_p].timebeforeexit = *insptr;
ps[g_p].customexitsound = -1;
ud.eog = true;
insptr++;
break;
case concmd_isdrunk: // todo: move out to player_r.
insptr++;
ps[g_p].drink_amt += *insptr;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
j = ps[g_p].GetActor()->s->extra;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j > 0)
j += *insptr;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if (j > gs.max_player_health * 2)
j = gs.max_player_health * 2;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (j < 0)
j = 0;
if (ud.god == 0)
{
if (*insptr > 0)
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if ((j - *insptr) < (gs.max_player_health >> 2) &&
j >= (gs.max_player_health >> 2))
- player.i, part 1
2020-11-02 19:23:05 +00:00
S_PlayActorSound(DUKE_GOTHEALTHATLOW, ps[g_p].GetActor());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].last_extra = j;
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
ps[g_p].GetActor()->s->extra = j;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
if (ps[g_p].drink_amt > 100)
ps[g_p].drink_amt = 100;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (ps[g_p].GetActor()->s->extra >= gs.max_player_health)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
ps[g_p].GetActor()->s->extra = gs.max_player_health;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
ps[g_p].last_extra = gs.max_player_health;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
insptr++;
break;
case concmd_strafeleft:
insptr++;
- buildutils: Replace `sintable[]` use within Duke's gameexec.cpp with `bsin()`/`bcos()`.
2020-11-14 11:15:17 +00:00
movesprite_ex(g_ac, -bsin(g_sp->ang, -10), bcos(g_sp->ang, -10), g_sp->zvel, CLIPMASK0, coll);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_straferight:
insptr++;
- buildutils: Replace `sintable[]` use within Duke's gameexec.cpp with `bsin()`/`bcos()`.
2020-11-14 11:15:17 +00:00
movesprite_ex(g_ac, bsin(g_sp->ang, -10), -bcos(g_sp->ang, -10), g_sp->zvel, CLIPMASK0, coll);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_larrybird:
insptr++;
- renamed DDukeActor::getSector.
2021-11-20 23:33:17 +00:00
ps[g_p].pos.z = ps[g_p].GetActor()->sector()->ceilingz;
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
ps[g_p].GetActor()->s->z = ps[g_p].pos.z;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_destroyit:
insptr++;
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
destroyit(g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_iseat: // move out to player_r.
insptr++;
ps[g_p].eat += *insptr;
if (ps[g_p].eat > 100)
{
ps[g_p].eat = 100;
}
ps[g_p].drink_amt -= *insptr;
if (ps[g_p].drink_amt < 0)
ps[g_p].drink_amt = 0;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
j = ps[g_p].GetActor()->s->extra;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (g_sp->picnum != TILE_ATOMICHEALTH)
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if (j > gs.max_player_health && *insptr > 0)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
insptr++;
break;
}
else
{
if (j > 0)
j += (*insptr) * 3;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if (j > gs.max_player_health && *insptr > 0)
j = gs.max_player_health;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
else
{
if (j > 0)
j += *insptr;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if (j > (gs.max_player_health << 1))
j = (gs.max_player_health << 1);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
if (j < 0) j = 0;
if (ud.god == 0)
{
if (*insptr > 0)
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if ((j - *insptr) < (gs.max_player_health >> 2) &&
j >= (gs.max_player_health >> 2))
- player.i, part 1
2020-11-02 19:23:05 +00:00
S_PlayActorSound(229, ps[g_p].GetActor());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].last_extra = j;
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
ps[g_p].GetActor()->s->extra = j;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
insptr++;
break;
case concmd_addphealth: // todo: move out to player.
insptr++;
- newowner and related code.
2020-11-02 23:20:51 +00:00
if(!isRR() && ps[g_p].newOwner != nullptr)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- newowner and related code.
2020-11-02 23:20:51 +00:00
ps[g_p].newOwner = nullptr;
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
ps[g_p].pos.x = ps[g_p].oposx;
ps[g_p].pos.y = ps[g_p].oposy;
ps[g_p].pos.z = ps[g_p].oposz;
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
ps[g_p].angle.restore();
replaced cursectnum with a cursector pointer
2021-11-21 07:56:39 +00:00
updatesector(ps[g_p].pos.x,ps[g_p].pos.y,&ps[g_p].cursector);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- parse - part 3.
2020-10-23 18:18:38 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto j = it.Next())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (j->s->picnum == TILE_CAMERA1)
j->s->yvel = 0;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
j = ps[g_p].GetActor()->s->extra;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if(g_sp->picnum != TILE_ATOMICHEALTH)
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if( j > gs.max_player_health && *insptr > 0 )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
insptr++;
break;
}
else
{
if(j > 0)
j += *insptr;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if ( j > gs.max_player_health && *insptr > 0 )
j = gs.max_player_health;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
else
{
if( j > 0 )
j += *insptr;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if ( j > (gs.max_player_health<<1) )
j = (gs.max_player_health<<1);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
if(j < 0) j = 0;
if(ud.god == 0)
{
if(*insptr > 0)
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if( ( j - *insptr ) < (gs.max_player_health>>2) &&
j >= (gs.max_player_health>>2) )
- player.i, part 1
2020-11-02 19:23:05 +00:00
S_PlayActorSound(isRR()? 229 : DUKE_GOTHEALTHATLOW,ps[g_p].GetActor());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].last_extra = j;
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
ps[g_p].GetActor()->s->extra = j;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
insptr++;
break;
case concmd_state:
{
auto tempscrptr = insptr + 2;
insptr = &ScriptCode[*(insptr + 1)];
while (1) if (parse()) break;
insptr = tempscrptr;
}
break;
case concmd_leftbrace:
insptr++;
while (1) if (parse()) break;
break;
case concmd_move:
g_t[0]=0;
insptr++;
g_t[1] = *insptr;
insptr++;
g_sp->hitag = *insptr;
insptr++;
if(g_sp->hitag&random_angle)
g_sp->ang = krand()&2047;
break;
case concmd_spawn:
insptr++;
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(g_ac->insector())
- parse - part 3.
2020-10-23 18:18:38 +00:00
spawn(g_ac,*insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_ifwasweapon:
case concmd_ifspawnedby: // these two are the same
insptr++;
- parse - part 3.
2020-10-23 18:18:38 +00:00
parseifelse( g_ac->picnum == *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifai:
insptr++;
parseifelse(g_t[5] == *insptr);
break;
case concmd_ifaction:
insptr++;
parseifelse(g_t[4] == *insptr);
break;
case concmd_ifactioncount:
insptr++;
parseifelse(g_t[2] >= *insptr);
break;
case concmd_resetactioncount:
insptr++;
g_t[2] = 0;
break;
case concmd_debris:
{
- Duke/RR: replaced more local short variables with ints.
2021-11-07 13:36:39 +00:00
int dnum;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
dnum = *insptr;
insptr++;
bool weap = fi.spawnweapondebris(g_sp->picnum, dnum);
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(g_ac->insector())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
for(j=(*insptr)-1;j>=0;j--)
{
if(weap)
s = 0;
else s = (krand()%3);
- lots of EGS calls.
2021-11-18 18:04:00 +00:00
auto l = EGS(g_sp->sector(),
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
g_sp->x + (krand() & 255) - 128, g_sp->y + (krand() & 255) - 128, g_sp->z - (8 << 8) - (krand() & 8191),
dnum + s, g_sp->shade, 32 + (krand() & 15), 32 + (krand() & 15),
- parse - part 3.
2020-10-23 18:18:38 +00:00
krand() & 2047, (krand() & 127) + 32, -(krand() & 2047), g_ac, 5);
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
if (l)
{
if (weap)
l->s->yvel = gs.weaponsandammosprites[j % 14];
else l->s->yvel = -1;
l->s->pal = g_sp->pal;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
insptr++;
}
break;
case concmd_count:
insptr++;
g_t[0] = (short) *insptr;
insptr++;
break;
case concmd_cstator:
insptr++;
g_sp->cstat |= (short)*insptr;
insptr++;
break;
case concmd_clipdist:
insptr++;
- fixed the remaining warnings.
2021-05-12 15:57:36 +00:00
g_sp->clipdist = (uint8_t) *insptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_cstat:
insptr++;
- removed a few unneeded type casts.
2021-11-07 13:06:44 +00:00
g_sp->cstat = (uint16_t)*insptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_newpic:
insptr++;
g_sp->picnum = (short)*insptr;
insptr++;
break;
case concmd_ifmove:
insptr++;
parseifelse(g_t[1] == *insptr);
break;
case concmd_resetplayer:
insptr++;
if(ud.multimode < 2)
{
gameaction = ga_autoloadgame;
killit_flag = 2;
}
else
{
- parse - part 4.
2020-10-23 18:19:44 +00:00
// I am not convinced this is even remotely smart to be executed from here..
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
pickrandomspot(g_p);
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
g_sp->x = ps[g_p].bobposx = ps[g_p].oposx = ps[g_p].pos.x;
g_sp->y = ps[g_p].bobposy = ps[g_p].oposy = ps[g_p].pos.y;
g_sp->z = ps[g_p].oposz = ps[g_p].pos.z;
- Duke: Leverage new `spritetype` methods within Duke, removing `bposx`/`bposy`/`bposz` from hittype.
2021-01-05 19:20:55 +00:00
g_sp->backuppos();
replaced cursectnum with a cursector pointer
2021-11-21 07:56:39 +00:00
updatesector(ps[g_p].pos.x, ps[g_p].pos.y, &ps[g_p].cursector);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
SetActor(ps[g_p].GetActor(), { ps[g_p].pos.x, ps[g_p].pos.y, ps[g_p].pos.z + gs.playerheight });
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
g_sp->cstat = 257;
g_sp->shade = -12;
g_sp->clipdist = 64;
g_sp->xrepeat = 42;
g_sp->yrepeat = 36;
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->SetOwner(g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
g_sp->xoffset = 0;
g_sp->pal = ps[g_p].palookup;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
ps[g_p].last_extra = g_sp->extra = gs.max_player_health;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].wantweaponfire = -1;
- gamecontrol: Initial setup of `PlayerHorizon` struct and deployment within Duke. * Started with the most complicated game first. * Struct made up of fixedhoriz class units. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 06:12:37 +00:00
ps[g_p].horizon.ohoriz = ps[g_p].horizon.horiz = q16horiz(0);
- made on_crane a pointer as well.
2020-10-17 08:44:00 +00:00
ps[g_p].on_crane = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].frag_ps = g_p;
- gamecontrol: Initial setup of `PlayerHorizon` struct and deployment within Duke. * Started with the most complicated game first. * Struct made up of fixedhoriz class units. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 06:12:37 +00:00
ps[g_p].horizon.ohorizoff = ps[g_p].horizon.horizoff = q16horiz(0);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].opyoff = 0;
- wackedbyactor, too.
2020-10-21 08:52:51 +00:00
ps[g_p].wackedbyactor = nullptr;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
ps[g_p].shield_amount = gs.max_armour_amount;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].dead_flag = 0;
- Duke: Add `resurrected` flag to handle resurrection via cheating or when pissing in RR.
2021-04-15 08:00:58 +00:00
ps[g_p].resurrected = false;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].pals.a = 0;
ps[g_p].footprintcount = 0;
ps[g_p].weapreccnt = 0;
ps[g_p].ftq = 0;
ps[g_p].posxv = ps[g_p].posyv = 0;
- binaryangle.h: Remove `lookangle` class and replace use with `binangle`. * Added in fca846272eb3795ddd3dd51ed48e494382c0a389 to deal with signed adjustments but its just not needed. * Made better use of `binangle`/`fixedhoriz` class getters and setters than before as well.
2021-04-11 05:43:11 +00:00
if (!isRR()) ps[g_p].angle.orotscrnang = ps[g_p].angle.rotscrnang = buildang(0);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].falling_counter = 0;
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->extra = -1;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->cgg = 0;
g_ac->movflag = 0;
g_ac->tempang = 0;
- actorstayput
2021-11-18 19:55:22 +00:00
g_ac->actorstayput = nullptr;
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->dispicnum = 0;
g_ac->SetHitOwner(ps[g_p].GetActor());
g_ac->temp_data[4] = 0;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
resetinventory(g_p);
resetweapons(g_p);
}
break;
case concmd_ifcoop:
parseifelse(ud.coop || numplayers > 2);
break;
case concmd_ifonmud:
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
parseifelse(abs(g_sp->z - g_sp->sector()->floorz) < (32 << 8) && g_sp->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifonwater:
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
parseifelse( abs(g_sp->z-g_sp->sector()->floorz) < (32<<8) && g_sp->sector()->lotag == ST_1_ABOVE_WATER);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifmotofast:
parseifelse(ps[g_p].MotoSpeed > 60);
break;
case concmd_ifonmoto:
parseifelse(ps[g_p].OnMotorcycle == 1);
break;
case concmd_ifonboat:
parseifelse(ps[g_p].OnBoat == 1);
break;
case concmd_ifsizedown:
g_sp->xrepeat--;
g_sp->yrepeat--;
parseifelse(g_sp->xrepeat <= 5);
break;
case concmd_ifwind:
parseifelse(WindTime > 0);
break;
case concmd_ifinwater:
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
parseifelse( g_sp->sector()->lotag == 2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifcount:
insptr++;
parseifelse(g_t[0] >= *insptr);
break;
case concmd_ifactor:
insptr++;
parseifelse(g_sp->picnum == *insptr);
break;
case concmd_resetcount:
insptr++;
g_t[0] = 0;
break;
case concmd_addinventory:
insptr+=2;
switch(*(insptr-1))
{
case 0:
ps[g_p].steroids_amount = *insptr;
ps[g_p].inven_icon = 2;
break;
case 1:
ps[g_p].shield_amount += *insptr;// 100;
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if(ps[g_p].shield_amount > gs.max_player_health)
ps[g_p].shield_amount = gs.max_player_health;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case 2:
ps[g_p].scuba_amount = *insptr;// 1600;
ps[g_p].inven_icon = 6;
break;
case 3:
ps[g_p].holoduke_amount = *insptr;// 1600;
ps[g_p].inven_icon = 3;
break;
case 4:
ps[g_p].jetpack_amount = *insptr;// 1600;
ps[g_p].inven_icon = 4;
break;
case 6:
if (isRR())
{
switch (g_sp->lotag)
{
case 100: ps[g_p].keys[1] = 1; break;
case 101: ps[g_p].keys[2] = 1; break;
case 102: ps[g_p].keys[3] = 1; break;
case 103: ps[g_p].keys[4] = 1; break;
}
}
else
{
switch (g_sp->pal)
{
case 0: ps[g_p].got_access |= 1; break;
case 21: ps[g_p].got_access |= 2; break;
case 23: ps[g_p].got_access |= 4; break;
}
}
break;
case 7:
ps[g_p].heat_amount = *insptr;
ps[g_p].inven_icon = 5;
break;
case 9:
ps[g_p].inven_icon = 1;
ps[g_p].firstaid_amount = *insptr;
break;
case 10:
ps[g_p].inven_icon = 7;
ps[g_p].boot_amount = *insptr;
break;
}
insptr++;
break;
case concmd_hitradius:
- parse - part 4.
2020-10-23 18:19:44 +00:00
fi.hitradius(g_ac, *(insptr + 1), *(insptr + 2), *(insptr + 3), *(insptr + 4), *(insptr + 5));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr+=6;
break;
case concmd_ifp:
{
insptr++;
l = *insptr;
j = 0;
s = g_sp->xvel;
- parse - part 4.
2020-10-23 18:19:44 +00:00
// sigh.. this was yet another place where number literals were used as bit masks for every single value, making the code totally unreadable.
- inputstate.cpp: Move `checkCrouchToggle()` from gameinput.ccp into `ApplyGlobalInput()` and use static bool for crouch toggling vs. game-side bool.
2020-11-07 07:16:16 +00:00
if( (l& pducking) && ps[g_p].on_ground && PlayerInput(g_p, SB_CROUCH))
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
else if( (l& pfalling) && ps[g_p].jumping_counter == 0 && !ps[g_p].on_ground && ps[g_p].poszv > 2048 )
j = 1;
else if( (l& pjumping) && ps[g_p].jumping_counter > 348 )
j = 1;
else if( (l& pstanding) && s >= 0 && s < 8)
j = 1;
else if( (l& pwalking) && s >= 8 && !(PlayerInput(g_p, SB_RUN)) )
j = 1;
else if( (l& prunning) && s >= 8 && PlayerInput(g_p, SB_RUN) )
j = 1;
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
else if( (l& phigher) && ps[g_p].pos.z < (g_sp->z-(48<<8)) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
else if( (l& pwalkingback) && s <= -8 && !(PlayerInput(g_p, SB_RUN)) )
j = 1;
else if( (l& prunningback) && s <= -8 && (PlayerInput(g_p, SB_RUN)) )
j = 1;
else if( (l& pkicking) && ( ps[g_p].quick_kick > 0 || ( ps[g_p].curr_weapon == KNEE_WEAPON && ps[g_p].kickback_pic > 0 ) ) )
j = 1;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if( (l& pshrunk) && ps[g_p].GetActor()->s->xrepeat < (isRR() ? 8 : 32))
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
else if( (l& pjetpack) && ps[g_p].jetpack_on )
j = 1;
else if( (l& ponsteroids) && ps[g_p].steroids_amount > 0 && ps[g_p].steroids_amount < 400 )
j = 1;
else if( (l& ponground) && ps[g_p].on_ground)
j = 1;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if( (l& palive) && ps[g_p].GetActor()->s->xrepeat > (isRR() ? 8 : 32) && ps[g_p].GetActor()->s->extra > 0 && ps[g_p].timebeforeexit == 0 )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if( (l& pdead) && ps[g_p].GetActor()->s->extra <= 0)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
else if( (l& pfacing) )
{
if (g_sp->picnum == TILE_APLAYER && ud.multimode > 1)
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
j = getincangle(ps[otherp].angle.ang.asbuild(), getangle(ps[g_p].pos.x - ps[otherp].pos.x, ps[g_p].pos.y - ps[otherp].pos.y));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
else
- Duke: Remove `posx`/`posy`/`posz` variables and replace with points in the previously unionised `pos` `vec3_t` variable.
2021-10-31 06:52:52 +00:00
j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_sp->x - ps[g_p].pos.x, g_sp->y - ps[g_p].pos.y));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if( j > -128 && j < 128 )
j = 1;
else
j = 0;
}
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are already int and called functions only accept an int so really just no need at all.
2021-03-31 09:07:36 +00:00
parseifelse( j);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
break;
case concmd_ifstrength:
insptr++;
parseifelse(g_sp->extra <= *insptr);
break;
case concmd_guts:
insptr += 2;
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
fi.guts(g_ac,*(insptr-1),*insptr,g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
case concmd_slapplayer:
insptr++;
- Blood/Duke/RR/SW: Unify the player's horizon function. * For Duke/SW, we continually apply `SB_CENTERVIEW` only if it was previously a toggled action, similar to Blood. * For SW, we remove two SW-specific bits (`PF_LOCK_HORIZ` and `PF_LOOKING`) that are no longer needed. * For Duke, we remove `return_to_center` and just use the `SB_CENTERVIEW` action bit as required. * For `sethorizon()`, feature set and adjustment speeds are an averaged out accumulation across Duke/SW: ** GameTicRate is factored in for adjustment decisions to provide consistency for SW being the faster game. ** Adjustment amounts are half way between Duke/SW.
2020-09-20 10:01:05 +00:00
forceplayerangle(g_p);
- buildutils: Replace `sintable[]` use within Duke's gameexec.cpp with `bsin()`/`bcos()`.
2020-11-14 11:15:17 +00:00
ps[g_p].posxv -= ps[g_p].angle.ang.bcos(7);
ps[g_p].posyv -= ps[g_p].angle.ang.bsin(7);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return 0;
case concmd_wackplayer:
insptr++;
if (!isRR())
- Blood/Duke/RR/SW: Unify the player's horizon function. * For Duke/SW, we continually apply `SB_CENTERVIEW` only if it was previously a toggled action, similar to Blood. * For SW, we remove two SW-specific bits (`PF_LOCK_HORIZ` and `PF_LOOKING`) that are no longer needed. * For Duke, we remove `return_to_center` and just use the `SB_CENTERVIEW` action bit as required. * For `sethorizon()`, feature set and adjustment speeds are an averaged out accumulation across Duke/SW: ** GameTicRate is factored in for adjustment decisions to provide consistency for SW being the faster game. ** Adjustment amounts are half way between Duke/SW.
2020-09-20 10:01:05 +00:00
forceplayerangle(g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
else
{
- buildutils: Replace `sintable[]` use within Duke's gameexec.cpp with `bsin()`/`bcos()`.
2020-11-14 11:15:17 +00:00
ps[g_p].posxv -= ps[g_p].angle.ang.bcos(10);
ps[g_p].posyv -= ps[g_p].angle.ang.bsin(10);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ps[g_p].jumping_counter = 767;
ps[g_p].jumping_toggle = 1;
}
return 0;
case concmd_ifgapzl:
insptr++;
- parse - part 4.
2020-10-23 18:19:44 +00:00
parseifelse( (( g_ac->floorz - g_ac->ceilingz ) >> 8 ) < *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifhitspace:
parseifelse(PlayerInput(g_p, SB_OPEN));
break;
case concmd_ifoutside:
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
parseifelse(g_sp->sector()->ceilingstat & 1);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifmultiplayer:
parseifelse(ud.multimode > 1);
break;
case concmd_operate:
insptr++;
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
if( g_sp->sector()->lotag == 0 )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Silence all the `-Wuninitialized` and `-Wmaybe-uninitialized` warnings relating to `HitInfo` objects passed through to functions by reference.
2021-12-06 11:24:22 +00:00
HitInfo hit{};
- adapted neartag in Duke.
2021-11-26 17:59:28 +00:00
neartag({ g_sp->x, g_sp->y, g_sp->z - (32 << 8) }, g_sp->sector(), g_sp->ang, hit, 768, 1);
auto sectp = hit.hitSector;
- Duke: let neartag return pointers
2021-11-18 17:21:05 +00:00
if (sectp)
- Duke: extended neartag wrapper to use 32 bit integers as return values.
2021-11-07 09:10:00 +00:00
{
if (isanearoperator(sectp->lotag))
if ((sectp->lotag & 0xff) == ST_23_SWINGING_DOOR || sectp->floorz == sectp->ceilingz)
if ((sectp->lotag & 16384) == 0 && (sectp->lotag & 32768) == 0)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: let neartag return pointers
2021-11-18 17:21:05 +00:00
DukeSectIterator it(sectp);
- parse - part 4.
2020-10-23 18:19:44 +00:00
DDukeActor* a2;
while ((a2 = it.Next()))
- replaced several sector iterators in Duke code.
2020-10-14 19:16:54 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
auto sj = a2->s;
- parse - part 4.
2020-10-23 18:19:44 +00:00
if (sj->picnum == ACTIVATOR)
- replaced several sector iterators in Duke code.
2020-10-14 19:16:54 +00:00
break;
}
- parse - part 4.
2020-10-23 18:19:44 +00:00
if (a2 == nullptr)
- operatesectors and activatebysector.
2021-11-18 17:51:19 +00:00
operatesectors(sectp, g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- Duke: extended neartag wrapper to use 32 bit integers as return values.
2021-11-07 09:10:00 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
break;
case concmd_ifinspace:
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
parseifelse(fi.ceilingspace(g_sp->sector()));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_spritepal:
insptr++;
if(g_sp->picnum != TILE_APLAYER)
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->tempang = g_sp->pal;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
g_sp->pal = *insptr;
insptr++;
break;
case concmd_cactor:
insptr++;
g_sp->picnum = *insptr;
insptr++;
break;
case concmd_ifbulletnear:
- dodge, furthestcanseepoint, furthestangle.
2020-10-21 23:12:16 +00:00
parseifelse( dodge(g_ac) == 1);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifrespawn:
- parse - part 4.
2020-10-23 18:19:44 +00:00
if( badguy(g_ac) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse( ud.respawn_monsters );
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if( inventory(g_ac->s) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse( ud.respawn_inventory );
else
parseifelse( ud.respawn_items );
break;
case concmd_iffloordistl:
insptr++;
- parse - part 4.
2020-10-23 18:19:44 +00:00
parseifelse( (g_ac->floorz - g_sp->z) <= ((*insptr)<<8));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifceilingdistl:
insptr++;
- parse - part 4.
2020-10-23 18:19:44 +00:00
parseifelse( ( g_sp->z - g_ac->ceilingz ) <= ((*insptr)<<8));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_palfrom:
insptr++;
SetPlayerPal(&ps[g_p], PalEntry(insptr[0], insptr[1], insptr[2], insptr[3]));
insptr += 4;
break;
/* case 74:
insptr++;
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
getglobalz(g_ac);
- parse - part 4.
2020-10-23 18:19:44 +00:00
parseifelse( (( g_ac->floorz - g_ac->ceilingz ) >> 8 ) >= *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
*/
case concmd_addlog:
{ int l;
int lFile;
insptr++;
lFile=*(insptr++); // file
l=*(insptr++); // line
// this was only printing file name and line number as debug output.
break;
}
case concmd_addlogvar:
{ int l;
int lFile;
insptr++;
lFile=*(insptr++); // file
l=*(insptr++); // l=Line number, *instpr=varID
if( (*insptr >= iGameVarCount)
|| *insptr < 0
)
{
// invalid varID
insptr++;
break; // out of switch
}
DPrintf(DMSG_NOTIFY, "ADDLOGVAR: ");
if( aGameVars[*insptr].dwFlags & GAMEVAR_FLAG_READONLY)
{
DPrintf(DMSG_NOTIFY, " (read-only)");
}
if( aGameVars[*insptr].dwFlags & GAMEVAR_FLAG_PERPLAYER)
{
DPrintf(DMSG_NOTIFY, " (Per Player. Player=%d)",g_p);
}
else if( aGameVars[*insptr].dwFlags & GAMEVAR_FLAG_PERACTOR)
{
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
DPrintf(DMSG_NOTIFY, " (Per Actor. Actor=%p)",g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
{
DPrintf(DMSG_NOTIFY, " (Global)");
}
- Tidy up some GCC warnings about ininitialised variables, memsetting non-trivial types and some others.
2021-12-07 22:27:12 +00:00
DPrintf(DMSG_NOTIFY, " =%d", GetGameVarID(*insptr, g_ac, g_p).safeValue());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_setvar:
{ int i;
insptr++;
i=*(insptr++); // ID of def
- use an actor pointer in Get/SetGameVarID's parameters to weed out the ordering screwups.
2020-11-01 17:23:09 +00:00
SetGameVarID(i, *insptr, g_ac, g_p );
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_setvarvar:
{ int i;
insptr++;
i=*(insptr++); // ID of def
- use an actor pointer in Get/SetGameVarID's parameters to weed out the ordering screwups.
2020-11-01 17:23:09 +00:00
SetGameVarID(i, GetGameVarID(*insptr, g_ac, g_p), g_ac, g_p );
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// aGameVars[i].lValue = aGameVars[*insptr].lValue;
insptr++;
break;
}
case concmd_addvar:
{ int i;
insptr++;
i=*(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue() + *insptr, g_ac, g_p );
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_addvarvar:
{ int i;
insptr++;
i=*(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue() + GetGameVarID(*insptr, g_ac, g_p).safeValue(), g_ac, g_p );
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_ifvarvare:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() == GetGameVarID(*(insptr), g_ac, g_p).safeValue())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifvarvarg:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() > GetGameVarID(*(insptr), g_ac, g_p).safeValue())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifvarvarl:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() < GetGameVarID(*(insptr), g_ac, g_p).safeValue())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifvare:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() == *insptr)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifvarg:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() > *insptr)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifvarl:
{
int i;
insptr++;
i=*(insptr++); // ID of def
j=0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if(GetGameVarID(i, g_ac, g_p).safeValue() < *insptr)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
j=1;
}
parseifelse( j );
break;
}
case concmd_ifphealthl:
insptr++;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
parseifelse( ps[g_p].GetActor()->s->extra < *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifpinventory:
{
insptr++;
j = 0;
switch(*(insptr++))
{
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 0:
if( ps[g_p].steroids_amount != *insptr)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
break;
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 1:
if(ps[g_p].shield_amount != gs.max_player_health )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
break;
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 2:
if(ps[g_p].scuba_amount != *insptr) j = 1;
break;
case 3:
if(ps[g_p].holoduke_amount != *insptr) j = 1;
break;
case 4:
if(ps[g_p].jetpack_amount != *insptr) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case 6:
if (isRR())
{
switch (g_sp->lotag)
{
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 100:
if (ps[g_p].keys[1]) j = 1;
break;
case 101:
if (ps[g_p].keys[2]) j = 1;
break;
case 102:
if (ps[g_p].keys[3]) j = 1;
break;
case 103:
if (ps[g_p].keys[4]) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
else
{
switch (g_sp->pal)
{
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 0:
if (ps[g_p].got_access & 1) j = 1;
break;
case 21:
if (ps[g_p].got_access & 2) j = 1;
break;
case 23:
if (ps[g_p].got_access & 4) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
break;
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
case 7:
if(ps[g_p].heat_amount != *insptr) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case 9:
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
if(ps[g_p].firstaid_amount != *insptr) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case 10:
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
if(ps[g_p].boot_amount != *insptr) j = 1;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
parseifelse(j);
break;
- safety commit
2020-05-14 07:07:07 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_pstomp:
- safety commit
2020-05-14 07:07:07 +00:00
insptr++;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->s->xrepeat >= (isRR()? 9: 40) )
- sectnum removal step
2021-11-21 08:05:58 +00:00
if( cansee(g_sp->x,g_sp->y,g_sp->z-(4<<8),g_sp->sector(),ps[g_p].pos.x,ps[g_p].pos.y,ps[g_p].pos.z+(16<<8),ps[g_p].GetActor()->s->sector()) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
ps[g_p].knee_incs = 1;
if(ps[g_p].weapon_pos == 0)
ps[g_p].weapon_pos = -1;
- parse - part 5.
2020-10-23 18:21:09 +00:00
ps[g_p].actorsqu = g_ac;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_ifawayfromwall:
{
- sectnum removal step
2021-11-21 08:05:58 +00:00
auto s1 = g_sp->sector();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 0;
updatesector(g_sp->x + 108, g_sp->y + 108, &s1);
- sectnum removal step
2021-11-21 08:05:58 +00:00
if (s1 == g_sp->sector())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
updatesector(g_sp->x - 108, g_sp->y - 108, &s1);
- sectnum removal step
2021-11-21 08:05:58 +00:00
if (s1 == g_sp->sector())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
updatesector(g_sp->x + 108, g_sp->y - 108, &s1);
- sectnum removal step
2021-11-21 08:05:58 +00:00
if (s1 == g_sp->sector())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
updatesector(g_sp->x - 108, g_sp->y + 108, &s1);
- sectnum removal step
2021-11-21 08:05:58 +00:00
if (s1 == g_sp->sector())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
}
}
}
parseifelse(j);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_quote:
insptr++;
FTA(*insptr,&ps[g_p]);
insptr++;
break;
case concmd_ifinouterspace:
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
parseifelse( fi.floorspace(g_sp->sector()));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifnotmoving:
- Duke: fixed bad check in 'ifnotmoving' CON command.
2021-05-14 08:03:07 +00:00
parseifelse( (g_ac->movflag&kHitTypeMask) > kHitSector );
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_respawnhitag:
insptr++;
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
fi.respawnhitag(g_ac);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifspritepal:
insptr++;
parseifelse( g_sp->pal == *insptr);
break;
case concmd_ifangdiffl:
insptr++;
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
j = abs(getincangle(ps[g_p].angle.ang.asbuild(),g_sp->ang));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse( j <= *insptr);
break;
case concmd_ifnosounds:
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
parseifelse(!S_CheckAnyActorSoundPlaying(g_ac));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
case concmd_ifplaybackon: //Twentieth Anniversary World Tour
parseifelse(false);
break;
case concmd_espawnvar:
- step 1.
2020-05-14 17:23:36 +00:00
{
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
DDukeActor* lReturn = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int lIn;
insptr++;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lIn = *insptr++;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lIn = GetGameVarID(lIn, g_ac, g_p).safeValue();
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(g_ac->insector())
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
lReturn = spawn(g_ac, lIn);
- safety commit
2020-05-14 07:07:07 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(g_iReturnVarID, (lReturn), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_espawn:
{
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
DDukeActor* lReturn = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(g_ac->insector())
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
lReturn = spawn(g_ac, *insptr);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(g_iReturnVarID, (lReturn), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setsector:
case concmd_getsector:
{
// syntax [gs]etsector[<var>].x <VAR>
// <varid> <xxxid> <varid>
int lLabelID;
int lVar1, lVar2;
int lWhat;
int lParm2;
lWhat = *(insptr++);
lVar1 = *(insptr++);
lLabelID = *(insptr++);
- added the SHOOT event and fixed some issues with poor code generation for the game data accessors. They created different code depending on the passed index, this was changed to always emit the optional parameter, even when not needed, so that the interpreter does not need to second-guess.
2020-09-17 21:02:52 +00:00
lParm2 = *(insptr++);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lVar2 = *(insptr++);
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DoSector(lWhat == concmd_setsector, lVar1, lLabelID, lVar2, g_ac, g_p, lParm2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_sqrt:
{
// syntax sqrt <invar> <outvar>
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int lInVarID;
int lOutVarID;
int lIn;
insptr++;
lInVarID = *(insptr++);
lOutVarID = *(insptr++);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lIn = GetGameVarID(lInVarID, g_ac, g_p).safeValue();
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(lOutVarID, ksqrt(lIn), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_findnearactor:
{
// 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>
int lType;
int lMaxDist;
int lVarID;
int lTemp;
int lDist;
insptr++;
lType = *(insptr++);
lMaxDist = *(insptr++);
lVarID = *(insptr++);
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
DDukeActor* lFound = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lDist = 32767; // big number
- parse - part 6.
2020-10-23 18:22:08 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto j = it.Next())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (j->s->picnum == lType)
- safety commit
2020-05-14 07:07:07 +00:00
{
- parse - part 6.
2020-10-23 18:22:08 +00:00
lTemp = ldist(g_ac, j);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (lTemp < lMaxDist)
{
if (lTemp < lDist)
{
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
lFound = j;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(lVarID, (lFound), g_ac, g_p);
- safety commit
2020-05-14 07:07:07 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_findnearactorvar:
{
// 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>
int lType;
int lMaxDistVar;
int lMaxDist;
int lVarID;
int lTemp;
int lDist;
insptr++;
lType = *(insptr++);
lMaxDistVar = *(insptr++);
lVarID = *(insptr++);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lMaxDist = GetGameVarID(lMaxDistVar, g_ac, g_p).safeValue();
- fixed most warnings GCC pointed out in game code.
2021-11-14 12:33:35 +00:00
DDukeActor* lFound = nullptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lDist = 32767; // big number
- parse - part 6.
2020-10-23 18:22:08 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto j = it.Next())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (j->s->picnum == lType)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- parse - part 6.
2020-10-23 18:22:08 +00:00
lTemp = ldist(g_ac, j);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (lTemp < lMaxDist)
{
if (lTemp < lDist)
{
- use the script interface where needed. Later the scripts should only see some token representing an actor, not an index.
2020-10-25 05:40:05 +00:00
lFound = j;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
}
}
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(lVarID, (lFound), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setplayer:
case concmd_getplayer:
{
// syntax [gs]etplayer[<var>].x <VAR>
// <varid> <xxxid> <varid>
int lLabelID;
int lVar1, lVar2;
int lWhat;
int lParm2;
lWhat = *(insptr++);
lVar1 = *(insptr++);
lLabelID = *(insptr++);
- added the SHOOT event and fixed some issues with poor code generation for the game data accessors. They created different code depending on the passed index, this was changed to always emit the optional parameter, even when not needed, so that the interpreter does not need to second-guess.
2020-09-17 21:02:52 +00:00
lParm2 = *(insptr++);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lVar2 = *(insptr++);
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DoPlayer(lWhat == concmd_setplayer, lVar1, lLabelID, lVar2, g_ac, g_p, lParm2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_getuserdef:
case concmd_setuserdef:
{
// syntax [gs]etuserdef.xxx <VAR>
// <xxxid> <varid>
int lLabelID;
int lVar1, lVar2;
int lWhat;
int lParm2;
lWhat = *(insptr++);
lVar1 = -1;
lLabelID = *(insptr++);
- added the SHOOT event and fixed some issues with poor code generation for the game data accessors. They created different code depending on the passed index, this was changed to always emit the optional parameter, even when not needed, so that the interpreter does not need to second-guess.
2020-09-17 21:02:52 +00:00
lParm2 = *(insptr++);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lVar2 = *(insptr++);
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DoUserDef(lWhat == concmd_setuserdef, lVar1, lLabelID, lVar2, g_ac, g_p, lParm2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setwall:
case concmd_getwall:
{
// syntax [gs]etwall[<var>].x <VAR>
// <varid> <xxxid> <varid>
int lLabelID;
int lVar1, lVar2;
int lWhat;
int lParm2;
lWhat = *(insptr++);
lVar1 = *(insptr++);
lLabelID = *(insptr++);
- added the SHOOT event and fixed some issues with poor code generation for the game data accessors. They created different code depending on the passed index, this was changed to always emit the optional parameter, even when not needed, so that the interpreter does not need to second-guess.
2020-09-17 21:02:52 +00:00
lParm2 = *(insptr++);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lVar2 = *(insptr++);
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DoWall(lWhat == concmd_setwall, lVar1, lLabelID, lVar2, g_ac, g_p, lParm2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setactorvar:
{
// syntax [gs]etactorvar[<var>].<varx> <VAR>
// gets the value of the per-actor variable varx into VAR
// <var> <varx> <VAR>
int lVar1, lVar2, lVar3;
insptr++;
lVar1 = *(insptr++);
lVar2 = *(insptr++);
lVar3 = *(insptr++);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto lSprite = GetGameVarID(lVar1, g_ac, g_p);
if (lSprite.isActor())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto lTemp = GetGameVarID(lVar3, g_ac, g_p);
SetGameVarID(lVar2, lTemp, lSprite.actor(), g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
break;
}
case concmd_getactorvar:
{
// syntax [gs]etactorvar[<var>].<varx> <VAR>
// gets the value of the per-actor variable varx into VAR
// <var> <varx> <VAR>
int lVar1, lVar2, lVar3;
insptr++;
lVar1 = *(insptr++);
lVar2 = *(insptr++);
lVar3 = *(insptr++);
- safety commit
2020-05-14 07:07:07 +00:00
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto lSprite = GetGameVarID(lVar1, g_ac, g_p);
if (lSprite.isActor())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
auto lTemp = GetGameVarID(lVar2, lSprite.actor(), g_p);
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(lVar3, lTemp, g_ac, g_p);
- safety commit
2020-05-14 07:07:07 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setactor:
case concmd_getactor:
{
// syntax [gs]etactor[<var>].x <VAR>
// <varid> <xxxid> <varid>
int lLabelID;
int lVar1, lVar2;
int lWhat;
int lParm2;
lWhat = *(insptr++);
lVar1 = *(insptr++);
lLabelID = *(insptr++);
- added the SHOOT event and fixed some issues with poor code generation for the game data accessors. They created different code depending on the passed index, this was changed to always emit the optional parameter, even when not needed, so that the interpreter does not need to second-guess.
2020-09-17 21:02:52 +00:00
lParm2 = *(insptr++);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lVar2 = *(insptr++);
- CON game access interface done.
2020-10-23 17:07:33 +00:00
DoActor(lWhat == concmd_setactor, lVar1, lLabelID, lVar2, g_ac, g_p, lParm2);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_getangletotarget:
{
int i;
- Duke/RR: replaced more local short variables with ints.
2021-11-07 13:36:39 +00:00
int ang;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
i = *(insptr++); // ID of def
- parse - part 6.
2020-10-23 18:22:08 +00:00
// g_ac->lastvx and lastvy are last known location of target.
ang = getangle(g_ac->lastvx - g_sp->x, g_ac->lastvy - g_sp->y);
SetGameVarID(i, ang, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_lockplayer:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
ps[g_p].transporter_hold = GetGameVarID(i, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_getplayerangle:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(i, ps[g_p].angle.ang.asbuild(), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_setplayerangle:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
ps[g_p].angle.ang = buildang(GetGameVarID(i, g_ac, g_p).safeValue() & 2047);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_getactorangle:
{
int i;
- safety commit
2020-05-14 07:07:07 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(i, g_sp->ang, g_ac, g_p);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_setactorangle:
{
int i;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
g_sp->ang = GetGameVarID(i, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
g_sp->ang &= 2047;
- step 1.
2020-05-14 17:23:36 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_randvar:
{
int i;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Replace `mulscale()` calls with `MulScale()` from common.
2021-01-04 11:57:26 +00:00
SetGameVarID(i, MulScale(rand(), *insptr, 15), g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_mulvar:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue()* (*insptr), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_divvar:
{
int i;
insptr++;
i = *(insptr++); // ID of def
if ((*insptr) == 0)
- step 1.
2020-05-14 17:23:36 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
I_Error("Divide by Zero in CON.");
- step 1.
2020-05-14 17:23:36 +00:00
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue() / (*insptr), g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_modvar:
{
int i;
int l;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
l = (*insptr);
if (l == 0)
- step 1.
2020-05-14 17:23:36 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
I_Error("Divide by Zero in CON");
- step 1.
2020-05-14 17:23:36 +00:00
}
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lResult = GetGameVarID(i, g_ac, g_p).safeValue() % l;
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
- step 1.
2020-05-14 17:23:36 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_andvar:
{
int i;
int l;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
l = (*insptr);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lResult = GetGameVarID(i, g_ac, g_p).safeValue() & l;
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_xorvar:
{
int i;
int l;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
l = (*insptr);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lResult = GetGameVarID(i, g_ac, g_p).safeValue() ^ l;
- parse - part 6.
2020-10-23 18:22:08 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_orvar:
{
int i;
int l;
int lResult;
insptr++;
i = *(insptr++); // ID of def
l = (*insptr);
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lResult = GetGameVarID(i, g_ac, g_p).safeValue() | l;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_randvarvar:
{
int i;
int l1, l2;
int lResult;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue(); // not used for this command
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- Replace `mulscale()` calls with `MulScale()` from common.
2021-01-04 11:57:26 +00:00
lResult = MulScale(rand(), l2, 15);
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_gmaxammo:
{
int i;
int l1, l2;
int lResult;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue(); // l2 not used in this one
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
lResult = gs.max_ammo_amount[l1];
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(*insptr, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_smaxammo:
{
int i;
int l1, l2;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
gs.max_ammo_amount[l1] = l2;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
case concmd_mulvarvar:
{
int i;
int l1, l2;
int lResult;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 * l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_divvarvar:
{
int i;
int l1, l2;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (l2 == 0)
- step 1.
2020-05-14 17:23:36 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
I_Error("Divide by Zero in CON");
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 / l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_modvarvar:
{
int i;
int l1, l2;
int lResult;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (l2 == 0)
- step 1.
2020-05-14 17:23:36 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
I_Error("Mod by Zero in CON");
- step 1.
2020-05-14 17:23:36 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 % l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_andvarvar:
{
int i;
int l1, l2;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 & l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_xorvarvar:
{
int i;
int l1, l2;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 ^ l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_orvarvar:
{
int i;
int l1, l2;
int lResult;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
l1 = GetGameVarID(i, g_ac, g_p).safeValue();
l2 = GetGameVarID(*insptr, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lResult = l1 | l2;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lResult, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_subvar:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue() - *insptr, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_subvarvar:
{
int i;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
SetGameVarID(i, GetGameVarID(i, g_ac, g_p).safeValue() - GetGameVarID(*insptr, g_ac, g_p).safeValue(), g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_sin:
{
int i;
int lValue;
insptr++;
i = *(insptr++); // ID of def
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lValue = bsin(GetGameVarID(*insptr, g_ac, g_p).safeValue());
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, lValue, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
break;
}
case concmd_spgetlotag:
{
insptr++;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(g_iLoTagID, g_sp->lotag, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_spgethitag:
{
insptr++;
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(g_iHiTagID, g_sp->hitag, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_sectgetlotag:
{
insptr++;
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
SetGameVarID(g_iLoTagID, g_sp->sector()->lotag, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_sectgethitag:
{
insptr++;
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
SetGameVarID(g_iHiTagID, g_sp->sector()->hitag, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_gettexturefloor:
{
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
SetGameVarID(g_iTextureID, g_sp->sector()->floorpicnum, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_startlevel:
{
// from 'level' cheat in game.c (about line 6250)
int volnume;
int levnume;
insptr++; // skip command
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
volnume = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
levnume = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
- adapted map transition in Duke/RR. There's still some issues which will be taken care of by adding map flags.
2021-05-02 08:35:43 +00:00
auto level = FindMapByIndex(volnume, levnume);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (level != nullptr)
- Ensure `g_nextskill` is used everywhere so that setting skill for next level works properly.
2021-07-20 08:51:34 +00:00
ChangeLevel(level, g_nextskill);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_myosx:
case concmd_myospalx:
case concmd_myos:
case concmd_myospal:
{
int x, y;
int tilenum;
int shade;
int orientation;
int pal;
int tw = *insptr++;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
x = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
y = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
tilenum = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
shade = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
orientation = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (tw == concmd_myospal)
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
pal = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
//myospal(x, y, tilenum, shade, orientation, pal);
}
else if (tw == concmd_myos)
{
//myos(x, y, tilenum, shade, orientation);
}
else if (tw == concmd_myosx)
{
//myos640(x, y, tilenum, shade, orientation);
}
else if (tw == concmd_myospalx)
{
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
pal = GetGameVarID(*insptr++, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
//myospal640(x, y, tilenum, shade, orientation, pal);
}
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_displayrand:
{
int i;
- step 1.
2020-05-14 17:23:36 +00:00
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
- parse - part 7.
2020-10-23 18:22:55 +00:00
SetGameVarID(i, rand(), g_ac, g_p);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_switch:
- step 1.
2020-05-14 17:23:36 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int lVarID;
int lValue;
int* lpDefault;
int* lpCases;
int lCases;
int lEnd;
int lCheckCase;
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
bool bMatched;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int* lTempInsPtr;
// 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
insptr++; // p-code
lVarID = *insptr++;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
lValue = GetGameVarID(lVarID, g_ac, g_p).safeValue();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lEnd = *insptr++;
lCases = *insptr++;
lpDefault = insptr++;
lpCases = insptr;
insptr += lCases * 2;
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
bMatched = false;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
lTempInsPtr = insptr;
for (lCheckCase = 0; lCheckCase < lCases && !bMatched; lCheckCase++)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (lpCases[lCheckCase * 2] == lValue)
{
insptr = &ScriptCode[lpCases[lCheckCase * 2 + 1]];
while (1)
{
if (parse())
break;
}
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
bMatched = true;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (!bMatched)
{
if (*lpDefault)
{
insptr = &ScriptCode[*lpDefault];
while (1) if (parse()) break;
}
else
{
//AddLog("No Matching Case: No Default to use");
}
}
insptr = &ScriptCode[lEnd];
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_endswitch:
insptr++;
return 1;
break;
case concmd_starttrack:
- step 1.
2020-05-14 17:23:36 +00:00
{
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
int music_select = *insptr++;
- adapted map transition in Duke/RR. There's still some issues which will be taken care of by adding map flags.
2021-05-02 08:35:43 +00:00
auto level = FindMapByIndex(currentLevel->cluster, music_select+1); // this was 0-based in EDuke 2.0...
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (level) S_PlayLevelMusic(level);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_gettextureceiling:
{
insptr++;
- use sector wrappers where easily doable with search and replace.
2021-11-06 12:47:06 +00:00
SetGameVarID(g_iTextureID, g_sp->sector()->ceilingpicnum, g_ac, g_p);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
}
case concmd_ifvarvarand:
- step 1.
2020-05-14 17:23:36 +00:00
{
int i;
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
j = 0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (GetGameVarID(i, g_ac, g_p).safeValue() & GetGameVarID(*(insptr), g_ac, g_p).safeValue())
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_ifvarvarn:
- step 1.
2020-05-14 17:23:36 +00:00
{
int i;
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
j = 0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (GetGameVarID(i, g_ac, g_p).safeValue() != GetGameVarID(*(insptr), g_ac, g_p).safeValue())
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_ifvarn:
- step 1.
2020-05-14 17:23:36 +00:00
{
int i;
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
j = 0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (GetGameVarID(i, g_ac, g_p).safeValue() != *insptr)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case concmd_ifvarand:
- step 1.
2020-05-14 17:23:36 +00:00
{
int i;
insptr++;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
i = *(insptr++); // ID of def
j = 0;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
if (GetGameVarID(i, g_ac, g_p).safeValue() & *insptr)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
j = 1;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
parseifelse(j);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
default:
Printf(TEXTCOLOR_RED "Unrecognized PCode of %d in parse. Killing current sprite.\n",*insptr);
Printf(TEXTCOLOR_RED "Offset=%0X\n",int(insptr-ScriptCode.Data()));
killit_flag = 1;
- step 1.
2020-05-14 17:23:36 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
return 0;
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- LoadActor.
2020-10-23 18:27:05 +00:00
void LoadActor(DDukeActor *actor, int p, int x)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
int done;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
ParseState s;
s.g_p = p; // Player ID
s.g_x = x; // ??
- LoadActor.
2020-10-23 18:27:05 +00:00
s.g_ac = actor;
s.g_t = &s.g_ac->temp_data[0]; // Sprite's 'extra' data
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
auto addr = gs.tileinfo[actor->s->picnum].loadeventscriptptr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (addr == 0) return;
s.killit_flag = 0;
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(!actor->insector())
- step 1.
2020-05-14 17:23:36 +00:00
{
- LoadActor.
2020-10-23 18:27:05 +00:00
deletesprite(actor);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
return;
}
do
done = s.parse();
while (done == 0);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (s.killit_flag == 1)
{
- LoadActor.
2020-10-23 18:27:05 +00:00
// if player was set to squish, first stop that..
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if (p >= 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- LoadActor.
2020-10-23 18:27:05 +00:00
if (ps[p].actorsqu == actor)
- made player.actorsqu a pointer and added the needed infrastructure for that.
2020-10-17 08:30:11 +00:00
ps[p].actorsqu = nullptr;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- LoadActor.
2020-10-23 18:27:05 +00:00
deletesprite(actor);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
else
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- LoadActor.
2020-10-23 18:27:05 +00:00
fi.move(actor, p, x);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (actor->s->statnum == STAT_ACTOR)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- LoadActor.
2020-10-23 18:27:05 +00:00
if (badguy(actor))
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (actor->s->xrepeat > 60) return;
if (ud.respawn_monsters == 1 && actor->s->extra <= 0) return;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if (ud.respawn_items == 1 && (actor->s->cstat & 32768)) return;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- LoadActor.
2020-10-23 18:27:05 +00:00
if (actor->timetosleep > 1)
actor->timetosleep--;
else if (actor->timetosleep == 1)
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(actor, STAT_ZOMBIEACTOR);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if (actor->s->statnum == 6)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
#if 0
- LoadActor.
2020-10-23 18:27:05 +00:00
switch (actor->s.picnum)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case RUBBERCAN:
case EXPLODINGBARREL:
case WOODENHORSE:
case HORSEONSIDE:
case CANWITHSOMETHING:
case FIREBARREL:
case NUKEBARREL:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case TRIPBOMB:
case EGG:
- LoadActor.
2020-10-23 18:27:05 +00:00
if (actor->timetosleep > 1)
actor->timetosleep--;
else if (actor->timetosleep == 1)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
changespritestat(i, 2);
break;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
#endif
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
- step 1.
2020-05-14 17:23:36 +00:00
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- execute.
2020-10-23 18:28:29 +00:00
void execute(DDukeActor *actor,int p,int x)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (gs.actorinfo[actor->s->picnum].scriptaddress == 0) return;
- got rid of the old interpreter code.
2020-05-15 06:04:30 +00:00
- step 1.
2020-05-14 17:23:36 +00:00
int done;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
ParseState s;
s.g_p = p; // Player ID
s.g_x = x; // ??
- execute.
2020-10-23 18:28:29 +00:00
s.g_ac = actor;
s.g_t = &actor->temp_data[0]; // Sprite's 'extra' data
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (gs.actorinfo[actor->s->picnum].scriptaddress == 0) return;
s.insptr = &ScriptCode[4 + (gs.actorinfo[actor->s->picnum].scriptaddress)];
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
s.killit_flag = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if(!actor->insector())
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- execute.
2020-10-23 18:28:29 +00:00
if(badguy(actor))
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
ps[p].actors_killed++;
- execute.
2020-10-23 18:28:29 +00:00
deletesprite(actor);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
return;
}
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
if (s.g_t[4])
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- step 1.
2020-05-14 17:23:36 +00:00
// This code was utterly cryptic in the original source.
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
auto ptr = &ScriptCode[s.g_t[4]];
- step 1.
2020-05-14 17:23:36 +00:00
int numframes = ptr[1];
int increment = ptr[3];
int delay = ptr[4];
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
actor->s->lotag += TICSPERFRAME;
if (actor->s->lotag > delay)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
s.g_t[2]++;
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
actor->s->lotag = 0;
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
s.g_t[3] += increment;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
if (abs(s.g_t[3]) >= abs(numframes * increment))
s.g_t[3] = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
do
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
done = s.parse();
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
while( done == 0 );
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
if(s.killit_flag == 1)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- execute.
2020-10-23 18:28:29 +00:00
// if player was set to squish, first stop that..
if(ps[p].actorsqu == actor)
- made player.actorsqu a pointer and added the needed infrastructure for that.
2020-10-17 08:30:11 +00:00
ps[p].actorsqu = nullptr;
- got rid of the old interpreter code.
2020-05-15 06:04:30 +00:00
killthesprite = true;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
else
{
- execute.
2020-10-23 18:28:29 +00:00
fi.move(actor, p, x);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (actor->s->statnum == STAT_ACTOR)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- execute.
2020-10-23 18:28:29 +00:00
if (badguy(actor))
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
if (actor->s->xrepeat > 60) goto quit;
if (ud.respawn_monsters == 1 && actor->s->extra <= 0) goto quit;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if (ud.respawn_items == 1 && (actor->s->cstat & 32768)) goto quit;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- execute.
2020-10-23 18:28:29 +00:00
if (actor->timetosleep > 1)
actor->timetosleep--;
else if (actor->timetosleep == 1)
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(actor, STAT_ZOMBIEACTOR);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- made DukeActor::s a pointer. As a reference we would never be able to export this to scripting
2021-04-15 17:21:43 +00:00
else if (actor->s->statnum == STAT_STANDABLE)
- execute.
2020-10-23 18:28:29 +00:00
fi.checktimetosleep(actor);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- got rid of the old interpreter code.
2020-05-15 06:04:30 +00:00
quit:
- execute.
2020-10-23 18:28:29 +00:00
if (killthesprite) deletesprite(actor);
- got rid of the old interpreter code.
2020-05-15 06:04:30 +00:00
killthesprite = false;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
void OnEvent(int iEventID, int p, DDukeActor *actor, int x)
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
{
- Duke/RR: eliminated all uses of 'char' outside of text management
2021-11-07 11:53:48 +00:00
int done;
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
if (iEventID >= MAXGAMEEVENTS)
{
Printf("Invalid Event ID\n");
return;
}
if (apScriptGameEvent[iEventID] == 0)
{
return;
}
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
ParseState s;
s.g_p = p; /// current player ID
s.g_x = x; // ?
- fixed the messed up parameter order of OnEvent. This should serve as a textbook example why passing around indices is a very, very bad idea!
2020-11-01 16:57:40 +00:00
s.g_ac = actor;
s.g_t = actor->temp_data;
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
s.insptr = &ScriptCode[apScriptGameEvent[iEventID]];
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
s.killit_flag = 0;
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
do
- put the CON interpreter into a class to get rid of its global variables.
2020-07-18 10:37:35 +00:00
done = s.parse();
- cleanup after removing EDukes's script code. # Conflicts: # source/games/duke/src/zz_game.cpp # source/games/duke/src/zz_gameexec.cpp
2020-05-15 08:44:57 +00:00
while (done == 0);
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
END_DUKE_NS
Reference in a new issue Copy permalink