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

3826 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);
};
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
int furthestcanseepoint(DDukeActor* i, DDukeActor* ts, DVector2& pos);
- 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)
{
- renamed wallnum and sectnum functions. These were creating a lot of search noise because local variables had the same name.
2022-11-15 11:03:44 +00:00
return sect ? sectindex(sect) : -1;
- 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
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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)
{
- renamed wallnum and sectnum functions. These were creating a lot of search noise because local variables had the same name.
2022-11-15 11:03:44 +00:00
return sect ? wallindex(sect) : -1;
- 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
}
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:
- floatified exit position.
2022-09-12 19:28:57 +00:00
if (bSet) ps[iPlayer].Exit.X = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].Exit.X / 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_EXITY:
- floatified exit position.
2022-09-12 19:28:57 +00:00
if (bSet) ps[iPlayer].Exit.Y = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].Exit.Y / 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_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.
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].PlayerNowPosition.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_POSY:
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].PlayerNowPosition.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_POSZ:
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].PlayerNowPosition.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_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;
}
- Negate everything to do with `PlayerHorizon::__horiz` where appropriate, including some loose `horizoff` members.
2022-10-11 06:46:56 +00:00
ps[iPlayer].horizon.settarget(maphoriz(-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
}
- Rename `PlayerHorizon::__horiz` back to `horiz`.
2022-10-11 02:37:20 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].horizon.horiz.Tan() * -128.), 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:
- Negate everything to do with `PlayerHorizon::__horiz` where appropriate, including some loose `horizoff` members.
2022-10-11 06:46:56 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].horizon.ohoriz.Tan() * -128.), 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:
- Negate everything to do with `PlayerHorizon::__horiz` where appropriate, including some loose `horizoff` members.
2022-10-11 06:46:56 +00:00
if (bSet) ps[iPlayer].horizon.horizoff = maphoriz(-lValue);
else SetGameVarID(lVar2, int(ps[iPlayer].horizon.horizoff.Tan() * -128.), 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:
- Negate everything to do with `PlayerHorizon::__horiz` where appropriate, including some loose `horizoff` members.
2022-10-11 06:46:56 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].horizon.ohorizoff.Tan() * -128.), 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:
- floatified bobpos.
2022-02-05 12:58:12 +00:00
if (bSet) ps[iPlayer].bobpos.X = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].bobpos.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_BOBPOSY:
- floatified bobpos.
2022-02-05 12:58:12 +00:00
if (bSet) ps[iPlayer].bobpos.Y = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].bobpos.Y * (1/maptoworld)), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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:
- Duke: Rename player's opos to something identifiable.
2022-11-14 07:52:08 +00:00
if (bSet) ps[iPlayer].PlayerOldPosition.X = lValue * maptoworld;
else SetGameVarID(lVar2, int(ps[iPlayer].PlayerOldPosition.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:
- Duke: Rename player's opos to something identifiable.
2022-11-14 07:52:08 +00:00
if (bSet) ps[iPlayer].PlayerOldPosition.Y = lValue * maptoworld;
else SetGameVarID(lVar2, int(ps[iPlayer].PlayerOldPosition.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:
- Duke: Rename player's opos to something identifiable.
2022-11-14 07:52:08 +00:00
if (bSet) ps[iPlayer].PlayerOldPosition.Z = lValue * zmaptoworld;
else SetGameVarID(lVar2, int(ps[iPlayer].PlayerOldPosition.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:
- Duke: floatified pyoff
2022-08-30 20:25:07 +00:00
if (bSet) ps[iPlayer].pyoff = lValue * zmaptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].pyoff / 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_OPYOFF:
- Duke: floatified pyoff
2022-08-30 20:25:07 +00:00
if (bSet) ps[iPlayer].opyoff = lValue * zmaptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].opyoff / 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_POSXV:
- first round of vel refactoring. VEL_FACTOR is used as a marker that later can be quickly removed once the data type gets changed over.
2022-09-11 22:14:31 +00:00
if (bSet) ps[iPlayer].vel.X = FixedToFloat<18>(lValue);
else SetGameVarID(lVar2, FloatToFixed<18>(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:
- first round of vel refactoring. VEL_FACTOR is used as a marker that later can be quickly removed once the data type gets changed over.
2022-09-11 22:14:31 +00:00
if (bSet) ps[iPlayer].vel.Y = FixedToFloat<18>(lValue);
else SetGameVarID(lVar2, FloatToFixed<18>(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:
- first round of vel refactoring. VEL_FACTOR is used as a marker that later can be quickly removed once the data type gets changed over.
2022-09-11 22:14:31 +00:00
if (bSet) ps[iPlayer].vel.Z = lValue * zmaptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].vel.Z / 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_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;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(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;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(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:
- use mapangle in more places, mainly constants and random values using special formula
2022-09-11 12:02:04 +00:00
if (bSet) ps[iPlayer].angle.settarget(mapangle(lValue));
- Replace player's `ang` with `DAngle` object. * This commit does not build. Committed items are everything that's been done by find and replace. * Next commit has hand-performed changes that are better separated out for clarity.
2022-08-27 13:09:22 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.ang.Buildang(), 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:
- Replace player's `ang` with `DAngle` object. * This commit does not build. Committed items are everything that's been done by find and replace. * Next commit has hand-performed changes that are better separated out for clarity.
2022-08-27 13:09:22 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].angle.oang.Buildang(), 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:
- use mapangle in more places, mainly constants and random values using special formula
2022-09-11 12:02:04 +00:00
if (bSet) ps[iPlayer].angle.look_ang = mapangle(lValue);
- Replace player's `rotscrnang` and `look_ang` angles with `DAngle` objects. * Went the el cheapo route and added some floating point Build angle methods. As these and the integer build methods are really just refactoring aids, we'll come back to this in due course.
2022-08-27 11:48:57 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.look_ang.Buildang(), 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:
- use mapangle in more places, mainly constants and random values using special formula
2022-09-11 12:02:04 +00:00
if (bSet) ps[iPlayer].angle.spin = mapangle(lValue);
- Eliminate some TAngle floating point Build method usage.
2022-08-28 02:09:44 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.spin.Buildang(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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:
- use mapangle in more places, mainly constants and random values using special formula
2022-09-11 12:02:04 +00:00
if (bSet) ps[iPlayer].angle.orotscrnang = ps[iPlayer].angle.rotscrnang = mapangle(lValue);
- Replace player's `rotscrnang` and `look_ang` angles with `DAngle` objects. * Went the el cheapo route and added some floating point Build angle methods. As these and the integer build methods are really just refactoring aids, we'll come back to this in due course.
2022-08-27 11:48:57 +00:00
else SetGameVarID(lVar2, ps[iPlayer].angle.rotscrnang.Buildang(), 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;
- Rename `PlayerHorizon::__horiz` back to `horiz`.
2022-10-11 02:37:20 +00:00
else SetGameVarID(lVar2, ps[iPlayer].sync.actions & SB_CENTERVIEW ? int(abs((ps[iPlayer].horizon.horiz * (DAngle::fromDeg(9.) / GetMaxPitch())).Degrees())) : 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:
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
if (!bSet) SetGameVarID(lVar2, int(wallp->pos.X / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
if (!bSet) SetGameVarID(lVar2, int(wallp->pos.Y / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- renamed everything back
2022-10-07 22:02:10 +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:
- renamed everything back
2022-10-07 22:02:10 +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:
- eliminated firstWall as well.
2022-11-15 14:44:33 +00:00
if (!bSet) SetGameVarID(lVar2, wallindex(sectp->walls.Data()), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- eliminate wall_count.
2022-11-15 13:59:28 +00:00
if (!bSet) SetGameVarID(lVar2, sectp->walls.Size(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- another batch of wrapper replacements
2022-08-28 09:34:54 +00:00
if (bSet) sectp->setceilingz(lValue * zmaptoworld);
else SetGameVarID(lVar2, (int)(sectp->ceilingz / 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 SECTOR_FLOORZ:
- another batch of wrapper replacements
2022-08-28 09:34:54 +00:00
if (bSet) sectp->setfloorz(lValue * zmaptoworld);
else SetGameVarID(lVar2, (int)(sectp->floorz / 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 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:
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
if (!bSet) SetGameVarID(lVar2, int(act->spr.pos.X / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
if (!bSet) SetGameVarID(lVar2, int(act->spr.pos.Y / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
if (!bSet) SetGameVarID(lVar2, int(act->spr.pos.Z / 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_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:
- replaced all set_native_clipdist Note that truncation has to be preserved here to ensure the size stays the same as before so the MulScales were not resolved into their factors.
2022-10-04 17:22:46 +00:00
if (bSet) act->clipdist = lValue * 0.25;
else SetGameVarID(lVar2, int(act->clipdist * 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_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:
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
if (bSet) act->spr.scale.X = (lValue * REPEAT_SCALE);
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
else SetGameVarID(lVar2, int(act->spr.scale.X * INV_REPEAT_SCALE), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
if (bSet) act->spr.scale.Y = (lValue * REPEAT_SCALE);
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
else SetGameVarID(lVar2, int(act->spr.scale.Y * INV_REPEAT_SCALE), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
if (bSet) act->spr.angle = DAngle::fromBuild(lValue);
else SetGameVarID(lVar2, act->spr.angle.Buildang(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
if (bSet) act->vel.X = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(act->vel.X / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- renamed yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
if (bSet) act->spr.yint = lValue;
else SetGameVarID(lVar2, act->spr.yint, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
if (bSet) act->vel.Z = lValue * zmaptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(act->vel.Z / 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_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:
- floatified player_struct::hitang
2022-09-11 22:11:44 +00:00
if (bSet) act->hitang = mapangle(lValue);
else SetGameVarID(lVar2, act->hitang.Buildang(), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- split use of tempang between real angles and other counters.
2022-09-14 21:30:10 +00:00
if (bSet) act->tempval = lValue;
else SetGameVarID(lVar2, act->tempval, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(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;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(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:
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
if (bSet) act->ovel.X = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(act->ovel.X / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
if (bSet) act->ovel.Y = lValue * maptoworld;
- silenced lots of warnings for deliberate type conversions. The ones in d_net.cpp are not in active code.
2022-10-12 17:00:29 +00:00
else SetGameVarID(lVar2, int(act->ovel.Y / maptoworld), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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
{
if (g_x > 1024)
{
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
double sclip;
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
DAngle 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
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
if (badguy(actor) && actor->spr.scale.X > 0.875)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
sclip = 3084 / 16.;
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
angdif = DAngle22_5 * 3 / 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
}
else
{
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
sclip = 48;
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
angdif = DAngle22_5 / 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
}
- ifcanshoottarget.
2020-10-23 18:13:35 +00:00
DDukeActor* hit;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
double hs = hitasprite(actor, &hit);
if (hs == INT_MAX)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 1;
}
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
if (hs > sclip)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 (hit != nullptr && hit->spr.picnum == actor->spr.picnum)
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
return 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
else
{
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
actor->spr.angle += angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
hs = hitasprite(actor, &hit);
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
actor->spr.angle -= angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
if (hs > sclip)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 (hit != nullptr && hit->spr.picnum == actor->spr.picnum)
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
return 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
else
{
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
actor->spr.angle += angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
hs = hitasprite(actor, &hit);
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
actor->spr.angle -= angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
if (hs > 48)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 (hit != nullptr && hit->spr.picnum == actor->spr.picnum)
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
return 0;
return 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
}
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
else return 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
}
}
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
else return 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
}
}
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
return 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
}
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
return 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
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- 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;
- cansee in Duke
2022-08-22 16:39:33 +00:00
j = cansee(actor->spr.pos.plusZ(-zrand(32)), actor->sector(), tosee->spr.pos, 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)
- cansee in Duke
2022-08-22 16:39:33 +00:00
j = cansee(actor->spr.pos.plusZ(-zrand(48)), actor->sector(), tosee->spr.pos.plusZ(isRR()? -28 : -24), 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.
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
j = furthestcanseepoint(actor, tosee, actor->ovel);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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..
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
actor->ovel = tosee->spr.pos;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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:
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
j = cansee(g_ac->spr.pos.plusZ(krand() & 41), g_ac->sector(), ps[g_p].PlayerNowPosition, 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:
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
j = cansee(g_ac->spr.pos, g_ac->sector(), ps[g_p].PlayerNowPosition, 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)
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle = randomAngle();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle += DAngle90 + randomAngle(90);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle -= DAngle90 + randomAngle(90);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle = randomAngle();
g_ac->vel.X = 25/16.;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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:
- scriptified touchplate
2022-11-19 14:40:35 +00:00
operateactivators(667, &ps[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())
- use PlayerIndex where appropriate.
2022-09-01 14:42:23 +00:00
g_ac->spr.pal = ps[g_ac->PlayerIndex()].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
}
- split use of tempang between real angles and other counters.
2022-09-14 21:30:10 +00:00
g_ac->spr.pal = (uint8_t)g_ac->tempval;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
}
- split use of tempang between real angles and other counters.
2022-09-14 21:30:10 +00:00
g_ac->tempval = 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++;
- use PlayerIndex where appropriate.
2022-09-01 14:42:23 +00:00
fi.checkweapons(&ps[g_ac->PlayerIndex()]);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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++;
- renamed yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
if (!S_CheckActorSoundPlaying(g_ac, g_ac->spr.yint))
S_PlayActorSound(g_ac->spr.yint, 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:
- minor cleanup on scaling code
2022-10-07 16:29:20 +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++;
- all remaining repeats in Duke except spawn_d and spawn_r
2022-10-07 17:16:37 +00:00
// JBF 20030805: As I understand it, if repeat becomes 0 it basically kills the
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
// 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
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
double siz = ((*insptr) * REPEAT_SCALE - g_ac->spr.scale.X);
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
g_ac->spr.scale.X = (clamp(g_ac->spr.scale.X + Sgn(siz) * REPEAT_SCALE, 0., 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
insptr++;
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
auto scale = g_ac->spr.scale.Y;
- minor cleanup on scaling code
2022-10-07 16:29:20 +00:00
if ((g_ac->isPlayer() && scale < 0.5626) || *insptr * REPEAT_SCALE < scale || (scale * (tileHeight(g_ac->spr.picnum) + 8)) < 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
{
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
siz = ((*insptr) * REPEAT_SCALE - g_ac->spr.scale.Y);
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
g_ac->spr.scale.Y = (clamp(g_ac->spr.scale.Y + Sgn(siz) * REPEAT_SCALE, 0., 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
}
insptr++;
break;
- minor cleanup on scaling code
2022-10-07 16:29:20 +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_sizeat:
insptr++;
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
g_ac->spr.scale.X = ((uint8_t)*insptr * REPEAT_SCALE);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- unwrapped SetScaleX/Y.
2022-10-07 21:46:28 +00:00
g_ac->spr.scale.Y = ((uint8_t)*insptr * REPEAT_SCALE);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- fixed failiure to initialize the ambient tags array. Also adding range checks to all places where it gets used. This is from CON code so proper values are never guaranteed.
2022-11-24 08:01:44 +00:00
parseifelse((short)*insptr == ambienttags.SafeGet(g_ac->spr.detail, {}).lo);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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)
- fixed failiure to initialize the ambient tags array. Also adding range checks to all places where it gets used. This is from CON code so proper values are never guaranteed.
2022-11-24 08:01:44 +00:00
parseifelse(ambienttags.SafeGet(g_ac->spr.detail, {}).hi > 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)
- fixed failiure to initialize the ambient tags array. Also adding range checks to all places where it gets used. This is from CON code so proper values are never guaranteed.
2022-11-24 08:01:44 +00:00
parseifelse(ambienttags.SafeGet(g_ac->spr.detail, {}).hi < 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++;
- fixed failiure to initialize the ambient tags array. Also adding range checks to all places where it gets used. This is from CON code so proper values are never guaranteed.
2022-11-24 08:01:44 +00:00
S_PlayActorSound(ambienttags.SafeGet(g_ac->spr.detail, {}).lo, 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++;
- fixed failiure to initialize the ambient tags array. Also adding range checks to all places where it gets used. This is from CON code so proper values are never guaranteed.
2022-11-24 08:01:44 +00:00
if (!S_CheckActorSoundPlaying(g_ac, ambienttags.SafeGet(g_ac->spr.detail, {}).lo))
S_PlayActorSound(ambienttags.SafeGet(g_ac->spr.detail, {}).lo, 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)
- implemented cl_weaponswitch for Duke.
2022-11-12 08:33:33 +00:00
if( ps[g_p].gotweapon[*insptr] && (WeaponSwitch(g_p) & 1))
fi.addweapon(&ps[g_p], *insptr, 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
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++;
- implemented cl_weaponswitch for Duke.
2022-11-12 08:33:33 +00:00
if( ps[g_p].gotweapon[*insptr] == 0 ) fi.addweapon( &ps[g_p], *insptr, !!(WeaponSwitch(g_p) & 1));
- 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)
- implemented cl_weaponswitch for Duke.
2022-11-12 08:33:33 +00:00
if( ps[g_p].gotweapon[*insptr] && (WeaponSwitch(g_p) & 1))
fi.addweapon(&ps[g_p], *insptr, 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
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++;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
movesprite_ex(g_ac, DVector3(-g_ac->spr.angle.Sin(), g_ac->spr.angle.Cos(), g_ac->vel.Z), 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++;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
movesprite_ex(g_ac, DVector3(g_ac->spr.angle.Sin(), -g_ac->spr.angle.Cos(), g_ac->vel.Z), 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++;
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
ps[g_p].GetActor()->spr.pos.Z = ps[g_p].PlayerNowPosition.Z = ps[g_p].GetActor()->sector()->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
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();
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
updatesector(ps[g_p].PlayerNowPosition, &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 yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
actj->spr.yint = 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)
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle = randomAngle();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
{
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +00:00
insptr++;
int dnum = *insptr - gs.firstdebris;
- restricted use of gs.firstdebris to the only place where it is really needed. Also no script export for this, it is only needed for converting CON parameters to propr indices.
2022-11-15 07:28:05 +00:00
if (dnum < 0 || dnum >= ScrapMax) break; // this code only works with scrap and nothing else.
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +00:00
insptr++;
int count = *insptr;
bool weap = fi.spawnweapondebris(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
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +00:00
if(g_ac->insector())
for(j = count; j >= 0; j--)
{
if(weap)
s = 0;
else s = (krand()%3);
DVector3 offs;
offs.X = krandf(16) - 8;
offs.Y = krandf(16) - 8;
offs.Z = -krandf(16) - 8;
auto a = randomAngle();
auto vel = krandf(8) + 2;
auto zvel = -krandf(8);
DVector2 scale(0.5 + (krand() & 15) * REPEAT_SCALE, 0.5 + (krand() & 15) * REPEAT_SCALE);
auto spawned = CreateActor(g_ac->sector(), g_ac->spr.pos + offs, PClass::FindActor("DukeScrap"), g_ac->spr.shade, scale, a, vel, zvel, g_ac, STAT_MISC);
if (spawned)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
{
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +00:00
spawned->spriteextra = dnum + s;
if (weap)
spawned->spr.yint = (j % 15) + 1;
else spawned->spr.yint = -1;
spawned->spr.pal = 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
}
}
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +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_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++;
- replaced all set_native_clipdist Note that truncation has to be preserved here to ensure the size stays the same as before so the MulScales were not resolved into their factors.
2022-10-04 17:22:46 +00:00
g_ac->clipdist = ((uint8_t) *insptr) * 0.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_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);
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
g_ac->spr.pos = ps[g_p].PlayerNowPosition;
- another batch of utility use
2022-02-05 11:05:29 +00:00
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();
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
updatesector(ps[g_p].PlayerNowPosition, &ps[g_p].cursector);
SetActor(ps[g_p].GetActor(), ps[g_p].PlayerNowPosition.plusZ(gs.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;
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
g_ac->clipdist = 16;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
g_ac->spr.scale = DVector2(0.65625, 0.5625);
- 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;
- Rename `PlayerHorizon::__horiz` back to `horiz`.
2022-10-11 02:37:20 +00:00
ps[g_p].horizon.ohoriz = ps[g_p].horizon.horiz = nullAngle;
- 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;
- Cut over to `DAngle` from `fixedhoriz` and remove the latter.
2022-09-28 03:39:01 +00:00
ps[g_p].horizon.ohorizoff = ps[g_p].horizon.horizoff = nullAngle;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- first round of vel refactoring. VEL_FACTOR is used as a marker that later can be quickly removed once the data type gets changed over.
2022-09-11 22:14:31 +00:00
ps[g_p].vel.X = ps[g_p].vel.Y = 0;
- Use the static constexpr `nullAngle` everywhere possible.
2022-08-28 00:40:50 +00:00
if (!isRR()) ps[g_p].angle.orotscrnang = ps[g_p].angle.rotscrnang = nullAngle;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- split use of tempang between real angles and other counters.
2022-09-14 21:30:10 +00:00
g_ac->tempval = 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:
- another batch of wrapper replacements
2022-08-28 09:34:54 +00:00
parseifelse(abs(g_ac->spr.pos.Z - g_ac->sector()->floorz) < 32 && 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:
- another batch of wrapper replacements
2022-08-28 09:34:54 +00:00
parseifelse( abs(g_ac->spr.pos.Z-g_ac->sector()->floorz) < 32 && 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:
- removed AddScale wrappers.
2022-10-07 21:44:21 +00:00
g_ac->spr.scale.X -= REPEAT_SCALE;
g_ac->spr.scale.Y -= REPEAT_SCALE;
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
parseifelse(g_ac->spr.scale.X <= 5 * REPEAT_SCALE);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
double vel = g_ac->vel.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
- 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;
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
else if( (l& pfalling) && ps[g_p].jumping_counter == 0 && !ps[g_p].on_ground && ps[g_p].vel.Z > 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& pjumping) && ps[g_p].jumping_counter > 348 )
j = 1;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
else if( (l& pstanding) && vel >= 0 && vel < 0.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
j = 1;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
else if( (l& pwalking) && vel >= 0.5 && !(PlayerInput(g_p, SB_RUN)) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
else if( (l& prunning) && vel >= 0.5 && PlayerInput(g_p, SB_RUN) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
else if( (l& phigher) && ps[g_p].PlayerNowPosition.Z < g_ac->spr.pos.Z - 48)
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
else if( (l& pwalkingback) && vel <= -0.5 && !(PlayerInput(g_p, SB_RUN)) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- eliminated int_xvel
2022-09-15 16:41:01 +00:00
else if( (l& prunningback) && vel <= -0.5 && (PlayerInput(g_p, SB_RUN)) )
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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& pkicking) && ( ps[g_p].quick_kick > 0 || ( ps[g_p].curr_weapon == KNEE_WEAPON && ps[g_p].kickback_pic > 0 ) ) )
j = 1;
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
else if( (l& pshrunk) && ps[g_p].GetActor()->spr.scale.X < (isRR() ? 0.125 : 0.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
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;
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
else if( (l& palive) && ps[g_p].GetActor()->spr.scale.X > (isRR() ? 0.125 : 0.5) && 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) )
{
- floatified all getangle calls.
2022-09-15 16:52:39 +00:00
DAngle ang;
- 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)
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
ang = absangle(ps[otherp].angle.ang, (ps[g_p].PlayerNowPosition.XY() - ps[otherp].PlayerNowPosition.XY()).Angle());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
ang = absangle(ps[g_p].angle.ang, (g_ac->spr.pos.XY() - ps[g_p].PlayerNowPosition.XY()).Angle());
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- floatified all getangle calls.
2022-09-15 16:52:39 +00:00
j = ang < DAngle22_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
}
- Duke: Remove unnecessary int casts from `gameexec.cpp`. * Incoming vars are 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);
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
ps[g_p].vel.XY() -= ps[g_p].angle.ang.ToVector() * 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
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
{
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
ps[g_p].vel.XY() -= ps[g_p].angle.ang.ToVector() * 64;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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{};
- use symbolic constants in neartag calls.
2022-09-25 08:57:46 +00:00
neartag(g_ac->spr.pos.plusZ(-32), g_ac->sector(), g_ac->spr.angle, hit, 48, NT_Lotag | NT_NoSpriteCheck);
- 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))
- another batch of wrapper replacements
2022-08-28 09:34:54 +00:00
if ((sectp->lotag & 0xff) == ST_23_SWINGING_DOOR || sectp->floorz == sectp->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
{
- scriptified activators and locators.
2022-11-20 11:43:24 +00:00
if (isactivator(a2))
- 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())
- split use of tempang between real angles and other counters.
2022-09-14 21:30:10 +00:00
g_ac->tempval = g_ac->spr.pal;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
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++;
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->spr.scale.X >= (isRR()? 0.140625 : 0.625) )
- Duke: Rename player's pos to something identifiable.
2022-11-14 07:57:18 +00:00
if (cansee(g_ac->spr.pos.plusZ(-4), g_ac->sector(), ps[g_p].PlayerNowPosition.plusZ(16), 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
- consolidated Duke’s ‚away from wall‘ check in the backend This was also very useful in SW to avoid spawning ‚floating‘ footprints due to lack of an equivalent check in the original.
2022-09-13 17:40:32 +00:00
j = isAwayFromWall(g_ac, 6.75);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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);
- 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:
- hitscan fully rewritten. No traces of Build code left here! :)
2022-09-26 13:04:20 +00:00
parseifelse( g_ac->movflag > 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:
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +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++;
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
auto ang = absangle(ps[g_p].angle.ang, g_ac->spr.angle);
parseifelse( ang <= mapangle(*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;
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +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_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;
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double lTemp;
double lDist;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
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;
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
lDist = 1000000; // big number
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- parse - part 6.
2020-10-23 18:22:08 +00:00
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
{
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
lTemp = (g_ac->spr.pos.XY() - actj->spr.pos.XY()).Length();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double lTemp;
double lDist;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
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;
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
lDist = 1000000; // big number
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- parse - part 6.
2020-10-23 18:22:08 +00:00
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
{
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
lTemp = (g_ac->spr.pos.XY() - actj->spr.pos.XY()).Length();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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:
{
insptr++;
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
int i = *(insptr++); // ID of def
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- parse - part 6.
2020-10-23 18:22:08 +00:00
// g_ac->lastvx and lastvy are last known location of target.
- VecToAngle() with `XY()` inside to .Angle() replacements.
2022-09-30 11:38:21 +00:00
int ang = (g_ac->ovel - g_ac->spr.pos.XY()).Angle().Buildang();
- 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
- Replace player's `ang` with `DAngle` object. * This commit does not build. Committed items are everything that's been done by find and replace. * Next commit has hand-performed changes that are better separated out for clarity.
2022-08-27 13:09:22 +00:00
SetGameVarID(i, ps[g_p].angle.ang.Buildang(), 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
- use mapangle in more places, mainly constants and random values using special formula
2022-09-11 12:02:04 +00:00
ps[g_p].angle.ang = mapangle(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
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
SetGameVarID(i, g_ac->spr.angle.Buildang(), 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
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
g_ac->spr.angle = DAngle::fromBuild(GetGameVarID(i, g_ac, g_p).safeValue() & 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
- second part of final bsin replacement.
2022-09-15 17:23:47 +00:00
lValue = int(16384 * BobVal(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
{
- got rid of deletesprite, plus one new flag.
2022-11-20 18:25:23 +00:00
actor->Destroy();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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
}
- got rid of deletesprite, plus one new flag.
2022-11-20 18:25:23 +00:00
actor->Destroy();
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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
{
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
if (actor->spr.scale.X > 0.9375 ) return;
- 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 (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
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
void execute(DDukeActor *actor,int p,double xx)
- 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
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
s.g_x = int(xx / maptoworld); // ??
- 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++;
- got rid of deletesprite, plus one new flag.
2022-11-20 18:25:23 +00:00
actor->Destroy();
- 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
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
fi.move(actor, p, int(xx / maptoworld));
- 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
{
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
if (actor->spr.scale.X > 0.9375 ) goto quit;
- 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 (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:
- got rid of deletesprite, plus one new flag.
2022-11-20 18:25:23 +00:00
if (killthesprite) actor->Destroy();
- 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