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

3756 lines
87 KiB
C++
Raw Normal View History

- reshuffling stuff.
2020-05-07 12:55:04 +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.
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
This file contains parts of DukeGDX by Alexander Makarov-[M210] (m210-2007@mail.ru)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "global.h"
- got rid of the dynamic tilemap. Most tile access is in game specific code, the remaining code only accesses 51 tiles
2020-07-03 21:56:14 +00:00
#include "names_d.h"
- added a serializer for the flamethrower's fire map.
2020-06-29 21:36:06 +00:00
#include "serializer.h"
- migrated EGS and deletesprite to new actor interface. Inline wrappers for old code exist. The backupplayer inline was moved into player.cpp because that's the only place it gets used.
2020-10-21 17:14:41 +00:00
#include "dukeactor.h"
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
BEGIN_DUKE_NS
- added a serializer for the flamethrower's fire map.
2020-06-29 21:36:06 +00:00
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
bool ceilingspace_d(sectortype* sectp)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with most of CSTAT_SECTOR_SKY and CSTAT_SECTOR_SLOPE
2021-12-18 12:14:56 +00:00
if (sectp && (sectp->ceilingstat & CSTAT_SECTOR_SKY) && sectp->ceilingpal == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
switch(sectp->ceilingpicnum)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case MOONSKY1:
case BIGORBIT1:
return 1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
bool floorspace_d(sectortype* sectp)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with most of CSTAT_SECTOR_SKY and CSTAT_SECTOR_SLOPE
2021-12-18 12:14:56 +00:00
if (sectp && (sectp->floorstat & CSTAT_SECTOR_SKY) && sectp->ceilingpal == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- pass a sector pointer to floorspace/ceilingspace.
2021-11-06 21:57:26 +00:00
switch(sectp->floorpicnum)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case MOONSKY1:
case BIGORBIT1:
return 1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
return 0;
}
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
void check_fta_sounds_d(DDukeActor* actor)
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +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.extra > 0) switch (actor->spr.picnum)
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
{
case LIZTROOPONTOILET:
case LIZTROOPJUSTSIT:
case LIZTROOPSHOOT:
case LIZTROOPJETPACK:
case LIZTROOPDUCKING:
case LIZTROOPRUNNING:
case LIZTROOP:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(PRED_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case LIZMAN:
case LIZMANSPITTING:
case LIZMANFEEDING:
case LIZMANJUMP:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(CAPT_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case PIGCOP:
case PIGCOPDIVE:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(PIG_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case RECON:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(RECO_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case DRONE:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(DRON_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case COMMANDER:
case COMMANDERSTAYPUT:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(COMM_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case ORGANTIC:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(TURR_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case OCTABRAIN:
case OCTABRAINSTAYPUT:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(OCTA_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case BOSS1:
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlaySound(BOS1_RECOG);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case BOSS2:
- 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.pal == 1)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlaySound(BOS2_RECOG);
else S_PlaySound(WHIPYOURASS);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case BOSS3:
- 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.pal == 1)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlaySound(BOS3_RECOG);
else S_PlaySound(RIPHEADNECK);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case BOSS4:
case BOSS4STAYPUT:
- 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.pal == 1)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlaySound(BOS4_RECOG);
S_PlaySound(BOSS4_FIRSTSEE);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
case GREENSLIME:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
S_PlayActorSound(SLIM_RECOG, actor);
- spawnglass functions and fta_sounds.
2020-05-16 10:47:01 +00:00
break;
}
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- remove C-style struct parameters.
2022-02-07 10:04:19 +00:00
void addweapon_d(player_struct *p, int weapon)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if ( p->gotweapon[weapon] == 0 )
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- engine side preparations for Duke Statusbar scriptification. Mainly, gotweapon had to be reverted to a flat bool array to avoid implementing FixedBitArray for the VM. Also adding a few new tile names and PushV for string arrays.
2021-05-15 08:23:50 +00:00
p->gotweapon[weapon] = true;
if (weapon == SHRINKER_WEAPON)
p->gotweapon[GROW_WEAPON] = true;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
p->random_club_frame = 0;
if (p->holster_weapon == 0)
{
p->weapon_pos = -1;
p->last_weapon = p->curr_weapon;
}
else
{
p->weapon_pos = 10;
p->holster_weapon = 0;
p->last_weapon = -1;
}
- Duke/RR: Address weapon drawer interpolation concerns raised in #403.
2020-09-16 11:01:09 +00:00
p->okickback_pic = p->kickback_pic = 0;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
p->curr_weapon = weapon;
- Duke/RR: Always ensure player's `wantweaponfire` is reset to `-1` after switching weapon. * Fixes #333.
2021-07-17 02:12:12 +00:00
p->wantweaponfire = -1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
switch (weapon)
{
case KNEE_WEAPON:
case TRIPBOMB_WEAPON:
case HANDREMOTE_WEAPON:
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case HANDBOMB_WEAPON:
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
break;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case SHOTGUN_WEAPON:
- ifsquished.
2020-10-22 17:12:48 +00:00
S_PlayActorSound(SHOTGUN_COCK, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
break;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case PISTOL_WEAPON:
- ifsquished.
2020-10-22 17:12:48 +00:00
S_PlayActorSound(INSERT_CLIP, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
break;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
default:
- ifsquished.
2020-10-22 17:12:48 +00:00
S_PlayActorSound(SELECT_WEAPON, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
break;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- ifsquished.
2020-10-22 17:12:48 +00:00
bool ifsquished(DDukeActor* actor, int p)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (isRR()) return false; // this function is a no-op in RR's source.
bool squishme = false;
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == APLAYER && ud.clipping)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return false;
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
- a few random wrapper removals in Duke
2022-09-03 15:43:39 +00:00
double floorceildist = sectp->floorz - sectp->ceilingz;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
if (sectp->lotag != ST_23_SWINGING_DOOR)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.pal == 1)
- a few random wrapper removals in Duke
2022-09-03 15:43:39 +00:00
squishme = floorceildist < 32 && (sectp->lotag & 32768) == 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
- a few random wrapper removals in Duke
2022-09-03 15:43:39 +00:00
squishme = floorceildist < 12;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
if (squishme)
{
FTA(QUOTE_SQUISHED, &ps[p]);
- ifsquished.
2020-10-22 17:12:48 +00:00
if (badguy(actor))
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.pal == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
actor->attackertype = SHOTSPARK1;
- 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
actor->hitextra = 1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return false;
}
return true;
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int hp4)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
double radius = r * inttoworld;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
static const uint8_t statlist[] = { STAT_DEFAULT, STAT_ACTOR, STAT_STANDABLE, STAT_PLAYER, STAT_FALLER, STAT_ZOMBIEACTOR, STAT_MISC };
- use BFSSearch in hitradius_d
2021-11-15 23:19:34 +00:00
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if(actor->spr.picnum != SHRINKSPARK && !(actor->spr.picnum == RPG && actor->spr.xrepeat < 11))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
BFSSectorSearch search(actor->sector());
- 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
— Duke: Use BFSSectorSearch to handle the hitradius searches without using indices. (and a bit nicer looking loop condition.)
2021-11-21 07:42:36 +00:00
while (auto dasectp = search.GetNext())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- cleanup of the wall hit checks in hitradius Yes, the z-check was indeed bad.
2022-09-12 22:55:15 +00:00
if ((dasectp->ceilingz- actor->spr.pos.Z) < radius * 16) // what value range is this supposed to be? The check that was here did not multiply correctly
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- Duke/RR: redo the supremely ugly code to access the third point in hitradius*
2021-11-16 16:43:19 +00:00
auto wal = dasectp->firstWall();
- cleanup of the wall hit checks in hitradius Yes, the z-check was indeed bad.
2022-09-12 22:55:15 +00:00
double d = (wal->pos - actor->spr.pos.XY()).Sum();
if (d < radius)
- checkhitceiling + ceilingglass are sector[] free.
2021-11-18 16:55:08 +00:00
fi.checkhitceiling(dasectp);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- Duke/RR: redo the supremely ugly code to access the third point in hitradius*
2021-11-16 16:43:19 +00:00
auto thirdpoint = wal->point2Wall()->point2Wall();
- cleanup of the wall hit checks in hitradius Yes, the z-check was indeed bad.
2022-09-12 22:55:15 +00:00
d = (thirdpoint->pos - actor->spr.pos.XY()).Sum();
if (d < radius)
- checkhitceiling + ceilingglass are sector[] free.
2021-11-18 16:55:08 +00:00
fi.checkhitceiling(dasectp);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- Duke/RR: cleaned up the rest of hitradius* as well Using wallsofsector iterator plus defining local variables more locally.
2021-11-16 16:45:41 +00:00
for (auto& wal : wallsofsector(dasectp))
{
- cleanup of the wall hit checks in hitradius Yes, the z-check was indeed bad.
2022-09-12 22:55:15 +00:00
if ((wal.pos - actor->spr.pos.XY()).Sum() < radius)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
— Duke: Use BFSSectorSearch to handle the hitradius searches without using indices. (and a bit nicer looking loop condition.)
2021-11-21 07:42:36 +00:00
if (wal.twoSided())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
— Duke: Use BFSSectorSearch to handle the hitradius searches without using indices. (and a bit nicer looking loop condition.)
2021-11-21 07:42:36 +00:00
search.Add(wal.nextSector());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- cansee in Duke
2022-08-22 16:39:33 +00:00
DVector3 w1(((wal.pos + wal.point2Wall()->pos) * 0.5 + actor->spr.pos) * 0.5, actor->spr.pos.Z); // half way between the actor and the wall's center.
- started eliminating sectnum
2021-11-21 08:00:47 +00:00
sectortype* sect = wal.sectorp();
- cansee in Duke
2022-08-22 16:39:33 +00:00
updatesector(w1, &sect);
if (sect && cansee(w1, sect, actor->spr.pos, actor->sector()))
- floatified position in checkhitwall
2022-08-23 20:39:07 +00:00
fi.checkhitwall(actor, &wal, DVector3(wal.pos, actor->spr.pos.Z), actor->spr.picnum);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- Duke/RR: cleaned up the rest of hitradius* as well Using wallsofsector iterator plus defining local variables more locally.
2021-11-16 16:45:41 +00:00
}
}
- use BFSSearch in hitradius_d
2021-11-15 23:19:34 +00:00
}
- 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
- Duke: Fix bad setups when calling `cansee()`. Fixes issues with pigcop on kerb in E2L1.
2022-10-08 11:01:47 +00:00
double q = zrand(32) - 16;
- 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
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
auto Owner = actor->GetOwner();
- Duke/RR: cleaned up the rest of hitradius* as well Using wallsofsector iterator plus defining local variables more locally.
2021-11-16 16:45:41 +00:00
for (int x = 0; x < 7; x++)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
DukeStatIterator itj(statlist[x]);
while (auto act2 = itj.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
if (isWorldTour() && Owner)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (Owner->spr.picnum == APLAYER && act2->spr.picnum == APLAYER && ud.coop != 0 && ud.ffire == 0 && Owner != act2)
- fixed some bugs.
2020-05-14 22:32:11 +00:00
{
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
continue;
- fixed some bugs.
2020-05-14 22:32:11 +00:00
}
- 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
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (actor->spr.picnum == FLAMETHROWERFLAME && ((Owner->spr.picnum == FIREFLY && act2->spr.picnum == FIREFLY) || (Owner->spr.picnum == BOSS5 && act2->spr.picnum == BOSS5)))
- fixed some bugs.
2020-05-14 22:32:11 +00:00
{
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
continue;
- fixed some bugs.
2020-05-14 22:32:11 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- 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
- flammable flags.
2022-01-26 23:41:33 +00:00
if (x == 0 || x >= 5 || actorflag(act2, SFLAG_HITRADIUS_FLAG1))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (actor->spr.picnum != SHRINKSPARK || (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL))
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
if ((actor->spr.pos - act2->spr.pos).Length() < radius)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- Duke: Fix bad setups when calling `cansee()`. Fixes issues with pigcop on kerb in E2L1.
2022-10-08 11:01:47 +00:00
if (badguy(act2) && !cansee(act2->spr.pos.plusZ(q), act2->sector(), actor->spr.pos.plusZ(q), actor->sector()))
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
continue;
- switched the checkhitsprite interface to actors.
2020-10-24 05:15:10 +00:00
fi.checkhitsprite(act2, actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- replaced one more actor list check in hitradius with a flag.
2022-01-18 22:09:42 +00:00
else if (act2->spr.extra >= 0 && act2 != actor && (actorflag(act2, SFLAG_HITRADIUS_FLAG2) || badguy(act2) || (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL)))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (actor->spr.picnum == SHRINKSPARK && act2->spr.picnum != SHARK && (act2 == Owner || act2->spr.xrepeat < 24))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
continue;
}
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == MORTER && act2 == Owner)
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
continue;
}
- 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 a float version of gs.playerheight.
2022-02-04 17:06:08 +00:00
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z -= gs.playerheight;
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
double dist = (actor->spr.pos - act2->spr.pos).Length();
- added a float version of gs.playerheight.
2022-02-04 17:06:08 +00:00
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z += gs.playerheight;
- 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
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
if (dist < radius && cansee(act2->spr.pos.plusZ(-8), act2->sector(), actor->spr.pos.plusZ(-12), actor->sector()))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified player_struct::hitang
2022-09-11 22:11:44 +00:00
act2->hitang = VecToAngle(act2->spr.pos - actor->spr.pos);
- 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
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (actor->spr.picnum == RPG && act2->spr.extra > 0)
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = RPG;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (!isWorldTour())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == SHRINKSPARK)
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = SHRINKSPARK;
else act2->attackertype = RADIUSEXPLOSION;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == SHRINKSPARK || actor->spr.picnum == FLAMETHROWERFLAME)
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = actor->spr.picnum;
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
else if (actor->spr.picnum != FIREBALL || !Owner || Owner->spr.picnum != APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == LAVAPOOL)
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = FLAMETHROWERFLAME;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = RADIUSEXPLOSION;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
act2->attackertype = FLAMETHROWERFLAME;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- 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
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum != SHRINKSPARK && (!isWorldTour() || actor->spr.picnum != LAVAPOOL))
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
if (dist < radius / 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (hp4 == hp3) hp4++;
- 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
act2->hitextra = hp3 + (krand() % (hp4 - hp3));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
else if (dist < 2 * radius / 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (hp3 == hp2) hp3++;
- 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
act2->hitextra = hp2 + (krand() % (hp3 - hp2));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
else if (dist < radius)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (hp2 == hp1) hp2++;
- 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
act2->hitextra = hp1 + (krand() % (hp2 - hp1));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- 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
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (act2->spr.picnum != TANK && act2->spr.picnum != ROTATEGUN && act2->spr.picnum != RECON && !bossguy(act2))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- eliminated add_int_xvel
2022-09-11 20:57:56 +00:00
if (act2->vel.X < 0) act2->vel.X = 0;
act2->vel.X += ( (actor->spr.extra / 4.));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- 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
- turn all special actor type checks in moveflammable into flags. Also wrap all flag checks in actorflag function
2022-01-17 23:54:10 +00:00
if (actorflag(act2, SFLAG_HITRADIUSCHECK))
- switched the checkhitsprite interface to actors.
2020-10-24 05:15:10 +00:00
fi.checkhitsprite(act2, actor);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- 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
else if (actor->spr.extra == 0) act2->hitextra = 0;
- 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
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (act2->spr.picnum != RADIUSEXPLOSION && Owner && Owner->spr.statnum < MAXSTATUS)
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (act2->spr.picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- 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
int p = act2->spr.yint;
- 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
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (isWorldTour() && act2->attackertype == FLAMETHROWERFLAME && Owner->spr.picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- 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
ps[p].numloogs = -1 - actor->spr.yint;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- 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
- newowner and related code.
2020-11-02 23:20:51 +00:00
if (ps[p].newOwner != nullptr)
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
clearcamera(&ps[p]);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
act2->SetHitOwner(actor->GetOwner());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- foundation for a better collision info management. The way this is handled is the main reason why Build maps are size limited, but since it is extremely invasive it needs to be taken out of the game code piece by piece, this is the framework for doing this for Duke.
2020-10-24 07:31:15 +00:00
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
int movesprite_ex_d(DDukeActor* actor, const DVector3& change, unsigned int cliptype, Collision &result)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
int clipdist;
- foundation for a better collision info management. The way this is handled is the main reason why Build maps are size limited, but since it is extremely invasive it needs to be taken out of the game code piece by piece, this is the framework for doing this for Duke.
2020-10-24 07:31:15 +00:00
int bg = badguy(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- Duke: second batch of refactoring writes to spr.pos.
2022-01-30 17:15:07 +00:00
if (actor->spr.statnum == STAT_MISC || (bg && actor->spr.xrepeat < 4))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
actor->spr.pos += change;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (bg)
- did some more.
2022-02-06 21:45:47 +00:00
SetActor(actor, actor->spr.pos);
- foundation for a better collision info management. The way this is handled is the main reason why Build maps are size limited, but since it is extremely invasive it needs to be taken out of the game code piece by piece, this is the framework for doing this for Duke.
2020-10-24 07:31:15 +00:00
return result.setNone();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto dasectp = actor->sector();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- floatify pos in movesprite_ex_d
2022-08-29 20:27:45 +00:00
auto ppos = actor->spr.pos;
ppos.Z -= (tileHeight(actor->spr.picnum) * actor->spr.yrepeat) * REPEAT_SCALE * 0.5;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (bg)
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.xrepeat > 60)
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
clipmove(ppos, &dasectp, FloatToFixed<18>(change.X * 0.5), FloatToFixed<18>(change.Y * 0.5), 1024, (4 << 8), (4 << 8), cliptype, result);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == LIZMAN)
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
clipdist = 292;
- actorflag, actorfella, automap, animateaccess, holoduke spawn, initreactor. # Conflicts: # source/games/duke/src/game_misc.cpp
2020-10-23 17:02:58 +00:00
else if (actorflag(actor, SFLAG_BADGUY))
- wrap clipdist << 2
2022-09-09 16:07:44 +00:00
clipdist = actor->int_clipdist();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
clipdist = 192;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
clipmove(ppos, &dasectp, FloatToFixed<18>(change.X * 0.5), FloatToFixed<18>(change.Y * 0.5), clipdist, (4 << 8), (4 << 8), cliptype, result);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
// conditional code from hell...
- movesprite handled
2021-11-21 08:05:58 +00:00
if (dasectp == nullptr || (dasectp != nullptr &&
- actorstayput
2021-11-18 19:55:22 +00:00
((actor->actorstayput != nullptr && actor->actorstayput != dasectp) ||
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
((actor->spr.picnum == BOSS2) && actor->spr.pal == 0 && dasectp->lotag != 3) ||
((actor->spr.picnum == BOSS1 || actor->spr.picnum == BOSS2) && dasectp->lotag == ST_1_ABOVE_WATER) ||
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
(dasectp->lotag == ST_1_ABOVE_WATER && (actor->spr.picnum == LIZMAN || (actor->spr.picnum == LIZTROOP && actor->vel.Z == 0)))
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
))
)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (dasectp && dasectp->lotag == ST_1_ABOVE_WATER && actor->spr.picnum == LIZMAN)
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
actor->spr.angle = randomAngle();
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
else if ((actor->temp_data[0]&3) == 1 && actor->spr.picnum != COMMANDER)
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
actor->spr.angle = randomAngle();
- GetActor pos replacement
2022-08-22 16:34:01 +00:00
SetActor(actor,actor->spr.pos);
- movesprite handled
2021-11-21 08:05:58 +00:00
if (dasectp == nullptr) dasectp = &sector[0];
return result.setSector(dasectp);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
if ((result.type == kHitWall || result.type == kHitSprite) && (actor->cgg == 0)) actor->spr.angle += DAngle90 + DAngle45;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.statnum == STAT_PROJECTILE)
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
clipmove(ppos, &dasectp, FloatToFixed<18>(change.X * 0.5), FloatToFixed<18>(change.Y * 0.5), 8, (4 << 8), (4 << 8), cliptype, result);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
clipmove(ppos, &dasectp, FloatToFixed<18>(change.X * 0.5), FloatToFixed<18>(change.Y * 0.5), (int)(actor->int_clipdist()), (4 << 8), (4 << 8), cliptype, result);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- floatify pos in movesprite_ex_d
2022-08-29 20:27:45 +00:00
actor->spr.pos.XY() = ppos.XY();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if (dasectp != nullptr && dasectp != actor->sector())
ChangeActorSect(actor, dasectp);
- floatified movesprite_ex
2022-09-13 18:09:29 +00:00
double daz = actor->spr.pos.Z + change.Z * 0.5;
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if (daz > actor->ceilingz && daz <= actor->floorz)
actor->spr.pos.Z = daz;
- addressed the updatesector related deprecation warnings with Duke.
2021-11-06 19:46:08 +00:00
else if (result.type == kHitNone)
- movesprite handled
2021-11-21 08:05:58 +00:00
return result.setSector(dasectp);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- addressed the updatesector related deprecation warnings with Duke.
2021-11-06 19:46:08 +00:00
return result.type;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
//
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
//
//---------------------------------------------------------------------------
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
void lotsofmoney_d(DDukeActor *actor, int n)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
lotsofstuff(actor, n, MONEY);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
void lotsofmail_d(DDukeActor *actor, int n)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
lotsofstuff(actor, n, MAIL);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
void lotsofpaper_d(DDukeActor *actor, int n)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
lotsofstuff(actor, n, PAPER);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
void guts_d(DDukeActor* actor, int gtype, int n, int p)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
int sx, sy;
uint8_t pal;
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (badguy(actor) && actor->spr.xrepeat < 16)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
sx = sy = 8;
else sx = sy = 32;
- spawn coordinate in guts
2022-09-12 23:02:13 +00:00
double gutz = actor->spr.pos.Z - 8;
double floorz = getflorzofslopeptrf(actor->sector(), actor->spr.pos);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- spawn coordinate in guts
2022-09-12 23:02:13 +00:00
if (gutz > floorz - 8)
gutz = floorz - 8;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- spawn coordinate in guts
2022-09-12 23:02:13 +00:00
gutz += gs.actorinfo[actor->spr.picnum].gutsoffset;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (badguy(actor) && actor->spr.pal == 6)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
pal = 6;
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
else if (actor->spr.picnum != LIZTROOP) // EDuke32 transfers the palette unconditionally, I'm not sure that's such a good idea.
- transfer palette to gibs for LIZTROOP EDuke did it for all actors - not sure if that is right. Needs checking.
2020-07-29 15:28:02 +00:00
pal = 0;
else
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
pal = actor->spr.pal;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
for (int j = 0; j < n; j++)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
// RANDCORRECT version from RR.
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
DAngle a = randomAngle();
double zvel = -2 -krandf(8);
double vel = 3 + krandf(2);
- spawn coordinate in guts
2022-09-12 23:02:13 +00:00
DVector3 offs;
offs.Z = gutz - krandf(16);
offs.Y = krandf(16) - 8;
offs.X = krandf(16) - 8;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
// TRANSITIONAL: owned by a player???
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
auto spawned = CreateActor(actor->sector(), offs + actor->spr.pos.XY(), gtype, -32, sx, sy, a, vel, zvel, ps[p].GetActor(), 5);
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
if (spawned)
- reshuffling stuff.
2020-05-07 12:55:04 +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 (spawned->spr.picnum == JIBS2)
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
{
- 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
spawned->spr.xrepeat >>= 2;
spawned->spr.yrepeat >>= 2;
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
}
if (pal != 0)
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
spawned->spr.pal = pal;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
int ifhitbyweapon_d(DDukeActor *actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
int p;
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
auto hitowner = actor->GetHitOwner();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- 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 (actor->hitextra >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.extra >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (ud.god && actor->attackertype != SHRINKSPARK) return -1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use PlayerIndex plus a bit of cleanup.
2022-09-01 15:26:46 +00:00
p = actor->PlayerIndex();
- 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
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
if (hitowner &&
- 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
hitowner->spr.picnum == APLAYER &&
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
ud.coop == 1 &&
ud.ffire == 0)
return -1;
- 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
actor->spr.extra -= actor->hitextra;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
if (hitowner)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (actor->spr.extra <= 0 && actor->attackertype != FREEZEBLAST)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
actor->spr.extra = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
ps[p].wackedbyactor = hitowner;
- reshuffling stuff.
2020-05-07 12:55:04 +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 (hitowner->spr.picnum == APLAYER && p != hitowner->PlayerIndex())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
ps[p].frag_ps = hitowner->PlayerIndex();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
actor->SetHitOwner(ps[p].GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- new explosion flags
2022-01-20 07:31:08 +00:00
if (attackerflag(actor, SFLAG2_DOUBLEDMGTHRUST))
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
ps[p].vel.XY() += actor->hitang.ToVector() * actor->hitextra * 0.25;
- new explosion flags
2022-01-20 07:31:08 +00:00
}
else
{
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
ps[p].vel.XY() += actor->hitang.ToVector() * actor->hitextra * 0.125;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- 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 (actor->hitextra == 0)
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (actor->attackertype == SHRINKSPARK && actor->spr.xrepeat < 24)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return -1;
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (isWorldTour() && actor->attackertype == FIREFLY && actor->spr.xrepeat < 48)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
if (actor->attackertype != RADIUSEXPLOSION && actor->attackertype != RPG)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return -1;
}
- 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
actor->spr.extra -= actor->hitextra;
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
auto Owner = actor->GetOwner();
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
if (actor->spr.picnum != RECON && Owner && Owner->spr.statnum < MAXSTATUS)
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
actor->SetOwner(hitowner);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- 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
actor->hitextra = -1;
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
return actor->attackertype;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
if (ud.multimode < 2 || !isWorldTour()
- renamed DDukeActor::picnum to attackertype. This one having the same name here as spritetype::picnum is just confusing as hell and badly describes this variable's function.
2021-12-27 22:52:16 +00:00
|| actor->attackertype != FLAMETHROWERFLAME
- 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
|| actor->hitextra >= 0
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
|| actor->spr.extra > 0
|| actor->spr.picnum != APLAYER
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
|| ps[actor->PlayerIndex()].numloogs > 0
|| hitowner == nullptr)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- 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
actor->hitextra = -1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return -1;
}
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
else
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
p = actor->PlayerIndex();
- deal with 'spri = actor->s;'
2021-12-21 18:13:49 +00:00
actor->spr.extra = 0;
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
ps[p].wackedbyactor = hitowner;
- reshuffling stuff.
2020-05-07 12:55:04 +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 (hitowner->spr.picnum == APLAYER && hitowner != ps[p].GetActor())
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
ps[p].frag_ps = hitowner->PlayerIndex(); // set the proper player index here - this previously set the sprite index...
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
actor->SetHitOwner(ps[p].GetActor());
- 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
actor->hitextra = -1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return FLAMETHROWERFLAME;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
void movefallers_d(void)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
int j;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movefallers.
2020-10-22 17:31:06 +00:00
DukeStatIterator iti(STAT_FALLER);
while (auto act = iti.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = act->sector();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movefallers.
2020-10-22 17:31:06 +00:00
if (act->temp_data[0] == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- some simple replacements.
2022-02-07 07:47:18 +00:00
act->spr.pos.Z -= 16;
- more int_ang()
2022-08-16 21:17:01 +00:00
act->temp_data[1] = act->int_ang();
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
int x = act->spr.extra;
- movefallers.
2020-10-22 17:31:06 +00:00
j = fi.ifhitbyweapon(act);
use iterators for moveplayers, movedummyplayers and movefallers_d.
2020-10-12 20:00:19 +00:00
if (j >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- two more flags to get sprite indices out of movecrack. # Conflicts: # source/games/duke/src/constants.h
2022-01-19 18:15:23 +00:00
if (gs.actorinfo[j].flags2 & SFLAG2_EXPLOSIVE)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (act->spr.extra <= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movefallers.
2020-10-22 17:31:06 +00:00
act->temp_data[0] = 1;
DukeStatIterator itj(STAT_FALLER);
while (auto a2 = itj.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (a2->spr.hitag == act->spr.hitag)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movefallers.
2020-10-22 17:31:06 +00:00
a2->temp_data[0] = 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
a2->spr.cstat &= ~CSTAT_SPRITE_ONE_SIDE;
if (a2->spr.picnum == CEILINGSTEAM || a2->spr.picnum == STEAM)
a2->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
}
else
{
- 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
act->hitextra = 0;
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
act->spr.extra = x;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- set_int_ang in Duke. Also changed SOUNDFX actor to use a different variable for its index.
2022-08-16 21:20:35 +00:00
act->set_int_ang(act->temp_data[1]);
- replaced all add_int_z calls with constants.
2022-08-20 15:59:15 +00:00
act->spr.pos.Z += 16;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movefallers.
2020-10-22 17:31:06 +00:00
else if (act->temp_data[0] == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (act->spr.lotag > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
act->spr.lotag-=3;
if (act->spr.lotag <= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- simple replacements in actor code
2022-09-13 17:55:54 +00:00
act->vel.X = 2 + krandf(4);
act->vel.Z = -4 + krandf(4);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
else
{
- trivial changes
2022-09-14 17:29:29 +00:00
if (act->vel.X > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more quick replacements
2022-09-03 08:05:20 +00:00
act->vel.X -= 0.5;
- movefallers.
2020-10-22 17:31:06 +00:00
ssp(act, CLIPMASK0);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
double grav;
if (fi.floorspace(act->sector())) grav = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (fi.ceilingspace(act->sector()))
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
grav = gs.gravity / 6;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
grav = gs.gravity;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- trivial wrapper replacements in Duke
2022-08-20 18:11:01 +00:00
if (act->spr.pos.Z < sectp->floorz - 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
act->vel.Z += grav;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (act->vel.Z > 24)
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
act->vel.Z = 24;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
act->spr.pos.Z += act->vel.Z;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- trivial wrapper replacements in Duke
2022-08-20 18:11:01 +00:00
if ((sectp->floorz - act->spr.pos.Z) < 16)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
j = 1 + (krand() & 7);
- floatified gs.gravity and all relations to player.vel.
2022-09-11 22:34:18 +00:00
for (int x = 0; x < j; x++) RANDOMSCRAP(act);
- movefallers.
2020-10-22 17:31:06 +00:00
deletesprite(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
}
}
use iterators for moveplayers, movedummyplayers and movefallers_d.
2020-10-12 20:00:19 +00:00
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
// split out of movestandables
//
//---------------------------------------------------------------------------
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
- movetripbomb.
2020-10-22 17:37:13 +00:00
static void movetripbomb(DDukeActor *actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
int j;
double x;
- Duke: made gamevars type safe and capable of managing actor pointers. Also a few unrelated changes needed to make it compile again.
2021-12-05 16:36:57 +00:00
int lTripBombControl = GetGameVar("TRIPBOMB_CONTROL", TRIPBOMB_TRIPWIRE, nullptr, -1).safeValue();
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (lTripBombControl & TRIPBOMB_TIMER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
// we're on a timer....
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (actor->spr.extra >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.extra--;
if (actor->spr.extra == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 16;
S_PlayActorSound(LASERTRIP_ARMING, actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (actor->temp_data[2] > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[2]--;
if (actor->temp_data[2] == 8)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
S_PlayActorSound(LASERTRIP_EXPLODE, actor);
for (j = 0; j < 5; j++) RANDOMSCRAP(actor);
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
int ex = actor->spr.extra;
fi.hitradius(actor, gs.tripbombblastradius, ex >> 2, ex >> 1, ex - (ex >> 2), ex);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
auto spawned = spawn(actor, EXPLOSION2);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (spawned)
{
- Utilise actor sprite's full precision in instances where angle was converted to Build and back again.
2022-08-28 03:15:31 +00:00
spawned->spr.angle = actor->spr.angle;
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
spawned->vel.X = 348 / 16.;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
ssp(spawned, CLIPMASK0);
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (a1->spr.picnum == LASERLINE && actor->spr.hitag == a1->spr.hitag)
- 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
a1->spr.xrepeat = a1->spr.yrepeat = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
deletesprite(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
return;
}
else
{
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
x = actor->spr.extra;
actor->spr.extra = 1;
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
auto ang = actor->spr.angle;
- movetripbomb.
2020-10-22 17:37:13 +00:00
j = fi.ifhitbyweapon(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (j >= 0)
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 16;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.extra = x;
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
actor->spr.angle = ang;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] < 32)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- findplayer
2020-10-23 15:44:45 +00:00
findplayer(actor, &x);
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
if (x > 48) actor->temp_data[0]++;
- movetripbomb.
2020-10-22 17:37:13 +00:00
else if (actor->temp_data[0] > 16) actor->temp_data[0]++;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] == 32)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
auto ang = actor->spr.angle;
- use temp_angle for TRIPBOMB’s saved angle
2022-08-29 21:12:39 +00:00
actor->spr.angle = actor->temp_angle;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- fixed position backup for trip bombs.
2022-09-14 22:40:34 +00:00
actor->temp_pos = actor->spr.pos;
- use ToVector where appropriate
2022-08-29 20:59:44 +00:00
actor->spr.pos += actor->temp_angle.ToVector() * 2;
- use temp_angle for TRIPBOMB’s saved angle
2022-08-29 21:12:39 +00:00
actor->spr.pos.Z -= 3;
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
// Laser fix from EDuke32.
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto const oldSect = actor->sector();
auto curSect = actor->sector();
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- pass a DVector3 to updatesectorneighbor
2022-08-29 17:29:20 +00:00
updatesectorneighbor(actor->spr.pos, &curSect, 128);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(actor, curSect);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
DDukeActor* hit;
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
x = hitasprite(actor, &hit);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- Duke: Replace `DDukeActor` `lastvx` with `ovel.X` calls.
2021-12-30 11:54:08 +00:00
actor->ovel.X = x;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
actor->spr.angle = ang;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (lTripBombControl & TRIPBOMB_TRIPWIRE)
{
// we're on a trip wire
while (x > 0)
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
auto spawned = spawn(actor, LASERLINE);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (spawned)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- GetActor pos replacement
2022-08-22 16:34:01 +00:00
SetActor(spawned, spawned->spr.pos);
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
spawned->spr.hitag = actor->spr.hitag;
- movetripbomb and movecrack
2022-09-13 18:11:45 +00:00
spawned->temp_pos.Z = spawned->spr.pos.Z; // doesn't look to be used anywhere...
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
if (x < 64)
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
{
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
spawned->spr.xrepeat = x / 2;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
break;
}
- floatified most of movetripbomb and ovel
2022-09-12 20:58:52 +00:00
x -= 64;
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- use ToVector where appropriate
2022-08-29 20:59:44 +00:00
actor->spr.pos += actor->temp_angle.ToVector() * 64;
- pass a DVector3 to updatesectorneighbor
2022-08-29 17:29:20 +00:00
updatesectorneighbor(actor->spr.pos, &curSect, 128);
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- sectnum removal step
2021-11-21 08:05:58 +00:00
if (curSect == nullptr)
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
break;
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(actor, curSect);
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- two more flags for LASERLINE.
2022-01-19 09:48:18 +00:00
// this is a hack to work around the laser line sprite's art tile offset
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(spawned, curSect);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[0]++;
- fixed position backup for trip bombs.
2022-09-14 22:40:34 +00:00
actor->spr.pos = actor->temp_pos;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(actor, oldSect);
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = 0;
if (hit && lTripBombControl & TRIPBOMB_TRIPWIRE)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 13;
S_PlayActorSound(LASERTRIP_ARMING, actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
else actor->temp_data[2] = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] == 33)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[1]++;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use temp_pos for TRIPBOMB and SE26
2022-08-29 21:13:54 +00:00
actor->temp_pos.XY() = actor->spr.pos.XY();
- use ToVector where appropriate
2022-08-29 20:59:44 +00:00
actor->spr.pos += actor->temp_angle.ToVector() * 2;
- use temp_angle for TRIPBOMB’s saved angle
2022-08-29 21:12:39 +00:00
actor->spr.pos.Z -= 3;
- did some more.
2022-02-06 21:45:47 +00:00
SetActor(actor, actor->spr.pos);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- floatified hitasprite's callers.
2022-09-13 22:11:16 +00:00
x = hitasprite(actor, nullptr);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use temp_pos for TRIPBOMB and SE26
2022-08-29 21:13:54 +00:00
actor->spr.pos.XY() = actor->temp_pos.XY();
- some simple replacements.
2022-02-07 07:47:18 +00:00
actor->spr.pos.Z += 3;
- did some more.
2022-02-06 21:45:47 +00:00
SetActor(actor, actor->spr.pos);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- Duke: Replace `DDukeActor` `lastvx` with `ovel.X` calls.
2021-12-30 11:54:08 +00:00
if (actor->ovel.X != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 13;
S_PlayActorSound(LASERTRIP_ARMING, actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
static void movecrack(DDukeActor* actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (actor->spr.hitag > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = actor->spr.cstat;
- movetripbomb and movecrack
2022-09-13 18:11:45 +00:00
actor->temp_angle = actor->spr.angle;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
int j = fi.ifhitbyweapon(actor);
- two more flags to get sprite indices out of movecrack. # Conflicts: # source/games/duke/src/constants.h
2022-01-19 18:15:23 +00:00
if (gs.actorinfo[j].flags2 & SFLAG2_EXPLOSIVE)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
DukeStatIterator it(STAT_STANDABLE);
while (auto a1 = it.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- two more flags to get sprite indices out of movecrack. # Conflicts: # source/games/duke/src/constants.h
2022-01-19 18:15:23 +00:00
if (actor->spr.hitag == a1->spr.hitag && actorflag(a1, SFLAG2_BRIGHTEXPLODE))
- 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 (a1->spr.shade != -32)
a1->spr.shade = -32;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
detonate(actor, EXPLOSION2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->spr.cstat = ESpriteFlags::FromInt(actor->temp_data[0]);
- movetripbomb and movecrack
2022-09-13 18:11:45 +00:00
actor->spr.angle = actor->temp_angle;
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.extra = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
static void movefireext(DDukeActor* actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
int j = fi.ifhitbyweapon(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (j == -1) return;
for (int k = 0; k < 16; k++)
{
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
auto a = randomAngle();
auto vel = krandf(4) + 4;
auto zvel = -krandf(16) - actor->vel.Z * 0.25;
auto spawned = CreateActor(actor->sector(), actor->spr.pos.plusZ(krandf(-48)), SCRAP3 + (krand() & 3), -8, 48, 48, a, vel, zvel, actor, 5);
- 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(spawned) spawned->spr.pal = 2;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
spawn(actor, EXPLOSION2);
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
S_PlayActorSound(GLASS_HEAVYBREAK, actor);
- reshuffling stuff.
2020-05-07 12:55:04 +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.hitag > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
DukeStatIterator it(STAT_STANDABLE);
while (auto a1 = it.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- two more flags to get sprite indices out of movecrack. # Conflicts: # source/games/duke/src/constants.h
2022-01-19 18:15:23 +00:00
if (actor->spr.hitag == a1->spr.hitag && actorflag(a1, SFLAG2_BRIGHTEXPLODE))
- 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 (a1->spr.shade != -32)
a1->spr.shade = -32;
- reshuffling stuff.
2020-05-07 12:55:04 +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
int x = actor->spr.extra;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
spawn(actor, EXPLOSION2);
- 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
fi.hitradius(actor, gs.pipebombblastradius, x >> 2, x - (x >> 1), x - (x >> 2), x);
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
detonate(actor, EXPLOSION2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- 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
fi.hitradius(actor, gs.seenineblastradius, 10, 15, 20, 25);
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
deletesprite(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
static void moveviewscreen(DDukeActor* actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
const double VIEWSCR_DIST = 1024; // was originally 2048, was increased to 8192 by EDuke32 and RedNukem, but with high resolutions the resulting 512 map units are still too low.
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (actor->spr.xrepeat == 0) deletesprite(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
double a;
int p = findplayer(actor, &a);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- converted all dist() calls to vector math and deleted the utilities
2022-09-13 18:01:17 +00:00
double x = (actor->spr.pos - ps[p].GetActor()->spr.pos).Length(); // the result from findplayer is not really useful.
- use the same camera sprite selection logic as EDuke32 and RedNukem. This is the only one that makes some sense.
2020-12-13 13:11:38 +00:00
if (x >= VIEWSCR_DIST && camsprite == actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- made camsprite an actor variable.
2020-11-04 18:25:49 +00:00
camsprite = nullptr;
- 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
actor->spr.yint = 0;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
actor->temp_data[0] = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
- move*bolt.
2020-10-22 17:46:42 +00:00
static void movesidebolt(DDukeActor* actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
findplayer(actor, &xx);
if (xx > 1280) return;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
CLEAR_THE_BOLT2:
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[2])
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2]--;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return;
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if ((actor->spr.xrepeat | actor->spr.yrepeat) == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->spr.xrepeat = actor->temp_data[0];
actor->spr.yrepeat = actor->temp_data[1];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
if ((krand() & 8) == 0)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = actor->spr.xrepeat;
actor->temp_data[1] = actor->spr.yrepeat;
actor->temp_data[2] = global_random & 4;
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.xrepeat = actor->spr.yrepeat = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
goto CLEAR_THE_BOLT2;
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.picnum++;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- flags for the bolts.
2022-01-21 13:02:59 +00:00
if ((krand() & 1) && (gs.tileinfo[sectp->floorpicnum].flags & TFLAG_ELECTRIC))
- move*bolt.
2020-10-22 17:46:42 +00:00
S_PlayActorSound(SHORT_CIRCUIT, actor);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (actor->spr.picnum == SIDEBOLT1 + 4) actor->spr.picnum = SIDEBOLT1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- move*bolt.
2020-10-22 17:46:42 +00:00
static void movebolt(DDukeActor *actor)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
findplayer(actor, &xx);
if (xx > 1280) return;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[3] == 0)
actor->temp_data[3] = sectp->floorshade;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
CLEAR_THE_BOLT:
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[2])
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2]--;
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
sectp->floorshade = 20;
sectp->ceilingshade = 20;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
return;
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if ((actor->spr.xrepeat | actor->spr.yrepeat) == 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->spr.xrepeat = actor->temp_data[0];
actor->spr.yrepeat = actor->temp_data[1];
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
else if ((krand() & 8) == 0)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = actor->spr.xrepeat;
actor->temp_data[1] = actor->spr.yrepeat;
actor->temp_data[2] = global_random & 4;
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.xrepeat = actor->spr.yrepeat = 0;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
goto CLEAR_THE_BOLT;
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.picnum++;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
int l = global_random & 7;
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
actor->spr.xrepeat = l + 8;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (l & 1) actor->spr.cstat ^= CSTAT_SPRITE_TRANSLUCENT;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- flags for the bolts.
2022-01-21 13:02:59 +00:00
if (actor->spr.picnum == (BOLT1+1) && (krand()&7) == 0 && (gs.tileinfo[sectp->floorpicnum].flags & TFLAG_ELECTRIC))
- move*bolt.
2020-10-22 17:46:42 +00:00
S_PlayActorSound(SHORT_CIRCUIT,actor);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (actor->spr.picnum==BOLT1+4) actor->spr.picnum=BOLT1;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
if (actor->spr.picnum & 1)
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
sectp->floorshade = 0;
sectp->ceilingshade = 0;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
else
{
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
sectp->floorshade = 20;
sectp->ceilingshade = 20;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
//---------------------------------------------------------------------------
//
// this has been broken up into lots of smaller subfunctions
//
//---------------------------------------------------------------------------
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
void movestandables_d(void)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
DukeStatIterator it(STAT_STANDABLE);
while (auto act = it.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +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
int picnum = act->spr.picnum;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if (!act->insector())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
deletesprite(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
continue;
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (picnum >= CRANE && picnum <= CRANE +3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movecrane(act, CRANE);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum >= WATERFOUNTAIN && picnum <= WATERFOUNTAIN + 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movefountain(act, WATERFOUNTAIN);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (AFLAMABLE(picnum))
{
- flammable flags.
2022-01-26 23:41:33 +00:00
moveflammable(act, BLOODPOOL);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == TRIPBOMB)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movetripbomb(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum >= CRACK1 && picnum <= CRACK1 + 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movecrack(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == FIREEXT)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movefireext(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == OOZFILTER || picnum == SEENINE || picnum == SEENINEDEAD || picnum == (SEENINEDEAD + 1))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
moveooz(act, SEENINE, SEENINEDEAD, OOZFILTER, EXPLOSION2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (picnum == MASTERSWITCH)
{
- two more flags to get sprite indices out of movecrack. # Conflicts: # source/games/duke/src/constants.h
2022-01-19 18:15:23 +00:00
movemasterswitch(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == VIEWSCREEN || picnum == VIEWSCREEN2)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
moveviewscreen(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == TRASH)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movetrash(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum >= SIDEBOLT1 && picnum <= SIDEBOLT1 + 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movesidebolt(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum >= BOLT1 && picnum <= BOLT1 + 3)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movebolt(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == WATERDRIP)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movewaterdrip(act, WATERDRIP);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (picnum == DOORSHOCK)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movedoorshock(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (picnum == TOUCHPLATE)
{
- movestandables.
2020-10-22 17:51:42 +00:00
movetouchplate(act, TOUCHPLATE);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (isIn(picnum, CANWITHSOMETHING, CANWITHSOMETHING2, CANWITHSOMETHING3, CANWITHSOMETHING4))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movestandables.
2020-10-22 17:51:42 +00:00
movecanwithsomething(act);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
else if (isIn(picnum,
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
EXPLODINGBARREL,
WOODENHORSE,
HORSEONSIDE,
FLOORFLAME,
FIREBARREL,
FIREVASE,
NUKEBARREL,
NUKEBARRELDENTED,
NUKEBARRELLEAKED,
TOILETWATER,
RUBBERCAN,
STEAM,
CEILINGSTEAM,
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
WATERBUBBLEMAKER))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double x;
- findplayer
2020-10-23 15:44:45 +00:00
int p = findplayer(act, &x);
- movestandables.
2020-10-22 17:51:42 +00:00
execute(act, p, x);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
static bool movefireball(DDukeActor* actor)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
auto Owner = actor->GetOwner();
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (actor->sector()->lotag == 2)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
deletesprite(actor);
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
return true;
}
- 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 (!Owner || Owner->spr.picnum != FIREBALL)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
if (actor->temp_data[0] >= 1 && actor->temp_data[0] < 6)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
float siz = 1.0f - (actor->temp_data[0] * 0.2f);
- do not use auto to make local copies of TObjPtr's. This will just copy the object without performing the read barrier on the source data which is not what we want here. For these assignments the type must be explicit.
2021-12-05 23:20:46 +00:00
DDukeActor* trail = actor->temp_actor;
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
auto ball = spawn(actor, FIREBALL);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (ball)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- moved the FireProj struct into DDukeActor to avoid the rather expensive TMap code. Later this can be moved to a dedicated subclass.
2021-12-07 15:45:39 +00:00
actor->temp_actor = ball;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
- simple replacements in actor code
2022-09-13 17:55:54 +00:00
ball->vel.X = actor->vel.X;
ball->vel.Z = actor->vel.Z;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (actor->temp_data[0] > 1)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
- moved the FireProj struct into DDukeActor to avoid the rather expensive TMap code. Later this can be moved to a dedicated subclass.
2021-12-07 15:45:39 +00:00
if (trail)
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
{
- use temp_pos instead of maintaining yet another variable for FIREBALL
2022-08-30 19:36:30 +00:00
ball->spr.pos = trail->temp_pos;
- replace FireProj struct with a second temp_pos vector We’re going to need this anyway for some SE’s.
2022-09-13 17:58:17 +00:00
ball->vel = trail->temp_pos2;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
}
- large block of s = actor->s; in actors_d.cpp
2021-12-21 18:19:05 +00:00
ball->spr.yrepeat = ball->spr.xrepeat = (uint8_t)(actor->spr.xrepeat * siz);
ball->spr.cstat = actor->spr.cstat;
ball->spr.extra = 0;
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
- use temp_pos instead of maintaining yet another variable for FIREBALL
2022-08-30 19:36:30 +00:00
ball->temp_pos = ball->spr.pos;
- replace FireProj struct with a second temp_pos vector We’re going to need this anyway for some SE’s.
2022-09-13 17:58:17 +00:00
ball->temp_pos2 = ball->vel;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(ball, STAT_PROJECTILE);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
}
- chickenarrow and movefireball.
2020-10-22 17:59:38 +00:00
actor->temp_data[0]++;
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
}
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
if (actor->vel.Z < 15000. / 256.)
actor->vel.Z += 200 / 256.;
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
return false;
}
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
static bool weaponhitsprite(DDukeActor* proj, DDukeActor *targ, bool fireball)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == FREEZEBLAST && targ->spr.pal == 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
if (badguy(targ) || targ->spr.picnum == APLAYER)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
auto spawned = spawn(targ, TRANSPORTERSTAR);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (spawned)
{
- 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
spawned->spr.pal = 1;
spawned->spr.xrepeat = 32;
spawned->spr.yrepeat = 32;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
deletesprite(proj);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (!isWorldTour() || proj->spr.picnum != FIREBALL || fireball)
- switched the checkhitsprite interface to actors.
2020-10-24 05:15:10 +00:00
fi.checkhitsprite(targ, proj);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +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 (targ->spr.picnum == APLAYER)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- 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
int p = targ->spr.yint;
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
auto Owner = proj->GetOwner();
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +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 (ud.multimode >= 2 && fireball && Owner && Owner->spr.picnum == APLAYER)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- 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
ps[p].numloogs = -1 - proj->spr.yint;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
}
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
S_PlayActorSound(PISTOL_BODYHIT, targ);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == SPIT)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- Remove multiple `addadjustment()`/`settarget()` overloads in favour of native `binangle`/`fixedhoriz` versions only. * Simplifies these classes a bit. * Better shows intent in actual game code. * Removes unnecessary int to double conversions.
2022-05-30 10:35:41 +00:00
ps[p].horizon.addadjustment(buildhoriz(32));
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
ps[p].sync.actions |= SB_CENTERVIEW;
if (ps[p].loogcnt == 0)
{
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
if (!S_CheckActorSoundPlaying(ps[p].GetActor(), DUKE_LONGTERM_PAIN))
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].GetActor());
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
int j = 3 + (krand() & 3);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
ps[p].numloogs = j;
ps[p].loogcnt = 24 * 4;
for (int x = 0; x < j; x++)
{
- Duke: Replace `player_struct` `loogiex[64]` with `loogie[64].X` calls.
2021-12-30 11:45:53 +00:00
ps[p].loogie[x].X = krand() % 320;
- Duke: Replace `player_struct` `loogiey[64]` with `loogie[64].Y` calls.
2021-12-30 11:47:19 +00:00
ps[p].loogie[x].Y = krand() % 200;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
}
}
}
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- eliminated the SetActor/Z function receiving a vec3_t pointer. The only one left is the one with a DVector3 now.
2022-08-22 21:57:39 +00:00
static bool weaponhitwall(DDukeActor *proj, walltype* wal, const DVector3 &oldpos)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum != RPG && proj->spr.picnum != FREEZEBLAST && proj->spr.picnum != SPIT &&
(!isWorldTour() || proj->spr.picnum != FIREBALL) &&
- Duke/RR: weaponhitwall cleaned up (both variants)
2021-11-16 16:51:50 +00:00
(wal->overpicnum == MIRROR || wal->picnum == MIRROR))
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- no need to use int_delta when all we want is the angle.
2022-08-30 21:05:54 +00:00
int k = getangle(wal->delta());
- set_int_ang in Duke. Also changed SOUNDFX actor to use a different variable for its index.
2022-08-16 21:20:35 +00:00
proj->set_int_ang(((k << 1) - proj->int_ang()) & 2047);
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
proj->SetOwner(proj);
spawn(proj, TRANSPORTERSTAR);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
else
{
- eliminated the SetActor/Z function receiving a vec3_t pointer. The only one left is the one with a DVector3 now.
2022-08-22 21:57:39 +00:00
SetActor(proj, oldpos);
- floatified position in checkhitwall
2022-08-23 20:39:07 +00:00
fi.checkhitwall(proj, wal, proj->spr.pos, proj->spr.picnum);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == FREEZEBLAST)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- Duke/RR: weaponhitwall cleaned up (both variants)
2021-11-16 16:51:50 +00:00
if (wal->overpicnum != MIRROR && wal->picnum != MIRROR)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
proj->spr.extra >>= 1;
- 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
proj->spr.yint--;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
}
- no need to use int_delta when all we want is the angle.
2022-08-30 21:05:54 +00:00
int k = getangle(wal->delta());
- set_int_ang in Duke. Also changed SOUNDFX actor to use a different variable for its index.
2022-08-16 21:20:35 +00:00
proj->set_int_ang(((k << 1) - proj->int_ang()) & 2047);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- eliminated the SetActor/Z function receiving a vec3_t pointer. The only one left is the one with a DVector3 now.
2022-08-22 21:57:39 +00:00
static bool weaponhitsector(DDukeActor* proj, const DVector3& oldpos, bool fireball)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- eliminated the SetActor/Z function receiving a vec3_t pointer. The only one left is the one with a DVector3 now.
2022-08-22 21:57:39 +00:00
SetActor(proj, oldpos);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (proj->vel.Z < 0)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (proj->sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (proj->sector()->ceilingpal == 0)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
deletesprite(proj);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
fi.checkhitceiling(proj->sector());
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
}
else if (fireball)
{
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
auto spawned = spawn(proj, LAVAPOOL);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (spawned)
{
spawned->SetOwner(proj);
spawned->SetHitOwner(proj);
- 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
spawned->spr.yint = proj->spr.yint;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
deletesprite(proj);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == FREEZEBLAST)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
{
- weaponcommon subfunctions.
2020-10-22 18:07:05 +00:00
bounce(proj);
ssp(proj, CLIPMASK1);
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
proj->spr.extra >>= 1;
if (proj->spr.xrepeat > 8)
proj->spr.xrepeat -= 2;
if (proj->spr.yrepeat > 8)
proj->spr.yrepeat -= 2;
- 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
proj->spr.yint--;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
return true;
}
return false;
}
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
//---------------------------------------------------------------------------
//
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
//
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
//
//---------------------------------------------------------------------------
- moveweapons.
2020-10-22 18:21:21 +00:00
static void weaponcommon_d(DDukeActor* proj)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == COOLEXPLOSION1)
- RR-movement + dummyplayersprite
2020-10-25 06:21:33 +00:00
if (!S_CheckActorSoundPlaying(proj, WIERDSHOT_FLY))
- moveweapons.
2020-10-22 18:21:21 +00:00
S_PlayActorSound(WIERDSHOT_FLY, proj);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
double vel = proj->vel.X;
double velz = proj->vel.Z;
int p = -1;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (proj->spr.picnum == RPG && proj->sector()->lotag == 2)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
vel *= 0.5;
velz *= 0.5;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
auto oldpos = proj->spr.pos;
- moveweapons.
2020-10-22 18:21:21 +00:00
getglobalz(proj);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
switch (proj->spr.picnum)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
case RPG:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (proj->attackertype != BOSS2 && proj->spr.xrepeat >= 10 && proj->sector()->lotag != 2)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
auto spawned = spawn(proj, SMALLSMOKE);
- more cleanup.
2022-02-06 21:56:25 +00:00
if (spawned) spawned->spr.pos.Z += 1;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
break;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
case FIREBALL:
- moveweapons.
2020-10-22 18:21:21 +00:00
if (movefireball(proj)) return;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
break;
}
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
Collision coll;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
movesprite_ex(proj, DVector3(proj->spr.angle.ToVector() * vel, velz), CLIPMASK1, coll);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == RPG && proj->temp_actor != nullptr)
- handled a few easy to change distance calculations and nearby assignments.
2022-09-11 18:46:21 +00:00
if ((proj->spr.pos.XY() - proj->temp_actor->spr.pos.XY()).Length() < 16)
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
coll.setSprite(proj->temp_actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use DCoreActor::insector instead of spritetype::insector.
2021-12-30 15:24:51 +00:00
if (!proj->insector())
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(proj);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
return;
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
if (proj->spr.pos.Z < proj->ceilingz)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
coll.setSector(proj->sector());
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
proj->vel.Z -= 1/256.;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
else
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if ((proj->spr.pos.Z > proj->floorz && proj->sector()->lotag != 1) ||
(proj->spr.pos.Z > proj->floorz + 16 && proj->sector()->lotag == 1))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
coll.setSector(proj->sector());
if (proj->sector()->lotag != 1)
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
proj->vel.Z += 1/256.;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == FIRELASER)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
for (int k = -3; k < 2; k++)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
double zAdd = k * proj->vel.Z / 24;
auto spawned = CreateActor(proj->sector(), proj->spr.pos.plusZ(zAdd) + proj->spr.angle.ToVector() * k * 2.,
FIRELASER, -40 + (k << 2),
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
proj->spr.xrepeat, proj->spr.yrepeat, nullAngle, 0., 0., proj->GetOwner(), 5);
Interpolate FIRELASER trails.
2022-04-19 06:41:19 +00:00
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
if (spawned)
{
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
spawned->opos = proj->opos - proj->spr.pos + spawned->spr.pos;
- 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
spawned->spr.cstat = CSTAT_SPRITE_YCENTER;
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
spawned->spr.pal = proj->spr.pal;
- Duke/RR: guard all calls to EGS with a null pointer check. Spawning sprites into the void will crash the engine so these must be blocked which requires a failure check here. With this pressing fire while in the void no longer crashes the game - it won't fire anything, either, though.
2021-11-19 08:47:17 +00:00
}
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
}
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
else if (proj->spr.picnum == SPIT) if (proj->vel.Z < 24)
- fixes for player velocity.
2022-10-05 22:07:01 +00:00
proj->vel.Z += gs.gravity - 112 / 256.;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
if (coll.type != 0)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == COOLEXPLOSION1)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +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 (coll.type == kHitSprite && coll.actor()->spr.picnum != APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
return;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
proj->vel.X = 0;
proj->vel.Z = 0;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
bool fireball = (isWorldTour() && proj->spr.picnum == FIREBALL && (!proj->GetOwner() || proj->GetOwner()->spr.picnum != FIREBALL));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
if (coll.type == kHitSprite)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- made Collision derive from a common base class and refactored clipmove to a single engine-side entry point. Done for Doom so far.
2021-11-26 12:41:15 +00:00
if (weaponhitsprite(proj, coll.actor(), fireball)) return;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
else if (coll.type == kHitWall)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- made Collision derive from a common base class and refactored clipmove to a single engine-side entry point. Done for Doom so far.
2021-11-26 12:41:15 +00:00
if (weaponhitwall(proj, coll.hitWall, oldpos)) return;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
else if (coll.type == kHitSector)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
if (weaponhitsector(proj, oldpos, fireball)) return;
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum != SPIT)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == RPG)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- cleanup and consolidation of moveweapons_r.
2020-10-18 08:42:26 +00:00
// j is only needed for the hit type mask.
- use the cleaned up movesprite interface in moveweapons.
2020-10-22 19:19:24 +00:00
rpgexplode(proj, coll.type, oldpos, EXPLOSION2, EXPLOSION2BOT, -1, RPG_EXPLODE);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
else if (proj->spr.picnum == SHRINKSPARK)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
spawn(proj, SHRINKEREXPLOSION);
S_PlayActorSound(SHRINKER_HIT, proj);
- 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
fi.hitradius(proj, gs.shrinkerblastradius, 0, 0, 0, 0);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
else if (proj->spr.picnum != COOLEXPLOSION1 && proj->spr.picnum != FREEZEBLAST && proj->spr.picnum != FIRELASER && (!isWorldTour() || proj->spr.picnum != FIREBALL))
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
auto spawned = spawn(proj, EXPLOSION2);
if (spawned)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
spawned->spr.xrepeat = spawned->spr.yrepeat = proj->spr.xrepeat >> 1;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (coll.type == kHitSector)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (proj->vel.Z < 0)
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
{
- Duke: second batch of refactoring writes to spr.pos.
2022-01-30 17:15:07 +00:00
spawned->spr.cstat |= CSTAT_SPRITE_YFLIP;
- replaced all add_int_z calls with constants.
2022-08-20 15:59:15 +00:00
spawned->spr.pos.Z += 72;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
if (fireball)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
auto spawned = spawn(proj, EXPLOSION2);
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (spawned) spawned->spr.xrepeat = spawned->spr.yrepeat = (short)(proj->spr.xrepeat >> 1);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum != COOLEXPLOSION1)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(proj);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
return;
}
}
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
if (proj->spr.picnum == COOLEXPLOSION1)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- more parts of actor_d.cpp
2021-12-21 18:39:33 +00:00
proj->spr.shade++;
if (proj->spr.shade >= 40)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(proj);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
return;
}
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
else if (proj->spr.picnum == RPG && proj->sector()->lotag == 2 && proj->spr.xrepeat >= 10 && rnd(140))
- moveweapons.
2020-10-22 18:21:21 +00:00
spawn(proj, WATERBUBBLE);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void moveweapons_d(void)
{
- moveweapons.
2020-10-22 18:21:21 +00:00
DukeStatIterator it(STAT_PROJECTILE);
while (auto act = it.Next())
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
if (!act->insector())
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(act);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
continue;
}
- 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
switch(act->spr.picnum)
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
case RADIUSEXPLOSION:
case KNEE:
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(act);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
continue;
case TONGUE:
- moveweapons.
2020-10-22 18:21:21 +00:00
movetongue(act, TONGUE, INNERJAW);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
continue;
case FREEZEBLAST:
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (act->spr.yint < 1 || act->spr.extra < 2 || (act->vel.X == 0 && act->vel.Z == 0))
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- moveweapons.
2020-10-22 18:21:21 +00:00
auto spawned = spawn(act,TRANSPORTERSTAR);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (spawned)
{
- 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
spawned->spr.pal = 1;
spawned->spr.xrepeat = 32;
spawned->spr.yrepeat = 32;
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
}
- moveweapons.
2020-10-22 18:21:21 +00:00
deletesprite(act);
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
continue;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
case FIREBALL:
// Twentieth Anniversary World Tour
- 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 (act->spr.picnum == FIREBALL && !isWorldTour()) break;
- added a few fallthrough annotations that were missed last time.
2021-11-14 23:06:07 +00:00
[[fallthrough]];
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
case SHRINKSPARK:
case RPG:
case FIRELASER:
case SPIT:
case COOLEXPLOSION1:
- moveweapons.
2020-10-22 18:21:21 +00:00
weaponcommon_d(act);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
break;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
case SHOTSPARK1:
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double x;
- findplayer
2020-10-23 15:44:45 +00:00
int p = findplayer(act, &x);
- moveweapons.
2020-10-22 18:21:21 +00:00
execute(act, p, x);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
break;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- further splitting of moveweapons_d. Progress with this but still not enough yet to break it down into manageable parts.
2020-10-18 06:38:29 +00:00
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- movetransports.
2020-05-07 22:03:51 +00:00
//---------------------------------------------------------------------------
//
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
//
- movetransports.
2020-05-07 22:03:51 +00:00
//
//---------------------------------------------------------------------------
void movetransports_d(void)
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int warpspriteto;
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
double ll;
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
DukeStatIterator iti(STAT_TRANSPORT);
while (auto act = iti.Next())
- movetransports.
2020-05-07 22:03:51 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
auto Owner = act->GetOwner();
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
if (Owner == act)
- movetransports.
2020-05-07 22:03:51 +00:00
{
continue;
}
- movetransports.
2020-10-22 19:42:02 +00:00
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = act->sector();
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
int sectlotag = sectp->lotag;
- movetransports.
2020-10-22 19:42:02 +00:00
int onfloorz = act->temp_data[4];
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
if (act->temp_data[0] > 0) act->temp_data[0]--;
- 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
- use insector and sector pointer initialization for iterator
2021-11-21 00:04:16 +00:00
DukeSectIterator itj(act->sector());
- movetransports.
2020-10-22 19:42:02 +00:00
while (auto act2 = itj.Next())
- movetransports.
2020-05-07 22:03:51 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
switch (act2->spr.statnum)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
case STAT_PLAYER:
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
if (act2->GetOwner())
- movetransports.
2020-05-07 22:03:51 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
int p = act2->PlayerIndex();
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].on_warping_sector = 1;
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
if (ps[p].transporter_hold == 0 && ps[p].jumping_counter == 0)
{
if (ps[p].on_ground && sectlotag == 0 && onfloorz && ps[p].jetpack_on == 0)
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.pal == 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
spawn(act, TRANSPORTERBEAM);
S_PlayActorSound(TELEPORTER, act);
- movetransports.
2020-05-07 22:03:51 +00:00
}
- 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
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
for (int k = connecthead; k >= 0; k = connectpoint2[k])
replaced cursectnum with a cursector pointer
2021-11-21 07:56:39 +00:00
if (ps[k].cursector == Owner->sector())
- movetransports.
2020-05-07 22:03:51 +00:00
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ps[k].frag_ps = p;
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[k].GetActor()->spr.extra = 0;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
}
- 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
- Utilise actor sprite's full precision in instances where angle was converted to Build and back again.
2022-08-28 03:15:31 +00:00
ps[p].angle.ang = Owner->spr.angle;
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
if (Owner->GetOwner() != Owner)
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
act->temp_data[0] = 13;
Owner->temp_data[0] = 13;
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = 13;
}
- 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
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].getposfromactor(Owner, -gs.playerheight);
ps[p].backupxyz();
ps[p].setbobpos();
- 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
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(act2, Owner->sector());
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
ps[p].setCursector(act2->sector());
- 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
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.pal == 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
auto k = spawn(Owner, TRANSPORTERBEAM);
- Duke/RR: added null checks to all spawn() calls
2021-11-19 11:32:12 +00:00
if (k) S_PlayActorSound(TELEPORTER, k);
- movetransports.
2020-05-07 22:03:51 +00:00
}
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
break;
}
}
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) 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
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 24)
- transitioned the 5 primary action keys: Open, Jump, Crouch and Fire/AltFire.
2020-08-28 20:51:05 +00:00
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
- 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
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
- movetransports.
2020-05-07 22:03:51 +00:00
{
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].backupxy();
- 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
- transitioned the 5 primary action keys: Open, Jump, Crouch and Fire/AltFire.
2020-08-28 20:51:05 +00:00
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
ps[p].pos.Z = Owner->spr.pos.Z - 24;
else ps[p].pos.Z = Owner->spr.pos.Z + 24;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].backupz();
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
auto pa = ps[p].GetActor();
- floatified player_struct::pos.
2022-02-05 12:29:21 +00:00
pa->opos = ps[p].pos;
- 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
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(act2, Owner->sector());
- cursectnum first half
2021-11-21 07:45:07 +00:00
ps[p].setCursector(Owner->sector());
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
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
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int k = 0;
- 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
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
if (onfloorz && sectlotag == ST_1_ABOVE_WATER && ps[p].on_ground && ps[p].pos.Z > (sectp->floorz - 16) && (PlayerInput(p, SB_CROUCH) || ps[p].vel.Z > 8))
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
// if( onfloorz && sectlotag == 1 && ps[p].pos.z > (sectp->floorz-(6<<8)) )
- movetransports.
2020-05-07 22:03:51 +00:00
{
k = 1;
if (screenpeek == p)
{
FX_StopAllSounds();
}
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
if (ps[p].GetActor()->spr.extra > 0)
- movetransports.
2020-10-22 19:42:02 +00:00
S_PlayActorSound(DUKE_UNDERWATER, act2);
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
ps[p].pos.Z = Owner->sector()->ceilingz + 7;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].backupz();
- 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
- 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
// this is actually below the precision <20>f the original Build coordinate system...
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
ps[p].vel.X = ((krand() & 8192) ? 1 / 64. : -1 / 64.);
ps[p].vel.Y = ((krand() & 8192) ? 1 / 64. : -1 / 64.);
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
}
- 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
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
if (onfloorz && sectlotag == ST_2_UNDERWATER && ps[p].pos.Z < (sectp->ceilingz + 6))
- movetransports.
2020-05-07 22:03:51 +00:00
{
k = 1;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
// if( act2->spr.extra <= 0) break;
- movetransports.
2020-05-07 22:03:51 +00:00
if (screenpeek == p)
{
FX_StopAllSounds();
}
- movetransports.
2020-10-22 19:42:02 +00:00
S_PlayActorSound(DUKE_GASP, act2);
- 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
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
ps[p].pos.Z = Owner->sector()->floorz - 7;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].backupz();
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].jumping_toggle = 1;
ps[p].jumping_counter = 0;
}
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
if (k == 1)
{
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].backupxy();
- 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
- movetransports.
2020-10-22 19:42:02 +00:00
if (!Owner || Owner->GetOwner() != Owner)
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = -2;
- cursectnum first half
2021-11-21 07:45:07 +00:00
ps[p].setCursector(Owner->sector());
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(act2, Owner->sector());
- cleanup, part 2.
2022-02-05 12:35:02 +00:00
SetActor(ps[p].GetActor(), ps[p].pos.plusZ(gs.playerheight));
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
if ((krand() & 255) < 32)
- movetransports.
2020-10-22 19:42:02 +00:00
spawn(act2, WATERSPLASH2);
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
if (sectlotag == 1)
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
for (int l = 0; l < 9; l++)
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
auto q = spawn(ps[p].GetActor(), WATERBUBBLE);
- 3x add_int_z.
2022-09-12 16:37:35 +00:00
if (q) q->spr.pos.Z += krandf(64);
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
}
- movetransports.
2020-05-07 22:03:51 +00:00
}
}
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
- movetransports.
2020-05-07 22:03:51 +00:00
case STAT_ACTOR:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
switch (act2->spr.picnum)
- movetransports.
2020-05-07 22:03:51 +00:00
{
case SHARK:
case COMMANDER:
case OCTABRAIN:
case GREENSLIME:
case GREENSLIME + 1:
case GREENSLIME + 2:
case GREENSLIME + 3:
case GREENSLIME + 4:
case GREENSLIME + 5:
case GREENSLIME + 6:
case GREENSLIME + 7:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act2->spr.extra > 0)
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
continue;
- movetransports.
2020-05-07 22:03:51 +00:00
}
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
- movetransports.
2020-05-07 22:03:51 +00:00
case STAT_PROJECTILE:
case STAT_MISC:
case STAT_FALLER:
case STAT_DUMMYPLAYER:
- 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
- eliminate the last int_zvel call
2022-09-14 18:55:50 +00:00
ll = abs(act2->vel.Z);
- 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
- movetransports.
2020-05-07 22:03:51 +00:00
{
warpspriteto = 0;
- added velocity checks when attempting to dive or surface. This could misbehave at low velocities that could be misinterpreted as a boundary crossing due to the missing check for the movement direction.
2022-10-17 21:19:57 +00:00
if (ll && sectlotag == 2 && act2->spr.pos.Z < (sectp->ceilingz + ll) && act2->vel.Z < 0)
- movetransports.
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
- 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 velocity checks when attempting to dive or surface. This could misbehave at low velocities that could be misinterpreted as a boundary crossing due to the missing check for the movement direction.
2022-10-17 21:19:57 +00:00
if (ll && sectlotag == 1 && act2->spr.pos.Z > (sectp->floorz - ll) && act2->vel.Z > 0)
- movetransports.
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
- 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
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 16))
- movetransports.
2020-05-07 22:03:51 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if ((!Owner || Owner->GetOwner() != Owner) && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != STAT_MISC)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- movetransports.
2020-10-22 19:42:02 +00:00
act->temp_data[0]++;
- movetransports.
2020-05-07 22:03:51 +00:00
goto BOLT;
}
warpspriteto = 1;
}
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (warpspriteto)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (actorflag(act2, SFLAG_NOTELEPORT)) continue;
switch (act2->spr.picnum)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
case PLAYERONWATER:
if (sectlotag == 2)
{
act2->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
break;
}
[[fallthrough]];
default:
if (act2->spr.statnum == 5 && !(sectlotag == 1 || sectlotag == 2))
break;
[[fallthrough]];
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
case WATERBUBBLE:
//if( rnd(192) && a2->s.picnum == WATERBUBBLE)
// 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (sectlotag > 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
auto k = spawn(act2, WATERSPLASH2);
if (k && sectlotag == 1 && act2->spr.statnum == 4)
{
- simple replacements in actor code
2022-09-13 17:55:54 +00:00
k->vel.X = act2->vel.X * 0.5;
- Utilise actor sprite's full precision in instances where angle was converted to Build and back again.
2022-08-28 03:15:31 +00:00
k->spr.angle = act2->spr.angle;
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
ssp(k, CLIPMASK0);
}
- movetransports.
2020-05-07 22:03:51 +00:00
}
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
switch (sectlotag)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- Duke: second batch of refactoring writes to spr.pos.
2022-01-30 17:15:07 +00:00
case ST_0_NO_EFFECT:
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (onfloorz)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1))
{
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
act2->spr.pos += (Owner->spr.pos - act->spr.pos.XY()).plusZ(-Owner->sector()->floorz);
- Utilise actor sprite's full precision in instances where angle was converted to Build and back again.
2022-08-28 03:15:31 +00:00
act2->spr.angle = Owner->spr.angle;
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
act2->backupang();
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (act->spr.pal == 0)
{
auto k = spawn(act, TRANSPORTERBEAM);
if (k) S_PlayActorSound(TELEPORTER, k);
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
k = spawn(Owner, TRANSPORTERBEAM);
if (k) S_PlayActorSound(TELEPORTER, k);
}
- 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 a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
if (Owner && Owner->GetOwner() == Owner)
{
act->temp_data[0] = 13;
Owner->temp_data[0] = 13;
}
ChangeActorSect(act2, Owner->sector());
- movetransports.
2020-05-07 22:03:51 +00:00
}
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
}
else
{
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
act2->spr.pos.XY() += Owner->spr.pos.XY() - act->spr.pos.XY();
- Duke: cleanup on z-checks, part 2.
2022-02-04 08:50:40 +00:00
act2->spr.pos.Z = Owner->spr.pos.Z + 16;
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
act2->backupz();
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(act2, Owner->sector());
- movetransports.
2020-05-07 22:03:51 +00:00
}
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
break;
- Duke: second batch of refactoring writes to spr.pos.
2022-01-30 17:15:07 +00:00
case ST_1_ABOVE_WATER:
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
act2->spr.pos.XY() += Owner->spr.pos.XY() - act->spr.pos.XY();
act2->spr.pos.Z = Owner->sector()->ceilingz + ll;
- moved the backup... methods to DCoreActor.
2021-12-30 16:10:08 +00:00
act2->backupz();
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorSect(act2, Owner->sector());
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
break;
- Duke: second batch of refactoring writes to spr.pos.
2022-01-30 17:15:07 +00:00
case ST_2_UNDERWATER:
- partial floatification of movetransports_d
2022-08-20 16:55:45 +00:00
act2->spr.pos.XY() += Owner->spr.pos.XY() - act->spr.pos.XY();
act2->spr.pos.Z = Owner->sector()->ceilingz - ll;
- added a new flag for non-teleporting items.
2022-01-19 07:20:40 +00:00
act2->backupz();
ChangeActorSect(act2, Owner->sector());
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
- movetransports.
2020-05-07 22:03:51 +00:00
break;
}
}
}
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
- movetransports.
2020-05-07 22:03:51 +00:00
}
}
BOLT:;
}
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- greenslime.
2020-10-22 19:49:29 +00:00
static void greenslime(DDukeActor *actor)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
int j;
- Duke: replaced the game type macros with inline functions.
2020-10-11 09:39:51 +00:00
// #ifndef isShareware()
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (ud.multimode < 2)
{
if (actor_tog == 1)
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else if (actor_tog == 2) actor->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
// #endif
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[1] += 128;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- deal with most of CSTAT_SECTOR_SKY and CSTAT_SECTOR_SLOPE
2021-12-18 12:14:56 +00:00
if (sectp->floorstat & CSTAT_SECTOR_SKY)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
int p = findplayer(actor, &xx);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
if (xx > 1280)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
actor->timetosleep++;
if (actor->timetosleep > SLEEPTIME)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
actor->timetosleep = 0;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(actor, 2);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == -5) // FROZEN
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[3]++;
if (actor->temp_data[3] > 280)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.pal = 0;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- greenslime.
2020-10-22 19:49:29 +00:00
makeitfall(actor);
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
actor->spr.picnum = GREENSLIME + 2;
actor->spr.extra = 1;
actor->spr.pal = 1;
- greenslime.
2020-10-22 19:49:29 +00:00
j = fi.ifhitbyweapon(actor);
if (j >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
if (j == FREEZEBLAST)
return;
for (j = 16; j >= 0; j--)
{
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
auto a = randomAngle();
auto vel = krandf(2) + 2;
auto zvel = 4 - krandf(4);
auto k = CreateActor(actor->sector(), actor->spr.pos, GLASSPIECES + (j % 3), -32, 36, 36, a, vel, zvel, actor, 5);
- 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
k->spr.pal = 1;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- copied some changes to kill count management from DukeGDX.
2020-07-27 18:53:31 +00:00
ps[p].actors_killed++;
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(GLASS_BREAKING, actor);
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
else if (xx < 64 && ps[p].quick_kick == 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Replace player's `ang` with `DAngle` object. * This commit does not build. Committed items are everything that's been done by find and replace. * Next commit has hand-performed changes that are better separated out for clarity.
2022-08-27 13:09:22 +00:00
j = getincangle(ps[p].angle.ang.Buildang(), getangle(actor->spr.pos.XY() - ps[p].pos.XY()));
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j > -128 && j < 128)
ps[p].quick_kick = 14;
}
return;
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
if (xx < 99.75)
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = 0;
else actor->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == -4) //On the player
moveactors plus backing code.
2020-05-08 22:34:48 +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 (ps[p].GetActor()->spr.extra < 1)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- did some more.
2022-02-06 21:45:47 +00:00
SetActor(actor, actor->spr.pos);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
actor->spr.angle = ps[p].angle.ang;
moveactors plus backing code.
2020-05-08 22:34:48 +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 ((PlayerInput(p, SB_FIRE) || (ps[p].quick_kick > 0)) && ps[p].GetActor()->spr.extra > 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (ps[p].quick_kick > 0 || (ps[p].curr_weapon != HANDREMOTE_WEAPON && ps[p].curr_weapon != HANDBOMB_WEAPON && ps[p].curr_weapon != TRIPBOMB_WEAPON && ps[p].ammo_amount[ps[p].curr_weapon] >= 0))
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
for (int x = 0; x < 8; x++)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
auto a = randomAngle();
auto vel = krandf(4) + 4;
auto zvel = -krandf(16) - actor->vel.Z * 0.25;
auto spawned = CreateActor(actor->sector(), actor->spr.pos.plusZ(-8), SCRAP3 + (krand() & 3), -8, 48, 48, a, vel, zvel, actor, 5);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
spawned->spr.pal = 6;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_DYING, actor);
S_PlayActorSound(SQUISHED, actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if ((krand() & 255) < 32)
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
auto spawned = spawn(actor, BLOODPOOL);
if (spawned) spawned->spr.pal = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
ps[p].actors_killed++;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = -3;
- greenslime.
2020-10-22 19:49:29 +00:00
if (ps[p].somethingonplayer == actor)
- something on player is now a pointer as well
2020-10-17 09:10:12 +00:00
ps[p].somethingonplayer = nullptr;
- greenslime.
2020-10-22 19:49:29 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- Duke: floatified pyoff
2022-08-30 20:25:07 +00:00
actor->spr.pos.Z = ps[p].pos.Z + 8 + ps[p].pyoff - (actor->temp_data[2] - (ps[p].horizon.horiz.asq16() >> 12)) * zinttoworld;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[2] > 512)
actor->temp_data[2] -= 128;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[2] < 348)
actor->temp_data[2] += 128;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- newowner and related code.
2020-11-02 23:20:51 +00:00
if (ps[p].newOwner != nullptr)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- newowner and related code.
2020-11-02 23:20:51 +00:00
ps[p].newOwner = nullptr;
- use the player position utilities in actor*.cpp
2022-02-05 09:51:45 +00:00
ps[p].restorexyz();
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
ps[p].angle.restore();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
updatesector(ps[p].pos, &ps[p].cursector);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- greenslime.
2020-10-22 19:49:29 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto ac = it.Next())
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- 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 (actorflag(ac, SFLAG2_CAMERA)) ac->spr.yint = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[3] > 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
static const uint8_t frames[] = { 5,5,6,6,7,7,6,5 };
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->spr.picnum = GREENSLIME + frames[actor->temp_data[3]];
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[3] == 5)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
auto psp = ps[p].GetActor();
- 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
psp->spr.extra += -(5 + (krand() & 3));
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_ATTACK, actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[3] < 7) actor->temp_data[3]++;
else actor->temp_data[3] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.picnum = GREENSLIME + 5;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (rnd(32))
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[3] = 1;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->spr.xrepeat = 20 + bsin(actor->temp_data[1], -13);
actor->spr.yrepeat = 15 + bsin(actor->temp_data[1], -13);
- use ToVector where appropriate
2022-08-29 20:59:44 +00:00
actor->spr.pos.XY() = ps[p].pos.XY() + ps[p].angle.ang.ToVector() * 8;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
else if (actor->vel.X < 4 && xx < 48)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- something on player is now a pointer as well
2020-10-17 09:10:12 +00:00
if (ps[p].somethingonplayer == nullptr)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
ps[p].somethingonplayer = actor;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 3 || actor->temp_data[0] == 2) //Falling downward
actor->temp_data[2] = (12 << 8);
else actor->temp_data[2] = -(13 << 8); //Climbing up duke
actor->temp_data[0] = -4;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- greenslime.
2020-10-22 19:49:29 +00:00
j = fi.ifhitbyweapon(actor);
if (j >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_DYING, actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- greenslime.
2020-10-22 19:49:29 +00:00
if (ps[p].somethingonplayer == actor)
- something on player is now a pointer as well
2020-10-17 09:10:12 +00:00
ps[p].somethingonplayer = nullptr;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j == FREEZEBLAST)
{
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SOMETHINGFROZE, actor);
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = -5; actor->temp_data[3] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- copied some changes to kill count management from DukeGDX.
2020-07-27 18:53:31 +00:00
ps[p].actors_killed++;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if ((krand() & 255) < 32)
{
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
auto spawned = spawn(actor, BLOODPOOL);
if (spawned) spawned->spr.pal = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
for (int x = 0; x < 8; x++)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- first round of CreateActor calls.
2022-09-14 18:10:41 +00:00
auto a = randomAngle();
auto vel = krandf(4) + 4;
auto zvel = -krandf(16) - actor->vel.Z * 0.25;
auto spawned = CreateActor(actor->sector(), actor->spr.pos.plusZ(-8), SCRAP3 + (krand() & 3), -8, 48, 48, a, vel, zvel, actor, 5);
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
if (spawned) spawned->spr.pal = 6;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = -3;
- greenslime.
2020-10-22 19:49:29 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
// All weap
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == -1) //Shrinking down
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
makeitfall(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat &= ~CSTAT_SPRITE_YFLIP;
actor->spr.picnum = GREENSLIME + 4;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.xrepeat > 32) actor->spr.xrepeat -= krand() & 7;
if (actor->spr.yrepeat > 16) actor->spr.yrepeat -= krand() & 7;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
else
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.xrepeat = 40;
actor->spr.yrepeat = 16;
- greenslime.
2020-10-22 19:49:29 +00:00
actor->temp_actor = nullptr;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
return;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if (actor->temp_data[0] != -2) getglobalz(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == -2) //On top of somebody (an enemy)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- do not use auto to make local copies of TObjPtr's. This will just copy the object without performing the read barrier on the source data which is not what we want here. For these assignments the type must be explicit.
2021-12-05 23:20:46 +00:00
DDukeActor* s5 = actor->temp_actor;
- greenslime.
2020-10-22 19:49:29 +00:00
makeitfall(actor);
- this better have a null check...
2021-04-04 11:02:26 +00:00
if (s5)
{
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
s5->vel.X = 0;
- 3 simple set_int_pos replacements
2022-08-30 19:36:09 +00:00
actor->spr.pos = s5->spr.pos + s5->spr.angle.ToVector() * 0.5;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.picnum = GREENSLIME + 2 + (global_random & 1);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.yrepeat < 64) actor->spr.yrepeat += 2;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
else
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.xrepeat < 32) actor->spr.xrepeat += 4;
- this better have a null check...
2021-04-04 11:02:26 +00:00
else
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = -1;
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double dist = (actor->spr.pos.XY() - s5->spr.pos.XY()).LengthSquared();
if (dist < 48*48) {
- 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
s5->spr.xrepeat = 0;
- this better have a null check...
2021-04-04 11:02:26 +00:00
}
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
}
return;
}
//Check randomly to see of there is an actor near
if (rnd(32))
{
- use actor->sector() to initialize iterators.
2021-11-20 23:41:52 +00:00
DukeSectIterator it(actor->sector());
- greenslime.
2020-10-22 19:49:29 +00:00
while (auto a2 = it.Next())
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- turn all special actor type checks in moveflammable into flags. Also wrap all flag checks in actorflag function
2022-01-17 23:54:10 +00:00
if (actorflag(a2, SFLAG_GREENSLIMEFOOD))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double dist = (actor->spr.pos.XY() - a2->spr.pos.XY()).LengthSquared();
if (dist < 48*48 && (abs(actor->spr.pos.Z - a2->spr.pos.Z) < 16)) //Gulp them
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- greenslime.
2020-10-22 19:49:29 +00:00
actor->temp_actor = a2;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = -2;
actor->temp_data[1] = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
}
}
}
//Moving on the ground or ceiling
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 0 || actor->temp_data[0] == 2)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.picnum = GREENSLIME;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if ((krand() & 511) == 0)
- greenslime.
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_ROAM, actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 2)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat &= ~CSTAT_SPRITE_YFLIP;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 24) < actor->spr.pos.Z)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
actor->spr.pos.Z += 8;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 3;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
}
else
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat |= CSTAT_SPRITE_YFLIP;
- greenslime.
2020-10-22 19:49:29 +00:00
makeitfall(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- greenslime.
2020-10-22 19:49:29 +00:00
if (everyothertime & 1) ssp(actor, CLIPMASK0);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- trivial changes
2022-09-14 17:29:29 +00:00
if (actor->vel.X > 6)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.X -= 1/8.;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
else
{
- trivial changes
2022-09-14 17:29:29 +00:00
if (actor->vel.X < 2) actor->vel.X += 0.25;
- GreenSlime stuff
2022-09-14 17:42:28 +00:00
actor->vel.X = 4 - BobVal(512 + actor->temp_data[1]) * 2;
- trivial changes
2022-09-14 17:29:29 +00:00
actor->spr.angle += deltaangle(actor->spr.angle, VecToAngle(ps[p].pos.XY() - actor->spr.pos.XY())) * 0.125;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
// TJR
}
- GreenSlime stuff
2022-09-14 17:42:28 +00:00
actor->spr.xrepeat = 36 + BobVal(512 + actor->temp_data[1]) * 8;
actor->spr.yrepeat = 16 + BobVal(actor->temp_data[1]) * 2;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- deal with most of CSTAT_SECTOR_SKY and CSTAT_SECTOR_SLOPE
2021-12-18 12:14:56 +00:00
if (rnd(4) && (sectp->ceilingstat & CSTAT_SECTOR_SKY) == 0 &&
- GreenSlime stuff
2022-09-14 17:42:28 +00:00
abs(actor->floorz - actor->ceilingz) < 192)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0]++;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 1)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.picnum = GREENSLIME;
if (actor->spr.yrepeat < 40) actor->spr.yrepeat += 8;
if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z > -12)
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.Z -= 348 / 256.;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
actor->spr.pos.Z += actor->vel.Z;
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
if (actor->spr.pos.Z < actor->ceilingz + 16)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
actor->spr.pos.Z = actor->ceilingz + 16;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 2;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 3)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.picnum = GREENSLIME + 1;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- greenslime.
2020-10-22 19:49:29 +00:00
makeitfall(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if (actor->spr.pos.Z > actor->floorz - 8)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.yrepeat -= 4;
actor->spr.xrepeat += 2;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.yrepeat < (40 - 4)) actor->spr.yrepeat += 8;
if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if (actor->spr.pos.Z > actor->floorz - 8)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
actor->spr.pos.Z = actor->floorz - 8;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 0;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
}
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- flamethrowerflame
2020-10-22 20:07:09 +00:00
static void flamethrowerflame(DDukeActor *actor)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
int p = findplayer(actor, &xx);
execute(actor, p, xx);
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0]++;
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
if (sectp->lotag == 2)
moveactors plus backing code.
2020-05-08 22:34:48 +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
spawn(actor, EXPLOSION2)->spr.shade = 127;
- flamethrowerflame
2020-10-22 20:07:09 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- eliminated one UpdateActor pverload.
2022-08-22 21:42:42 +00:00
auto dapos = actor->spr.pos;
- more xvel wraps.
2022-09-01 14:52:45 +00:00
int xvel = actor->int_xvel();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- flamethrowerflame
2020-10-22 20:07:09 +00:00
getglobalz(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
int ds = actor->temp_data[0] / 6;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.xrepeat < 80)
actor->spr.yrepeat = actor->spr.xrepeat += ds;
actor->spr.clipdist += ds;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] <= 2)
actor->temp_data[3] = krand() % 10;
if (actor->temp_data[0] > 30)
moveactors plus backing code.
2020-05-08 22:34:48 +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
spawn(actor, EXPLOSION2)->spr.shade = 127;
- flamethrowerflame
2020-10-22 20:07:09 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- flamethrowerflame
2020-10-22 20:07:09 +00:00
Collision coll;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
movesprite_ex(actor, DVector3(actor->spr.angle.ToVector() * actor->vel.X, actor->vel.Z), CLIPMASK1, coll);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- use DCoreActor::insector instead of spritetype::insector.
2021-12-30 15:24:51 +00:00
if (!actor->insector())
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- flamethrowerflame
2020-10-22 20:07:09 +00:00
deletesprite(actor);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
- flamethrowerflame
2020-10-22 20:07:09 +00:00
if (coll.type != kHitSprite)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- Duke: cleanup on z-checks, part 3.
2022-02-03 23:55:12 +00:00
if (actor->spr.pos.Z < actor->ceilingz)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
coll.setSector(actor->sector());
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.Z -= 1/256.;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
else if ((actor->spr.pos.Z > actor->floorz && actor->sector()->lotag != 1)
|| (actor->spr.pos.Z > actor->floorz + 16 && actor->sector()->lotag == 1))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
coll.setSector(actor->sector());
if (actor->sector()->lotag != 1)
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.Z += 1/256.;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- flamethrowerflame
2020-10-22 20:07:09 +00:00
if (coll.type != 0) {
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->ZeroVelocityXY();
actor->vel.Z = 0;
- flamethrowerflame
2020-10-22 20:07:09 +00:00
if (coll.type == kHitSprite)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- made Collision derive from a common base class and refactored clipmove to a single engine-side entry point. Done for Doom so far.
2021-11-26 12:41:15 +00:00
fi.checkhitsprite(coll.actor(), 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
if (coll.actor()->spr.picnum == APLAYER)
- made Collision derive from a common base class and refactored clipmove to a single engine-side entry point. Done for Doom so far.
2021-11-26 12:41:15 +00:00
S_PlayActorSound(PISTOL_BODYHIT, coll.actor());
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- flamethrowerflame
2020-10-22 20:07:09 +00:00
else if (coll.type == kHitWall)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- eliminated one UpdateActor pverload.
2022-08-22 21:42:42 +00:00
SetActor(actor, dapos);
- floatified position in checkhitwall
2022-08-23 20:39:07 +00:00
fi.checkhitwall(actor, coll.hitWall, actor->spr.pos, actor->spr.picnum);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- flamethrowerflame
2020-10-22 20:07:09 +00:00
else if (coll.type == kHitSector)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- eliminated one UpdateActor pverload.
2022-08-22 21:42:42 +00:00
SetActor(actor, dapos);
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z < 0)
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
fi.checkhitceiling(actor->sector());
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.xrepeat >= 10)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
int x = actor->spr.extra;
- 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
fi.hitradius(actor, gs.rpgblastradius, x >> 2, x >> 1, x - (x >> 2), x);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
int x = actor->spr.extra + (global_random & 3);
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
fi.hitradius(actor, (gs.rpgblastradius >> 1), x >> 2, x >> 1, x - (x >> 2), x);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- heavyhbomb
2020-10-22 20:18:47 +00:00
static void heavyhbomb(DDukeActor *actor)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
auto Owner = actor->GetOwner();
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = actor->sector();
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
int l;
double xx;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if ((actor->spr.cstat & CSTAT_SPRITE_INVISIBLE))
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2]--;
if (actor->temp_data[2] <= 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
S_PlayActorSound(TELEPORTER, actor);
spawn(actor, TRANSPORTERSTAR);
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
return;
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
int p = findplayer(actor, &xx);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
if (xx < 1220 / 16.) actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else actor->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[3] == 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
int j = fi.ifhitbyweapon(actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
if (j >= 0)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[3] = 1;
actor->temp_data[4] = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
l = 0;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
goto DETONATEB;
}
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.picnum != BOUNCEMINE)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
makeitfall(actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- 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 (sectp->lotag != 1 && actor->spr.pos.Z >= actor->floorz - FOURSLEIGHT_F && actor->spr.yint < 3)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- 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 (actor->spr.yint > 0 || (actor->spr.yint == 0 && actor->floorz == sectp->floorz))
- heavyhbomb
2020-10-22 20:18:47 +00:00
S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
- handle all remaining set_int_xvel and set_int_zvel.
2022-09-14 17:49:38 +00:00
actor->vel.Z = -(4 - actor->spr.yint);
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (actor->sector()->lotag == 2)
- removed the mul vel wrappers
2022-09-03 08:04:16 +00:00
actor->vel.Z *= 0.25;
- 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
actor->spr.yint++;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
if (actor->spr.pos.Z < actor->ceilingz) // && sectp->lotag != 2 )
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- Duke: cleanup on z-checks, part 1.
2022-02-03 23:45:24 +00:00
actor->spr.pos.Z = actor->ceilingz + 3;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
}
- heavyhbomb
2020-10-22 20:18:47 +00:00
Collision coll;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
movesprite_ex(actor, DVector3(actor->spr.angle.ToVector() * actor->vel.X, actor->vel.Z), CLIPMASK0, coll);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->sector()->lotag == 1 && actor->vel.Z == 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- replaced all add_int_z calls with constants.
2022-08-20 15:59:15 +00:00
actor->spr.pos.Z += 32;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[5] == 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[5] = 1;
- heavyhbomb
2020-10-22 20:18:47 +00:00
spawn(actor, WATERSPLASH2);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else actor->temp_data[5] = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
if (actor->temp_data[3] == 0 && (actor->spr.picnum == BOUNCEMINE || actor->spr.picnum == MORTER) && (coll.type || xx < 844/16.))
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[3] = 1;
actor->temp_data[4] = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
l = 0;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
goto DETONATEB;
}
- 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 ( Owner && Owner->spr.picnum == APLAYER)
- heavyhbomb
2020-10-22 20:18:47 +00:00
l = Owner->PlayerIndex();
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
else l = -1;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if(actor->vel.X > 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.X -= 5. / 16;
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
if (sectp->lotag == 2)
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
actor->vel.X -= 10. / 16;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if(actor->vel.X < 0)
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (int(actor->vel.X * 16) & 8) actor->spr.cstat ^= CSTAT_SPRITE_XFLIP;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (coll.type== kHitWall)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- made Collision derive from a common base class and refactored clipmove to a single engine-side entry point. Done for Doom so far.
2021-11-26 12:41:15 +00:00
auto wal = coll.hitWall;
- floatified position in checkhitwall
2022-08-23 20:39:07 +00:00
fi.checkhitwall(actor, wal, actor->spr.pos, actor->spr.picnum);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- no need to use int_delta when all we want is the angle.
2022-08-30 21:05:54 +00:00
int k = getangle(wal->delta());
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- set_int_ang in Duke. Also changed SOUNDFX actor to use a different variable for its index.
2022-08-16 21:20:35 +00:00
actor->set_int_ang(((k << 1) - actor->int_ang()) & 2047);
- removed the mul vel wrappers
2022-09-03 08:04:16 +00:00
actor->vel.X *= 0.5;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
DETONATEB:
bool bBoom = false;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if ((l >= 0 && ps[l].hbomb_on == 0) || actor->temp_data[3] == 1)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
bBoom = true;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (isNamWW2GI() && actor->spr.picnum == HEAVYHBOMB)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.extra--;
if (actor->spr.extra <= 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
bBoom = true;
}
if (bBoom)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[4]++;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] == 2)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
int x = actor->spr.extra;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
int m = 0;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
switch (actor->spr.picnum)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
case HEAVYHBOMB: m = gs.pipebombblastradius; break;
case MORTER: m = gs.morterblastradius; break;
case BOUNCEMINE: m = gs.bouncemineblastradius; break;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
- heavyhbomb
2020-10-22 20:18:47 +00:00
fi.hitradius(actor, m, x >> 2, x >> 1, x - (x >> 2), x);
spawn(actor, EXPLOSION2);
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z == 0) spawn(actor, EXPLOSION2BOT);
- heavyhbomb
2020-10-22 20:18:47 +00:00
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
for (x = 0; x < 8; x++)
- heavyhbomb
2020-10-22 20:18:47 +00:00
RANDOMSCRAP(actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.yrepeat)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.yrepeat = 0;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
return;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] > 20)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (Owner != actor || ud.respawn_items == 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
deletesprite(actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
return;
}
else
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2] = gs.respawnitemtime;
- heavyhbomb
2020-10-22 20:18:47 +00:00
spawn(actor, RESPAWNMARKERRED);
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
actor->spr.yrepeat = 9;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
return;
}
}
}
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
else if (actor->spr.picnum == HEAVYHBOMB && xx < 788 / 16. && actor->temp_data[0] > 7 && actor->vel.X == 0)
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
if (cansee(actor->spr.pos.plusZ(-8), actor->sector(), ps[p].pos, ps[p].cursector))
- grouped all of Duke's constant per-session state in a single struct. Mainly done so later the script export can be done more easily. This also renames a few of the affected variables for clarity.
2020-11-29 12:54:58 +00:00
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < gs.max_ammo_amount[HANDBOMB_WEAPON])
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (ud.coop >= 1 && Owner == actor)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
for (int j = 0; j < ps[p].weapreccnt; j++)
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (ps[p].weaprecs[j] == actor->spr.picnum)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
continue;
if (ps[p].weapreccnt < 255) // DukeGDX has 16 here.
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
ps[p].weaprecs[ps[p].weapreccnt++] = actor->spr.picnum;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
addammo(HANDBOMB_WEAPON, &ps[p], 1);
- heavyhbomb
2020-10-22 20:18:47 +00:00
S_PlayActorSound(DUKE_GET, ps[p].GetActor());
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (ps[p].gotweapon[HANDBOMB_WEAPON] == 0 || Owner == ps[p].GetActor())
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.addweapon(&ps[p], HANDBOMB_WEAPON);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +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 (!Owner || Owner->spr.picnum != APLAYER)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
SetPlayerPal(&ps[p], PalEntry(32, 0, 32, 0));
}
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (Owner != actor || ud.respawn_items == 0)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
{
- heavyhbomb
2020-10-22 20:18:47 +00:00
if (Owner == actor && ud.coop >= 1)
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
return;
- heavyhbomb
2020-10-22 20:18:47 +00:00
deletesprite(actor);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
return;
}
else
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2] = gs.respawnitemtime;
- heavyhbomb
2020-10-22 20:18:47 +00:00
spawn(actor, RESPAWNMARKERRED);
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
actor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] < 8) actor->temp_data[0]++;
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
void moveactors_d(void)
{
- sectnum removal step
2021-11-21 08:05:58 +00:00
int p;
- moveactors.
2020-10-22 20:48:51 +00:00
unsigned int k;
- 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
- moveactors.
2020-10-22 20:48:51 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto act = it.Next())
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = act->sector();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.xrepeat == 0 || sectp == nullptr)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- moveactors.
2020-10-22 20:48:51 +00:00
deletesprite(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
}
- moveactors.
2020-10-22 20:48:51 +00:00
int *t = &act->temp_data[0];
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
switch (act->spr.picnum)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
case FLAMETHROWERFLAME:
- moveactors.
2020-10-22 20:48:51 +00:00
if (isWorldTour()) flamethrowerflame(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case DUCK:
case TARGET:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act->temp_data[0]++;
if (act->temp_data[0] > 60)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act->temp_data[0] = 0;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
act->spr.cstat = CSTAT_SPRITE_YCENTER | CSTAT_SPRITE_BLOCK_ALL | CSTAT_SPRITE_ALIGNMENT_WALL;
act->spr.extra = 1;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
else
{
- moveactors.
2020-10-22 20:48:51 +00:00
int j = fi.ifhitbyweapon(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j >= 0)
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
act->spr.cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_YCENTER;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
k = 1;
- renamed all shadowing variables in Duke.
2021-12-24 09:53:27 +00:00
DukeStatIterator itr(STAT_ACTOR);
while (auto act2 = itr.Next())
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act2->spr.lotag == act->spr.lotag &&
act2->spr.picnum == act->spr.picnum)
moveactors plus backing code.
2020-05-08 22:34:48 +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 ((act2->spr.hitag && !(act2->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) ||
(!act2->spr.hitag && (act2->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
)
{
k = 0;
break;
}
}
}
if (k == 1)
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
operateactivators(act->spr.lotag, -1);
fi.operateforcefields(act, act->spr.lotag);
operatemasterswitches(act->spr.lotag);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
}
continue;
case RESPAWNMARKERRED:
case RESPAWNMARKERYELLOW:
case RESPAWNMARKERGREEN:
- moveactors.
2020-10-22 20:48:51 +00:00
if (!respawnmarker(act, RESPAWNMARKERYELLOW, RESPAWNMARKERGREEN)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case HELECOPT:
case DUKECAR:
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
act->spr.pos.Z += act->vel.Z;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act->temp_data[0]++;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (act->temp_data[0] == 4) S_PlayActorSound(WAR_AMBIENCE2, act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (act->temp_data[0] > (26 * 8))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlaySound(RPG_EXPLODE);
- moveactors.
2020-10-22 20:48:51 +00:00
for (int j = 0; j < 32; j++)
RANDOMSCRAP(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
earthquaketime = 16;
- moveactors.
2020-10-22 20:48:51 +00:00
deletesprite(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if ((act->temp_data[0] & 3) == 0)
- moveactors.
2020-10-22 20:48:51 +00:00
spawn(act, EXPLOSION2);
ssp(act, CLIPMASK0);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case RAT:
- moveactors.
2020-10-22 20:48:51 +00:00
if (!rat(act, true)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case QUEBALL:
case STRIPEBALL:
- moveactors.
2020-10-22 20:48:51 +00:00
if (!queball(act, POCKET, QUEBALL, STRIPEBALL)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case FORCESPHERE:
- moveactors.
2020-10-22 20:48:51 +00:00
forcesphere(act, FORCESPHERE);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case RECON:
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
recon(act, EXPLOSION2, FIRELASER, RECO_ATTACK, RECO_PAIN, RECO_ROAM, 4, [](DDukeActor* i)->int { return PIGCOP; });
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case OOZ:
case OOZ2:
- moveactors.
2020-10-22 20:48:51 +00:00
ooz(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case GREENSLIME:
case GREENSLIME + 1:
case GREENSLIME + 2:
case GREENSLIME + 3:
case GREENSLIME + 4:
case GREENSLIME + 5:
case GREENSLIME + 6:
case GREENSLIME + 7:
- moveactors.
2020-10-22 20:48:51 +00:00
greenslime(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case BOUNCEMINE:
case MORTER:
- moveactors.
2020-10-22 20:48:51 +00:00
spawn(act, FRAMEEFFECT1)->temp_data[0] = 3;
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
case HEAVYHBOMB:
- moveactors.
2020-10-22 20:48:51 +00:00
heavyhbomb(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case REACTORBURNT:
case REACTOR2BURNT:
continue;
case REACTOR:
case REACTOR2:
- moveactors.
2020-10-22 20:48:51 +00:00
reactor(act, REACTOR, REACTOR2, REACTORBURNT, REACTOR2BURNT, REACTORSPARK, REACTOR2SPARK);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
- fixed mixed up tile numbers. For consistency all shared numbers now use the TILE_ prefix.
2020-05-14 19:42:11 +00:00
case CAMERA1:
- moveactors.
2020-10-22 20:48:51 +00:00
camera(act);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
}
// #ifndef VOLOMEONE
- moveactors.
2020-10-22 20:48:51 +00:00
if (ud.multimode < 2 && badguy(act))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
if (actor_tog == 1)
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else if (actor_tog == 2) act->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
// #endif
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
p = findplayer(act, &xx);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
execute(act, p, xx);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
}
- moveexplosions
2020-05-09 18:27:06 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moveexplosions.
2020-10-22 20:51:51 +00:00
static void fireflyflyingeffect(DDukeActor *actor)
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
int p = findplayer(actor, &xx);
execute(actor, p, xx);
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
- moveexplosions.
2020-10-22 20:51:51 +00:00
auto Owner = actor->GetOwner();
- 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 (!Owner || Owner->spr.picnum != FIREFLY)
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
{
- moveexplosions.
2020-10-22 20:51:51 +00:00
deletesprite(actor);
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
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 (Owner->spr.xrepeat >= 24 || Owner->spr.pal == 1)
actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
else
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
- large batch of set_int_pos, minus Exhumed
2022-08-16 21:46:18 +00:00
auto dvec = Owner->spr.pos.XY() - ps[p].GetActor()->spr.pos.XY();
double dist = dvec.Length();
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
- large batch of set_int_pos, minus Exhumed
2022-08-16 21:46:18 +00:00
if (dist != 0.0) dvec /= dist;
actor->spr.pos = Owner->spr.pos + DVector3(dvec.X * -0.625, dvec.Y * -0.625, 8);
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +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 (Owner->spr.extra <= 0)
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
{
- moveexplosions.
2020-10-22 20:51:51 +00:00
deletesprite(actor);
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moveexplosions
2020-05-09 18:27:06 +00:00
void moveexplosions_d(void) // STATNUM 5
{
-Duke: replaced sector array accesses in actors_d.cpp.
2021-11-06 22:16:23 +00:00
int p;
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double xx;
- 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
- moveexplosions.
2020-10-22 20:51:51 +00:00
DukeStatIterator it(STAT_MISC);
while (auto act = it.Next())
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- use DCoreActor::insector instead of spritetype::insector.
2021-12-30 15:24:51 +00:00
if (!act->insector() || act->spr.xrepeat == 0)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- moveexplosions.
2020-10-22 20:51:51 +00:00
deletesprite(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = act->sector();
- moveexplosions
2020-05-09 18:27:06 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
switch (act->spr.picnum)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
case FIREFLYFLYINGEFFECT:
- moveexplosions.
2020-10-22 20:51:51 +00:00
if (isWorldTour()) fireflyflyingeffect(act);
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
continue;
- 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
- moveexplosions
2020-05-09 18:27:06 +00:00
case NEON1:
case NEON2:
case NEON3:
case NEON4:
case NEON5:
case NEON6:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if ((global_random / (act->spr.lotag + 1) & 31) > 4) act->spr.shade = -127;
else act->spr.shade = 127;
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case BLOODSPLAT1:
case BLOODSPLAT2:
case BLOODSPLAT3:
case BLOODSPLAT4:
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (act->temp_data[0] == 7 * 26) continue;
- 3x add_int_z.
2022-09-12 16:37:35 +00:00
act->spr.pos.Z += 1 / 16. + krandf(1 / 16.);
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act->temp_data[0]++;
if ((act->temp_data[0] % 9) == 0) act->spr.yrepeat++;
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case NUKEBUTTON:
case NUKEBUTTON + 1:
case NUKEBUTTON + 2:
case NUKEBUTTON + 3:
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (act->temp_data[0])
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act->temp_data[0]++;
- moveexplosions.
2020-10-22 20:51:51 +00:00
auto Owner = act->GetOwner();
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (act->temp_data[0] == 8) act->spr.picnum = NUKEBUTTON + 1;
else if (act->temp_data[0] == 16 && Owner)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
act->spr.picnum = NUKEBUTTON + 2;
- moveexplosions.
2020-10-22 20:51:51 +00:00
ps[Owner->PlayerIndex()].fist_incs = 1;
- moveexplosions
2020-05-09 18:27:06 +00:00
}
- moveexplosions.
2020-10-22 20:51:51 +00:00
if (Owner && ps[Owner->PlayerIndex()].fist_incs == 26)
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
act->spr.picnum = NUKEBUTTON + 3;
- moveexplosions
2020-05-09 18:27:06 +00:00
}
continue;
case FORCESPHERE:
- moveexplosions.
2020-10-22 20:51:51 +00:00
forcesphereexplode(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case WATERSPLASH2:
- moveexplosions.
2020-10-22 20:51:51 +00:00
watersplash2(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case FRAMEEFFECT1:
- moveexplosions.
2020-10-22 20:51:51 +00:00
frameeffect1(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case INNERJAW:
case INNERJAW + 1:
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
p = findplayer(act, &xx);
if (xx < 32)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
SetPlayerPal(&ps[p], PalEntry(32, 32, 0, 0));
- global search & replace of ->s-> with ->spr. This is the largest part of uses of DDukeActor's 's' pointer.
2021-12-21 17:19:45 +00:00
ps[p].GetActor()->spr.extra -= 4;
- moveexplosions
2020-05-09 18:27:06 +00:00
}
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
- moveexplosions
2020-05-09 18:27:06 +00:00
case FIRELASER:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.extra != 999)
act->spr.extra = 999;
- moveexplosions
2020-05-09 18:27:06 +00:00
else
{
- moveexplosions.
2020-10-22 20:51:51 +00:00
deletesprite(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
}
break;
case TONGUE:
- moveexplosions.
2020-10-22 20:51:51 +00:00
deletesprite(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
- This makes no sense either way…
2022-09-13 18:29:18 +00:00
act->vel.Z = act->floorz = getflorzofslopeptrf(act->sector(), act->spr.pos.X, act->spr.pos.Y);
- moveexplosions
2020-05-09 18:27:06 +00:00
break;
case MONEY:
case MAIL:
case PAPER:
- moveexplosions.
2020-10-22 20:51:51 +00:00
money(act, BLOODPOOL);
- moveexplosions
2020-05-09 18:27:06 +00:00
break;
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case HEADJIB1:
case ARMJIB1:
case LEGJIB1:
case LIZMANHEAD1:
case LIZMANARM1:
case LIZMANLEG1:
case DUKETORSO:
case DUKEGUN:
case DUKELEG:
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
jibs(act, JIBS6, true, false, false, act->spr.picnum == DUKELEG || act->spr.picnum == DUKETORSO || act->spr.picnum == DUKEGUN, false);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case BLOODPOOL:
case PUKE:
- flammable flags.
2022-01-26 23:41:33 +00:00
bloodpool(act, act->spr.picnum == PUKE);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case LAVAPOOL:
case ONFIRE:
- fixing some HUD stuff.
2020-07-06 13:48:51 +00:00
case ONFIRESMOKE:
- moveexplosions
2020-05-09 18:27:06 +00:00
case BURNEDCORPSE:
case LAVAPOOLBUBBLE:
case WHISPYSMOKE:
if (!isWorldTour())
continue;
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
- moveexplosions
2020-05-09 18:27:06 +00:00
case BURNING:
case BURNING2:
case FECES:
case WATERBUBBLE:
case SMALLSMOKE:
case EXPLOSION2:
case SHRINKEREXPLOSION:
case EXPLOSION2BOT:
case BLOOD:
case LASERSITE:
case FORCERIPPLE:
case TRANSPORTERSTAR:
case TRANSPORTERBEAM:
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
p = findplayer(act, &xx);
execute(act, p, xx);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case SHELL:
case SHOTGUNSHELL:
- trivial wrapper replacements in Duke
2022-08-20 18:11:01 +00:00
shell(act, sectp->floorz + 24 < act->spr.pos.Z);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case GLASSPIECES:
case GLASSPIECES + 1:
case GLASSPIECES + 2:
- moveexplosions.
2020-10-22 20:51:51 +00:00
glasspieces(act);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act->spr.picnum >= SCRAP6 && act->spr.picnum <= SCRAP5 + 3)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
- moveexplosions.
2020-10-22 20:51:51 +00:00
scrap(act, SCRAP1, SCRAP6);
- moveexplosions
2020-05-09 18:27:06 +00:00
}
}
}
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
void handle_se06_d(DDukeActor* actor)
{
- renamed DDukeActor::getSector.
2021-11-20 23:33:17 +00:00
auto sc = actor->sector();
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
int sh = actor->spr.hitag;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
int k = sc->extra;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] > 0)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[4]--;
if (actor->temp_data[4] >= (k - (k >> 3)))
- floatified handle_se06 (both variants)
2022-09-11 19:01:38 +00:00
actor->vel.X -= (k >> 5) / 16.;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] > ((k >> 1) - 1) && actor->temp_data[4] < (k - (k >> 3)))
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.X = 0;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] < (k >> 1))
- floatified handle_se06 (both variants)
2022-09-11 19:01:38 +00:00
actor->vel.X += (k >> 5) / 16.;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[4] < ((k >> 1) - (k >> 3)))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[4] = 0;
- floatified handle_se06 (both variants)
2022-09-11 19:01:38 +00:00
actor->vel.X = k / 16.;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
}
- floatified handle_se06 (both variants)
2022-09-11 19:01:38 +00:00
else actor->vel.X = k / 16.;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
DukeStatIterator it(STAT_EFFECTOR);
while (auto act2 = it.Next())
{
- handled a few easy to change distance calculations and nearby assignments.
2022-09-11 18:46:21 +00:00
if ((act2->spr.lotag == SE_14_SUBWAY_CAR) && (sh == act2->spr.hitag) && (act2->temp_data[0] == actor->temp_data[0]))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- handled a few easy to change distance calculations and nearby assignments.
2022-09-11 18:46:21 +00:00
act2->vel.X = actor->vel.X;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
//if( actor->temp_data[4] == 1 )
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- floatified handle_se06 (both variants)
2022-09-11 19:01:38 +00:00
if (act2->temp_pos.X == 0)
act2->temp_pos.X = (act2->spr.pos - actor->spr.pos).LengthSquared();
int x = Sgn((act2->spr.pos - actor->spr.pos).LengthSquared() - act2->temp_pos.X);
- 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 (act2->spr.extra)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
x = -x;
- handled a few easy to change distance calculations and nearby assignments.
2022-09-11 18:46:21 +00:00
actor->vel.X += x / 16.;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
act2->temp_data[4] = actor->temp_data[4];
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
}
handle_se14(actor, true, RPG, JIBS6);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void handle_se28(DDukeActor* actor)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[5] > 0)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[5]--;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
return;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] == 0)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
double x;
- addressed most unused/uninitialized variable warnings from MSVC.
2021-11-14 14:03:50 +00:00
findplayer(actor, &x);
- only use the floatified version of findplayer.
2022-09-14 20:49:01 +00:00
if (x > 15500 / 16.)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
return;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 1;
actor->temp_data[1] = 64 + (krand() & 511);
actor->temp_data[2] = 0;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
else
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[2]++;
if (actor->temp_data[2] > actor->temp_data[1])
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0] = 0;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
ps[screenpeek].visibility = ud.const_visibility;
return;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if (actor->temp_data[2] == (actor->temp_data[1] >> 1))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
S_PlayActorSound(THUNDER, actor);
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if (actor->temp_data[2] == (actor->temp_data[1] >> 3))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
S_PlayActorSound(LIGHTNING_SLAP, actor);
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if (actor->temp_data[2] == (actor->temp_data[1] >> 2))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
DukeStatIterator it(STAT_DEFAULT);
while (auto act2 = it.Next())
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act2->spr.picnum == NATURALLIGHTNING && act2->spr.hitag == actor->spr.hitag)
- 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
act2->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
else if (actor->temp_data[2] > (actor->temp_data[1] >> 3) && actor->temp_data[2] < (actor->temp_data[1] >> 2))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
int j = !!cansee(actor->spr.pos, actor->sector(), ps[screenpeek].pos, ps[screenpeek].cursector);
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (rnd(192) && (actor->temp_data[2] & 1))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
if (j) ps[screenpeek].visibility = 0;
}
else if (j) ps[screenpeek].visibility = ud.const_visibility;
DukeStatIterator it(STAT_DEFAULT);
while (auto act2 = it.Next())
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (act2->spr.picnum == NATURALLIGHTNING && act2->spr.hitag == actor->spr.hitag)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (rnd(32) && (actor->temp_data[2] & 1))
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +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
act2->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
- fixed bad spawn owner in refactored loop.
2020-11-02 19:58:46 +00:00
spawn(act2, SMALLSMOKE);
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double x;
- findplayer
2020-10-23 15:44:45 +00:00
int p = findplayer(actor, &x);
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
auto psa = ps[p].GetActor();
- eliminated all ldist calls outside the weapon code.
2022-09-13 21:29:41 +00:00
double dist = (psa->spr.pos.XY() - act2->spr.pos.XY()).LengthSquared();
if (dist < 49*48)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
{
- RR-movement + dummyplayersprite
2020-10-25 06:21:33 +00:00
if (S_CheckActorSoundPlaying(psa, DUKE_LONGTERM_PAIN) < 1)
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
S_PlayActorSound(DUKE_LONGTERM_PAIN, psa);
S_PlayActorSound(SHORT_CIRCUIT, psa);
- 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
psa->spr.extra -= 8 + (krand() & 7);
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
SetPlayerPal(&ps[p], PalEntry(32, 16, 0, 0));
}
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
else act2->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
}
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
void moveeffectors_d(void) //STATNUM 3
{
clearfriction();
- 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
- moveeffectors.
2020-10-22 21:17:51 +00:00
DukeStatIterator it(STAT_EFFECTOR);
while (auto act = it.Next())
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
- renamed DDukeActor::getSector.
2021-11-20 23:33:17 +00:00
auto sc = act->sector();
- 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
switch (act->spr.lotag)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
case SE_0_ROTATING_SECTOR:
- two more flags for LASERLINE.
2022-01-19 09:48:18 +00:00
handle_se00(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
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
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case SE_1_PIVOT: //Nothing for now used as the pivot
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se01(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
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
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case SE_6_SUBWAY:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se06_d(act);
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
break;
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case SE_14_SUBWAY_CAR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se14(act, true, RPG, JIBS6);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_30_TWO_WAY_TRAIN:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se30(act, JIBS6);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_2_EARTHQUAKE:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se02(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
//Flashing sector lights after reactor EXPLOSION2
case SE_3_RANDOM_LIGHTS_AFTER_SHOT_OUT:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se03(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_4_RANDOM_LIGHTS:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se04(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
//BOSS
case SE_5_BOSS:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se05(act, FIRELASER);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_8_UP_OPEN_DOOR_LIGHTS:
case SE_9_DOWN_OPEN_DOOR_LIGHTS:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se08(act, false);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_10_DOOR_AUTO_CLOSE:
{
static const int tags[] = { 20, 21, 22, 26, 0};
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se10(act, tags);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
}
case SE_11_SWINGING_DOOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se11(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
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
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case SE_12_LIGHT_SWITCH:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se12(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_13_EXPLOSIVE:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se13(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_15_SLIDING_DOOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se15(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_16_REACTOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se16(act, REACTOR, REACTOR2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_17_WARP_ELEVATOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se17(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_18_INCREMENTAL_SECTOR_RISE_FALL:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se18(act, true);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_19_EXPLOSION_LOWERS_CEILING:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se19(act, BIGFORCE);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_20_STRETCH_BRIDGE:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se20(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_21_DROP_FLOOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se21(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_22_TEETH_DOOR:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se22(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_24_CONVEYOR:
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_34:
- all sector iterators in actors_d.cpp, actors_r.cpp and actors_lava.cpp.
2020-10-14 18:49:43 +00:00
{
- floatified handle_se24
2022-09-12 19:59:34 +00:00
handle_se24(act, true, 0.25);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- all sector iterators in actors_d.cpp, actors_r.cpp and actors_lava.cpp.
2020-10-14 18:49:43 +00:00
}
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_35:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se35(act, SMALLSMOKE, EXPLOSION2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_25_PISTON: //PISTONS
- moveeffectors.
2020-10-22 21:17:51 +00:00
if (act->temp_data[4] == 0) break;
- floatified handle_se25
2022-09-12 21:35:48 +00:00
handle_se25(act, -1, -1);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_26:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se26(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_27_DEMO_CAM:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se27(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_28_LIGHTNING:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se28(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- made SE06 and SE28 separate functions.
2020-10-22 20:55:53 +00:00
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_29_WAVES:
- floatified and consolidated handle_se29.
2022-09-11 21:51:48 +00:00
handle_se29(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- floatified and consolidated handle_se29.
2022-09-11 21:51:48 +00:00
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se31(act, true);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_32_CEILING_RISE_FALL: // True Drop Ceiling
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se32(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_33_QUAKE_DEBRIS:
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
if (earthquaketime > 0 && (krand() & 7) == 0)
- moveeffectors.
2020-10-22 21:17:51 +00:00
RANDOMSCRAP(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
- replaced a few more literal numbers.
2020-11-27 19:06:38 +00:00
case SE_36_PROJ_SHOOTER:
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
- moveeffectors.
2020-10-22 21:17:51 +00:00
if (act->temp_data[0])
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
- moveeffectors.
2020-10-22 21:17:51 +00:00
if (act->temp_data[0] == 1)
- shoot interface transitioned/operateweapon mostly done.
2020-10-24 05:34:39 +00:00
fi.shoot(act, sc->extra);
- moveeffectors.
2020-10-22 21:17:51 +00:00
else if (act->temp_data[0] == 26 * 5)
act->temp_data[0] = 0;
act->temp_data[0]++;
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
}
break;
- Duke: SE20 + SE128 are wall-free Also use symbolic constantfor SE_128 to make it easier to find.
2021-11-15 22:32:41 +00:00
case SE_128_GLASS_BREAKING:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se128(act);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 130:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se130(act, 80, EXPLOSION2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 131:
- moveeffectors.
2020-10-22 21:17:51 +00:00
handle_se130(act, 40, EXPLOSION2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
}
}
//Sloped sin-wave floors!
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
it.Reset(STAT_EFFECTOR);
- moveeffectors.
2020-10-22 21:17:51 +00:00
while (auto act = it.Next())
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +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 (act->spr.lotag != SE_29_WAVES) continue;
- renamed DDukeActor::getSector.
2021-11-20 23:33:17 +00:00
auto sc = act->sector();
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
if (sc->wallnum != 4) continue;
- Duke: get rid of the remaining wall[] references in actors_d.cpp
2021-11-16 17:01:12 +00:00
auto wal = sc->firstWall() + 2;
- floatified RR hitscan teleporter stuff and other minor things.
2022-09-12 19:26:17 +00:00
if (wal->nextSector()) alignflorslope(act->sector(), DVector3(wal->pos, wal->nextSector()->floorz));
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
}
}
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
//---------------------------------------------------------------------------
//
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
//
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
//
//---------------------------------------------------------------------------
- renamed variables in move functions.
2020-11-01 14:56:50 +00:00
void move_d(DDukeActor *actor, int playernum, int xvel)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- Duke: eliminated all local short variables in actors*.cpp.
2021-11-07 13:07:08 +00:00
int goalang, angdif;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
int daxvel;
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
int a = actor->spr.hitag;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a == -1) a = 0;
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
actor->temp_data[0]++;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a & face_player)
{
- newowner and related code.
2020-11-02 23:20:51 +00:00
if (ps[playernum].newOwner != nullptr)
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
goalang = getangle(ps[playernum].opos.XY() - actor->spr.pos.XY());
else goalang = getangle(ps[playernum].pos.XY() - actor->spr.pos.XY());
- more int_ang()
2022-08-16 21:17:01 +00:00
angdif = getincangle(actor->int_ang(), goalang) >> 2;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (angdif > -8 && angdif < 0) angdif = 0;
- add_int_ang
2022-08-16 21:26:39 +00:00
actor->add_int_ang(angdif);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
if (a & spin)
- add_int_ang
2022-08-16 21:26:39 +00:00
actor->add_int_ang(bsin(actor->temp_data[0] << 3, -6));
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a & face_player_slow)
{
- newowner and related code.
2020-11-02 23:20:51 +00:00
if (ps[playernum].newOwner != nullptr)
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
goalang = getangle(ps[playernum].opos.XY() - actor->spr.pos.XY());
else goalang = getangle(ps[playernum].pos.XY() - actor->spr.pos.XY());
- more int_ang()
2022-08-16 21:17:01 +00:00
angdif = Sgn(getincangle(actor->int_ang(), goalang)) << 5;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (angdif > -32 && angdif < 0)
{
angdif = 0;
- set_int_ang in Duke. Also changed SOUNDFX actor to use a different variable for its index.
2022-08-16 21:20:35 +00:00
actor->set_int_ang(goalang);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- add_int_ang
2022-08-16 21:26:39 +00:00
actor->add_int_ang(angdif);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
if ((a & jumptoplayer) == jumptoplayer)
{
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[0] < 16)
- Duke: Fix bad setup in `move_d()` that stopped enforcer working properly in E3L1. * Merge with or above `- eliminated all of add_int_zvel.`.
2022-10-08 09:31:50 +00:00
actor->vel.Z -= BobVal(512 + (actor->temp_data[0] << 4)) * 2;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
if (a & face_player_smart)
{
- made player.vel a real float vector with proper value range.
2022-09-11 22:40:33 +00:00
DVector2 newpos = ps[playernum].pos.XY() + (ps[playernum].vel.XY() * (4. / 3.));
- 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
goalang = getangle(newpos - actor->spr.pos.XY());
- more int_ang()
2022-08-16 21:17:01 +00:00
angdif = getincangle(actor->int_ang(), goalang) >> 2;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (angdif > -8 && angdif < 0) angdif = 0;
- add_int_ang
2022-08-16 21:26:39 +00:00
actor->add_int_ang(angdif);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
if (actor->temp_data[1] == 0 || a == 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- floatified opos.
2022-02-03 21:06:09 +00:00
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->spr.pos.X) || (actor->opos.Y != actor->spr.pos.Y))
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- moved the backup... methods to DCoreActor.
2021-12-30 16:10:08 +00:00
actor->backupvec2();
- did some more.
2022-02-06 21:45:47 +00:00
SetActor(actor, actor->spr.pos);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
return;
}
- t[] replacement in actors_d.cpp and actors_r.cpp.
2021-12-23 15:20:32 +00:00
auto moveptr = &ScriptCode[actor->temp_data[1]];
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- eliminated add_int_xvel
2022-09-11 20:57:56 +00:00
if (a & geth) actor->vel.X += (moveptr[0] / 16 - actor->vel.X) * 0.5;
if (a & getv) actor->vel.Z += (moveptr[1] / 16 - actor->vel.Z) * 0.5;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a & dodgebullet)
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
dodge(actor);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.picnum != APLAYER)
- renamed variables in move functions.
2020-11-01 14:56:50 +00:00
alterang(a, actor, playernum);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- eliminated add_int_xvel
2022-09-11 20:57:56 +00:00
if (abs(actor->vel.X) < 6 / 16.) actor->vel.X = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
a = badguy(actor);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- eliminated add_int_xvel
2022-09-11 20:57:56 +00:00
if (actor->vel.X != 0 || actor->vel.X != 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (a && actor->spr.picnum != ROTATEGUN)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if ((actor->spr.picnum == DRONE || actor->spr.picnum == COMMANDER) && actor->spr.extra > 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (actor->spr.picnum == COMMANDER)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
double c, f;
getzsofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, &c, &f);
actor->floorz = f;
actor->ceilingz = c;
if (actor->spr.pos.Z > f - 8)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
actor->spr.pos.Z = f - 8;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
if (actor->spr.pos.Z < c + 80)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
actor->spr.pos.Z = c + 80;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
else
{
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z > 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
double f = getflorzofslopeptrf(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->floorz = f;
if (actor->spr.pos.Z > f - 30)
actor->spr.pos.Z = f - 30;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
else
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
double c = getceilzofslopeptrf(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->ceilingz = c;
if (actor->spr.pos.Z < c + 50)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
actor->spr.pos.Z = c + 50;
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
actor->vel.Z = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
}
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else if (actor->spr.picnum != ORGANTIC)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z > 0 && actor->floorz < actor->spr.pos.Z)
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
actor->spr.pos.Z = actor->floorz;
- removed the non-Blood float_* access wrappers
2022-09-03 08:03:30 +00:00
if (actor->vel.Z < 0)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
double c = getceilzofslopeptrf(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z < c + 66)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
actor->spr.pos.Z = c + 66;
- removed the mul vel wrappers
2022-09-03 08:04:16 +00:00
actor->vel.Z *= 0.5;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
}
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else if (actor->spr.picnum == APLAYER)
- cleaned up the remaining uses of the integer floorz/ceilingz variables. This concerns two particularly ugly blocks of code in the move functions - these were fully redone with pure floating point math.
2022-02-03 23:45:00 +00:00
if ((actor->spr.pos.Z - actor->ceilingz) < 32)
actor->spr.pos.Z = actor->ceilingz + 32;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- more xvel wraps.
2022-09-01 14:52:45 +00:00
daxvel = actor->int_xvel();
- more int_ang()
2022-08-16 21:17:01 +00:00
angdif = actor->int_ang();
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (a && actor->spr.picnum != ROTATEGUN)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
if (xvel < 960 && actor->spr.xrepeat > 16)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- renamed variables in move functions.
2020-11-01 14:56:50 +00:00
daxvel = -(1024 - xvel);
- floatification access method cleanup in actors_d.cpp.
2022-02-05 22:47:14 +00:00
angdif = getangle(ps[playernum].pos.XY() - actor->spr.pos.XY());
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- renamed variables in move functions.
2020-11-01 14:56:50 +00:00
if (xvel < 512)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- floatified gs.playerfriction
2022-09-11 22:08:42 +00:00
ps[playernum].vel.X = 0;
ps[playernum].vel.Y = 0;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
else
{
- floatified gs.playerfriction
2022-09-11 22:08:42 +00:00
ps[playernum].vel.XY() *= gs.playerfriction - 0.125;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
- second half of actors_d.cpp
2021-12-21 18:45:48 +00:00
else if (actor->spr.picnum != DRONE && actor->spr.picnum != SHARK && actor->spr.picnum != COMMANDER)
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
Duke3d: make actors set to move vertically in CON act as if SFLAG_SMOOTHMOVE was explicitly enabled This smooths out stuff like octabrains and flying liztroops without making them look stupid when they move on the ground.
2021-11-12 15:53:56 +00:00
if (!*(moveptr + 1))
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
{
- floatified opos.
2022-02-03 21:06:09 +00:00
if (actor->opos.Z != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
Duke3d: make actors set to move vertically in CON act as if SFLAG_SMOOTHMOVE was explicitly enabled This smooths out stuff like octabrains and flying liztroops without making them look stupid when they move on the ground.
2021-11-12 15:53:56 +00:00
{
if ((actor->temp_data[0] & 1) || ps[playernum].actorsqu == actor) return;
else daxvel <<= 1;
}
else
{
if ((actor->temp_data[0] & 3) || ps[playernum].actorsqu == actor) return;
else daxvel <<= 2;
}
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
}
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
Collision coll;
- handle the remaining movesprite_ex calls
2022-09-13 18:06:47 +00:00
actor->movflag = movesprite_ex(actor, DVector3(actor->spr.angle.ToVector() * daxvel * inttoworld, actor->vel.Z), CLIPMASK0, coll);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
if (a)
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (actor->sector()->ceilingstat & CSTAT_SECTOR_SKY)
actor->spr.shade += (actor->sector()->ceilingshade - actor->spr.shade) >> 1;
else actor->spr.shade += (actor->sector()->floorshade - actor->spr.shade) >> 1;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (actor->sector()->floorpicnum == MIRROR)
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
deletesprite(actor);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
}
}
- move, fakebubbaspawn and destroyit.
2020-10-22 21:41:07 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
void fall_d(DDukeActor *actor, int g_p)
- safety commit
2020-05-14 07:07:07 +00:00
{
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
fall_common(actor, g_p, JIBS6, DRONE, BLOODPOOL, SHOTSPARK1, SQUISHED, THUD, nullptr);
- safety commit
2020-05-14 07:07:07 +00:00
}
- step 1.
2020-05-14 17:23:36 +00:00
bool spawnweapondebris_d(int picnum, int dnum)
{
return picnum == BLIMP && dnum == SCRAP1;
}
- the last remaining small functions in actors_d.cpp and actors_r.cpp.
2020-10-22 21:45:49 +00:00
void respawnhitag_d(DDukeActor* actor)
- step 1.
2020-05-14 17:23:36 +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
switch (actor->spr.picnum)
- step 1.
2020-05-14 17:23:36 +00:00
{
case FEM1:
case FEM2:
case FEM3:
case FEM4:
case FEM5:
case FEM6:
case FEM7:
case FEM8:
case FEM9:
case FEM10:
case PODFEM1:
case NAKED1:
case STATUE:
- 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 (actor->spr.yint) fi.operaterespawns(actor->spr.yint);
- step 1.
2020-05-14 17:23:36 +00:00
break;
default:
- 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.hitag >= 0) fi.operaterespawns(actor->spr.hitag);
- step 1.
2020-05-14 17:23:36 +00:00
break;
}
}
- a small bit more is gone.
2020-06-23 19:12:15 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void think_d(void)
{
thinktime.Reset();
thinktime.Clock();
- interpolation fix from EDuke: "Patch from Striker to improve sprite interpolation" Fixes #109
2020-09-11 20:54:52 +00:00
recordoldspritepos();
- a small bit more is gone.
2020-06-23 19:12:15 +00:00
- merged both movefta functions, using the already defined flags instead of explicit picnum checks.
2022-01-02 14:44:52 +00:00
movefta(); //ST 2
- a small bit more is gone.
2020-06-23 19:12:15 +00:00
moveweapons_d(); //ST 4
movetransports_d(); //ST 9
moveplayers(); //ST 10
movefallers_d(); //ST 12
moveexplosions_d(); //ST 5
actortime.Reset();
actortime.Clock();
moveactors_d(); //ST 1
actortime.Unclock();
moveeffectors_d(); //ST 3
movestandables_d(); //ST 6
doanimations();
movefx(); //ST 11
thinktime.Unclock();
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
END_DUKE_NS
Reference in a new issue Copy permalink