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

3843 lines
94 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:
- Duke: Replace `player_struct` `exitx` with `exit.X` calls.
2021-12-30 11:37:32 +00:00
if (bSet) ps[iPlayer].exit.X = lValue;
else SetGameVarID(lVar2, ps[iPlayer].exit.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_EXITY:
- Duke: Replace `player_struct` `exity` with `exit.Y` calls.
2021-12-30 11:39:32 +00:00
if (bSet) ps[iPlayer].exit.Y = lValue;
else SetGameVarID(lVar2, ps[iPlayer].exit.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_LOOGIEX:
- Duke: Replace `player_struct` `loogiex[64]` with `loogie[64].X` calls.
2021-12-30 11:45:53 +00:00
if (bSet) ps[iPlayer].loogie[lParm2].X = lValue;
else SetGameVarID(lVar2, ps[iPlayer].loogie[lParm2].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_LOOGIEY:
- Duke: Replace `player_struct` `loogiey[64]` with `loogie[64].Y` calls.
2021-12-30 11:47:19 +00:00
if (bSet) ps[iPlayer].loogie[lParm2].Y = lValue;
else SetGameVarID(lVar2, ps[iPlayer].loogie[lParm2].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_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:
- Duke: Interpolate `loogcnt` when drawing onscreen.
2022-06-06 01:24:38 +00:00
if (bSet) ps[iPlayer].oloogcnt = 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.
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].player_int_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:
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].player_int_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:
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].player_int_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;
}
- Remove multiple `addadjustment()`/`settarget()` overloads in favour of native `binangle`/`fixedhoriz` versions only. * Simplifies these classes a bit. * Better shows intent in actual game code. * Removes unnecessary int to double conversions.
2022-05-30 10:35:41 +00:00
ps[iPlayer].horizon.settarget(buildhoriz(lValue));
- 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
}
- 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:
- Duke: Replace `player_struct` `bobposx` with `bobpos.X` calls.
2021-12-30 11:57:39 +00:00
if (bSet) ps[iPlayer].bobpos.X = lValue;
else SetGameVarID(lVar2, ps[iPlayer].bobpos.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_BOBPOSY:
- Duke: Replace `player_struct` `bobposy` with `bobpos.Y` calls.
2021-12-30 11:59:45 +00:00
if (bSet) ps[iPlayer].bobpos.Y = lValue;
else SetGameVarID(lVar2, ps[iPlayer].bobpos.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;
- 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:
- __int_opos is gone.
2022-02-05 11:30:00 +00:00
if (bSet) ps[iPlayer].opos.X = lValue * maptoworld;
else SetGameVarID(lVar2, ps[iPlayer].opos.X * (1/maptoworld), 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:
- __int_opos is gone.
2022-02-05 11:30:00 +00:00
if (bSet) ps[iPlayer].opos.Y = lValue * maptoworld;
else SetGameVarID(lVar2, ps[iPlayer].opos.Y * (1 / maptoworld), 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:
- __int_opos is gone.
2022-02-05 11:30:00 +00:00
if (bSet) ps[iPlayer].opos.Z = lValue * zmaptoworld;
else SetGameVarID(lVar2, ps[iPlayer].opos.Z * (1 / zmaptoworld), 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:
- Duke: Replace `player_struct` `posxv` with `vel.X` calls.
2021-12-30 11:14:55 +00:00
if (bSet) ps[iPlayer].vel.X = lValue;
else SetGameVarID(lVar2, ps[iPlayer].vel.X, 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:
- Duke: Replace `player_struct` `posyv` with `vel.Y` calls.
2021-12-30 11:18:56 +00:00
if (bSet) ps[iPlayer].vel.Y = lValue;
else SetGameVarID(lVar2, ps[iPlayer].vel.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;
- 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:
- Duke: Replace `player_struct` `poszv` with `vel.Z` calls.
2021-12-30 11:14:04 +00:00
if (bSet) ps[iPlayer].vel.Z = lValue;
else SetGameVarID(lVar2, ps[iPlayer].vel.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;
- 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:
- floatified player_struct::truecz/truefz.
2022-02-04 16:49:48 +00:00
if (bSet) ps[iPlayer].truefz = lValue * zmaptoworld;
else SetGameVarID(lVar2, ps[iPlayer].truefz * (1/zmaptoworld), 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:
- floatified player_struct::truecz/truefz.
2022-02-04 16:49:48 +00:00
if (bSet) ps[iPlayer].truecz = lValue * zmaptoworld;
else SetGameVarID(lVar2, ps[iPlayer].truecz * (1 / zmaptoworld), 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:
- Remove multiple `addadjustment()`/`settarget()` overloads in favour of native `binangle`/`fixedhoriz` versions only. * Simplifies these classes a bit. * Better shows intent in actual game code. * Removes unnecessary int to double conversions.
2022-05-30 10:35:41 +00:00
if (bSet) ps[iPlayer].angle.settarget(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.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:
- Duke: Interpolate `tipincs` when drawing onscreen (tipping the dancers).
2022-06-05 23:40:47 +00:00
if (bSet) ps[iPlayer].otipincs = 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:
- Duke: Interpolate `knee_incs` when drawing onscreen (stomping on shrunken enemies).
2022-06-05 23:19:55 +00:00
if (bSet) ps[iPlayer].oknee_incs = 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:
- Duke: Interpolate `access_incs` when drawing onscreen (security card usage).
2022-06-05 23:47:30 +00:00
if (bSet) ps[iPlayer].oaccess_incs = 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:
- Duke: Interpolate `fist_incs` when drawing onscreen (hitting the nuke detonator at the end of each level).
2022-06-05 14:12:51 +00:00
if (bSet) ps[iPlayer].ofist_incs = 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:
- Remove some uses of `xs_Float.h` functions in game-side code where overflow protection isn't needed. * Went a little bit nuts and just used this everywhere back way back when.
2022-07-21 10:18:40 +00:00
if (bSet) ps[iPlayer].sync.actions |= SB_CENTERVIEW;
else SetGameVarID(lVar2, ps[iPlayer].sync.actions & SB_CENTERVIEW ? abs(int(ps[iPlayer].horizon.horiz.asq16() * (9. / gi->playerHorizMax()))) : 0, 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);
- replaced most of numsectors, too.
2021-12-21 09:51:41 +00:00
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
- replaced numwalls with wall.Size in several places.
2021-12-21 08:54:21 +00:00
if (iWall < 0 || iWall >= (int)wall.Size() || 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:
-use an access function for reading wall positions so that we have a non-modifiable value wherever this is possible.
2022-01-27 16:41:10 +00:00
if (!bSet) SetGameVarID(lVar2, wallp->wall_int_pos().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:
-use an access function for reading wall positions so that we have a non-modifiable value wherever this is possible.
2022-01-27 16:41:10 +00:00
if (bSet) SetGameVarID(lVar2, wallp->wall_int_pos().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:
- made wall flags type safe
2021-12-18 14:36:50 +00:00
if (bSet) wallp->cstat = EWallFlags::FromInt(lValue);
- Duke: wall[] replacement in script code.
2021-11-06 23:29:16 +00:00
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'...
- moved sectno method to DCoreActor.
2021-12-30 15:39:43 +00:00
iSector = sActor->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
}
- replaced most of numsectors, too.
2021-12-21 09:51:41 +00:00
if (iSector < 0 || iSector >= (int)sector.Size() || 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:
- renamed sectortype::floorz and ceilingz as preparation for floatification
2022-02-02 23:35:12 +00:00
if (bSet) sectp->set_int_ceilingz(lValue);
- use inline access functions to read floorz/ceilingz.
2022-02-02 23:46:04 +00:00
else SetGameVarID(lVar2, sectp->int_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:
- renamed sectortype::floorz and ceilingz as preparation for floatification
2022-02-02 23:35:12 +00:00
if (bSet) sectp->set_int_floorz(lValue);
- use inline access functions to read floorz/ceilingz.
2022-02-02 23:46:04 +00:00
else SetGameVarID(lVar2, sectp->int_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:
- made sector ceiling/floor flags type safe. - made sector flags type safe.
2021-12-18 13:08:57 +00:00
if (bSet) sectp->ceilingstat = ESectorFlags::FromInt(lValue);
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
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:
- made sector ceiling/floor flags type safe. - made sector flags type safe.
2021-12-18 13:08:57 +00:00
if (bSet) sectp->floorstat = ESectorFlags::FromInt(lValue);
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
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:
- added slope setter methods to sectortype. To make sure that setting the slope flags is always done properly. (Why are the flags even needed?) As a nice side effect, this, plus use of other inlines made the align*slope functions implode into virtually nothing.
2021-12-17 22:33:16 +00:00
if (bSet) sectp->setceilingslope(lValue);
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
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:
- added slope setter methods to sectortype. To make sure that setting the slope flags is always done properly. (Why are the flags even needed?) As a nice side effect, this, plus use of other inlines made the align*slope functions implode into virtually nothing.
2021-12-17 22:33:16 +00:00
if (bSet) sectp->setfloorslope(lValue);
- Duke: a large batch of quick'n easy sector[] replacements with pointers.
2021-11-06 22:05:25 +00:00
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
}
- 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:
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
/*if (bSet) act->int_pos().X = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().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:
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
/*if (bSet) act->int_pos().Y = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().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:
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
/*if (bSet) act->int_pos().Z = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.cstat = ESpriteFlags::FromInt(lValue);
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.picnum = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.shade = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.pal = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.clipdist = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.xrepeat = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.yrepeat = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.xoffset = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.yoffset = lValue;
else SetGameVarID(lVar2, act->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);
- moved sectno method to DCoreActor.
2021-12-30 15:39:43 +00:00
else*/ SetGameVarID(lVar2, act->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);
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
else*/ SetGameVarID(lVar2, act->spr.statnum, 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;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.ang = lValue;
else SetGameVarID(lVar2, act->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.
-renamed spritetype’s owner field to ‚intowner‘ Mainly for easier searching. Also remove the duplicate ‚detail‘ field.
2022-05-23 22:30:41 +00:00
if (bSet) act->spr.intowner = lValue;
else SetGameVarID(lVar2, act->spr.intowner, 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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.xvel = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.yvel = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.zvel = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.lotag = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.hitag = lValue;
else SetGameVarID(lVar2, act->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:
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (bSet) act->spr.extra = lValue;
else SetGameVarID(lVar2, act->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:
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (bSet) act->attackertype = lValue;
else SetGameVarID(lVar2, act->attackertype, 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:
- exported DukeActor's native member variables. This includes renaming two native ones because they shared the same name with members of spritetype.
2022-01-23 23:10:25 +00:00
if (bSet) act->hitang = lValue;
else SetGameVarID(lVar2, act->hitang, 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:
- exported DukeActor's native member variables. This includes renaming two native ones because they shared the same name with members of spritetype.
2022-01-23 23:10:25 +00:00
if (bSet) act->hitextra = lValue;
else SetGameVarID(lVar2, act->hitextra, 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:
- remapped all copy assignments to DDukeActor::ceilingz/floorz. This commit does not work! It was split for clarity.
2022-02-03 23:44:13 +00:00
if (bSet) act->floorz = lValue * zmaptoworld;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
else SetGameVarID(lVar2, act->floorz * (1/zmaptoworld), 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:
- remapped all copy assignments to DDukeActor::ceilingz/floorz. This commit does not work! It was split for clarity.
2022-02-03 23:44:13 +00:00
if (bSet) act->ceilingz = lValue * zmaptoworld;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
else SetGameVarID(lVar2, act->ceilingz * (1/zmaptoworld), 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:
- Duke: Replace `DDukeActor` `lastvx` with `ovel.X` calls.
2021-12-30 11:54:08 +00:00
if (bSet) act->ovel.X = lValue;
else SetGameVarID(lVar2, act->ovel.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_HTLASTVY:
- Duke: Replace `DDukeActor` `lastvy` with `ovel.Y` calls.
2021-12-30 11:55:05 +00:00
if (bSet) act->ovel.Y = lValue;
else SetGameVarID(lVar2, act->ovel.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_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
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (badguy(actor) && actor->spr.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)
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (hit != nullptr && hit->spr.picnum == actor->spr.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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
actor->spr.ang += angdif; j = hitasprite(actor, &hit); actor->spr.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)
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (hit != nullptr && hit->spr.picnum == actor->spr.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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
actor->spr.ang -= angdif; j = hitasprite(actor, &hit); actor->spr.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)
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (hit != nullptr && hit->spr.picnum == actor->spr.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;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().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)
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((47 << 8))), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().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.
- Duke: Replace `DDukeActor` `lastvy` with `ovel.Y` calls.
2021-12-30 11:55:05 +00:00
j = furthestcanseepoint(actor, tosee, &actor->ovel.X, &actor->ovel.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
{
// else, they did see it.
- ifcansee.
2020-10-23 18:14:50 +00:00
// save where we were looking..
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
actor->ovel.X = tosee->int_pos().X;
actor->ovel.Y = tosee->int_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
}
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (j == 1 && (actor->spr.statnum == STAT_ACTOR || 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;
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.
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
int spnum = g_ac->spr.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:
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
j = cansee(g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - ((krand() & 41) << 8), g_ac->sector(), ps[g_p].player_int_pos().X, ps[g_p].player_int_pos().Y, ps[g_p].__int_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:
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
j = cansee(g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z, g_ac->sector(), ps[g_p].player_int_pos().X, ps[g_p].player_int_pos().Y, ps[g_p].player_int_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:
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
j = g_ac->spr.extra;
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
if (g_ac->isPlayer())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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--;
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
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.hitag = ScriptCode[g_t[5] + 2]; // Ai
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_t[0] = g_t[2] = g_t[3] = 0;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (g_ac->spr.hitag & random_angle)
g_ac->spr.ang = krand() & 2047;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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
insptr++;
break;
case concmd_strength:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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
insptr++;
break;
case concmd_smacksprite:
switch (krand() & 1)
{
case 0:
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.ang = (+512 + g_ac->spr.ang + (krand() & 511)) & 2047;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 1:
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.ang = (-512 + g_ac->spr.ang - (krand() & 511)) & 2047;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
}
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:
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.ang = krand() & 2047;
g_ac->spr.xvel = 25;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_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:
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (g_ac->spr.pal == 31)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
earthquaketime = 4;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
else if (g_ac->spr.pal == 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
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++)
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (ps[g_p].weaprecs[j] == g_ac->spr.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
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)
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
ps[g_p].weaprecs[ps[g_p].weapreccnt++] = g_ac->spr.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++;
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
if (g_ac->isPlayer())
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.pal = ps[g_ac->spr.yvel].palookup;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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
{
// Copied from DukeGDX.
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (g_ac->spr.picnum == TILE_EGG && g_ac->temp_data[5] == TILE_EGG + 2 && g_ac->spr.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
}
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
fi.checkweapons(&ps[g_ac->spr.yvel]);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_nullop:
insptr++;
break;
case concmd_mikesnd:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (!S_CheckActorSoundPlaying(g_ac, g_ac->spr.yvel))
S_PlayActorSound(g_ac->spr.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++;
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
if (ud.multimode > 1 && g_ac->isPlayer())
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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[otherp].quick_kick == 0)
ps[otherp].quick_kick = 14;
}
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
else if (!g_ac->isPlayer() && ps[g_p].quick_kick == 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].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
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
j = ((*insptr) - g_ac->spr.xrepeat) << 1;
g_ac->spr.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++;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
if ((g_ac->isPlayer() && g_ac->spr.yrepeat < 36) || *insptr < g_ac->spr.yrepeat || (g_ac->spr.yrepeat * (tileHeight(g_ac->spr.picnum) + 8) * REPEAT_SCALE) < 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
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
j = ((*insptr) - g_ac->spr.yrepeat) << 1;
if (abs(j)) g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.xrepeat = (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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.yrepeat = (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_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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse((short)*insptr == ambientlotag[g_ac->spr.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
break;
case concmd_ifsounddist:
insptr++;
if (*insptr == 0)
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(ambienthitag[g_ac->spr.ang] > 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
else if (*insptr == 1)
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(ambienthitag[g_ac->spr.ang] < 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_soundtag:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
S_PlayActorSound(ambientlotag[g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (!S_CheckActorSoundPlaying(g_ac, ambientlotag[g_ac->spr.ang]))
S_PlayActorSound(ambientlotag[g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (!isRRRA() || g_ac->spr.pal != 105)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
setnextmap(false);
}
break;
case concmd_mamaend:
insptr++;
ps[myconnectindex].MamaEnd = 150;
break;
case concmd_ifactorhealthg:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(g_ac->spr.extra > (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
break;
case concmd_ifactorhealthl:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(g_ac->spr.extra < (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
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++;
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
tearitup(g_ac->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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.xoffset = 0;
g_ac->spr.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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
j = ps[g_p].GetActor()->spr.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;
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[g_p].GetActor()->spr.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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (ps[g_p].GetActor()->spr.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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[g_p].GetActor()->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
movesprite_ex(g_ac, -bsin(g_ac->spr.ang, -10), bcos(g_ac->spr.ang, -10), g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
movesprite_ex(g_ac, bsin(g_ac->spr.ang, -10), -bcos(g_ac->spr.ang, -10), g_ac->spr.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++;
- wrapped player::pos z-assignments.
2022-02-05 11:56:49 +00:00
ps[g_p].player_set_int_z(ps[g_p].GetActor()->sector()->int_ceilingz());
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
ps[g_p].GetActor()->set_int_z(ps[g_p].player_int_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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
j = ps[g_p].GetActor()->spr.extra;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (g_ac->spr.picnum != TILE_ATOMICHEALTH)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- 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;
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[g_p].GetActor()->spr.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;
- another batch of utility use
2022-02-05 11:05:29 +00:00
ps[g_p].restorexyz();
- 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();
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
updatesector(ps[g_p].player_int_pos().X,ps[g_p].player_int_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);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
while (auto actj = 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
{
- fix the camera. - camera flag added
2022-01-21 00:04:08 +00:00
if (actorflag(actj, SFLAG2_CAMERA))
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
actj->spr.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
}
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
j = ps[g_p].GetActor()->spr.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
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if(g_ac->spr.picnum != TILE_ATOMICHEALTH)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- 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;
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[g_p].GetActor()->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.hitag = *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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if(g_ac->spr.hitag&random_angle)
g_ac->spr.ang = krand()&2047;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_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++;
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
parseifelse( g_ac->attackertype == *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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
bool weap = fi.spawnweapondebris(g_ac->spr.picnum, 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
- 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);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto spawned = EGS(g_ac->sector(),
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
g_ac->int_pos().X + (krand() & 255) - 128, g_ac->int_pos().Y + (krand() & 255) - 128, g_ac->int_pos().Z - (8 << 8) - (krand() & 8191),
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
dnum + s, g_ac->spr.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);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
if (spawned)
- 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 (weap)
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
spawned->spr.yvel = gs.weaponsandammosprites[j % 14];
else spawned->spr.yvel = -1;
spawned->spr.pal = g_ac->spr.pal;
- 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
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.cstat |= ESpriteFlags::FromInt(*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_clipdist:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.cstat = ESpriteFlags::FromInt(*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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.picnum = (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_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);
- another batch of utility use
2022-02-05 11:05:29 +00:00
g_ac->set_int_pos(ps[g_p].player_int_pos());
ps[g_p].backupxyz();
ps[g_p].setbobpos();
- moved the backup... methods to DCoreActor.
2021-12-30 16:10:08 +00:00
g_ac->backuppos();
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
updatesector(ps[g_p].player_int_pos().X, ps[g_p].player_int_pos().Y, &ps[g_p].cursector);
- added some utilities. This also had to use explicit types in a few places to clear ambiguities.
2022-02-05 09:16:50 +00:00
SetActor(ps[g_p].GetActor(), vec3_t( ps[g_p].player_int_pos().X, ps[g_p].player_int_pos().Y, ps[g_p].player_int_pos().Z + gs.int_playerheight ));
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.shade = -12;
g_ac->spr.clipdist = 64;
g_ac->spr.xrepeat = 42;
g_ac->spr.yrepeat = 36;
- parse - part 4.
2020-10-23 18:19:44 +00:00
g_ac->SetOwner(g_ac);
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.xoffset = 0;
g_ac->spr.pal = ps[g_p].palookup;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
ps[g_p].last_extra = g_ac->spr.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;
- Duke: Replace `player_struct` `posyv` with `vel.Y` calls.
2021-12-30 11:18:56 +00:00
ps[g_p].vel.X = ps[g_p].vel.Y = 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;
- exported DukeActor's native member variables. This includes renaming two native ones because they shared the same name with members of spritetype.
2022-01-23 23:10:25 +00:00
g_ac->hitextra = -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 inline access functions to read floorz/ceilingz.
2022-02-02 23:46:04 +00:00
parseifelse(abs(g_ac->int_pos().Z - g_ac->sector()->int_floorz()) < (32 << 8) && g_ac->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 inline access functions to read floorz/ceilingz.
2022-02-02 23:46:04 +00:00
parseifelse( abs(g_ac->int_pos().Z-g_ac->sector()->int_floorz()) < (32<<8) && g_ac->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:
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.xrepeat--;
g_ac->spr.yrepeat--;
parseifelse(g_ac->spr.xrepeat <= 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
break;
case concmd_ifwind:
parseifelse(WindTime > 0);
break;
case concmd_ifinwater:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
parseifelse( g_ac->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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(g_ac->spr.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_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())
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
switch (g_ac->spr.lotag)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 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
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
switch (g_ac->spr.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
{
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;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
s = g_ac->spr.xvel;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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
// 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;
- Duke: Replace `player_struct` `poszv` with `vel.Z` calls.
2021-12-30 11:14:04 +00:00
else if( (l& pfalling) && ps[g_p].jumping_counter == 0 && !ps[g_p].on_ground && ps[g_p].vel.Z > 2048 )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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& 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;
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
else if( (l& phigher) && ps[g_p].player_int_pos().Z < (g_ac->int_pos().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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
else if( (l& pshrunk) && ps[g_p].GetActor()->spr.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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
else if( (l& palive) && ps[g_p].GetActor()->spr.xrepeat > (isRR() ? 8 : 32) && ps[g_p].GetActor()->spr.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;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
else if( (l& pdead) && ps[g_p].GetActor()->spr.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) )
{
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
if (g_ac->isPlayer() && ud.multimode > 1)
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
j = getincangle(ps[otherp].angle.ang.asbuild(), getangle(ps[g_p].player_int_pos().X - ps[otherp].player_int_pos().X, ps[g_p].player_int_pos().Y - ps[otherp].player_int_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
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->int_pos().X - ps[g_p].player_int_pos().X, g_ac->int_pos().Y - ps[g_p].player_int_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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse(g_ac->spr.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_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);
- Duke: Replace `player_struct` `posxv` with `vel.X` calls.
2021-12-30 11:14:55 +00:00
ps[g_p].vel.X -= ps[g_p].angle.ang.bcos(7);
- Duke: Replace `player_struct` `posyv` with `vel.Y` calls.
2021-12-30 11:18:56 +00:00
ps[g_p].vel.Y -= 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
{
- Duke: Replace `player_struct` `posxv` with `vel.X` calls.
2021-12-30 11:14:55 +00:00
ps[g_p].vel.X -= ps[g_p].angle.ang.bcos(10);
- Duke: Replace `player_struct` `posyv` with `vel.Y` calls.
2021-12-30 11:18:56 +00:00
ps[g_p].vel.Y -= 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++;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
parseifelse(int(g_ac->floorz - g_ac->ceilingz) < *insptr); // Note: int cast here is needed to use the same truncation behavior as the old fixed point code.
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
parseifelse(g_ac->sector()->ceilingstat & CSTAT_SECTOR_SKY);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if( g_ac->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{};
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
neartag({ g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
- adapted neartag in Duke.
2021-11-26 17:59:28 +00:00
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))
- use inline access functions to read floorz/ceilingz.
2022-02-02 23:46:04 +00:00
if ((sectp->lotag & 0xff) == ST_23_SWINGING_DOOR || sectp->int_floorz() == sectp->int_ceilingz())
- Duke: extended neartag wrapper to use 32 bit integers as return values.
2021-11-07 09:10:00 +00:00
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
{
- game_misc.cpp + gameexec.cpp.
2021-12-21 19:29:46 +00:00
if (a2->spr.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:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
parseifelse(fi.ceilingspace(g_ac->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++;
- Duke: abstracted all checks for TILE_APLAYER with an isPlayer method.
2021-12-31 17:47:00 +00:00
if(!g_ac->isPlayer())
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->tempang = g_ac->spr.pal;
g_ac->spr.pal = *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_cactor:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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
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 );
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
else if( inventory(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_inventory );
else
parseifelse( ud.respawn_items );
break;
case concmd_iffloordistl:
insptr++;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
parseifelse(g_ac->floorz - g_ac->spr.pos.Z <= *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_ifceilingdistl:
insptr++;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
parseifelse(g_ac->spr.pos.Z - g_ac->ceilingz <= *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_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:
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
{ int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 lFile;
insptr++;
lFile=*(insptr++); // file
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr=*(insptr++); // line
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// this was only printing file name and line number as debug output.
break;
}
case concmd_addlogvar:
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
{ int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 lFile;
insptr++;
lFile=*(insptr++); // file
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr=*(insptr++); // l=Line number, *instpr=varID
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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( (*insptr >= iGameVarCount)
|| *insptr < 0
)
{
// invalid varID
insptr++;
break; // out of switch
}
DPrintf(DMSG_NOTIFY, "ADDLOGVAR: ");
- Replace every line that just contains spaces or tabs with an empty line feed in all files except 3rd party libraries.
2021-12-30 09:30:21 +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( 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;
}
- Replace every line that just contains spaces or tabs with an empty line feed in all files except 3rd party libraries.
2021-12-30 09:30:21 +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_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++;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
parseifelse( ps[g_p].GetActor()->spr.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())
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
switch (g_ac->spr.lotag)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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: 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
{
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
switch (g_ac->spr.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
{
- 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++;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->spr.xrepeat >= (isRR()? 9: 40) )
- use wrapper functions for pos/opos where possible.
2022-02-04 17:11:44 +00:00
if( cansee(g_ac->int_pos().X,g_ac->int_pos().Y,g_ac->int_pos().Z-(4<<8),g_ac->sector(),ps[g_p].player_int_pos().X,ps[g_p].player_int_pos().Y,ps[g_p].__int_pos.Z+(16<<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
{
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:
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto s1 = g_ac->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;
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y + 108, &s1);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (s1 == g_ac->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
{
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y - 108, &s1);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (s1 == g_ac->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
{
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y - 108, &s1);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (s1 == g_ac->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
{
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y + 108, &s1);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (s1 == g_ac->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:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
parseifelse( fi.floorspace(g_ac->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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
parseifelse( g_ac->spr.pal == *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_ifangdiffl:
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
j = abs(getincangle(ps[g_p].angle.ang.asbuild(),g_ac->spr.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);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
while (auto actj = 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
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
if (actj->spr.picnum == lType)
- safety commit
2020-05-14 07:07:07 +00:00
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
lTemp = ldist(g_ac, actj);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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)
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
lFound = actj;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
while (auto actj = 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
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
if (actj->spr.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
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
lTemp = ldist(g_ac, actj);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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)
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
lFound = actj;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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.
- Duke: renamed all spr.pos This was pure search&replace with no other code edits.
2022-01-31 18:21:49 +00:00
ang = getangle(g_ac->ovel.X - g_ac->int_pos().X, g_ac->ovel.Y - g_ac->int_pos().Y);
- parse - part 6.
2020-10-23 18:22:08 +00:00
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
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
SetGameVarID(i, g_ac->spr.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
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.ang = GetGameVarID(i, g_ac, g_p).safeValue();
g_ac->spr.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;
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 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
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr = (*insptr);
if (instr == 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
}
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
lResult = GetGameVarID(i, g_ac, g_p).safeValue() % instr;
- 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;
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 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
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr = (*insptr);
lResult = GetGameVarID(i, g_ac, g_p).safeValue() & instr;
- 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;
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 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
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr = (*insptr);
lResult = GetGameVarID(i, g_ac, g_p).safeValue() ^ instr;
- 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;
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
int instr;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 lResult;
insptr++;
i = *(insptr++); // ID of def
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
instr = (*insptr);
lResult = GetGameVarID(i, g_ac, g_p).safeValue() | instr;
- 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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
SetGameVarID(g_iLoTagID, g_ac->spr.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++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
SetGameVarID(g_iHiTagID, g_ac->spr.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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
SetGameVarID(g_iLoTagID, g_ac->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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
SetGameVarID(g_iHiTagID, g_ac->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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
SetGameVarID(g_iTextureID, g_ac->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 DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
SetGameVarID(g_iTextureID, g_ac->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
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
auto addr = gs.tileinfo[actor->spr.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
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (actor->spr.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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (actor->spr.xrepeat > 60) return;
if (ud.respawn_monsters == 1 && actor->spr.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
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
else if (ud.respawn_items == 1 && (actor->spr.cstat & CSTAT_SPRITE_INVISIBLE)) 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
}
- 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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (gs.actorinfo[actor->spr.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
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (gs.actorinfo[actor->spr.picnum].scriptaddress == 0) return;
s.insptr = &ScriptCode[4 + (gs.actorinfo[actor->spr.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];
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
actor->spr.lotag += TICSPERFRAME;
if (actor->spr.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]++;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
actor->spr.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
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (actor->spr.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
{
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (actor->spr.xrepeat > 60) goto quit;
if (ud.respawn_monsters == 1 && actor->spr.extra <= 0) goto quit;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
else if (ud.respawn_items == 1 && (actor->spr.cstat & CSTAT_SPRITE_INVISIBLE)) goto quit;
- replaced checktimetosleep with a flag.
2022-01-18 22:26:06 +00:00
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- replaced checktimetosleep with a flag.
2022-01-18 22:26:06 +00:00
if (actor->spr.statnum == STAT_ACTOR || (actor->spr.statnum == STAT_STANDABLE && actorflag(actor, SFLAG_CHECKSLEEP)))
{
- 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
}
}
- 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