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

4123 lines
90 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
struct FireProj
{
int x, y, z;
int xv, yv, zv;
};
static TMap<int, FireProj> fire;
- added a serializer for the flamethrower's fire map.
2020-06-29 21:36:06 +00:00
static FSerializer& Serialize(FSerializer& arc, const char* key, FireProj& p, FireProj* def)
{
if (arc.BeginObject(key))
{
arc("x", p.x)
("y", p.y)
("z", p.z)
("xv", p.xv)
("yv", p.yv)
("zv", p.zv)
.EndObject();
}
return arc;
}
void SerializeActorGlobals(FSerializer& arc)
{
if (arc.isWriting() && fire.CountUsed() == 0) return;
bool res = arc.BeginArray("FireProj");
if (arc.isReading())
{
fire.Clear();
if (!res) return;
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
int length = arc.ArraySize() / 2;
- added a serializer for the flamethrower's fire map.
2020-06-29 21:36:06 +00:00
int key;
FireProj value;
for (int i = 0; i < length; i++)
{
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
arc(nullptr, key);
- added a serializer for the flamethrower's fire map.
2020-06-29 21:36:06 +00:00
Serialize(arc, nullptr, value, nullptr);
fire.Insert(key, value);
}
}
else
{
TMap<int, FireProj>::Iterator it(fire);
TMap<int, FireProj>::Pair* pair;
while (it.NextPair(pair))
{
int k = pair->Key;
Serialize(arc, nullptr, k, nullptr);
Serialize(arc, nullptr, pair->Value, nullptr);
}
}
arc.EndArray();
}
- 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
bool ceilingspace_d(int sectnum)
- 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( (sector[sectnum].ceilingstat&1) && sector[sectnum].ceilingpal == 0 )
- 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
switch(sector[sectnum].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;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
bool floorspace_d(int sectnum)
- 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( (sector[sectnum].floorstat&1) && sector[sectnum].ceilingpal == 0 )
- 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
switch(sector[sectnum].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
{
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
if (actor->s.extra > 0) switch (actor->s.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:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
if (actor->s.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:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
if (actor->s.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:
- check_fta_sounds.
2020-10-22 17:08:10 +00:00
if (actor->s.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
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
void addweapon_d(struct 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
{
p->gotweapon.Set(weapon);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if(weapon == SHRINKER_WEAPON)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
p->gotweapon.Set(GROW_WEAPON);
}
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;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
#ifdef EDUKE
- 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->curr_weapon != weapon)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int snum;
- ifsquished.
2020-10-22 17:12:48 +00:00
snum = p->GetPlayerNum();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifsquished.
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWeaponVarID,weapon, snum, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (p->curr_weapon >= 0)
{
- ifsquished.
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWorksLikeVarID, aplWeaponWorksLike[weapon][snum], snum, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- ifsquished.
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWorksLikeVarID, -1, snum, p->GetActor());
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- more gamevar cleanup.
2020-05-13 15:39:30 +00:00
SetGameVarID(g_iReturnVarID, 0, snum, -1);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
OnEvent(EVENT_CHANGEWEAPON, p->i, snum, -1);
if (GetGameVarID(g_iReturnVarID, -1, snum) == 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;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
#else
- 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;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
#endif
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.
- ifsquished.
2020-10-22 17:12:48 +00:00
auto spri = &actor->s;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
bool squishme = false;
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->picnum == APLAYER && ud.clipping)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return false;
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
auto& sc = sector[spri->sectnum];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
int floorceildist = sc.floorz - sc.ceilingz;
if (sc.lotag != ST_23_SWINGING_DOOR)
{
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->pal == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
squishme = floorceildist < (32 << 8) && (sc.lotag & 32768) == 0;
else
squishme = floorceildist < (12 << 8);
}
if (squishme)
{
FTA(QUOTE_SQUISHED, &ps[p]);
- ifsquished.
2020-10-22 17:12:48 +00:00
if (badguy(actor))
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
spri->xvel = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->pal == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifsquished.
2020-10-22 17:12:48 +00:00
actor->picnum = SHOTSPARK1;
actor->extra = 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
{
walltype* wal;
int d, q, x1, y1;
int sectcnt, sectend, dasect, startwall, endwall, nextsect;
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
short p, x, sect;
- 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 };
short tempshort[MAXSECTORS]; // originally hijacked a global buffer which is bad. Q: How many do we really need? RedNukem says 64.
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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 spri = &actor->s;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if(spri->picnum == RPG && spri->xrepeat < 11) goto SKIPWALLCHECK;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if(spri->picnum != SHRINKSPARK)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
tempshort[0] = spri->sectnum;
dasect = spri->sectnum;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
sectcnt = 0; sectend = 1;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
do
{
dasect = tempshort[sectcnt++];
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (((sector[dasect].ceilingz - spri->z) >> 8) < r)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
d = abs(wall[sector[dasect].wallptr].x - spri->x) + abs(wall[sector[dasect].wallptr].y - spri->y);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (d < r)
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitceiling(dasect);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
// ouch...
- renaming in hitradius
2020-10-24 20:41:14 +00:00
d = abs(wall[wall[wall[sector[dasect].wallptr].point2].point2].x - spri->x) + abs(wall[wall[wall[sector[dasect].wallptr].point2].point2].y - spri->y);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (d < r)
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitceiling(dasect);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
startwall = sector[dasect].wallptr;
endwall = startwall + sector[dasect].wallnum;
for (x = startwall, wal = &wall[startwall]; x < endwall; x++, wal++)
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if ((abs(wal->x - spri->x) + abs(wal->y - spri->y)) < r)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
nextsect = wal->nextsector;
if (nextsect >= 0)
{
for (dasect = sectend - 1; dasect >= 0; dasect--)
if (tempshort[dasect] == nextsect) break;
if (dasect < 0) tempshort[sectend++] = nextsect;
}
- renaming in hitradius
2020-10-24 20:41:14 +00:00
x1 = (((wal->x + wall[wal->point2].x) >> 1) + spri->x) >> 1;
y1 = (((wal->y + wall[wal->point2].y) >> 1) + spri->y) >> 1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
updatesector(x1, y1, &sect);
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (sect >= 0 && cansee(x1, y1, spri->z, sect, spri->x, spri->y, spri->z, spri->sectnum))
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.checkhitwall(actor->GetIndex(), x, wal->x, wal->y, spri->z, spri->picnum);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
} while (sectcnt < sectend);
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
SKIPWALLCHECK:
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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
q = -(16 << 8) + (krand() & ((32 << 8) - 1));
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
for (x = 0; x < 7; x++)
{
- 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
auto spri2 = &act2->s;
if (isWorldTour() && Owner)
- 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 (Owner->s.picnum == APLAYER && spri2->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
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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 (spri->picnum == FLAMETHROWERFLAME && ((Owner->s.picnum == FIREFLY && spri2->picnum == FIREFLY) || (Owner->s.picnum == BOSS5 && spri2->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
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (x == 0 || x >= 5 || AFLAMABLE(spri2->picnum))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum != SHRINKSPARK || (spri2->cstat & 257))
- 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 (dist(actor, act2) < r)
- 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 (badguy(act2) && !cansee(spri2->x, spri2->y, spri2->z + q, spri2->sectnum, spri->x, spri->y, spri->z + q, spri->sectnum))
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
continue;
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.checkhitsprite(act2->GetIndex(), actor->GetIndex());
- 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
else if (spri2->extra >= 0 && act2 != actor && (spri2->picnum == TRIPBOMB || badguy(act2) || spri2->picnum == QUEBALL || spri2->picnum == STRIPEBALL || (spri2->cstat & 257) || spri2->picnum == DUKELYINGDEAD))
- 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 (spri->picnum == SHRINKSPARK && spri2->picnum != SHARK && (act2 == Owner || spri2->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;
}
- 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 (spri->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;
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri2->picnum == APLAYER) spri2->z -= PHEIGHT;
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
d = dist(actor, act2);
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri2->picnum == APLAYER) spri2->z += PHEIGHT;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (d < r && cansee(spri2->x, spri2->y, spri2->z - (8 << 8), spri2->sectnum, spri->x, spri->y, spri->z - (12 << 8), spri->sectnum))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->ang = getangle(spri2->x - spri->x, spri2->y - spri->y);
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum == RPG && spri2->extra > 0)
act2->picnum = 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
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum == SHRINKSPARK)
act2->picnum = SHRINKSPARK;
else act2->picnum = 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
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum == SHRINKSPARK || spri->picnum == FLAMETHROWERFLAME)
act2->picnum = spri->picnum;
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
else if (spri->picnum != FIREBALL || !Owner || Owner->s.picnum != APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum == LAVAPOOL)
act2->picnum = 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
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->picnum = RADIUSEXPLOSION;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->picnum = FLAMETHROWERFLAME;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri->picnum != SHRINKSPARK && (!isWorldTour() || spri->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
{
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (d < r / 3)
{
if (hp4 == hp3) hp4++;
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->extra = hp3 + (krand() % (hp4 - hp3));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (d < 2 * r / 3)
{
if (hp3 == hp2) hp3++;
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->extra = hp2 + (krand() % (hp3 - hp2));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (d < r)
{
if (hp2 == hp1) hp2++;
- renaming in hitradius
2020-10-24 20:41:14 +00:00
act2->extra = hp1 + (krand() % (hp2 - hp1));
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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 (spri2->picnum != TANK && spri2->picnum != ROTATEGUN && spri2->picnum != RECON && !bossguy(act2))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri2->xvel < 0) spri2->xvel = 0;
spri2->xvel += (spri->extra << 2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri2->picnum == PODFEM1 || spri2->picnum == FEM1 ||
spri2->picnum == FEM2 || spri2->picnum == FEM3 ||
spri2->picnum == FEM4 || spri2->picnum == FEM5 ||
spri2->picnum == FEM6 || spri2->picnum == FEM7 ||
spri2->picnum == FEM8 || spri2->picnum == FEM9 ||
spri2->picnum == FEM10 || spri2->picnum == STATUE ||
spri2->picnum == STATUEFLASH || spri2->picnum == SPACEMARINE || spri2->picnum == QUEBALL || spri2->picnum == STRIPEBALL)
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.checkhitsprite(act2->GetIndex(), actor->GetIndex());
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- renaming in hitradius
2020-10-24 20:41:14 +00:00
else if (spri->extra == 0) act2->extra = 0;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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 (spri2->picnum != RADIUSEXPLOSION && Owner && Owner->s.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
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
if (spri2->picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
p = spri2->yvel;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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() && act2->picnum == FLAMETHROWERFLAME && Owner->s.picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- renaming in hitradius
2020-10-24 20:41:14 +00:00
ps[p].numloogs = -1 - spri->yvel;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
}
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +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 (ps[p].newowner >= 0)
{
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
int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, unsigned int cliptype, Collision &result)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
int daz, h, oldx, oldy;
short retval, dasectnum, cd;
- 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
auto spri = &actor->s;
int bg = badguy(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->statnum == 5 || (bg && spri->xrepeat < 4))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
spri->x += (xchange * TICSPERFRAME) >> 2;
spri->y += (ychange * TICSPERFRAME) >> 2;
spri->z += (zchange * TICSPERFRAME) >> 2;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (bg)
- 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
setsprite(actor, spri->x, spri->y, spri->z);
return result.setNone();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
dasectnum = spri->sectnum;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
daz = spri->z;
- 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
h = ((tileHeight(spri->picnum) * spri->yrepeat) << 1);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
daz -= h;
if (bg)
{
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
oldx = spri->x;
oldy = spri->y;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->xrepeat > 60)
retval = clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 1024L, (4 << 8), (4 << 8), cliptype);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if (spri->picnum == LIZMAN)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
cd = 292;
- 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
else if (actorflag(actor->GetIndex(), SFLAG_BADGUY))
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
cd = spri->clipdist << 2;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
cd = 192;
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
retval = clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), cd, (4 << 8), (4 << 8), cliptype);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
// conditional code from hell...
if (dasectnum < 0 || (dasectnum >= 0 &&
- 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
((actor->actorstayput >= 0 && actor->actorstayput != dasectnum) ||
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
((spri->picnum == BOSS2) && spri->pal == 0 && sector[dasectnum].lotag != 3) ||
((spri->picnum == BOSS1 || spri->picnum == BOSS2) && sector[dasectnum].lotag == ST_1_ABOVE_WATER) ||
(sector[dasectnum].lotag == ST_1_ABOVE_WATER && (spri->picnum == LIZMAN || (spri->picnum == LIZTROOP && spri->zvel == 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
{
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
spri->x = oldx;
spri->y = oldy;
if (sector[dasectnum].lotag == ST_1_ABOVE_WATER && spri->picnum == LIZMAN)
spri->ang = (krand()&2047);
- 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
else if ((actor->temp_data[0]&3) == 1 && spri->picnum != COMMANDER)
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
spri->ang = (krand()&2047);
- 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
setsprite(actor,oldx,oldy,spri->z);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (dasectnum < 0) dasectnum = 0;
- 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.setSector(dasectnum);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- fixed bad collision state check in movesprite. Fixes #147
2020-10-24 19:36:27 +00:00
if ((retval & kHitTypeMask) > kHitSector && (actor->cgg == 0)) spri->ang += 768;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- 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
if (spri->statnum == STAT_PROJECTILE)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
retval =
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 8L, (4 << 8), (4 << 8), cliptype);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
retval =
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), (int)(spri->clipdist << 2), (4 << 8), (4 << 8), cliptype);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
if (dasectnum >= 0)
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
if ((dasectnum != spri->sectnum))
- 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
changespritesect(actor, dasectnum);
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
daz = spri->z + ((zchange * TICSPERFRAME) >> 3);
- 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
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
- use a pointer to access sprites in movesprite.
2020-10-12 18:59:08 +00:00
spri->z = daz;
- 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
else if (retval == 0)
return result.setSector(dasectnum);
- 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
return result.setFromEngine(retval);
- 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
//
//---------------------------------------------------------------------------
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
void lotsofmoney_d(DDukeActor *actor, short 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
}
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
void lotsofmail_d(DDukeActor *actor, short 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
}
- pass spawner as an actor pointer to 'lotsofstuff'. Allows doing this without using sprite indices.
2020-10-24 07:35:43 +00:00
void lotsofpaper_d(DDukeActor *actor, short 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
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
void guts_d(DDukeActor* actor, short gtype, short n, short p)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
auto s = &actor->s;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
int gutz, floorz;
int i=0, j;
int sx, sy;
uint8_t pal;
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
if (badguy(actor) && s->xrepeat < 16)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
sx = sy = 8;
else sx = sy = 32;
gutz = s->z - (8 << 8);
floorz = getflorzofslope(s->sectnum, s->x, s->y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
- consolidated gutsdir functions by making the spawn offset for Duke's commander an actor property.
2020-10-21 22:05:08 +00:00
gutz += actorinfo[s->picnum].gutsoffset;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
if (badguy(actor) && s->pal == 6)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
pal = 6;
- 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
else if (s->picnum != LIZTROOP) // EDuke32 transfers the palette unconditionally, I'm not sure that's such a good idea.
pal = 0;
else
pal = s->pal;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
for (j = 0; j < n; j++)
{
// RANDCORRECT version from RR.
int a = krand() & 2047;
int r1 = krand();
int r2 = krand();
int r3 = krand();
int r4 = krand();
int r5 = krand();
// TRANSITIONAL: owned by a player???
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
auto spawned = EGS(s->sectnum, s->x + (r5 & 255) - 128, s->y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
if (spawned->s.picnum == JIBS2)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
spawned->s.xrepeat >>= 2;
spawned->s.yrepeat >>= 2;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
if (pal != 0)
- guts_d and guts_r.
2020-10-22 17:21:21 +00:00
spawned->s.pal = pal;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
//---------------------------------------------------------------------------
//
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
//
- 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
void movefta_d(void)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
int x, px, py, sx, sy;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
short p, psect, ssect;
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
int j;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
DukeStatIterator iti(STAT_ZOMBIEACTOR);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
while (auto act = iti.Next())
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
{
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
auto s = &act->s;
p = findplayer(act, &x);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
ssect = psect = s->sectnum;
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
auto pa = ps[p].GetActor();
if (pa->s.extra > 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (x < 30000)
{
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
act->timetosleep++;
if (act->timetosleep >= (x >> 8))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
if (badguy(act))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
px = ps[p].oposx + 64 - (krand() & 127);
py = ps[p].oposy + 64 - (krand() & 127);
updatesector(px, py, &psect);
if (psect == -1)
{
continue;
}
sx = s->x + 64 - (krand() & 127);
sy = s->y + 64 - (krand() & 127);
updatesector(px, py, &ssect);
if (ssect == -1)
{
continue;
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
int r1 = krand();
int r2 = krand();
j = cansee(sx, sy, s->z - (r2 % (52 << 8)), s->sectnum, px, py, ps[p].oposz - (r1 % (32 << 8)), ps[p].cursectnum);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
int r1 = krand();
int r2 = krand();
j = cansee(s->x, s->y, s->z - ((r2 & 31) << 8), s->sectnum, ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursectnum);
}
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (j) switch(s->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
case RUBBERCAN:
case EXPLODINGBARREL:
case WOODENHORSE:
case HORSEONSIDE:
case CANWITHSOMETHING:
case CANWITHSOMETHING2:
case CANWITHSOMETHING3:
case CANWITHSOMETHING4:
case FIREBARREL:
case FIREVASE:
case NUKEBARREL:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case TRIPBOMB:
if (sector[s->sectnum].ceilingstat&1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->shade = sector[s->sectnum].ceilingshade;
else s->shade = sector[s->sectnum].floorshade;
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
act->timetosleep = 0;
changespritestat(act, STAT_STANDABLE);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
break;
default:
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
act->timetosleep = 0;
check_fta_sounds_d(act);
changespritestat(act, STAT_ACTOR);
- 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
}
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
else act->timetosleep = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
if (badguy(act))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (sector[s->sectnum].ceilingstat & 1)
s->shade = sector[s->sectnum].ceilingshade;
else s->shade = sector[s->sectnum].floorshade;
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
DDukeActor* ifhitsectors_d(int sectnum)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
if (a1->s.picnum == EXPLOSION2 && sectnum == a1->s.sectnum)
return a1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movefta and ifhitsectors.
2020-10-22 17:27:59 +00:00
return nullptr;
- 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
{
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
short p;
auto spri = &actor->s;
auto hitowner = actor->GetHitOwner();
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (actor->extra >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (spri->extra >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (spri->picnum == APLAYER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (ud.god && actor->picnum != SHRINKSPARK) return -1;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
p = spri->yvel;
- 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 &&
hitowner->s.picnum == APLAYER &&
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
ud.coop == 1 &&
ud.ffire == 0)
return -1;
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
spri->extra -= actor->extra;
- 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
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (spri->extra <= 0 && actor->picnum != FREEZEBLAST)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
spri->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
- 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->s.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
}
}
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
switch(actor->picnum)
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
{
case RADIUSEXPLOSION:
case RPG:
case HYDRENT:
case HEAVYHBOMB:
case SEENINE:
case OOZFILTER:
case EXPLODINGBARREL:
ps[p].posxv +=
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra*(sintable[(actor->ang+512)&2047]) << 2;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
ps[p].posyv +=
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra*(sintable[actor->ang&2047]) << 2;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
break;
default:
ps[p].posxv +=
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra*(sintable[(actor->ang+512)&2047]) << 1;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
ps[p].posyv +=
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra*(sintable[actor->ang&2047]) << 1;
- 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
}
else
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (actor->extra == 0)
if (actor->picnum == SHRINKSPARK && spri->xrepeat < 24)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return -1;
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (isWorldTour() && actor->picnum == FIREFLY && spri->xrepeat < 48)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
if (actor->picnum != RADIUSEXPLOSION && actor->picnum != RPG)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
return -1;
}
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
spri->extra -= actor->extra;
- 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();
if (spri->picnum != RECON && Owner && Owner->s.statnum < MAXSTATUS)
actor->SetOwner(hitowner);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra = -1;
return actor->picnum;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
if (ud.multimode < 2 || !isWorldTour()
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
|| actor->picnum != FLAMETHROWERFLAME
|| actor->extra >= 0
|| spri->extra > 0
|| spri->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
{
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra = -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();
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
spri->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
- 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->s.picnum == APLAYER && hitowner != ps[p].GetActor())
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());
- ifhitbyweapon cleanup. Variables renamed and array accesses replaced with pointers in RR version.
2020-10-24 08:45:30 +00:00
actor->extra = -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
{
use iterators for moveplayers, movedummyplayers and movefallers_d.
2020-10-12 20:00:19 +00:00
short sect;
- movefallers.
2020-10-22 17:31:06 +00:00
int j, x;
- 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
{
- movefallers.
2020-10-22 17:31:06 +00:00
auto s = &act->s;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
sect = s->sectnum;
- 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
{
s->z -= (16 << 8);
- movefallers.
2020-10-22 17:31:06 +00:00
act->temp_data[1] = s->ang;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
x = s->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
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (j == FIREEXT || j == RPG || j == RADIUSEXPLOSION || j == SEENINE || j == OOZFILTER)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (s->extra <= 0)
{
- 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
{
- movefallers.
2020-10-22 17:31:06 +00:00
if (a2->s.hitag == s->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;
a2->s.cstat &= (65535 - 64);
if (a2->s.picnum == CEILINGSTEAM || a2->s.picnum == STEAM)
a2->s.cstat |= 32768;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
}
else
{
- movefallers.
2020-10-22 17:31:06 +00:00
act->extra = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->extra = x;
}
}
- movefallers.
2020-10-22 17:31:06 +00:00
s->ang = act->temp_data[1];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->z += (16 << 8);
}
- 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
{
if (s->lotag > 0)
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
s->lotag-=3;
if (s->lotag <= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
s->xvel = (32 + (krand() & 63));
s->zvel = -(1024 + (krand() & 1023));
}
}
else
{
if (s->xvel > 0)
{
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
s->xvel -= 8;
- movefallers.
2020-10-22 17:31:06 +00:00
ssp(act, CLIPMASK0);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
if (fi.floorspace(s->sectnum)) x = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
if (fi.ceilingspace(s->sectnum))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
x = gc / 6;
else
x = gc;
}
if (s->z < (sector[sect].floorz - FOURSLEIGHT))
{
s->zvel += x;
if (s->zvel > 6144)
s->zvel = 6144;
s->z += s->zvel;
}
if ((sector[sect].floorz - s->z) < (16 << 8))
{
j = 1 + (krand() & 7);
- movefallers.
2020-10-22 17:31:06 +00:00
for (x = 0; x < j; x++) RANDOMSCRAP(act);
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
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
auto s = &actor->s;
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
int j, x;
int lTripBombControl = GetGameVar("TRIPBOMB_CONTROL", TRIPBOMB_TRIPWIRE, -1, -1);
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....
if (s->extra >= 0)
- 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
s->extra--;
if (s->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);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
x = s->extra;
- movetripbomb.
2020-10-22 17:37:13 +00:00
fi.hitradius(actor, tripbombblastradius, x >> 2, x >> 1, x - (x >> 2), x);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
auto spawned = spawn(actor, EXPLOSION2);
spawned->s.ang = s->ang;
spawned->s.xvel = 348;
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
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (a1->s.picnum == LASERLINE && s->hitag == a1->s.hitag)
a1->s.xrepeat = a1->s.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
{
x = s->extra;
s->extra = 1;
int16_t l = s->ang;
- 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
}
s->extra = x;
s->ang = l;
}
- 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
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
findplayer(&actor->s, &x);
if (x > 768) actor->temp_data[0]++;
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
{
int16_t l = s->ang;
- movetripbomb.
2020-10-22 17:37:13 +00:00
s->ang = actor->temp_data[5];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = s->x; actor->temp_data[4] = s->y;
s->x += sintable[(actor->temp_data[5] + 512) & 2047] >> 9;
s->y += sintable[(actor->temp_data[5]) & 2047] >> 9;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->z -= (3 << 8);
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
// Laser fix from EDuke32.
int16_t const oldSectNum = s->sectnum;
int16_t curSectNum = s->sectnum;
updatesectorneighbor(s->x, s->y, &curSectNum, 1024, 2048);
- movetripbomb.
2020-10-22 17:37:13 +00:00
changespritesect(actor, curSectNum);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
DDukeActor* hit;
x = hitasprite(actor, &hit);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->lastvx = x;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->ang = l;
int k = 0;
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);
setsprite(spawned, spawned->s.pos);
spawned->s.hitag = s->hitag;
spawned->temp_data[1] = spawned->s.z;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (x < 1024)
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
spawned->s.xrepeat = x >> 5;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
break;
}
x -= 1024;
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
s->x += sintable[(actor->temp_data[5] + 512) & 2047] >> 4;
s->y += sintable[(actor->temp_data[5]) & 2047] >> 4;
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
updatesectorneighbor(s->x, s->y, &curSectNum, 1024, 2048);
if (curSectNum == -1)
break;
- movetripbomb.
2020-10-22 17:37:13 +00:00
changespritesect(actor, curSectNum);
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +00:00
// this is a hack to work around the LASERLINE sprite's art tile offset
- movetripbomb.
2020-10-22 17:37:13 +00:00
changespritesect(spawned, curSectNum);
- ported EDuke32's trip bomb fix Still needs to be tested.
2020-07-27 15:52:17 +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]++;
s->x = actor->temp_data[3]; s->y = actor->temp_data[4];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->z += (3 << 8);
- movetripbomb.
2020-10-22 17:37:13 +00:00
changespritesect(actor, oldSectNum);
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
- movetripbomb.
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = s->x; actor->temp_data[4] = s->y;
s->x += sintable[(actor->temp_data[5] + 512) & 2047] >> 9;
s->y += sintable[(actor->temp_data[5]) & 2047] >> 9;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->z -= (3 << 8);
- movetripbomb.
2020-10-22 17:37:13 +00:00
setsprite(actor, s->pos);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
x = hitasprite(actor, nullptr);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
s->x = actor->temp_data[3]; s->y = actor->temp_data[4];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
s->z += (3 << 8);
- movetripbomb.
2020-10-22 17:37:13 +00:00
setsprite(actor, s->x, s->y, s->z);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- movetripbomb.
2020-10-22 17:37:13 +00:00
if (actor->lastvx != 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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
auto s = &actor->s;
int* t = &actor->temp_data[0];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (s->hitag > 0)
{
t[0] = s->cstat;
t[1] = s->ang;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
int j = fi.ifhitbyweapon(actor);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (j == FIREEXT || j == RPG || j == RADIUSEXPLOSION || j == SEENINE || j == OOZFILTER)
- 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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
if (s->hitag == a1->s.hitag && (a1->s.picnum == OOZFILTER || a1->s.picnum == SEENINE))
if (a1->s.shade != -32)
a1->s.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
{
s->cstat = t[0];
s->ang = t[1];
s->extra = 0;
}
}
}
//---------------------------------------------------------------------------
//
// 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;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
int* t = &actor->temp_data[0];
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
for (int k = 0; k < 16; k++)
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
auto spawned = EGS(actor->s.sectnum, actor->s.x, actor->s.y, actor->s.z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->s.zvel >> 2), actor, 5);
spawned->s.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
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
if (actor->s.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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
if (actor->s.hitag == a1->s.hitag && (a1->s.picnum == OOZFILTER || a1->s.picnum == SEENINE))
if (a1->s.shade != -32)
a1->s.shade = -32;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
int x = actor->s.extra;
spawn(actor, EXPLOSION2);
fi.hitradius(actor, pipebombblastradius, x >> 2, x - (x >> 1), x - (x >> 2), x);
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
detonate(actor, EXPLOSION2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
fi.hitradius(actor, seenineblastradius, 10, 15, 20, 25);
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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
if (actor->s.xrepeat == 0) deletesprite(actor);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
else
{
int x;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
findplayer(&actor->s, &x);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
if (x < 2048)
{
#if 0
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
if (actor->s.yvel == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
camsprite = i;
#endif
}
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
else if (camsprite != -1 && actor->temp_data[0] == 1)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
camsprite = -1;
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
actor->s.yvel = 0;
actor->temp_data[0] = 0;
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
static void movesidebolt(int i)
{
auto s = &sprite[i];
auto t = &hittype[i].temp_data[0];
int x;
int sect = s->sectnum;
auto p = findplayer(s, &x);
if (x > 20480) return;
CLEAR_THE_BOLT2:
if (t[2])
{
t[2]--;
return;
}
if ((s->xrepeat | s->yrepeat) == 0)
{
s->xrepeat = t[0];
s->yrepeat = t[1];
}
if ((krand() & 8) == 0)
{
t[0] = s->xrepeat;
t[1] = s->yrepeat;
t[2] = global_random & 4;
s->xrepeat = s->yrepeat = 0;
goto CLEAR_THE_BOLT2;
}
s->picnum++;
#if 0
// content of l was undefined.
if (l & 1) s->cstat ^= 2;
#endif
if ((krand() & 1) && sector[sect].floorpicnum == HURTRAIL)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SHORT_CIRCUIT, i);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (s->picnum == SIDEBOLT1 + 4) s->picnum = SIDEBOLT1;
- 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
static void movebolt(int i)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
auto s = &sprite[i];
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
auto t = &hittype[i].temp_data[0];
int x;
int sect = s->sectnum;
auto p = findplayer(s, &x);
if (x > 20480) return;
if (t[3] == 0)
t[3] = sector[sect].floorshade;
CLEAR_THE_BOLT:
if (t[2])
{
t[2]--;
sector[sect].floorshade = 20;
sector[sect].ceilingshade = 20;
return;
}
if ((s->xrepeat | s->yrepeat) == 0)
- 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
s->xrepeat = t[0];
s->yrepeat = t[1];
}
else if ((krand() & 8) == 0)
{
t[0] = s->xrepeat;
t[1] = s->yrepeat;
t[2] = global_random & 4;
s->xrepeat = s->yrepeat = 0;
goto CLEAR_THE_BOLT;
}
s->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;
s->xrepeat = l + 8;
- 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 (l & 1) s->cstat ^= 2;
if (s->picnum == (BOLT1+1) && (krand()&7) == 0 && sector[sect].floorpicnum == HURTRAIL)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SHORT_CIRCUIT,i);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +00:00
if (s->picnum==BOLT1+4) s->picnum=BOLT1;
if (s->picnum & 1)
{
sector[sect].floorshade = 0;
sector[sect].ceilingshade = 0;
}
else
{
sector[sect].floorshade = 20;
sector[sect].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
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_STANDABLE);
int i;
while ((i = it.NextIndex()) >= 0)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
auto s = &sprite[i];
int picnum = s->picnum;
if (s->sectnum < 0)
{
deletesprite(i);
continue;
}
hittype[i].bposx = s->x;
hittype[i].bposy = s->y;
hittype[i].bposz = s->z;
- 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
{
- movecrane interface cleanup.
2020-10-24 08:37:20 +00:00
movecrane(&hittype[i], 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
{
- movefountain and moveflammable. # Conflicts: # source/games/duke/src/actors.cpp
2020-10-21 19:46:39 +00:00
movefountain(&hittype[i], WATERFOUNTAIN);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (AFLAMABLE(picnum))
{
- movefountain and moveflammable. # Conflicts: # source/games/duke/src/actors.cpp
2020-10-21 19:46:39 +00:00
moveflammable(&hittype[i], TIRE, BOX, 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
{
- movetripbomb.
2020-10-22 17:37:13 +00:00
movetripbomb(&hittype[i]);
- 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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
movecrack(&hittype[i]);
- 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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
movefireext(&hittype[i]);
- 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
{
- movetouchplate, moveooz, movecanwithsomething. # Conflicts: # source/games/duke/src/funct.h
2020-10-21 20:22:12 +00:00
moveooz(&hittype[i], SEENINE, SEENINEDEAD, OOZFILTER, EXPLOSION2);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (picnum == MASTERSWITCH)
{
- 3 smaller functions.
2020-10-21 20:17:25 +00:00
movemasterswitch(&hittype[i], SEENINE, OOZFILTER);
- 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
{
- movecrack, movefireext, moveviewscreen.
2020-10-22 17:40:14 +00:00
moveviewscreen(&hittype[i]);
- 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
{
- 3 smaller functions.
2020-10-21 20:17:25 +00:00
movetrash(&hittype[i]);
- 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
{
movesidebolt(i);
}
- 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
{
movebolt(i);
}
- 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
{
- 3 smaller functions.
2020-10-21 20:17:25 +00:00
movewaterdrip(&hittype[i], 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
{
- 3 smaller functions.
2020-10-21 20:17:25 +00:00
movedoorshock(&hittype[i]);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
}
else if (picnum == TOUCHPLATE)
{
- movetouchplate, moveooz, movecanwithsomething. # Conflicts: # source/games/duke/src/funct.h
2020-10-21 20:22:12 +00:00
movetouchplate(&hittype[i], 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
{
- movetouchplate, moveooz, movecanwithsomething. # Conflicts: # source/games/duke/src/funct.h
2020-10-21 20:22:12 +00:00
movecanwithsomething(&hittype[i]);
- 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
{
int x;
int p = findplayer(s, &x);
execute(i, p, x);
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
static bool movefireball(int i)
- split fireball handling out of moveweapons_d to reduce the function's size.
2020-10-17 17:53:04 +00:00
{
auto s = &sprite[i];
auto ht = &hittype[i];
if (sector[s->sectnum].lotag == 2)
{
deletesprite(i);
return true;
}
if (sprite[s->owner].picnum != FIREBALL)
{
if (ht->temp_data[0] >= 1 && ht->temp_data[0] < 6)
{
float siz = 1.0f - (ht->temp_data[0] * 0.2f);
int trail = ht->temp_data[1];
int j = ht->temp_data[1] = fi.spawn(i, FIREBALL);
auto spr = &sprite[j];
spr->xvel = s->xvel;
spr->yvel = s->yvel;
spr->zvel = s->zvel;
if (ht->temp_data[0] > 1)
{
FireProj* proj = fire.CheckKey(trail);
if (proj != nullptr)
{
spr->x = proj->x;
spr->y = proj->y;
spr->z = proj->z;
spr->xvel = proj->xv;
spr->yvel = proj->yv;
spr->zvel = proj->zv;
}
}
spr->yrepeat = spr->xrepeat = (short)(sprite[i].xrepeat * siz);
spr->cstat = sprite[i].cstat;
spr->extra = 0;
FireProj proj = { spr->x, spr->y, spr->z, spr->xvel, spr->yvel, spr->zvel };
fire.Insert(j, proj);
changespritestat((short)j, (short)4);
}
ht->temp_data[0]++;
}
if (s->zvel < 15000)
s->zvel += 200;
return false;
}
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static bool weaponhitsprite(int i, int j, bool fireball)
{
auto s = &sprite[i];
if (s->picnum == FREEZEBLAST && sprite[j].pal == 1)
if (badguy(&sprite[j]) || sprite[j].picnum == APLAYER)
{
j = fi.spawn(i, TRANSPORTERSTAR);
sprite[j].pal = 1;
sprite[j].xrepeat = 32;
sprite[j].yrepeat = 32;
deletesprite(i);
return true;
}
if (!isWorldTour() || s->picnum != FIREBALL || fireball)
fi.checkhitsprite(j, i);
if (sprite[j].picnum == APLAYER)
{
int p = sprite[j].yvel;
if (ud.multimode >= 2 && fireball && sprite[s->owner].picnum == APLAYER)
{
ps[p].numloogs = -1 - sprite[i].yvel;
}
S_PlayActorSound(PISTOL_BODYHIT, j);
if (s->picnum == SPIT)
{
ps[p].horizon.addadjustment(32);
ps[p].sync.actions |= SB_CENTERVIEW;
if (ps[p].loogcnt == 0)
{
if (!S_CheckActorSoundPlaying(ps[p].i, DUKE_LONGTERM_PAIN))
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].i);
j = 3 + (krand() & 3);
ps[p].numloogs = j;
ps[p].loogcnt = 24 * 4;
for (int x = 0; x < j; x++)
{
ps[p].loogiex[x] = krand() % 320;
ps[p].loogiey[x] = krand() % 200;
}
}
}
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static bool weaponhitwall(int i, int j, const vec3_t &oldpos)
{
auto s = &sprite[i];
if (s->picnum != RPG && s->picnum != FREEZEBLAST && s->picnum != SPIT &&
(!isWorldTour() || s->picnum != FIREBALL) &&
(wall[j].overpicnum == MIRROR || wall[j].picnum == MIRROR))
{
int k = getangle(
wall[wall[j].point2].x - wall[j].x,
wall[wall[j].point2].y - wall[j].y);
s->ang = ((k << 1) - s->ang) & 2047;
s->owner = i;
fi.spawn(i, TRANSPORTERSTAR);
return true;
}
else
{
setsprite(i, &oldpos);
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
if (s->picnum == FREEZEBLAST)
{
if (wall[j].overpicnum != MIRROR && wall[j].picnum != MIRROR)
{
s->extra >>= 1;
s->yvel--;
}
int k = getangle(
wall[wall[j].point2].x - wall[j].x,
wall[wall[j].point2].y - wall[j].y);
s->ang = ((k << 1) - s->ang) & 2047;
return true;
}
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static bool weaponhitsector(int i, const vec3_t& oldpos, bool fireball)
{
auto s = &sprite[i];
setsprite(i, &oldpos);
if (s->zvel < 0)
{
if (sector[s->sectnum].ceilingstat & 1)
if (sector[s->sectnum].ceilingpal == 0)
{
deletesprite(i);
return true;
}
fi.checkhitceiling(s->sectnum);
}
else if (fireball)
{
int j = fi.spawn(i, LAVAPOOL);
sprite[j].owner = sprite[i].owner;
sprite[j].yvel = sprite[i].yvel;
hittype[j].owner = sprite[i].owner;
deletesprite(i);
return true;
}
if (s->picnum == FREEZEBLAST)
{
- bounce, movetongue and rpgexplode.
2020-10-21 20:29:35 +00:00
bounce(&hittype[i]);
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
ssp(i, CLIPMASK1);
s->extra >>= 1;
if (s->xrepeat > 8)
s->xrepeat -= 2;
if (s->yrepeat > 8)
s->yrepeat -= 2;
s->yvel--;
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
//
//---------------------------------------------------------------------------
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
static void weaponcommon_d(int i)
- 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
auto s = &sprite[i];
- 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 (s->picnum == COOLEXPLOSION1)
if (!S_CheckSoundPlaying(i, WIERDSHOT_FLY))
S_PlayActorSound(WIERDSHOT_FLY, i);
int p = -1;
int k, ll;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
auto oldpos = s->pos;
- 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 (s->picnum == RPG && sector[s->sectnum].lotag == 2)
{
k = s->xvel >> 1;
ll = s->zvel >> 1;
}
else
- 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
k = s->xvel;
ll = s->zvel;
}
- 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
getglobalz(i);
- 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
switch (s->picnum)
{
case RPG:
if (hittype[i].picnum != BOSS2 && s->xrepeat >= 10 && sector[s->sectnum].lotag != 2)
- 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
int j = fi.spawn(i, SMALLSMOKE);
sprite[j].z += (1 << 8);
}
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:
if (movefireball(i)) return;
break;
}
int j = fi.movesprite(i,
(k * (sintable[(s->ang + 512) & 2047])) >> 14,
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
(k * (sintable[s->ang & 2047])) >> 14, ll, CLIPMASK1);
- separated Duke and RR implementations because the more complex functions would become too messy otherwise.
2020-05-07 20:30:19 +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 (s->picnum == RPG && s->yvel >= 0)
if (FindDistance2D(s->x - sprite[s->yvel].x, s->y - sprite[s->yvel].y) < 256)
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
j = kHitSprite | s->yvel;
- 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 (s->sectnum < 0)
{
deletesprite(i);
return;
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
if ((j & kHitTypeMask) != kHitSprite && s->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
{
if (s->z < hittype[i].ceilingz)
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
j = kHitSector | (s->sectnum);
- 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
s->zvel = -1;
}
else
if ((s->z > hittype[i].floorz && sector[s->sectnum].lotag != 1) ||
(s->z > hittype[i].floorz + (16 << 8) && sector[s->sectnum].lotag == 1))
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
j = kHitSector | (s->sectnum);
- 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 (sector[s->sectnum].lotag != 1)
s->zvel = 1;
- 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 (s->picnum == FIRELASER)
{
for (k = -3; k < 2; k++)
{
int x = EGS(s->sectnum,
s->x + ((k * sintable[(s->ang + 512) & 2047]) >> 9),
s->y + ((k * sintable[s->ang & 2047]) >> 9),
s->z + ((k * ksgn(s->zvel)) * abs(s->zvel / 24)), FIRELASER, -40 + (k << 2),
s->xrepeat, s->yrepeat, 0, 0, 0, s->owner, 5);
sprite[x].cstat = 128;
sprite[x].pal = s->pal;
}
}
else if (s->picnum == SPIT) if (s->zvel < 6144)
s->zvel += gc - 112;
if (j != 0)
{
if (s->picnum == COOLEXPLOSION1)
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
if ((j & kHitTypeMask) == kHitSprite && sprite[j & kHitIndexMask].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
}
- 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
s->xvel = 0;
s->zvel = 0;
}
- 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
bool fireball = (isWorldTour() && s->picnum == FIREBALL && sprite[s->owner].picnum != FIREBALL);
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
if ((j & kHitTypeMask) == 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
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
j &= kHitIndexMask;
if (weaponhitsprite(i, j, 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
}
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
else if ((j & kHitTypeMask) == 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
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
j &= kHitIndexMask;
if (weaponhitwall(i, j, 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
}
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
else if ((j & kHitTypeMask) == 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
{
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
if (weaponhitsector(i, 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
- 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 (s->picnum != SPIT)
{
if (s->picnum == RPG)
{
- cleanup and consolidation of moveweapons_r.
2020-10-18 08:42:26 +00:00
// j is only needed for the hit type mask.
- bounce, movetongue and rpgexplode.
2020-10-21 20:29:35 +00:00
rpgexplode(&hittype[i], j, 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
}
else if (s->picnum == SHRINKSPARK)
{
fi.spawn(i, SHRINKEREXPLOSION);
S_PlayActorSound(SHRINKER_HIT, i);
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.hitradius(&hittype[i], 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
}
else if (s->picnum != COOLEXPLOSION1 && s->picnum != FREEZEBLAST && s->picnum != FIRELASER && (!isWorldTour() || s->picnum != FIREBALL))
{
k = fi.spawn(i, EXPLOSION2);
sprite[k].xrepeat = sprite[k].yrepeat = s->xrepeat >> 1;
- split moveweapons_d further up into more smaller parts.
2020-10-18 07:45:41 +00:00
if ((j & kHitTypeMask) == kHitSector)
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
{
if (s->zvel < 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
sprite[k].cstat |= 8; sprite[k].z += (72 << 8);
- 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
{
- 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
j = fi.spawn(i, EXPLOSION2);
sprite[j].xrepeat = sprite[j].yrepeat = (short)(s->xrepeat >> 1);
}
}
if (s->picnum != COOLEXPLOSION1)
{
deletesprite(i);
return;
}
}
if (s->picnum == COOLEXPLOSION1)
{
s->shade++;
if (s->shade >= 40)
{
deletesprite(i);
return;
}
}
else if (s->picnum == RPG && sector[s->sectnum].lotag == 2 && s->xrepeat >= 10 && rnd(140))
fi.spawn(i, WATERBUBBLE);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void moveweapons_d(void)
{
StatIterator it(STAT_PROJECTILE);
int i;
while ((i = it.NextIndex()) >= 0)
{
auto s = &sprite[i];
if (s->sectnum < 0)
{
deletesprite(i);
continue;
}
hittype[i].bposx = s->x;
hittype[i].bposy = s->y;
hittype[i].bposz = s->z;
switch(s->picnum)
{
case RADIUSEXPLOSION:
case KNEE:
deletesprite(i);
continue;
case TONGUE:
- bounce, movetongue and rpgexplode.
2020-10-21 20:29:35 +00:00
movetongue(&hittype[i], 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:
if (s->yvel < 1 || s->extra < 2 || (s->xvel|s->zvel) == 0)
{
int j = fi.spawn(i,TRANSPORTERSTAR);
sprite[j].pal = 1;
sprite[j].xrepeat = 32;
sprite[j].yrepeat = 32;
deletesprite(i);
continue;
- 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:
// Twentieth Anniversary World Tour
- fixed freezer projectile not moving. These endless fallthrough switch/case blocks are a genuine menace. :( Fixes #136
2020-10-20 21:21:38 +00:00
if (s->picnum == FIREBALL && !isWorldTour()) break;
- 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:
weaponcommon_d(i);
- 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
{
int x;
int p = findplayer(s, &x);
execute(i, 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;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
int ll, onfloorz, q;
int i, j;
StatIterator iti(STAT_TRANSPORT);
while ((i = iti.NextIndex()) >= 0)
- 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
auto spri = &sprite[i];
auto hiti = &hittype[i];
auto spriowner = spri->owner < 0? nullptr : &sprite[spri->owner];
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int sect = spri->sectnum;
int sectlotag = sector[sect].lotag;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (spri->owner == i)
- movetransports.
2020-05-07 22:03:51 +00:00
{
continue;
}
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
onfloorz = hiti->temp_data[4];
if (hiti->temp_data[0] > 0) hiti->temp_data[0]--;
SectIterator itj(sect);
while ((j = itj.NextIndex()) >= 0)
- 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
auto sprj = &sprite[j];
auto hitj = &hittype[j];
switch (sprj->statnum)
- 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
case STAT_PLAYER: // Player
if (sprj->owner != -1)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int p = sprj->yvel;
- 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
ps[p].on_warping_sector = 1;
- 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
if (ps[p].transporter_hold == 0 && ps[p].jumping_counter == 0)
{
if (ps[p].on_ground && sectlotag == 0 && onfloorz && ps[p].jetpack_on == 0)
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (spri->pal == 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, TRANSPORTERBEAM);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(TELEPORTER, i);
- 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
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
for (int k = connecthead; k >= 0; k = connectpoint2[k])
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (ps[k].cursectnum == spriowner->sectnum)
- 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;
sprite[ps[k].i].extra = 0;
}
ps[p].angle.ang = buildang(spriowner->ang);
if (spriowner->owner != spri->owner)
{
hiti->temp_data[0] = 13;
hittype[spri->owner].temp_data[0] = 13;
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = 13;
}
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ps[p].bobposx = ps[p].oposx = ps[p].posx = spriowner->x;
ps[p].bobposy = ps[p].oposy = ps[p].posy = spriowner->y;
ps[p].oposz = ps[p].posz = spriowner->z - PHEIGHT;
changespritesect(j, spriowner->sectnum);
ps[p].cursectnum = sprj->sectnum;
if (spri->pal == 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int k = fi.spawn(spri->owner, TRANSPORTERBEAM);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(TELEPORTER, k);
- 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
break;
}
}
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (onfloorz == 0 && abs(spri->z - ps[p].posz) < 6144)
- 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))) ||
(ps[p].jetpack_on && (PlayerInput(p, SB_CROUCH) ^ !!ps[p].crouch_toggle)))
- 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[p].oposx = ps[p].posx += spriowner->x - spri->x;
ps[p].oposy = ps[p].posy += spriowner->y - spri->y;
- 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))
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ps[p].posz = spriowner->z - 6144;
else ps[p].posz = spriowner->z + 6144;
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].oposz = ps[p].posz;
- 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
hittype[ps[p].i].bposx = ps[p].posx;
hittype[ps[p].i].bposy = ps[p].posy;
hittype[ps[p].i].bposz = ps[p].posz;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
changespritesect(j, spriowner->sectnum);
ps[p].cursectnum = spriowner->sectnum;
- movetransports.
2020-05-07 22:03:51 +00:00
break;
}
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int k = 0;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
- transitioned the 5 primary action keys: Open, Jump, Crouch and Fire/AltFire.
2020-08-28 20:51:05 +00:00
if (onfloorz && sectlotag == ST_1_ABOVE_WATER && ps[p].on_ground && ps[p].posz > (sector[sect].floorz - (16 << 8)) && (PlayerInput(p, SB_CROUCH) || ps[p].poszv > 2048))
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
// if( onfloorz && sectlotag == 1 && ps[p].posz > (sector[sect].floorz-(6<<8)) )
- movetransports.
2020-05-07 22:03:51 +00:00
{
k = 1;
if (screenpeek == p)
{
FX_StopAllSounds();
}
if (sprite[ps[p].i].extra > 0)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(DUKE_UNDERWATER, j);
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].oposz = ps[p].posz =
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sector[spriowner->sectnum].ceilingz + (7 << 8);
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].posxv = 4096 - (krand() & 8192);
ps[p].posyv = 4096 - (krand() & 8192);
- 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
}
- 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
if (onfloorz && sectlotag == ST_2_UNDERWATER && ps[p].posz < (sector[sect].ceilingz + (6 << 8)))
{
k = 1;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
// if( sprj->extra <= 0) break;
- movetransports.
2020-05-07 22:03:51 +00:00
if (screenpeek == p)
{
FX_StopAllSounds();
}
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(DUKE_GASP, j);
- 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
ps[p].oposz = ps[p].posz =
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sector[spriowner->sectnum].floorz - (7 << 8);
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].jumping_toggle = 1;
ps[p].jumping_counter = 0;
}
- 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
if (k == 1)
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ps[p].oposx = ps[p].posx += spriowner->x - spri->x;
ps[p].oposy = ps[p].posy += spriowner->y - spri->y;
if (spriowner->owner != spri->owner)
- movetransports.
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = -2;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ps[p].cursectnum = spriowner->sectnum;
changespritesect(j, spriowner->sectnum);
- movetransports.
2020-05-07 22:03:51 +00:00
setsprite(ps[p].i, ps[p].posx, ps[p].posy, ps[p].posz + PHEIGHT);
- 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
setpal(&ps[p]);
- 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
if ((krand() & 255) < 32)
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(j, WATERSPLASH2);
- 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
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
{
q = fi.spawn(ps[p].i, WATERBUBBLE);
sprite[q].z += krand() & 16383;
}
- movetransports.
2020-05-07 22:03:51 +00:00
}
}
break;
- 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
case STAT_ACTOR:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
switch (sprj->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:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (sprj->extra > 0)
continue;
- movetransports.
2020-05-07 22:03:51 +00:00
}
case STAT_PROJECTILE:
case STAT_MISC:
case STAT_FALLER:
case STAT_DUMMYPLAYER:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
ll = abs(sprj->zvel);
- movetransports.
2020-05-07 22:03:51 +00:00
{
warpspriteto = 0;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (ll && sectlotag == 2 && sprj->z < (sector[sect].ceilingz + ll))
- movetransports.
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (ll && sectlotag == 1 && sprj->z > (sector[sect].floorz - ll))
- movetransports.
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (sectlotag == 0 && (onfloorz || abs(sprj->z - spri->z) < 4096))
- 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
if (spriowner->owner != spri->owner && onfloorz && hiti->temp_data[0] > 0 && sprj->statnum != 5)
- 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
hiti->temp_data[0]++;
- movetransports.
2020-05-07 22:03:51 +00:00
goto BOLT;
}
warpspriteto = 1;
}
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (warpspriteto) switch (sprj->picnum)
- movetransports.
2020-05-07 22:03:51 +00:00
{
case TRANSPORTERSTAR:
case TRANSPORTERBEAM:
case TRIPBOMB:
case BULLETHOLE:
case WATERSPLASH2:
case BURNING:
case BURNING2:
case FIRE:
case FIRE2:
case TOILETWATER:
case LASERLINE:
- 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
case PLAYERONWATER:
if (sectlotag == 2)
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sprj->cstat &= 32767;
- movetransports.
2020-05-07 22:03:51 +00:00
break;
}
default:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (sprj->statnum == 5 && !(sectlotag == 1 || sectlotag == 2))
- movetransports.
2020-05-07 22:03:51 +00:00
break;
- 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
case WATERBUBBLE:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
//if( rnd(192) && sprj->picnum == WATERBUBBLE)
// break;
- movetransports.
2020-05-07 22:03:51 +00:00
if (sectlotag > 0)
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int k = fi.spawn(j, WATERSPLASH2);
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (sectlotag == 1 && sprj->statnum == 4)
- 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
sprite[k].xvel = sprj->xvel >> 1;
sprite[k].ang = sprj->ang;
- movetransports.
2020-05-07 22:03:51 +00:00
ssp(k, CLIPMASK0);
}
}
- 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
switch (sectlotag)
{
case 0:
if (onfloorz)
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
if (sprj->statnum == 4 || (checkcursectnums(sect) == -1 && checkcursectnums(spriowner->sectnum) == -1))
- 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
sprj->x += (spriowner->x - spri->x);
sprj->y += (spriowner->y - spri->y);
sprj->z -= spri->z - sector[spriowner->sectnum].floorz;
sprj->ang = spriowner->ang;
hitj->bposx = sprj->x;
hitj->bposy = sprj->y;
hitj->bposz = sprj->z;
if (spri->pal == 0)
- movetransports.
2020-05-07 22:03:51 +00:00
{
- same for movefta_d and ifhitbyweapon_d
2020-10-12 19:15:54 +00:00
int k = fi.spawn(i, TRANSPORTERBEAM);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(TELEPORTER, k);
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
k = fi.spawn(spri->owner, TRANSPORTERBEAM);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(TELEPORTER, k);
- 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
if (spriowner->owner != spri->owner)
- 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
hiti->temp_data[0] = 13;
hittype[spri->owner].temp_data[0] = 13;
- 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
changespritesect(j, spriowner->sectnum);
- movetransports.
2020-05-07 22:03:51 +00:00
}
}
else
{
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sprj->x += (spriowner->x - spri->x);
sprj->y += (spriowner->y - spri->y);
sprj->z = spriowner->z + 4096;
hitj->bposx = sprj->x;
hitj->bposy = sprj->y;
hitj->bposz = sprj->z;
changespritesect(j, spriowner->sectnum);
- movetransports.
2020-05-07 22:03:51 +00:00
}
break;
case 1:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sprj->x += (spriowner->x - spri->x);
sprj->y += (spriowner->y - spri->y);
sprj->z = sector[spriowner->sectnum].ceilingz + ll;
hitj->bposx = sprj->x;
hitj->bposy = sprj->y;
hitj->bposz = sprj->z;
changespritesect(j, spriowner->sectnum);
- movetransports.
2020-05-07 22:03:51 +00:00
break;
case 2:
- use the new iterators in the movetransports functions. Also prefer pointers over array access.
2020-10-12 18:45:08 +00:00
sprj->x += (spriowner->x - spri->x);
sprj->y += (spriowner->y - spri->y);
sprj->z = sector[spriowner->sectnum].floorz - ll;
hitj->bposx = sprj->x;
hitj->bposy = sprj->y;
hitj->bposz = sprj->z;
changespritesect(j, spriowner->sectnum);
- movetransports.
2020-05-07 22:03:51 +00:00
break;
}
- 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;
}
}
break;
- 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
}
}
BOLT:;
}
}
- reshuffling stuff.
2020-05-07 12:55:04 +00:00
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void greenslime(int i)
{
spritetype* s = &sprite[i];
auto t = &hittype[i].temp_data[0];
int sect = s->sectnum;
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)
{
s->cstat = (short)32768;
return;
}
else if (actor_tog == 2) s->cstat = 257;
}
// #endif
t[1] += 128;
if (sector[sect].floorstat & 1)
{
deletesprite(i);
return;
}
int x;
int p = findplayer(s, &x);
if (x > 20480)
{
hittype[i].timetosleep++;
if (hittype[i].timetosleep > SLEEPTIME)
{
hittype[i].timetosleep = 0;
changespritestat(i, 2);
return;
}
}
if (t[0] == -5) // FROZEN
{
t[3]++;
if (t[3] > 280)
{
s->pal = 0;
t[0] = 0;
return;
}
makeitfall(i);
s->cstat = 257;
s->picnum = GREENSLIME + 2;
s->extra = 1;
s->pal = 1;
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
j = fi.ifhitbyweapon(&hittype[i]); 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--)
{
int k = EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sprite[i].z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), i, 5);
sprite[k].pal = 1;
}
- copied some changes to kill count management from DukeGDX.
2020-07-27 18:53:31 +00:00
ps[p].actors_killed++;
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(GLASS_BREAKING, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
deletesprite(i);
}
else if (x < 1024 && ps[p].quick_kick == 0)
{
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
j = getincangle(ps[p].angle.ang.asbuild(), getangle(sprite[i].x - ps[p].posx, sprite[i].y - ps[p].posy));
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j > -128 && j < 128)
ps[p].quick_kick = 14;
}
return;
}
if (x < 1596)
s->cstat = 0;
else s->cstat = 257;
if (t[0] == -4) //On the player
{
if (sprite[ps[p].i].extra < 1)
{
t[0] = 0;
return;
}
setsprite(i, s->x, s->y, s->z);
- 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
s->ang = ps[p].angle.ang.asbuild();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
- transitioned the 5 primary action keys: Open, Jump, Crouch and Fire/AltFire.
2020-08-28 20:51:05 +00:00
if ((PlayerInput(p, SB_FIRE) || (ps[p].quick_kick > 0)) && sprite[ps[p].i].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))
{
for (x = 0; x < 8; x++)
{
j = EGS(sect, s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), i, 5);
sprite[j].pal = 6;
}
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SLIM_DYING, i);
S_PlayActorSound(SQUISHED, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if ((krand() & 255) < 32)
{
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
j = fi.spawn(i, BLOODPOOL);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
sprite[j].pal = 0;
}
ps[p].actors_killed++;
t[0] = -3;
- something on player is now a pointer as well
2020-10-17 09:10:12 +00:00
if (ps[p].somethingonplayer == &hittype[i])
ps[p].somethingonplayer = nullptr;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
deletesprite(i);
return;
}
s->z = ps[p].posz + ps[p].pyoff - t[2] + (8 << 8);
- gamecontrol: Initial setup of `PlayerHorizon` struct and deployment within Duke. * Started with the most complicated game first. * Struct made up of fixedhoriz class units. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 06:12:37 +00:00
s->z += -ps[p].horizon.horiz.asq16() >> 12;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (t[2] > 512)
t[2] -= 128;
if (t[2] < 348)
t[2] += 128;
if (ps[p].newowner >= 0)
{
ps[p].newowner = -1;
ps[p].posx = ps[p].oposx;
ps[p].posy = ps[p].oposy;
ps[p].posz = ps[p].oposz;
- gamecontrol: Initial setup of `PlayerAngle` struct and deployment within Duke. * Struct made up of binangle class units. * Create signed clone of binangle for use with look_ang and rotscrnang. * Append currently outgoing function names with `2` at the end to avoid conflict.
2020-10-07 12:13:21 +00:00
ps[p].angle.restore();
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
updatesector(ps[p].posx, ps[p].posy, &ps[p].cursectnum);
setpal(&ps[p]);
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_ACTOR);
while ((j = it.NextIndex()) >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
if (sprite[j].picnum == CAMERA1) sprite[j].yvel = 0;
}
}
if (t[3] > 0)
{
short frames[] = { 5,5,6,6,7,7,6,5 };
s->picnum = GREENSLIME + frames[t[3]];
if (t[3] == 5)
{
sprite[ps[p].i].extra += -(5 + (krand() & 3));
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SLIM_ATTACK, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
if (t[3] < 7) t[3]++;
else t[3] = 0;
}
else
{
s->picnum = GREENSLIME + 5;
if (rnd(32))
t[3] = 1;
}
s->xrepeat = 20 + (sintable[t[1] & 2047] >> 13);
s->yrepeat = 15 + (sintable[t[1] & 2047] >> 13);
- 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
s->x = ps[p].posx + (sintable[(ps[p].angle.ang.asbuild() + 512) & 2047] >> 7);
s->y = ps[p].posy + (sintable[ps[p].angle.ang.asbuild() & 2047] >> 7);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
return;
}
else if (s->xvel < 64 && x < 768)
{
- 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
{
- something on player is now a pointer as well
2020-10-17 09:10:12 +00:00
ps[p].somethingonplayer = &hittype[i];
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (t[0] == 3 || t[0] == 2) //Falling downward
t[2] = (12 << 8);
else t[2] = -(13 << 8); //Climbing up duke
t[0] = -4;
}
}
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
j = fi.ifhitbyweapon(&hittype[i]); if (j >= 0)
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_PlayActorSound(SLIM_DYING, i);
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 == &hittype[i])
ps[p].somethingonplayer = nullptr;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j == FREEZEBLAST)
{
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SOMETHINGFROZE, i); t[0] = -5; t[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)
{
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
j = fi.spawn(i, BLOODPOOL);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
sprite[j].pal = 0;
}
for (x = 0; x < 8; x++)
{
j = EGS(sect, s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), i, 5);
sprite[j].pal = 6;
}
t[0] = -3;
deletesprite(i);
return;
}
// All weap
if (t[0] == -1) //Shrinking down
{
makeitfall(i);
s->cstat &= 65535 - 8;
s->picnum = GREENSLIME + 4;
- tabification of new sources and replacement of the CON instruction symbols. # Conflicts: # source/games/duke/src/zz_gamedef.cpp
2020-05-12 11:43:24 +00:00
// if(s->yrepeat > 62)
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
// fi.guts(s,JIBS6,5,myconnectindex);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (s->xrepeat > 32) s->xrepeat -= krand() & 7;
if (s->yrepeat > 16) s->yrepeat -= krand() & 7;
else
{
s->xrepeat = 40;
s->yrepeat = 16;
t[5] = -1;
t[0] = 0;
}
return;
}
else if (t[0] != -2) getglobalz(i);
if (t[0] == -2) //On top of somebody (an enemy)
{
makeitfall(i);
sprite[t[5]].xvel = 0;
int l = sprite[t[5]].ang;
s->z = sprite[t[5]].z;
s->x = sprite[t[5]].x + (sintable[(l + 512) & 2047] >> 11);
s->y = sprite[t[5]].y + (sintable[l & 2047] >> 11);
s->picnum = GREENSLIME + 2 + (global_random & 1);
if (s->yrepeat < 64) s->yrepeat += 2;
else
{
if (s->xrepeat < 32) s->xrepeat += 4;
else
{
t[0] = -1;
x = ldist(s, &sprite[t[5]]);
if (x < 768) {
sprite[t[5]].xrepeat = 0;
}
}
}
return;
}
//Check randomly to see of there is an actor near
if (rnd(32))
{
- all sector iterators in actors_d.cpp, actors_r.cpp and actors_lava.cpp.
2020-10-14 18:49:43 +00:00
SectIterator it(sect);
while ((j = it.NextIndex()) >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
switch (sprite[j].picnum)
{
case LIZTROOP:
case LIZMAN:
case PIGCOP:
case NEWBEAST:
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
if (ldist(s, &sprite[j]) < 768 && (abs(s->z - sprite[j].z) < 8192)) //Gulp them
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
t[5] = j;
t[0] = -2;
t[1] = 0;
return;
}
}
}
}
//Moving on the ground or ceiling
if (t[0] == 0 || t[0] == 2)
{
s->picnum = GREENSLIME;
if ((krand() & 511) == 0)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(SLIM_ROAM, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (t[0] == 2)
{
s->zvel = 0;
s->cstat &= (65535 - 8);
if ((sector[sect].ceilingstat & 1) || (hittype[i].ceilingz + 6144) < s->z)
{
s->z += 2048;
t[0] = 3;
return;
}
}
else
{
s->cstat |= 8;
makeitfall(i);
}
if (everyothertime & 1) ssp(i, CLIPMASK0);
if (s->xvel > 96)
{
s->xvel -= 2;
return;
}
else
{
if (s->xvel < 32) s->xvel += 4;
s->xvel = 64 - (sintable[(t[1] + 512) & 2047] >> 9);
s->ang += getincangle(s->ang,
getangle(ps[p].posx - s->x, ps[p].posy - s->y)) >> 3;
// TJR
}
s->xrepeat = 36 + (sintable[(t[1] + 512) & 2047] >> 11);
s->yrepeat = 16 + (sintable[t[1] & 2047] >> 13);
if (rnd(4) && (sector[sect].ceilingstat & 1) == 0 &&
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
abs(hittype[i].floorz - hittype[i].ceilingz)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
< (192 << 8))
{
s->zvel = 0;
t[0]++;
}
}
if (t[0] == 1)
{
s->picnum = GREENSLIME;
if (s->yrepeat < 40) s->yrepeat += 8;
if (s->xrepeat > 8) s->xrepeat -= 4;
if (s->zvel > -(2048 + 1024))
s->zvel -= 348;
s->z += s->zvel;
if (s->z < hittype[i].ceilingz + 4096)
{
s->z = hittype[i].ceilingz + 4096;
s->xvel = 0;
t[0] = 2;
}
}
if (t[0] == 3)
{
s->picnum = GREENSLIME + 1;
makeitfall(i);
if (s->z > hittype[i].floorz - (8 << 8))
{
s->yrepeat -= 4;
s->xrepeat += 2;
}
else
{
if (s->yrepeat < (40 - 4)) s->yrepeat += 8;
if (s->xrepeat > 8) s->xrepeat -= 4;
}
if (s->z > hittype[i].floorz - 2048)
{
s->z = hittype[i].floorz - 2048;
t[0] = 0;
s->xvel = 0;
}
}
}
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void flamethrowerflame(int i)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
spritetype* s = &sprite[i];
auto t = &hittype[i].temp_data[0];
int sect = s->sectnum;
int x, j;
int p = findplayer(s, &x);
execute(i, p, x);
t[0]++;
if (sector[sect].lotag == 2)
{
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
sprite[fi.spawn(i, EXPLOSION2)].shade = 127;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
deletesprite(i);
return;
}
int dax = s->x;
int day = s->y;
int daz = s->z;
- fixed WT's incinerator and a few other minor things I found while comparing Raze's WT support code with BuildGDX's. Fixes #357
2020-09-07 19:38:17 +00:00
int xvel = s->xvel;
int zvel = s->zvel;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
getglobalz(i);
int ds = t[0] / 6;
if (s->xrepeat < 80)
s->yrepeat = s->xrepeat += ds;
s->clipdist += ds;
if (t[0] <= 2)
t[3] = krand() % 10;
if (t[0] > 30)
{
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
sprite[fi.spawn(i, EXPLOSION2)].shade = 127;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
deletesprite(i);
return;
}
- fixed WT's incinerator and a few other minor things I found while comparing Raze's WT support code with BuildGDX's. Fixes #357
2020-09-07 19:38:17 +00:00
j = fi.movesprite(i, (xvel * (sintable[(s->ang + 512) & 2047])) >> 14,
(xvel * (sintable[s->ang & 2047])) >> 14, s->zvel, CLIPMASK1);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (s->sectnum < 0)
{
deletesprite(i);
return;
}
if ((j & kHitTypeMask) != kHitSprite)
{
if (s->z < hittype[i].ceilingz)
{
j = kHitSector | (s->sectnum);
s->zvel = -1;
}
else if ((s->z > hittype[i].floorz && sector[s->sectnum].lotag != 1)
|| (s->z > hittype[i].floorz + (16 << 8) && sector[s->sectnum].lotag == 1))
{
j = kHitSector | (s->sectnum);
if (sector[s->sectnum].lotag != 1)
s->zvel = 1;
}
}
if (j != 0) {
- fixed WT's incinerator and a few other minor things I found while comparing Raze's WT support code with BuildGDX's. Fixes #357
2020-09-07 19:38:17 +00:00
s->xvel = s->yvel = s->zvel = 0;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if ((j & kHitTypeMask) == kHitSprite)
{
j &= (MAXSPRITES - 1);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitsprite((short)j, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (sprite[j].picnum == APLAYER)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(j, PISTOL_BODYHIT);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else if ((j & kHitTypeMask) == kHitWall)
{
j &= (MAXWALLS - 1);
setsprite(i, dax, day, daz);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else if ((j & kHitTypeMask) == kHitSector)
{
setsprite(i, dax, day, daz);
if (s->zvel < 0)
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitceiling(s->sectnum);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
if (s->xrepeat >= 10)
{
x = s->extra;
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.hitradius(&hittype[i], rpgblastradius, x >> 2, x >> 1, x - (x >> 2), x);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
}
else
{
x = s->extra + (global_random & 3);
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.hitradius(&hittype[i], (rpgblastradius >> 1), x >> 2, x >> 1, x - (x >> 2), x);
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
static void heavyhbomb(int i)
{
spritetype* s = &sprite[i];
auto t = &hittype[i].temp_data[0];
int sect = s->sectnum;
int x, j, l;
if ((s->cstat & 32768))
{
t[2]--;
if (t[2] <= 0)
{
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(TELEPORTER, i);
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, TRANSPORTERSTAR);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
s->cstat = 257;
}
return;
}
int p = findplayer(s, &x);
if (x < 1220) s->cstat &= ~257;
else s->cstat |= 257;
if (t[3] == 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
j = fi.ifhitbyweapon(&hittype[i]);
- 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[3] = 1;
t[4] = 0;
l = 0;
s->xvel = 0;
goto DETONATEB;
}
}
if (s->picnum != BOUNCEMINE)
{
makeitfall(i);
if (sector[sect].lotag != 1 && s->z >= hittype[i].floorz - (FOURSLEIGHT) && s->yvel < 3)
{
if (s->yvel > 0 || (s->yvel == 0 && hittype[i].floorz == sector[sect].floorz))
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(PIPEBOMB_BOUNCE, i);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
s->zvel = -((4 - s->yvel) << 8);
if (sector[s->sectnum].lotag == 2)
s->zvel >>= 2;
s->yvel++;
}
if (s->z < hittype[i].ceilingz) // && sector[sect].lotag != 2 )
{
s->z = hittype[i].ceilingz + (3 << 8);
s->zvel = 0;
}
}
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
j = fi.movesprite(i,
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
(s->xvel * (sintable[(s->ang + 512) & 2047])) >> 14,
(s->xvel * (sintable[s->ang & 2047])) >> 14,
s->zvel, CLIPMASK0);
if (sector[sprite[i].sectnum].lotag == 1 && s->zvel == 0)
{
s->z += (32 << 8);
if (t[5] == 0)
{
t[5] = 1;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, WATERSPLASH2);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
}
}
else t[5] = 0;
if (t[3] == 0 && (s->picnum == BOUNCEMINE || s->picnum == MORTER) && (j || x < 844))
{
t[3] = 1;
t[4] = 0;
l = 0;
s->xvel = 0;
goto DETONATEB;
}
if (sprite[s->owner].picnum == APLAYER)
l = sprite[s->owner].yvel;
else l = -1;
if (s->xvel > 0)
{
s->xvel -= 5;
if (sector[sect].lotag == 2)
s->xvel -= 10;
if (s->xvel < 0)
s->xvel = 0;
if (s->xvel & 8) s->cstat ^= 4;
}
if ((j & 49152) == 32768)
{
j &= (MAXWALLS - 1);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
int k = getangle(
wall[wall[j].point2].x - wall[j].x,
wall[wall[j].point2].y - wall[j].y);
s->ang = ((k << 1) - s->ang) & 2047;
s->xvel >>= 1;
}
DETONATEB:
bool bBoom = false;
if ((l >= 0 && ps[l].hbomb_on == 0) || t[3] == 1)
bBoom = true;
if (isNamWW2GI() && s->picnum == HEAVYHBOMB)
{
s->extra--;
if (s->extra <= 0)
bBoom = true;
}
if (bBoom)
{
t[4]++;
if (t[4] == 2)
{
x = s->extra;
int m = 0;
switch (s->picnum)
{
case HEAVYHBOMB: m = pipebombblastradius; break;
case MORTER: m = morterblastradius; break;
case BOUNCEMINE: m = bouncemineblastradius; break;
}
- hitradius # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 20:04:39 +00:00
fi.hitradius(&hittype[i], m, x >> 2, x >> 1, x - (x >> 2), x);
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, EXPLOSION2);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
if (s->zvel == 0)
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, EXPLOSION2BOT);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(PIPEBOMB_EXPLODE, i);
- 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++)
RANDOMSCRAP(s, i);
}
if (s->yrepeat)
{
s->yrepeat = 0;
return;
}
if (t[4] > 20)
{
if (s->owner != i || ud.respawn_items == 0)
{
deletesprite(i);
return;
}
else
{
t[2] = respawnitemtime;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, RESPAWNMARKERRED);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
s->cstat = (short)32768;
s->yrepeat = 9;
return;
}
}
}
else if (s->picnum == HEAVYHBOMB && x < 788 && t[0] > 7 && s->xvel == 0)
if (cansee(s->x, s->y, s->z - (8 << 8), s->sectnum, ps[p].posx, ps[p].posy, ps[p].posz, ps[p].cursectnum))
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < max_ammo_amount[HANDBOMB_WEAPON])
{
if (ud.coop >= 1 && s->owner == i)
{
for (j = 0; j < ps[p].weapreccnt; j++)
if (ps[p].weaprecs[j] == s->picnum)
continue;
if (ps[p].weapreccnt < 255) // DukeGDX has 16 here.
ps[p].weaprecs[ps[p].weapreccnt++] = s->picnum;
}
addammo(HANDBOMB_WEAPON, &ps[p], 1);
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(DUKE_GET, ps[p].i);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
if (ps[p].gotweapon[HANDBOMB_WEAPON] == 0 || s->owner == ps[p].i)
- 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
if (sprite[s->owner].picnum != APLAYER)
{
SetPlayerPal(&ps[p], PalEntry(32, 0, 32, 0));
}
if (s->owner != i || ud.respawn_items == 0)
{
if (s->owner == i && ud.coop >= 1)
return;
deletesprite(i);
return;
}
else
{
t[2] = respawnitemtime;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, RESPAWNMARKERRED);
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
s->cstat = (short)32768;
}
}
if (t[0] < 8) t[0]++;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
void moveactors_d(void)
{
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
int x, * t;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
short j, sect, p;
spritetype* s;
unsigned short k;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_ACTOR);
int i;
while ((i = it.NextIndex()) >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
s = &sprite[i];
sect = s->sectnum;
if (s->xrepeat == 0 || sect < 0 || sect >= MAXSECTORS)
{
deletesprite(i);
continue;
}
t = &hittype[i].temp_data[0];
hittype[i].bposx = s->x;
hittype[i].bposy = s->y;
hittype[i].bposz = s->z;
switch (s->picnum)
{
case FLAMETHROWERFLAME:
if (isWorldTour()) flamethrowerflame(i);
continue;
case DUCK:
case TARGET:
if (s->cstat & 32)
{
t[0]++;
if (t[0] > 60)
{
t[0] = 0;
s->cstat = 128 + 257 + 16;
s->extra = 1;
}
}
else
{
- ifhitbyweapon. # Conflicts: # source/games/duke/src/actors_d.cpp # source/games/duke/src/actors_r.cpp
2020-10-21 19:41:14 +00:00
j = fi.ifhitbyweapon(&hittype[i]);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (j >= 0)
{
s->cstat = 32 + 128;
k = 1;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_ACTOR);
int j;
while ((j = it.NextIndex()) >= 0)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
auto sj = &sprite[j];
if (sj->lotag == s->lotag &&
sj->picnum == s->picnum)
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
if ((sj->hitag && !(sj->cstat & 32)) ||
(!sj->hitag && (sj->cstat & 32))
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
)
{
k = 0;
break;
}
}
}
if (k == 1)
{
operateactivators(s->lotag, -1);
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
fi.operateforcefields(i, s->lotag);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
operatemasterswitches(s->lotag);
}
}
}
continue;
case RESPAWNMARKERRED:
case RESPAWNMARKERYELLOW:
case RESPAWNMARKERGREEN:
- respawnmarker, rat and queball.
2020-10-21 20:34:45 +00:00
if (!respawnmarker(&hittype[i], RESPAWNMARKERYELLOW, RESPAWNMARKERGREEN)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case HELECOPT:
case DUKECAR:
s->z += s->zvel;
t[0]++;
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
if (t[0] == 4) S_PlayActorSound(WAR_AMBIENCE2, i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
if (t[0] > (26 * 8))
{
- 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 plus backing code.
2020-05-08 22:34:48 +00:00
for (j = 0; j < 32; j++)
RANDOMSCRAP(s, i);
earthquaketime = 16;
deletesprite(i);
continue;
}
else if ((t[0] & 3) == 0)
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(i, EXPLOSION2);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
ssp(i, CLIPMASK0);
break;
case RAT:
- respawnmarker, rat and queball.
2020-10-21 20:34:45 +00:00
if (!rat(&hittype[i], true)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case QUEBALL:
case STRIPEBALL:
- respawnmarker, rat and queball.
2020-10-21 20:34:45 +00:00
if (!queball(&hittype[i], POCKET, QUEBALL, STRIPEBALL)) continue;
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
break;
case FORCESPHERE:
- forcesphere and recon.
2020-10-21 20:59:56 +00:00
forcesphere(&hittype[i], FORCESPHERE);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case RECON:
- forcesphere and recon.
2020-10-21 20:59:56 +00:00
recon(&hittype[i], EXPLOSION2, FIRELASER, RECO_ATTACK, RECO_PAIN, RECO_ROAM, 10, [](DDukeActor* i)->int { return PIGCOP; });
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case OOZ:
case OOZ2:
- ooz, reactor and camera.
2020-10-21 21:04:14 +00:00
ooz(&hittype[i]);
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:
greenslime(i);
continue;
case BOUNCEMINE:
case MORTER:
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
j = fi.spawn(i, FRAMEEFFECT1);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
hittype[j].temp_data[0] = 3;
case HEAVYHBOMB:
- make moveactors work and RR weapon name cleanup. # Conflicts: # source/games/duke/src/sbar.cpp
2020-05-09 09:44:50 +00:00
heavyhbomb(i);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
case REACTORBURNT:
case REACTOR2BURNT:
continue;
case REACTOR:
case REACTOR2:
- ooz, reactor and camera.
2020-10-21 21:04:14 +00:00
reactor(&hittype[i], 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:
- ooz, reactor and camera.
2020-10-21 21:04:14 +00:00
camera(&hittype[i]);
moveactors plus backing code.
2020-05-08 22:34:48 +00:00
continue;
}
// #ifndef VOLOMEONE
if (ud.multimode < 2 && badguy(s))
{
if (actor_tog == 1)
{
s->cstat = (short)32768;
continue;
}
else if (actor_tog == 2) s->cstat = 257;
}
// #endif
p = findplayer(s, &x);
execute(i, p, x);
}
}
- 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
static void fireflyflyingeffect(int i)
{
spritetype* s = &sprite[i];
auto t = &hittype[i].temp_data[0];
int x, p = findplayer(s, &x);
execute(i, p, x);
auto owner = &sprite[s->owner];
if (owner->picnum != FIREFLY)
{
deletesprite(i);
return;
}
if (owner->xrepeat >= 24 || owner->pal == 1)
s->cstat |= 0x8000;
else
s->cstat &= ~0x8000;
double dx = owner->x - sprite[ps[p].i].x;
double dy = owner->y - sprite[ps[p].i].y;
double dist = sqrt(dx * dx + dy * dy);
if (dist != 0.0)
{
dx /= dist;
dy /= dist;
}
s->x = (int) (owner->x - (dx * -10.0));
s->y = (int) (owner->y - (dy * -10.0));
s->z = owner->z + 2048;
if (owner->extra <= 0)
{
deletesprite(i);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
- moveexplosions
2020-05-09 18:27:06 +00:00
void moveexplosions_d(void) // STATNUM 5
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
int sect, p;
- moveexplosions
2020-05-09 18:27:06 +00:00
int x, * t;
spritetype* s;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_MISC);
int i;
while ((i = it.NextIndex()) >= 0)
- moveexplosions
2020-05-09 18:27:06 +00:00
{
t = &hittype[i].temp_data[0];
s = &sprite[i];
sect = s->sectnum;
if (sect < 0 || s->xrepeat == 0)
{
deletesprite(i);
continue;
}
hittype[i].bposx = s->x;
hittype[i].bposy = s->y;
hittype[i].bposz = s->z;
switch (s->picnum)
{
- renamed unprocessed files and added missing WT firefly effect.
2020-05-10 07:28:13 +00:00
case FIREFLYFLYINGEFFECT:
if (isWorldTour()) fireflyflyingeffect(i);
continue;
- moveexplosions
2020-05-09 18:27:06 +00:00
case NEON1:
case NEON2:
case NEON3:
case NEON4:
case NEON5:
case NEON6:
if ((global_random / (s->lotag + 1) & 31) > 4) s->shade = -127;
else s->shade = 127;
continue;
case BLOODSPLAT1:
case BLOODSPLAT2:
case BLOODSPLAT3:
case BLOODSPLAT4:
if (t[0] == 7 * 26) continue;
s->z += 16 + (krand() & 15);
t[0]++;
if ((t[0] % 9) == 0) s->yrepeat++;
continue;
case NUKEBUTTON:
case NUKEBUTTON + 1:
case NUKEBUTTON + 2:
case NUKEBUTTON + 3:
if (t[0])
{
t[0]++;
if (t[0] == 8) s->picnum = NUKEBUTTON + 1;
else if (t[0] == 16)
{
s->picnum = NUKEBUTTON + 2;
ps[sprite[s->owner].yvel].fist_incs = 1;
}
if (ps[sprite[s->owner].yvel].fist_incs == 26)
s->picnum = NUKEBUTTON + 3;
}
continue;
case FORCESPHERE:
- forcesphere, watersplash2, frameeffect and money.
2020-10-21 21:11:06 +00:00
forcesphereexplode(&hittype[i]);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case WATERSPLASH2:
- forcesphere, watersplash2, frameeffect and money.
2020-10-21 21:11:06 +00:00
watersplash2(&hittype[i]);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case FRAMEEFFECT1:
- forcesphere, watersplash2, frameeffect and money.
2020-10-21 21:11:06 +00:00
frameeffect1(&hittype[i]);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case INNERJAW:
case INNERJAW + 1:
p = findplayer(s, &x);
if (x < 512)
{
SetPlayerPal(&ps[p], PalEntry(32, 32, 0, 0));
sprite[ps[p].i].extra -= 4;
}
case FIRELASER:
if (s->extra != 999)
s->extra = 999;
else
{
deletesprite(i);
continue;
}
break;
case TONGUE:
deletesprite(i);
continue;
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
hittype[i].floorz = s->z = getflorzofslope(s->sectnum, s->x, s->y);
break;
case MONEY:
case MAIL:
case PAPER:
- forcesphere, watersplash2, frameeffect and money.
2020-10-21 21:11:06 +00:00
money(&hittype[i], 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:
- jibs, bloodpool, shell, glasspieces and scrap.
2020-10-21 21:18:24 +00:00
jibs(&hittype[i], JIBS6, true, false, false, s->picnum == DUKELEG || s->picnum == DUKETORSO || s->picnum == DUKEGUN, false);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case BLOODPOOL:
case PUKE:
- jibs, bloodpool, shell, glasspieces and scrap.
2020-10-21 21:18:24 +00:00
bloodpool(&hittype[i], s->picnum == PUKE, TIRE);
- 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;
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:
p = findplayer(s, &x);
execute(i, p, x);
continue;
case SHELL:
case SHOTGUNSHELL:
- jibs, bloodpool, shell, glasspieces and scrap.
2020-10-21 21:18:24 +00:00
shell(&hittype[i], (sector[sect].floorz + (24 << 8)) < s->z);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
case GLASSPIECES:
case GLASSPIECES + 1:
case GLASSPIECES + 2:
- jibs, bloodpool, shell, glasspieces and scrap.
2020-10-21 21:18:24 +00:00
glasspieces(&hittype[i]);
- moveexplosions
2020-05-09 18:27:06 +00:00
continue;
}
if (s->picnum >= SCRAP6 && s->picnum <= SCRAP5 + 3)
{
- jibs, bloodpool, shell, glasspieces and scrap.
2020-10-21 21:18:24 +00:00
scrap(&hittype[i], SCRAP1, SCRAP6);
- moveexplosions
2020-05-09 18:27:06 +00:00
}
}
}
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void moveeffectors_d(void) //STATNUM 3
{
int q = 0, l, x, st, j, * t;
- all sector iterators in actors_d.cpp, actors_r.cpp and actors_lava.cpp.
2020-10-14 18:49:43 +00:00
int p, sh;
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
short k;
spritetype* s;
sectortype* sc;
walltype* wal;
clearfriction();
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_EFFECTOR);
int i;
while ((i = it.NextIndex()) >= 0)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
s = &sprite[i];
sc = &sector[s->sectnum];
st = s->lotag;
sh = s->hitag;
t = &hittype[i].temp_data[0];
switch (st)
{
case SE_0_ROTATING_SECTOR:
- SE 0 and 1 handlers.
2020-10-21 21:39:12 +00:00
handle_se00(&hittype[i], LASERLINE);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_1_PIVOT: //Nothing for now used as the pivot
- SE 0 and 1 handlers.
2020-10-21 21:39:12 +00:00
handle_se01(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_6_SUBWAY:
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
{
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
k = sc->extra;
if (t[4] > 0)
{
t[4]--;
if (t[4] >= (k - (k >> 3)))
s->xvel -= (k >> 5);
if (t[4] > ((k >> 1) - 1) && t[4] < (k - (k >> 3)))
s->xvel = 0;
if (t[4] < (k >> 1))
s->xvel += (k >> 5);
if (t[4] < ((k >> 1) - (k >> 3)))
{
t[4] = 0;
s->xvel = k;
}
}
else s->xvel = k;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_EFFECTOR);
int j;
while ((j = it.NextIndex()) >= 0)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
auto sj = &sprite[j];
if ((sj->lotag == 14) && (sh == sj->hitag) && (hittype[j].temp_data[0] == t[0]))
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
sj->xvel = s->xvel;
- tabification of new sources and replacement of the CON instruction symbols. # Conflicts: # source/games/duke/src/zz_gamedef.cpp
2020-05-12 11:43:24 +00:00
// if( t[4] == 1 )
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
if (hittype[j].temp_data[5] == 0)
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
hittype[j].temp_data[5] = dist(sj, s);
x = sgn(dist(sj, s) - hittype[j].temp_data[5]);
if (sj->extra)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
x = -x;
s->xvel += x;
}
hittype[j].temp_data[4] = t[4];
}
}
x = 0;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
}
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case SE_14_SUBWAY_CAR:
- handle_SE14 function signature and recordoldspritepos
2020-10-21 21:56:46 +00:00
handle_se14(&hittype[i], true, RPG, JIBS6);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_30_TWO_WAY_TRAIN:
- handle_se30.
2020-10-21 22:00:43 +00:00
handle_se30(&hittype[i], JIBS6);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_2_EARTHQUAKE:
- handle SE02-SE04.
2020-10-21 22:10:43 +00:00
handle_se02(&hittype[i]);
- 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:
- handle SE02-SE04.
2020-10-21 22:10:43 +00:00
handle_se03(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_4_RANDOM_LIGHTS:
- handle SE02-SE04.
2020-10-21 22:10:43 +00:00
handle_se04(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
//BOSS
case SE_5_BOSS:
- handle_se05, 08, 10.
2020-10-21 22:14:54 +00:00
handle_se05(&hittype[i], 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:
- handle_se05, 08, 10.
2020-10-21 22:14:54 +00:00
handle_se08(&hittype[i], 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};
- handle_se05, 08, 10.
2020-10-21 22:14:54 +00:00
handle_se10(&hittype[i], tags);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
}
case SE_11_SWINGING_DOOR:
- handle_se11-13.
2020-10-21 22:20:47 +00:00
handle_se11(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_12_LIGHT_SWITCH:
- handle_se11-13.
2020-10-21 22:20:47 +00:00
handle_se12(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_13_EXPLOSIVE:
- handle_se11-13.
2020-10-21 22:20:47 +00:00
handle_se13(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_15_SLIDING_DOOR:
- handle_se15-17.
2020-10-21 22:25:11 +00:00
handle_se15(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_16_REACTOR:
- handle_se15-17.
2020-10-21 22:25:11 +00:00
handle_se16(&hittype[i], REACTOR, REACTOR2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_17_WARP_ELEVATOR:
- handle_se15-17.
2020-10-21 22:25:11 +00:00
handle_se17(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_18_INCREMENTAL_SECTOR_RISE_FALL:
- handle_se18+19
2020-10-21 22:30:22 +00:00
handle_se18(&hittype[i], true);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_19_EXPLOSION_LOWERS_CEILING:
- handle_se18+19
2020-10-21 22:30:22 +00:00
handle_se19(&hittype[i], BIGFORCE);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_20_STRETCH_BRIDGE:
- handle_se20-26.
2020-10-21 22:35:30 +00:00
handle_se20(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_21_DROP_FLOOR:
- handle_se20-26.
2020-10-21 22:35:30 +00:00
handle_se21(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_22_TEETH_DOOR:
- handle_se20-26.
2020-10-21 22:35:30 +00:00
handle_se22(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_24_CONVEYOR:
case 34:
- all sector iterators in actors_d.cpp, actors_r.cpp and actors_lava.cpp.
2020-10-14 18:49:43 +00:00
{
- shared SE24 code.
2020-10-21 22:50:01 +00:00
static int16_t list1[] = { BLOODPOOL, PUKE, FOOTPRINTS, FOOTPRINTS2, FOOTPRINTS3, FOOTPRINTS4, BULLETHOLE, BLOODSPLAT1, BLOODSPLAT2, BLOODSPLAT3, BLOODSPLAT4, -1 };
static int16_t list2[] = { BOLT1, BOLT1 + 1,BOLT1 + 2, BOLT1 + 3, SIDEBOLT1, SIDEBOLT1 + 1, SIDEBOLT1 + 2, SIDEBOLT1 + 3, -1 };
handle_se24(&hittype[i], list1, list2, TRIPBOMB, LASERLINE, CRANE, 2);
- 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
}
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
case 35:
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se35(&hittype[i], SMALLSMOKE, EXPLOSION2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 25: //PISTONS
- shared SE25 code.
2020-10-21 22:59:42 +00:00
if (hittype[i].temp_data[4] == 0) break;
handle_se25(&hittype[i], 3, -1, -1);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 26:
- handle_se20-26.
2020-10-21 22:35:30 +00:00
handle_se26(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case SE_27_DEMO_CAM:
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se27(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 28:
if (t[5] > 0)
{
t[5]--;
break;
}
if (hittype[i].temp_data[0] == 0)
{
p = findplayer(s, &x);
if (x > 15500)
break;
hittype[i].temp_data[0] = 1;
hittype[i].temp_data[1] = 64 + (krand() & 511);
hittype[i].temp_data[2] = 0;
}
else
{
hittype[i].temp_data[2]++;
if (hittype[i].temp_data[2] > hittype[i].temp_data[1])
{
hittype[i].temp_data[0] = 0;
ps[screenpeek].visibility = ud.const_visibility;
break;
}
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 1))
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(THUNDER, i);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 3))
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(LIGHTNING_SLAP, i);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 2))
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_DEFAULT);
while ((j = it.NextIndex()) >= 0)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
if (sprite[j].picnum == NATURALLIGHTNING && sprite[j].hitag == s->hitag)
sprite[j].cstat |= 32768;
}
}
else if (hittype[i].temp_data[2] > (hittype[i].temp_data[1] >> 3) && hittype[i].temp_data[2] < (hittype[i].temp_data[1] >> 2))
{
if (cansee(s->x, s->y, s->z, s->sectnum, ps[screenpeek].posx, ps[screenpeek].posy, ps[screenpeek].posz, ps[screenpeek].cursectnum))
j = 1;
else j = 0;
if (rnd(192) && (hittype[i].temp_data[2] & 1))
{
if (j)
ps[screenpeek].visibility = 0;
}
else if (j)
ps[screenpeek].visibility = ud.const_visibility;
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
StatIterator it(STAT_DEFAULT);
while ((j = it.NextIndex()) >= 0)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
auto sj = &sprite[j];
if (sj->picnum == NATURALLIGHTNING && sj->hitag == s->hitag)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
if (rnd(32) && (hittype[i].temp_data[2] & 1))
{
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
sj->cstat &= 32767;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
fi.spawn(j, SMALLSMOKE);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
p = findplayer(s, &x);
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
x = ldist(&sprite[ps[p].i], sj);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
if (x < 768)
{
- CCMD cleanup.
2020-07-04 19:36:27 +00:00
if (S_CheckSoundPlaying(ps[p].i, DUKE_LONGTERM_PAIN) < 1)
- cleaned up the sound system interface to have consistent naming and no aliases.
2020-07-25 07:32:54 +00:00
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].i);
S_PlayActorSound(SHORT_CIRCUIT, ps[p].i);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
sprite[ps[p].i].extra -= 8 + (krand() & 7);
SetPlayerPal(&ps[p], PalEntry(32, 16, 0, 0));
}
break;
}
- replaced all stat iterators in actors_d.cpp.
2020-10-14 18:02:05 +00:00
else sj->cstat |= 32768;
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
}
}
}
}
break;
case 29:
s->hitag += 64;
l = mulscale12((int)s->yvel, sintable[s->hitag & 2047]);
sc->floorz = s->z + l;
break;
case 31: // True Drop Floor
- shared SE31 code.
2020-10-21 23:04:13 +00:00
handle_se31(&hittype[i], true);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 32: // True Drop Ceiling
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se32(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 33:
if (earthquaketime > 0 && (krand() & 7) == 0)
RANDOMSCRAP(s, i);
break;
case 36:
if (t[0])
{
if (t[0] == 1)
-'shoot' replaced. # Conflicts: # source/build/src/palette.cpp
2020-05-16 21:55:21 +00:00
fi.shoot(i, sc->extra);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
else if (t[0] == 26 * 5)
t[0] = 0;
t[0]++;
}
break;
case 128: //SE to control glass breakage
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se128(&hittype[i]);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 130:
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se130(&hittype[i], 80, EXPLOSION2);
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
break;
case 131:
- the 5 remaining shared SE handlers.
2020-10-21 22:40:57 +00:00
handle_se130(&hittype[i], 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);
while ((i = it.NextIndex()) >= 0)
- moveeffectors, actors.c complete.
2020-05-10 07:08:02 +00:00
{
s = &sprite[i];
if (s->lotag != 29) continue;
sc = &sector[s->sectnum];
if (sc->wallnum != 4) continue;
wal = &wall[sc->wallptr + 2];
alignflorslope(s->sectnum, wal->x, wal->y, sector[wal->nextsector].floorz);
}
}
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
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void move_d(int g_i, int g_p, int g_x)
{
auto g_sp = &sprite[g_i];
- Big cleanup.
2020-07-06 20:23:18 +00:00
auto g_t = hittype[g_i].temp_data;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
int l;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
short goalang, angdif;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
int daxvel;
- hitradius_d uses the iterator now.
2020-10-12 19:30:12 +00:00
int a = g_sp->hitag;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a == -1) a = 0;
g_t[0]++;
if (a & face_player)
{
if (ps[g_p].newowner >= 0)
goalang = getangle(ps[g_p].oposx - g_sp->x, ps[g_p].oposy - g_sp->y);
else goalang = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
angdif = getincangle(g_sp->ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
g_sp->ang += angdif;
}
if (a & spin)
g_sp->ang += sintable[((g_t[0] << 3) & 2047)] >> 6;
if (a & face_player_slow)
{
if (ps[g_p].newowner >= 0)
goalang = getangle(ps[g_p].oposx - g_sp->x, ps[g_p].oposy - g_sp->y);
else goalang = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
angdif = ksgn(getincangle(g_sp->ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
angdif = 0;
g_sp->ang = goalang;
}
g_sp->ang += angdif;
}
if ((a & jumptoplayer) == jumptoplayer)
{
if (g_t[0] < 16)
g_sp->zvel -= (sintable[(512 + (g_t[0] << 4)) & 2047] >> 5);
}
if (a & face_player_smart)
{
- eliminated a few overlooked 'long's.
2020-10-02 20:14:20 +00:00
int newx, newy;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
newx = ps[g_p].posx + (ps[g_p].posxv / 768);
newy = ps[g_p].posy + (ps[g_p].posyv / 768);
goalang = getangle(newx - g_sp->x, newy - g_sp->y);
angdif = getincangle(g_sp->ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
g_sp->ang += angdif;
}
if (g_t[1] == 0 || a == 0)
{
if ((badguy(g_sp) && g_sp->extra <= 0) || (hittype[g_i].bposx != g_sp->x) || (hittype[g_i].bposy != g_sp->y))
{
hittype[g_i].bposx = g_sp->x;
hittype[g_i].bposy = g_sp->y;
setsprite(g_i, g_sp->x, g_sp->y, g_sp->z);
}
return;
}
- use 4 byte entries for the script. We no longer store pointers in here.
2020-05-15 09:36:46 +00:00
auto moveptr = &ScriptCode[g_t[1]];
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (a & geth) g_sp->xvel += (*moveptr - g_sp->xvel) >> 1;
if (a & getv) g_sp->zvel += ((*(moveptr + 1) << 4) - g_sp->zvel) >> 1;
if (a & dodgebullet)
- dodge, furthestcanseepoint, furthestangle.
2020-10-21 23:12:16 +00:00
dodge(&hittype[g_i]);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (g_sp->picnum != APLAYER)
- alterang
2020-10-22 14:40:48 +00:00
alterang(a, &hittype[g_i], g_p);
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
if (g_sp->xvel > -6 && g_sp->xvel < 6) g_sp->xvel = 0;
a = badguy(g_sp);
if (g_sp->xvel || g_sp->zvel)
{
if (a && g_sp->picnum != ROTATEGUN)
{
if ((g_sp->picnum == DRONE || g_sp->picnum == COMMANDER) && g_sp->extra > 0)
{
if (g_sp->picnum == COMMANDER)
{
hittype[g_i].floorz = l = getflorzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
if (g_sp->z > (l - (8 << 8)))
{
if (g_sp->z > (l - (8 << 8))) g_sp->z = l - (8 << 8);
g_sp->zvel = 0;
}
hittype[g_i].ceilingz = l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
if ((g_sp->z - l) < (80 << 8))
{
g_sp->z = l + (80 << 8);
g_sp->zvel = 0;
}
}
else
{
if (g_sp->zvel > 0)
{
hittype[g_i].floorz = l = getflorzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
if (g_sp->z > (l - (30 << 8)))
g_sp->z = l - (30 << 8);
}
else
{
hittype[g_i].ceilingz = l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
if ((g_sp->z - l) < (50 << 8))
{
g_sp->z = l + (50 << 8);
g_sp->zvel = 0;
}
}
}
}
else if (g_sp->picnum != ORGANTIC)
{
if (g_sp->zvel > 0 && hittype[g_i].floorz < g_sp->z)
g_sp->z = hittype[g_i].floorz;
if (g_sp->zvel < 0)
{
l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
if ((g_sp->z - l) < (66 << 8))
{
g_sp->z = l + (66 << 8);
g_sp->zvel >>= 1;
}
}
}
}
else if (g_sp->picnum == APLAYER)
if ((g_sp->z - hittype[g_i].ceilingz) < (32 << 8))
g_sp->z = hittype[g_i].ceilingz + (32 << 8);
daxvel = g_sp->xvel;
angdif = g_sp->ang;
if (a && g_sp->picnum != ROTATEGUN)
{
if (g_x < 960 && g_sp->xrepeat > 16)
{
daxvel = -(1024 - g_x);
angdif = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
if (g_x < 512)
{
ps[g_p].posxv = 0;
ps[g_p].posyv = 0;
}
else
{
ps[g_p].posxv = mulscale(ps[g_p].posxv, dukefriction - 0x2000, 16);
ps[g_p].posyv = mulscale(ps[g_p].posyv, dukefriction - 0x2000, 16);
}
}
else if (g_sp->picnum != DRONE && g_sp->picnum != SHARK && g_sp->picnum != COMMANDER)
{
if (hittype[g_i].bposz != g_sp->z || (ud.multimode < 2 && ud.player_skill < 2))
{
- made player.actorsqu a pointer and added the needed infrastructure for that.
2020-10-17 08:30:11 +00:00
if ((g_t[0] & 1) || ps[g_p].actorsqu == &hittype[g_i]) return;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
else daxvel <<= 1;
}
else
{
- made player.actorsqu a pointer and added the needed infrastructure for that.
2020-10-17 08:30:11 +00:00
if ((g_t[0] & 3) || ps[g_p].actorsqu == &hittype[g_i]) return;
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
else daxvel <<= 2;
}
}
}
- safety commit. # Conflicts: # source/games/duke/src/zz_sbar.cpp
2020-05-14 10:14:03 +00:00
hittype[g_i].movflag = fi.movesprite(g_i,
- movement code of the VM transitioned
2020-05-13 22:04:14 +00:00
(daxvel * (sintable[(angdif + 512) & 2047])) >> 14,
(daxvel * (sintable[angdif & 2047])) >> 14, g_sp->zvel, CLIPMASK0);
}
if (a)
{
if (sector[g_sp->sectnum].ceilingstat & 1)
g_sp->shade += (sector[g_sp->sectnum].ceilingshade - g_sp->shade) >> 1;
else g_sp->shade += (sector[g_sp->sectnum].floorshade - g_sp->shade) >> 1;
if (sector[g_sp->sectnum].floorpicnum == MIRROR)
deletesprite(g_i);
}
}
- safety commit
2020-05-14 07:07:07 +00:00
void fall_d(int g_i, int g_p)
{
- fall_common and its fallspecial subfunction.
2020-10-22 16:51:20 +00:00
fall_common(&hittype[g_i], 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;
}
void respawnhitag_d(spritetype* g_sp)
{
switch (g_sp->picnum)
{
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:
if (g_sp->yvel) fi.operaterespawns(g_sp->yvel);
break;
default:
if (g_sp->hitag >= 0) fi.operaterespawns(g_sp->hitag);
break;
}
}
void checktimetosleep_d(int g_i)
{
auto g_sp = &sprite[g_i];
if (g_sp->statnum == 6)
{
switch (g_sp->picnum)
{
case RUBBERCAN:
case EXPLODINGBARREL:
case WOODENHORSE:
case HORSEONSIDE:
case CANWITHSOMETHING:
case FIREBARREL:
case NUKEBARREL:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case TRIPBOMB:
case EGG:
if (hittype[g_i].timetosleep > 1)
hittype[g_i].timetosleep--;
else if (hittype[g_i].timetosleep == 1)
changespritestat(g_i, 2);
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
movefta_d(); //ST 2
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