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

3350 lines
84 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;
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);
- 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;
- exported a bunch of stuff we're going to need soon.
2022-11-27 20:00:22 +00:00
else SetGameVarID(lVar2, (int)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;
- exported a bunch of stuff we're going to need soon.
2022-11-27 20:00:22 +00:00
else SetGameVarID(lVar2, (int)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: Remove `player_struct::posX()` and `player_struct::posY()`.
2022-11-21 02:29:33 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->spr.pos.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: Remove `player_struct::posX()` and `player_struct::posY()`.
2022-11-21 02:29:33 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->spr.pos.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: Remove `player_struct::posZget()`.
2022-11-21 04:20:08 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->getOffsetZ() * (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;
}
- Remove `PlayerAngles::setPitch()` method usage.
2022-12-03 03:53:53 +00:00
ps[iPlayer].GetActor()->spr.Angles.Pitch = 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
}
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
else SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->spr.Angles.Pitch.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:
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->PrevAngles.Pitch.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:
- Move all PlayerAngles view angle properties into new DRotator objects.
2022-11-27 03:48:37 +00:00
if (bSet) ps[iPlayer].Angles.ViewAngles.Pitch = maphoriz(-lValue);
else SetGameVarID(lVar2, int(ps[iPlayer].Angles.ViewAngles.Pitch.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:
- Move all PlayerAngles view angle properties into new DRotator objects.
2022-11-27 03:48:37 +00:00
if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].Angles.PrevViewAngles.Pitch.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: Remove `player_struct::posoldX()`, `player_struct::posoldY()`, and `player_struct::posoldXY()`.
2022-11-20 09:00:26 +00:00
if (bSet) ps[iPlayer].GetActor()->opos.X = lValue * maptoworld;
else SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->opos.X * (1/maptoworld)), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPOSY:
- Duke: Remove `player_struct::posoldX()`, `player_struct::posoldY()`, and `player_struct::posoldXY()`.
2022-11-20 09:00:26 +00:00
if (bSet) ps[iPlayer].GetActor()->opos.Y = lValue * maptoworld;
else SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->opos.Y * (1 / maptoworld)), sActor, sPlayer);
- safety commit
2020-05-14 07:07:07 +00:00
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
case PLAYER_OPOSZ:
- Duke: Remove `player_struct::posoldZset()` and `player_struct::posoldZget()`.
2022-11-24 08:47:02 +00:00
if (bSet) ps[iPlayer].GetActor()->opos.Z = (lValue * zmaptoworld) + gs.playerheight;
else SetGameVarID(lVar2, int(ps[iPlayer].GetActor()->getPrevOffsetZ() * (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:
- Remove `PlayerAngles::setYaw()` method usage and remaining associated code.
2022-12-03 04:10:02 +00:00
if (bSet) ps[iPlayer].GetActor()->spr.Angles.Yaw = mapangle(lValue);
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
else SetGameVarID(lVar2, ps[iPlayer].GetActor()->spr.Angles.Yaw.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:
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
if (!bSet) SetGameVarID(lVar2, ps[iPlayer].GetActor()->PrevAngles.Yaw.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:
- Move all PlayerAngles view angle properties into new DRotator objects.
2022-11-27 03:48:37 +00:00
if (bSet) ps[iPlayer].Angles.ViewAngles.Yaw = mapangle(lValue);
else SetGameVarID(lVar2, ps[iPlayer].Angles.ViewAngles.Yaw.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:
- Make `setForcedSyncInput()` require a player index. * This should only ever apply to the console player.
2023-03-23 06:09:02 +00:00
if (bSet && (ps[iPlayer].newOwner = vValue.safeActor())) setForcedSyncInput(iPlayer);
- 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
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:
- Make `setForcedSyncInput()` require a player index. * This should only ever apply to the console player.
2023-03-23 06:09:02 +00:00
if (bSet && (ps[iPlayer].on_crane = vValue.safeActor())) setForcedSyncInput(iPlayer);
- 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
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:
- Merge `PlayerHorizon` and `PlayerAngle` structs into `PlayerAngles` struct.
2022-11-25 06:09:11 +00:00
if (bSet) ps[iPlayer].Angles.YawSpin = mapangle(lValue);
else SetGameVarID(lVar2, ps[iPlayer].Angles.YawSpin.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:
- Move all PlayerAngles view angle properties into new DRotator objects.
2022-11-27 03:48:37 +00:00
if (bSet) ps[iPlayer].Angles.PrevViewAngles.Roll = ps[iPlayer].Angles.ViewAngles.Roll = -mapangle(lValue);
else SetGameVarID(lVar2, -ps[iPlayer].Angles.ViewAngles.Roll.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;
- 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;
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
else SetGameVarID(lVar2, ps[iPlayer].sync.actions & SB_CENTERVIEW ? int(abs((ps[iPlayer].GetActor()->spr.Angles.Pitch * (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:
- wrap a few more accesses to picnum variables
2022-12-06 13:14:10 +00:00
if (bSet) wallp->setwalltexture(tileGetTextureID(lValue));
- got rid of wallpicnum and overpicnum. All map geometry npw uses texture IDs and no longer depends on Build's tile system. (What's missing is a new map format, though, but this was a necessary prerequisite to make that worthwile...)
2022-12-10 18:03:17 +00:00
else SetGameVarID(lVar2, legacyTileNum(wallp->walltexture), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- wrap a few more accesses to picnum variables
2022-12-06 13:14:10 +00:00
if (bSet) wallp->setovertexture(tileGetTextureID(lValue));
- got rid of wallpicnum and overpicnum. All map geometry npw uses texture IDs and no longer depends on Build's tile system. (What's missing is a new map format, though, but this was a necessary prerequisite to make that worthwile...)
2022-12-10 18:03:17 +00:00
else SetGameVarID(lVar2, legacyTileNum(wallp->overtexture), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- use the texture wrappers in a few places.
2022-12-06 10:47:56 +00:00
if (bSet) sectp->setceilingtexture(tileGetTextureID(lValue));
- migrated floorpicnum and ceilingpicnum to FTextures. The sky code still needs some work.
2022-12-09 09:48:47 +00:00
else SetGameVarID(lVar2, legacyTileNum(sectp->ceilingtexture), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- use the texture wrappers in a few places.
2022-12-06 10:47:56 +00:00
if (bSet) sectp->setfloortexture(tileGetTextureID(lValue));
- migrated floorpicnum and ceilingpicnum to FTextures. The sky code still needs some work.
2022-12-09 09:48:47 +00:00
else SetGameVarID(lVar2, legacyTileNum(sectp->floortexture), sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
if (bSet) act->spr.Angles.Yaw = DAngle::fromBuild(lValue);
else SetGameVarID(lVar2, act->spr.Angles.Yaw.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_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:
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
if (bSet) act->counter = lValue;
else SetGameVarID(lVar2, act->counter, sActor, sPlayer);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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:
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
if (bSet) act->temp_data[0] = lValue;
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;
default:
break;
}
return;
}
- scriptified the pipe bomb and RR's dynamite, which is mostly the same thing. The mortars were split off because they made the code too convoluted.
2022-12-01 09:19:37 +00:00
//---------------------------------------------------------------------------
//
// what a lousy hack job... :(
//
//---------------------------------------------------------------------------
int CheckWeapRec(player_struct* p, DDukeActor* g_ac, int testonly)
{
int j;
for (j = 0; j < p->weapreccnt; j++)
if (p->weaprecs[j] == g_ac->spr.picnum)
break;
if (testonly)
{
return (j < p->weapreccnt && g_ac->GetOwner() == g_ac);
}
else if (p->weapreccnt < 32)
{
p->weaprecs[p->weapreccnt++] = g_ac->spr.picnum;
return (g_ac->GetOwner() == g_ac);
}
return 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
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
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
{
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
actor->spr.Angles.Yaw += angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
hs = hitasprite(actor, &hit);
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
actor->spr.Angles.Yaw -= 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
{
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
actor->spr.Angles.Yaw += angdif;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
hs = hitasprite(actor, &hit);
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
actor->spr.Angles.Yaw -= 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
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
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)
{
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
int j, l;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
if(killit_flag) return 1;
switch (*insptr)
{
case concmd_ifrnd:
{
insptr++;
- exported several fire related actors.
2022-12-14 17:26:40 +00:00
// 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. (identical in Duke and RR.)
- moved actions out of the ScriptCode array and gave them a dedicated struct with meaningful member names.
2022-12-21 12:20:14 +00:00
if (g_ac->IsKindOf(NAME_RedneckFire) && g_ac->curAction->name == NAME_None && *insptr == 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
{
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: Remove `player_struct::posGet()`.
2022-11-24 02:20:17 +00:00
j = cansee(g_ac->spr.pos.plusZ(krand() & 41), g_ac->sector(), ps[g_p].GetActor()->getPosWithOffsetZ(), 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: Remove `player_struct::posGet()`.
2022-11-24 02:20:17 +00:00
j = cansee(g_ac->spr.pos, g_ac->sector(), ps[g_p].GetActor()->getPosWithOffsetZ(), 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:
- refactored AI storage as well to not use ScriptCode anymore.
2022-12-17 14:41:53 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- refactored AI storage as well to not use ScriptCode anymore.
2022-12-17 14:41:53 +00:00
auto ai = &ais[*insptr];
g_ac->curAI = ai->name;
g_ac->curAction = &actions[ai->action];
g_ac->curMove = &moves[ai->move];
g_ac->spr.hitag = ai->moveflags;
- moved actioncounter and curframe to a dedicated variable. The third generic counter is not as easy to fix as its use is far more widespread
2022-12-17 14:55:01 +00:00
g_ac->actioncounter = g_ac->curframe = 0;
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
g_ac->counter = 0;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
if (g_ac->spr.hitag & random_angle)
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw = 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;
- refactored AI storage as well to not use ScriptCode anymore.
2022-12-17 14:41:53 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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_action:
insptr++;
- moved actioncounter and curframe to a dedicated variable. The third generic counter is not as easy to fix as its use is far more widespread
2022-12-17 14:55:01 +00:00
g_ac->actioncounter = g_ac->curframe = 0;
- moved actions out of the ScriptCode array and gave them a dedicated struct with meaningful member names.
2022-12-21 12:20:14 +00:00
g_ac->curAction = &actions[*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_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:
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw += 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:
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw -= 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:
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw = randomAngle();
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
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)
- scriptified transport vehicles.
2022-11-30 16:15:44 +00:00
ud.earthquaketime = 4;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
else if (g_ac->spr.pal == 32)
- scriptified transport vehicles.
2022-11-30 16:15:44 +00:00
ud.earthquaketime = 6;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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_garybanjo:
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
garybanjo(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_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)
{
- scriptified the pipe bomb and RR's dynamite, which is mostly the same thing. The mortars were split off because they made the code too convoluted.
2022-12-01 09:19:37 +00:00
parseifelse(CheckWeapRec(&ps[g_p], 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
}
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
{
- 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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
playerkick(&ps[g_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
break;
case concmd_sizeto:
insptr++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
actorsizeto(g_ac, *insptr * REPEAT_SCALE, *(insptr + 1) * REPEAT_SCALE);
insptr += 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_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:
- made some annotations in concmd_shoot how to deal with RRRA's merged projectiles.
2022-12-22 11:36:16 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- made some annotations in concmd_shoot how to deal with RRRA's merged projectiles.
2022-12-22 11:36:16 +00:00
int type = *insptr;
// hackery to separate RRRA's merged projectiles. We'd prefer not to keep this mess in the core implementation.
// Separating it here is easiest as long as the ZScript reimplementation explicitly takes care of these differences.
if (isRRRA())
{
//if (g_ac->GetClass.TypeName == NAME_RedneckCheerleader && type == 3400) typecls = PClass::FindActor(NAME_RedneckCheerBaton);
//if (g_ac->GetClass.TypeName == NAME_RedneckMama && type == 3390) typecls = PClass::FindActor(NAME_RedneckRabbitBall);
//if (g_ac->GetClass.TypeName == NAME_RedneckMinion && type == 3390 && g_ac->spr.pal == 8) typecls = PClass::FindActor(NAME_RedneckFrogBall);
//if (g_ac->GetClass.TypeName == NAME_RedneckMinion && type == 3390 && g_ac->spr.pal == 19)) typecls = PClass::FindActor(NAME_RedneckShitBurn);
}
shoot(g_ac, *insptr, 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;
- made some annotations in concmd_shoot how to deal with RRRA's merged projectiles.
2022-12-22 11:36:16 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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_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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
if (!playeraddammo(&ps[g_p], *insptr, *(insptr + 1))) killit_flag = 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
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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
dokill(&ps[g_p], 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
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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
if (!playeraddweapon(&ps[g_p], *insptr, *(insptr + 1))) killit_flag = 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
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++;
- moved the 3 health related instructions out of the CON interpreter. This code can be shared with ZScript so it needs to be elsewhere.
2022-12-15 14:18:46 +00:00
playerdrink(&ps[g_p], *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_strafeleft:
insptr++;
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
movesprite_ex(g_ac, DVector3(-g_ac->spr.Angles.Yaw.Sin(), g_ac->spr.Angles.Yaw.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++;
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
movesprite_ex(g_ac, DVector3(g_ac->spr.Angles.Yaw.Sin(), -g_ac->spr.Angles.Yaw.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: Swap out the internals of the player's pos methods and get the game going again.
2022-11-21 03:55:33 +00:00
ps[g_p].GetActor()->spr.pos.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;
- moved the 3 health related instructions out of the CON interpreter. This code can be shared with ZScript so it needs to be elsewhere.
2022-12-15 14:18:46 +00:00
case concmd_iseat:
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 the actual actor flags. Not fully working yet...
2022-12-20 21:25:48 +00:00
playereat(&ps[g_p], *insptr++, !!(g_ac->flags3 & SFLAG3_BIGHEALTH));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
break;
- moved the 3 health related instructions out of the CON interpreter. This code can be shared with ZScript so it needs to be elsewhere.
2022-12-15 14:18:46 +00:00
case concmd_addphealth:
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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 the actual actor flags. Not fully working yet...
2022-12-20 21:25:48 +00:00
addphealth(&ps[g_p], *insptr++, !!(g_ac->flags3 & SFLAG3_BIGHEALTH));
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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_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:
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
g_ac->counter=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++;
- moved 'move' data out of the ScriptCode array as well.
2022-12-21 12:32:00 +00:00
g_ac->curMove = &moves[*insptr];
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
insptr++;
- getting rid of DDukeActor::s, final part.
2021-12-21 21:31:25 +00:00
g_ac->spr.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)
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw = 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++;
- migrated attackertype to class objects.
2022-12-16 15:56:47 +00:00
parseifelse( g_ac->attackertype == GetSpawnType(*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++;
- refactored AI storage as well to not use ScriptCode anymore.
2022-12-17 14:41:53 +00:00
parseifelse(g_ac->curAI == ais[*insptr].name);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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_ifaction:
insptr++;
- moved actions out of the ScriptCode array and gave them a dedicated struct with meaningful member names.
2022-12-21 12:20:14 +00:00
parseifelse((g_ac->curAction - actions.Data()) == *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_ifactioncount:
insptr++;
- moved actioncounter and curframe to a dedicated variable. The third generic counter is not as easy to fix as its use is far more widespread
2022-12-17 14:55:01 +00:00
parseifelse(g_ac->actioncounter >= *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_resetactioncount:
insptr++;
- moved actioncounter and curframe to a dedicated variable. The third generic counter is not as easy to fix as its use is far more widespread
2022-12-17 14:55:01 +00:00
g_ac->actioncounter = 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_debris:
- scriptified the scraps. A Duke-ish mess of epic proportions.
2022-11-14 22:55:46 +00:00
insptr++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
spawndebris(g_ac, *insptr - gs.firstdebris, *(insptr + 1));
insptr += 2;
break;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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++;
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
g_ac->counter = (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_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_ifmove:
insptr++;
- moved 'move' data out of the ScriptCode array as well.
2022-12-21 12:32:00 +00:00
parseifelse((g_ac->curMove - moves.Data()) == *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_resetplayer:
insptr++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
playerreset(&ps[g_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
break;
case concmd_ifcoop:
parseifelse(ud.coop || numplayers > 2);
break;
case concmd_ifonmud:
- migrated floorpicnum and ceilingpicnum to FTextures. The sky code still needs some work.
2022-12-09 09:48:47 +00:00
parseifelse(abs(g_ac->spr.pos.Z - g_ac->sector()->floorz) < 32 && (tilesurface(g_ac->sector()->floortexture) == TSURF_MUDDY) != 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_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:
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
parseifelse( g_ac->sector()->lotag == ST_2_UNDERWATER);
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not 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++;
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
parseifelse(g_ac->counter >= *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_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++;
- renamed temp_data[0] to 'counter' and map temp_data[5] to the now free temp_data[0]. This not only matches its use in CON but seems to be used as a counter in most other places as well. The main reason is to improve readability of CON to ZScript conversions.
2022-12-22 08:49:42 +00:00
g_ac->counter = 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_addinventory:
insptr++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
playeraddinventory(&ps[g_p], g_ac, *insptr, *(insptr+1));
insptr += 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_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: Remove `player_struct::posZget()`.
2022-11-21 04:20:08 +00:00
else if( (l& phigher) && ps[g_p].GetActor()->getOffsetZ() < 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: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
ang = absangle(ps[otherp].GetActor()->spr.Angles.Yaw, (ps[g_p].GetActor()->spr.pos.XY() - ps[otherp].GetActor()->spr.pos.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: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
ang = absangle(ps[g_p].GetActor()->spr.Angles.Yaw, (g_ac->spr.pos.XY() - ps[g_p].GetActor()->spr.pos.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:
- scriptified the guts spawning function.
2022-11-22 22:21:45 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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;
- migrated attackertype to class objects.
2022-12-16 15:56:47 +00:00
auto clstype = GetSpawnType(*(insptr - 1));
if (clstype) spawnguts(g_ac, clstype, *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;
- scriptified the guts spawning function.
2022-11-22 22:21:45 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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_slapplayer:
insptr++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
forceplayerangle(&ps[g_p]);
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
ps[g_p].vel.XY() -= ps[g_p].GetActor()->spr.Angles.Yaw.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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
wackplayer(&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
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++;
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
actoroperate(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_ifinspace:
- use a flag for outer space textures.
2022-11-25 16:43:13 +00:00
parseifelse(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;
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
case concmd_newpic:
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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_cactor:
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
{
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this 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++;
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
auto info = spawnMap.CheckKey(*insptr);
if (info != nullptr)
{
g_ac->ChangeType(info->cls);
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;
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
}
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does 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_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:
{
- moved a lot of shareable code out of the CON interpreter.
2022-12-15 20:12:20 +00:00
insptr++;
j = playercheckinventory(&ps[g_p], g_ac, *insptr, *(insptr + 1));
insptr ++;
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: Remove `player_struct::posGet()`.
2022-11-24 02:20:17 +00:00
if (cansee(g_ac->spr.pos.plusZ(-4), g_ac->sector(), ps[g_p].GetActor()->getPosWithOffsetZ().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 a flag for outer space textures.
2022-11-25 16:43:13 +00:00
parseifelse( 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++;
- added a new sprite flag for those types which can trigger respawn actions.
2022-11-30 13:29:34 +00:00
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++;
- Clean up all previously annotated angle/yaw checks.
2022-11-27 00:13:43 +00:00
auto ang = absangle(ps[g_p].GetActor()->spr.Angles.Yaw, g_ac->spr.Angles.Yaw);
- gameexec.cpp code cleanup
2022-09-13 16:24:02 +00:00
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
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
SetGameVarID(i, ps[g_p].GetActor()->spr.Angles.Yaw.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
- Duke: Remove all remaining angle wrapper usage.
2022-11-25 11:30:40 +00:00
ps[g_p].GetActor()->spr.Angles.Yaw = 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
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
SetGameVarID(i, g_ac->spr.Angles.Yaw.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
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
g_ac->spr.Angles.Yaw = 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++;
- migrated floorpicnum and ceilingpicnum to FTextures. The sky code still needs some work.
2022-12-09 09:48:47 +00:00
SetGameVarID(g_iTextureID, legacyTileNum(g_ac->sector()->floortexture), 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++;
- migrated floorpicnum and ceilingpicnum to FTextures. The sky code still needs some work.
2022-12-09 09:48:47 +00:00
SetGameVarID(g_iTextureID, legacyTileNum(g_ac->sector()->ceilingtexture), 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;
- added the remaining CON features from EDuke 2.x Not everything will do something, though. This was some incredibly careless code operating without a safety net allowing uncontrolled write access to the map structure. Most of the critical fields have been made read-only, which has been the only mode of access in the mods I checked. Note that this does not enable scripting of the weapon sprite drawer, only the gameplay related features were done.
2020-09-17 20:36:09 +00:00
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
auto coninf = actor->conInfo();
if (coninf == nullptr) return;
auto addr = coninf->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
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moved the CON execute call to DDukeActor::Tick and removed a large portion of the special handling for scriptified actors.
2022-12-03 16:09:40 +00:00
bool execute(DDukeActor *actor,int p,double xx)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
auto coninf = actor->conInfo();
if (coninf == nullptr)
return false;
- got rid of the old interpreter code.
2020-05-15 06:04:30 +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;
- 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
s.insptr = &ScriptCode[4 + (gs.actorinfo[actor->spr.picnum].scriptaddress)];
- migrate all script related info to the data stored in the actor classes. This also needs cactor to really change the class descriptor now so that the correct script code is found.
2022-12-21 21:36:15 +00:00
auto insptr = coninf? &ScriptCode[4 + coninf->scriptaddress] : nullptr;
if (insptr != s.insptr) Printf("%s: %p vs. %p\n", insptr, s.insptr);
- 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
- moved sprite animation code out of 'execute'.
2022-12-17 11:41:56 +00:00
int done;
- 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
- use the actual actor flags. Not fully working yet...
2022-12-20 21:25:48 +00:00
if (actor->spr.statnum == STAT_ACTOR || (actor->spr.statnum == STAT_STANDABLE && (actor->flags1 & SFLAG_CHECKSLEEP)))
- replaced checktimetosleep with a flag.
2022-01-18 22:26:06 +00:00
{
- execute.
2020-10-23 18:28:29 +00:00
if (actor->timetosleep > 1)
actor->timetosleep--;
else if (actor->timetosleep == 1)
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(actor, STAT_ZOMBIEACTOR);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
- 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;
- moved the CON execute call to DDukeActor::Tick and removed a large portion of the special handling for scriptified actors.
2022-12-03 16:09:40 +00:00
return true;
- 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;
- 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