raze/source/games/duke/src/actors_d.cpp

4086 lines
88 KiB
C++
Raw Normal View History

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.
This file contains parts of DukeGDX by Alexander Makarov-[M210] (m210-2007@mail.ru)
2020-05-07 12:55:04 +00:00
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "global.h"
#include "names_d.h"
#include "serializer.h"
#include "dukeactor.h"
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;
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;
2020-10-22 17:08:10 +00:00
int length = arc.ArraySize() / 2;
int key;
FireProj value;
for (int i = 0; i < length; i++)
{
2020-10-22 17:08:10 +00:00
arc(nullptr, key);
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();
}
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool ceilingspace_d(sectortype* sectp)
2020-05-07 12:55:04 +00:00
{
if (sectp && (sectp->ceilingstat&1) && sectp->ceilingpal == 0)
2020-05-07 12:55:04 +00:00
{
switch(sectp->ceilingpicnum)
2020-05-07 12:55:04 +00:00
{
case MOONSKY1:
case BIGORBIT1:
return 1;
2020-05-07 12:55:04 +00:00
}
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool floorspace_d(sectortype* sectp)
2020-05-07 12:55:04 +00:00
{
if (sectp && (sectp->floorstat&1) && sectp->ceilingpal == 0)
2020-05-07 12:55:04 +00:00
{
switch(sectp->floorpicnum)
2020-05-07 12:55:04 +00:00
{
case MOONSKY1:
case BIGORBIT1:
return 1;
2020-05-07 12:55:04 +00:00
}
}
return 0;
}
2020-05-16 10:47:01 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 17:08:10 +00:00
void check_fta_sounds_d(DDukeActor* actor)
2020-05-16 10:47:01 +00:00
{
if (actor->s->extra > 0) switch (actor->s->picnum)
2020-05-16 10:47:01 +00:00
{
case LIZTROOPONTOILET:
case LIZTROOPJUSTSIT:
case LIZTROOPSHOOT:
case LIZTROOPJETPACK:
case LIZTROOPDUCKING:
case LIZTROOPRUNNING:
case LIZTROOP:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(PRED_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case LIZMAN:
case LIZMANSPITTING:
case LIZMANFEEDING:
case LIZMANJUMP:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(CAPT_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case PIGCOP:
case PIGCOPDIVE:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(PIG_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case RECON:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(RECO_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case DRONE:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(DRON_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case COMMANDER:
case COMMANDERSTAYPUT:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(COMM_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case ORGANTIC:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(TURR_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case OCTABRAIN:
case OCTABRAINSTAYPUT:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(OCTA_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
case BOSS1:
S_PlaySound(BOS1_RECOG);
2020-05-16 10:47:01 +00:00
break;
case BOSS2:
if (actor->s->pal == 1)
S_PlaySound(BOS2_RECOG);
else S_PlaySound(WHIPYOURASS);
2020-05-16 10:47:01 +00:00
break;
case BOSS3:
if (actor->s->pal == 1)
S_PlaySound(BOS3_RECOG);
else S_PlaySound(RIPHEADNECK);
2020-05-16 10:47:01 +00:00
break;
case BOSS4:
case BOSS4STAYPUT:
if (actor->s->pal == 1)
S_PlaySound(BOS4_RECOG);
S_PlaySound(BOSS4_FIRSTSEE);
2020-05-16 10:47:01 +00:00
break;
case GREENSLIME:
2020-10-22 17:08:10 +00:00
S_PlayActorSound(SLIM_RECOG, actor);
2020-05-16 10:47:01 +00:00
break;
}
}
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void addweapon_d(struct player_struct *p, int weapon)
2020-05-07 12:55:04 +00:00
{
if ( p->gotweapon[weapon] == 0 )
2020-05-07 12:55:04 +00:00
{
p->gotweapon[weapon] = true;
if (weapon == SHRINKER_WEAPON)
p->gotweapon[GROW_WEAPON] = true;
2020-05-07 12:55:04 +00:00
}
p->random_club_frame = 0;
if (p->holster_weapon == 0)
{
p->weapon_pos = -1;
p->last_weapon = p->curr_weapon;
}
else
{
p->weapon_pos = 10;
p->holster_weapon = 0;
p->last_weapon = -1;
}
p->okickback_pic = p->kickback_pic = 0;
2020-05-07 12:55:04 +00:00
#ifdef EDUKE
if(p->curr_weapon != weapon)
2020-05-07 12:55:04 +00:00
{
int snum;
2020-10-22 17:12:48 +00:00
snum = p->GetPlayerNum();
2020-05-07 12:55:04 +00:00
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWeaponVarID,weapon, snum, p->GetActor());
2020-05-07 12:55:04 +00:00
if (p->curr_weapon >= 0)
{
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWorksLikeVarID, aplWeaponWorksLike[weapon][snum], snum, p->GetActor());
2020-05-07 12:55:04 +00:00
}
else
{
2020-10-22 17:12:48 +00:00
SetGameVarID(g_iWorksLikeVarID, -1, snum, p->GetActor());
2020-05-07 12:55:04 +00:00
}
2020-05-13 15:39:30 +00:00
SetGameVarID(g_iReturnVarID, 0, snum, -1);
OnEvent(EVENT_CHANGEWEAPON, snum, p->GetActor(), -1);
if (GetGameVarID(g_iReturnVarID, nullptr, snum) == 0)
2020-05-07 12:55:04 +00:00
{
p->curr_weapon = weapon;
2020-05-07 12:55:04 +00:00
}
}
#else
p->curr_weapon = weapon;
2020-05-07 12:55:04 +00:00
#endif
p->wantweaponfire = -1;
2020-05-07 12:55:04 +00:00
switch (weapon)
{
case KNEE_WEAPON:
case TRIPBOMB_WEAPON:
case HANDREMOTE_WEAPON:
case HANDBOMB_WEAPON:
2020-05-07 12:55:04 +00:00
break;
case SHOTGUN_WEAPON:
2020-10-22 17:12:48 +00:00
S_PlayActorSound(SHOTGUN_COCK, p->GetActor());
2020-05-07 12:55:04 +00:00
break;
case PISTOL_WEAPON:
2020-10-22 17:12:48 +00:00
S_PlayActorSound(INSERT_CLIP, p->GetActor());
2020-05-07 12:55:04 +00:00
break;
default:
2020-10-22 17:12:48 +00:00
S_PlayActorSound(SELECT_WEAPON, p->GetActor());
2020-05-07 12:55:04 +00:00
break;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 17:12:48 +00:00
bool ifsquished(DDukeActor* actor, int p)
2020-05-07 12:55:04 +00:00
{
if (isRR()) return false; // this function is a no-op in RR's source.
auto spri = actor->s;
2020-05-07 12:55:04 +00:00
bool squishme = false;
if (spri->picnum == APLAYER && ud.clipping)
2020-05-07 12:55:04 +00:00
return false;
auto sectp = spri->sector();
int floorceildist = sectp->floorz - sectp->ceilingz;
2020-05-07 12:55:04 +00:00
if (sectp->lotag != ST_23_SWINGING_DOOR)
2020-05-07 12:55:04 +00:00
{
if (spri->pal == 1)
squishme = floorceildist < (32 << 8) && (sectp->lotag & 32768) == 0;
2020-05-07 12:55:04 +00:00
else
squishme = floorceildist < (12 << 8);
}
if (squishme)
{
FTA(QUOTE_SQUISHED, &ps[p]);
2020-10-22 17:12:48 +00:00
if (badguy(actor))
spri->xvel = 0;
2020-05-07 12:55:04 +00:00
if (spri->pal == 1)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:12:48 +00:00
actor->picnum = SHOTSPARK1;
actor->extra = 1;
2020-05-07 12:55:04 +00:00
return false;
}
return true;
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int hp4)
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 };
2021-11-15 23:19:34 +00:00
auto spri = actor->s;
2020-10-12 19:30:12 +00:00
if(spri->picnum != SHRINKSPARK && !(spri->picnum == RPG && spri->xrepeat < 11))
2020-05-07 12:55:04 +00:00
{
BFSSectorSearch search(spri->sector());
2021-11-15 23:19:34 +00:00
while (auto dasectp = search.GetNext())
2020-05-07 12:55:04 +00:00
{
if (((dasectp->ceilingz - spri->z) >> 8) < r)
2020-05-07 12:55:04 +00:00
{
auto wal = dasectp->firstWall();
int d = abs(wal->x - spri->x) + abs(wal->y - spri->y);
2020-05-07 12:55:04 +00:00
if (d < r)
fi.checkhitceiling(dasectp);
2020-05-07 12:55:04 +00:00
else
{
auto thirdpoint = wal->point2Wall()->point2Wall();
d = abs(thirdpoint->x - spri->x) + abs(thirdpoint->y - spri->y);
2020-05-07 12:55:04 +00:00
if (d < r)
fi.checkhitceiling(dasectp);
2020-05-07 12:55:04 +00:00
}
}
for (auto& wal : wallsofsector(dasectp))
{
if ((abs(wal.x - spri->x) + abs(wal.y - spri->y)) < r)
2020-05-07 12:55:04 +00:00
{
if (wal.twoSided())
2020-05-07 12:55:04 +00:00
{
search.Add(wal.nextSector());
2020-05-07 12:55:04 +00:00
}
int x1 = (((wal.x + wal.point2Wall()->x) >> 1) + spri->x) >> 1;
int y1 = (((wal.y + wal.point2Wall()->y) >> 1) + spri->y) >> 1;
int sect;
2020-05-07 12:55:04 +00:00
updatesector(x1, y1, &sect);
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))
fi.checkhitwall(actor, &wal, wal.x, wal.y, spri->z, spri->picnum);
2020-05-07 12:55:04 +00:00
}
}
}
2021-11-15 23:19:34 +00:00
}
2020-10-12 19:30:12 +00:00
int q = -(16 << 8) + (krand() & ((32 << 8) - 1));
2020-10-12 19:30:12 +00:00
auto Owner = actor->GetOwner();
for (int x = 0; x < 7; x++)
2020-05-07 12:55:04 +00:00
{
DukeStatIterator itj(statlist[x]);
while (auto act2 = itj.Next())
2020-05-07 12:55:04 +00:00
{
auto spri2 = act2->s;
if (isWorldTour() && Owner)
2020-05-07 12:55:04 +00:00
{
if (Owner->s->picnum == APLAYER && spri2->picnum == APLAYER && ud.coop != 0 && ud.ffire == 0 && Owner != act2)
2020-05-14 22:32:11 +00:00
{
2020-05-07 12:55:04 +00:00
continue;
2020-05-14 22:32:11 +00:00
}
2020-10-12 19:30:12 +00:00
if (spri->picnum == FLAMETHROWERFLAME && ((Owner->s->picnum == FIREFLY && spri2->picnum == FIREFLY) || (Owner->s->picnum == BOSS5 && spri2->picnum == BOSS5)))
2020-05-14 22:32:11 +00:00
{
2020-05-07 12:55:04 +00:00
continue;
2020-05-14 22:32:11 +00:00
}
2020-05-07 12:55:04 +00:00
}
2020-10-12 19:30:12 +00:00
2020-10-24 20:41:14 +00:00
if (x == 0 || x >= 5 || AFLAMABLE(spri2->picnum))
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
if (spri->picnum != SHRINKSPARK || (spri2->cstat & 257))
if (dist(actor, act2) < r)
2020-05-07 12:55:04 +00:00
{
if (badguy(act2) && !cansee(spri2->x, spri2->y, spri2->z + q, spri2->sectnum, spri->x, spri->y, spri->z + q, spri->sectnum))
2020-10-12 19:30:12 +00:00
continue;
fi.checkhitsprite(act2, actor);
2020-05-07 12:55:04 +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))
2020-05-07 12:55:04 +00:00
{
if (spri->picnum == SHRINKSPARK && spri2->picnum != SHARK && (act2 == Owner || spri2->xrepeat < 24))
2020-05-07 12:55:04 +00:00
{
continue;
}
if (spri->picnum == MORTER && act2 == Owner)
{
continue;
}
2020-10-12 19:30:12 +00:00
if (spri2->picnum == APLAYER) spri2->z -= gs.playerheight;
int d = dist(actor, act2);
if (spri2->picnum == APLAYER) spri2->z += gs.playerheight;
2020-10-12 19:30:12 +00:00
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))
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
act2->ang = getangle(spri2->x - spri->x, spri2->y - spri->y);
2020-10-12 19:30:12 +00:00
2020-10-24 20:41:14 +00:00
if (spri->picnum == RPG && spri2->extra > 0)
act2->picnum = RPG;
else if (!isWorldTour())
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
if (spri->picnum == SHRINKSPARK)
act2->picnum = SHRINKSPARK;
else act2->picnum = RADIUSEXPLOSION;
2020-05-07 12:55:04 +00:00
}
else
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
if (spri->picnum == SHRINKSPARK || spri->picnum == FLAMETHROWERFLAME)
act2->picnum = spri->picnum;
else if (spri->picnum != FIREBALL || !Owner || Owner->s->picnum != APLAYER)
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
if (spri->picnum == LAVAPOOL)
act2->picnum = FLAMETHROWERFLAME;
else
2020-10-24 20:41:14 +00:00
act2->picnum = RADIUSEXPLOSION;
2020-05-07 12:55:04 +00:00
}
else
2020-10-24 20:41:14 +00:00
act2->picnum = FLAMETHROWERFLAME;
}
2020-10-12 19:30:12 +00:00
2020-10-24 20:41:14 +00:00
if (spri->picnum != SHRINKSPARK && (!isWorldTour() || spri->picnum != LAVAPOOL))
{
2020-05-07 12:55:04 +00:00
if (d < r / 3)
{
if (hp4 == hp3) hp4++;
2020-10-24 20:41:14 +00:00
act2->extra = hp3 + (krand() % (hp4 - hp3));
2020-05-07 12:55:04 +00:00
}
else if (d < 2 * r / 3)
{
if (hp3 == hp2) hp3++;
2020-10-24 20:41:14 +00:00
act2->extra = hp2 + (krand() % (hp3 - hp2));
2020-05-07 12:55:04 +00:00
}
else if (d < r)
{
if (hp2 == hp1) hp2++;
2020-10-24 20:41:14 +00:00
act2->extra = hp1 + (krand() % (hp2 - hp1));
2020-05-07 12:55:04 +00:00
}
2020-10-12 19:30:12 +00:00
if (spri2->picnum != TANK && spri2->picnum != ROTATEGUN && spri2->picnum != RECON && !bossguy(act2))
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
if (spri2->xvel < 0) spri2->xvel = 0;
spri2->xvel += (spri->extra << 2);
2020-05-07 12:55:04 +00:00
}
2020-10-12 19:30:12 +00:00
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)
fi.checkhitsprite(act2, actor);
}
2020-10-24 20:41:14 +00:00
else if (spri->extra == 0) act2->extra = 0;
2020-10-12 19:30:12 +00:00
if (spri2->picnum != RADIUSEXPLOSION && Owner && Owner->s->statnum < MAXSTATUS)
{
2020-10-24 20:41:14 +00:00
if (spri2->picnum == APLAYER)
2020-05-07 12:55:04 +00:00
{
int p = spri2->yvel;
2020-10-12 19:30:12 +00:00
if (isWorldTour() && act2->picnum == FLAMETHROWERFLAME && Owner->s->picnum == APLAYER)
2020-05-07 12:55:04 +00:00
{
2020-10-24 20:41:14 +00:00
ps[p].numloogs = -1 - spri->yvel;
}
2020-10-12 19:30:12 +00:00
2020-11-02 23:20:51 +00:00
if (ps[p].newOwner != nullptr)
{
clearcamera(&ps[p]);
2020-05-07 12:55:04 +00:00
}
}
act2->SetHitOwner(actor->GetOwner());
2020-05-07 12:55:04 +00:00
}
}
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, unsigned int cliptype, Collision &result)
2020-05-07 12:55:04 +00:00
{
int clipdist;
int dasectnum;
2020-05-07 12:55:04 +00:00
auto spri = actor->s;
int bg = badguy(actor);
2020-05-07 12:55:04 +00:00
if (spri->statnum == 5 || (bg && spri->xrepeat < 4))
2020-05-07 12:55:04 +00:00
{
spri->x += (xchange * TICSPERFRAME) >> 2;
spri->y += (ychange * TICSPERFRAME) >> 2;
spri->z += (zchange * TICSPERFRAME) >> 2;
2020-05-07 12:55:04 +00:00
if (bg)
setsprite(actor, spri->x, spri->y, spri->z);
return result.setNone();
2020-05-07 12:55:04 +00:00
}
dasectnum = spri->sectnum;
auto dasectp = spri->sector();
2020-05-07 12:55:04 +00:00
vec3_t pos = spri->pos;
pos.z -= ((tileHeight(spri->picnum) * spri->yrepeat) << 1);
2020-05-07 12:55:04 +00:00
if (bg)
{
if (spri->xrepeat > 60)
clipmove_ex(&pos, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 1024, (4 << 8), (4 << 8), cliptype, result);
2020-05-07 12:55:04 +00:00
else
{
if (spri->picnum == LIZMAN)
clipdist = 292;
else if (actorflag(actor, SFLAG_BADGUY))
clipdist = spri->clipdist << 2;
2020-05-07 12:55:04 +00:00
else
clipdist = 192;
2020-05-07 12:55:04 +00:00
clipmove_ex(&pos, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), clipdist, (4 << 8), (4 << 8), cliptype, result);
2020-05-07 12:55:04 +00:00
}
// conditional code from hell...
if (dasectnum < 0 || (dasectnum >= 0 &&
2021-11-18 19:55:22 +00:00
((actor->actorstayput != nullptr && actor->actorstayput != dasectp) ||
((spri->picnum == BOSS2) && spri->pal == 0 && dasectp->lotag != 3) ||
((spri->picnum == BOSS1 || spri->picnum == BOSS2) && dasectp->lotag == ST_1_ABOVE_WATER) ||
(dasectp->lotag == ST_1_ABOVE_WATER && (spri->picnum == LIZMAN || (spri->picnum == LIZTROOP && spri->zvel == 0)))
))
)
2020-05-07 12:55:04 +00:00
{
if (dasectp->lotag == ST_1_ABOVE_WATER && spri->picnum == LIZMAN)
spri->ang = (krand()&2047);
else if ((actor->temp_data[0]&3) == 1 && spri->picnum != COMMANDER)
spri->ang = (krand()&2047);
setsprite(actor,spri->pos);
2020-05-07 12:55:04 +00:00
if (dasectnum < 0) dasectnum = 0;
return result.setSector(dasectnum);
2020-05-07 12:55:04 +00:00
}
if ((result.type == kHitWall || result.type == kHitSprite) && (actor->cgg == 0)) spri->ang += 768;
2020-05-07 12:55:04 +00:00
}
else
{
if (spri->statnum == STAT_PROJECTILE)
clipmove_ex(&pos, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 8, (4 << 8), (4 << 8), cliptype, result);
2020-05-07 12:55:04 +00:00
else
clipmove_ex(&pos, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), (int)(spri->clipdist << 2), (4 << 8), (4 << 8), cliptype, result);
2020-05-07 12:55:04 +00:00
}
spri->x = pos.x;
spri->y = pos.y;
2020-05-07 12:55:04 +00:00
if (dasectnum >= 0)
if ((dasectnum != spri->sectnum))
2021-08-27 14:38:53 +00:00
changeactorsect(actor, dasectnum);
int daz = spri->z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
spri->z = daz;
else if (result.type == kHitNone)
return result.setSector(dasectnum);
2020-05-07 12:55:04 +00:00
return result.type;
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
2020-05-07 12:55:04 +00:00
//
//---------------------------------------------------------------------------
void lotsofmoney_d(DDukeActor *actor, int n)
2020-05-07 12:55:04 +00:00
{
lotsofstuff(actor, n, MONEY);
2020-05-07 12:55:04 +00:00
}
void lotsofmail_d(DDukeActor *actor, int n)
2020-05-07 12:55:04 +00:00
{
lotsofstuff(actor, n, MAIL);
2020-05-07 12:55:04 +00:00
}
void lotsofpaper_d(DDukeActor *actor, int n)
2020-05-07 12:55:04 +00:00
{
lotsofstuff(actor, n, PAPER);
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void guts_d(DDukeActor* actor, int gtype, int n, int p)
2020-05-07 12:55:04 +00:00
{
auto s = actor->s;
2020-05-07 12:55:04 +00:00
int gutz, floorz;
int j;
2020-05-07 12:55:04 +00:00
int sx, sy;
uint8_t pal;
2020-10-22 17:21:21 +00:00
if (badguy(actor) && s->xrepeat < 16)
2020-05-07 12:55:04 +00:00
sx = sy = 8;
else sx = sy = 32;
gutz = s->z - (8 << 8);
floorz = getflorzofslopeptr(s->sector(), s->x, s->y);
2020-05-07 12:55:04 +00:00
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
gutz += gs.actorinfo[s->picnum].gutsoffset;
2020-05-07 12:55:04 +00:00
2020-10-22 17:21:21 +00:00
if (badguy(actor) && s->pal == 6)
2020-05-07 12:55:04 +00:00
pal = 6;
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;
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???
2021-11-18 18:04:00 +00:00
auto spawned = EGS(s->sector(), 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)
2020-05-07 12:55:04 +00:00
{
if (spawned->s->picnum == JIBS2)
{
spawned->s->xrepeat >>= 2;
spawned->s->yrepeat >>= 2;
}
if (pal != 0)
spawned->s->pal = pal;
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
2020-05-07 12:55:04 +00:00
//
//---------------------------------------------------------------------------
void movefta_d(void)
2020-05-07 12:55:04 +00:00
{
int x, px, py, sx, sy;
int p;
int psect, ssect;
2020-10-22 17:27:59 +00:00
int j;
2020-05-07 12:55:04 +00:00
2020-10-22 17:27:59 +00:00
DukeStatIterator iti(STAT_ZOMBIEACTOR);
2020-05-07 12:55:04 +00:00
2020-10-22 17:27:59 +00:00
while (auto act = iti.Next())
{
auto s = act->s;
2020-10-22 17:27:59 +00:00
p = findplayer(act, &x);
2020-05-07 12:55:04 +00:00
ssect = psect = s->sectnum;
2020-10-22 17:27:59 +00:00
auto pa = ps[p].GetActor();
if (pa->s->extra > 0)
2020-05-07 12:55:04 +00:00
{
if (x < 30000)
{
2020-10-22 17:27:59 +00:00
act->timetosleep++;
if (act->timetosleep >= (x >> 8))
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:27:59 +00:00
if (badguy(act))
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;
}
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);
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);
}
if (j) switch(s->picnum)
2020-05-07 12:55:04 +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 (s->sector()->ceilingstat&1)
s->shade = s->sector()->ceilingshade;
else s->shade = s->sector()->floorshade;
2020-05-07 12:55:04 +00:00
2020-10-22 17:27:59 +00:00
act->timetosleep = 0;
changeactorstat(act, STAT_STANDABLE);
break;
default:
2020-10-22 17:27:59 +00:00
act->timetosleep = 0;
check_fta_sounds_d(act);
changeactorstat(act, STAT_ACTOR);
break;
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:27:59 +00:00
else act->timetosleep = 0;
2020-05-07 12:55:04 +00:00
}
}
2020-10-22 17:27:59 +00:00
if (badguy(act))
2020-05-07 12:55:04 +00:00
{
if (s->sector()->ceilingstat & 1)
s->shade = s->sector()->ceilingshade;
else s->shade = s->sector()->floorshade;
2020-05-07 12:55:04 +00:00
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 17:27:59 +00:00
DDukeActor* ifhitsectors_d(int sectnum)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:27:59 +00:00
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
2020-05-07 12:55:04 +00:00
{
if (a1->s->picnum == EXPLOSION2 && sectnum == a1->s->sectnum)
2020-10-22 17:27:59 +00:00
return a1;
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:27:59 +00:00
return nullptr;
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int ifhitbyweapon_d(DDukeActor *actor)
2020-05-07 12:55:04 +00:00
{
int p;
auto spri = actor->s;
auto hitowner = actor->GetHitOwner();
2020-05-07 12:55:04 +00:00
if (actor->extra >= 0)
2020-05-07 12:55:04 +00:00
{
if (spri->extra >= 0)
2020-05-07 12:55:04 +00:00
{
if (spri->picnum == APLAYER)
2020-05-07 12:55:04 +00:00
{
if (ud.god && actor->picnum != SHRINKSPARK) return -1;
2020-05-07 12:55:04 +00:00
p = spri->yvel;
if (hitowner &&
hitowner->s->picnum == APLAYER &&
2020-05-07 12:55:04 +00:00
ud.coop == 1 &&
ud.ffire == 0)
return -1;
spri->extra -= actor->extra;
2020-05-07 12:55:04 +00:00
if (hitowner)
2020-05-07 12:55:04 +00:00
{
if (spri->extra <= 0 && actor->picnum != FREEZEBLAST)
2020-05-07 12:55:04 +00:00
{
spri->extra = 0;
2020-05-07 12:55:04 +00:00
ps[p].wackedbyactor = hitowner;
2020-05-07 12:55:04 +00:00
if (hitowner->s->picnum == APLAYER && p != hitowner->PlayerIndex())
2020-05-07 12:55:04 +00:00
{
ps[p].frag_ps = hitowner->PlayerIndex();
2020-05-07 12:55:04 +00:00
}
actor->SetHitOwner(ps[p].GetActor());
2020-05-07 12:55:04 +00:00
}
}
switch(actor->picnum)
{
case RADIUSEXPLOSION:
case RPG:
case HYDRENT:
case HEAVYHBOMB:
case SEENINE:
case OOZFILTER:
case EXPLODINGBARREL:
ps[p].posxv += actor->extra * bcos(actor->ang, 2);
ps[p].posyv += actor->extra * bsin(actor->ang, 2);
break;
default:
ps[p].posxv += actor->extra * bcos(actor->ang, 1);
ps[p].posyv += actor->extra * bsin(actor->ang, 1);
break;
}
2020-05-07 12:55:04 +00:00
}
else
{
if (actor->extra == 0)
if (actor->picnum == SHRINKSPARK && spri->xrepeat < 24)
2020-05-07 12:55:04 +00:00
return -1;
if (isWorldTour() && actor->picnum == FIREFLY && spri->xrepeat < 48)
2020-05-07 12:55:04 +00:00
{
if (actor->picnum != RADIUSEXPLOSION && actor->picnum != RPG)
2020-05-07 12:55:04 +00:00
return -1;
}
spri->extra -= actor->extra;
auto Owner = actor->GetOwner();
if (spri->picnum != RECON && Owner && Owner->s->statnum < MAXSTATUS)
actor->SetOwner(hitowner);
2020-05-07 12:55:04 +00:00
}
actor->extra = -1;
return actor->picnum;
2020-05-07 12:55:04 +00:00
}
}
if (ud.multimode < 2 || !isWorldTour()
|| actor->picnum != FLAMETHROWERFLAME
|| actor->extra >= 0
|| spri->extra > 0
|| spri->picnum != APLAYER
|| ps[actor->PlayerIndex()].numloogs > 0
|| hitowner == nullptr)
2020-05-07 12:55:04 +00:00
{
actor->extra = -1;
2020-05-07 12:55:04 +00:00
return -1;
}
else
2020-05-07 12:55:04 +00:00
{
p = actor->PlayerIndex();
spri->extra = 0;
ps[p].wackedbyactor = hitowner;
2020-05-07 12:55:04 +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...
2020-05-07 12:55:04 +00:00
actor->SetHitOwner(ps[p].GetActor());
actor->extra = -1;
2020-05-07 12:55:04 +00:00
return FLAMETHROWERFLAME;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void movefallers_d(void)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:31:06 +00:00
int j, x;
2020-05-07 12:55:04 +00:00
2020-10-22 17:31:06 +00:00
DukeStatIterator iti(STAT_FALLER);
while (auto act = iti.Next())
2020-05-07 12:55:04 +00:00
{
auto s = act->s;
auto sectp = s->sector();
2020-05-07 12:55:04 +00:00
2020-10-22 17:31:06 +00:00
if (act->temp_data[0] == 0)
2020-05-07 12:55:04 +00:00
{
s->z -= (16 << 8);
2020-10-22 17:31:06 +00:00
act->temp_data[1] = s->ang;
2020-05-07 12:55:04 +00:00
x = s->extra;
2020-10-22 17:31:06 +00:00
j = fi.ifhitbyweapon(act);
if (j >= 0)
2020-05-07 12:55:04 +00:00
{
if (j == FIREEXT || j == RPG || j == RADIUSEXPLOSION || j == SEENINE || j == OOZFILTER)
2020-05-07 12:55:04 +00:00
{
if (s->extra <= 0)
{
2020-10-22 17:31:06 +00:00
act->temp_data[0] = 1;
DukeStatIterator itj(STAT_FALLER);
while (auto a2 = itj.Next())
2020-05-07 12:55:04 +00:00
{
if (a2->s->hitag == s->hitag)
2020-05-07 12:55:04 +00:00
{
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;
2020-05-07 12:55:04 +00:00
}
}
}
}
else
{
2020-10-22 17:31:06 +00:00
act->extra = 0;
2020-05-07 12:55:04 +00:00
s->extra = x;
}
}
2020-10-22 17:31:06 +00:00
s->ang = act->temp_data[1];
2020-05-07 12:55:04 +00:00
s->z += (16 << 8);
}
2020-10-22 17:31:06 +00:00
else if (act->temp_data[0] == 1)
2020-05-07 12:55:04 +00:00
{
if (s->lotag > 0)
{
s->lotag-=3;
if (s->lotag <= 0)
2020-05-07 12:55:04 +00:00
{
s->xvel = (32 + (krand() & 63));
s->zvel = -(1024 + (krand() & 1023));
}
}
else
{
if (s->xvel > 0)
{
s->xvel -= 8;
2020-10-22 17:31:06 +00:00
ssp(act, CLIPMASK0);
2020-05-07 12:55:04 +00:00
}
if (fi.floorspace(s->sector())) x = 0;
2020-05-07 12:55:04 +00:00
else
{
if (fi.ceilingspace(s->sector()))
x = gs.gravity / 6;
2020-05-07 12:55:04 +00:00
else
x = gs.gravity;
2020-05-07 12:55:04 +00:00
}
if (s->z < (sectp->floorz - FOURSLEIGHT))
2020-05-07 12:55:04 +00:00
{
s->zvel += x;
if (s->zvel > 6144)
s->zvel = 6144;
s->z += s->zvel;
}
if ((sectp->floorz - s->z) < (16 << 8))
2020-05-07 12:55:04 +00:00
{
j = 1 + (krand() & 7);
2020-10-22 17:31:06 +00:00
for (x = 0; x < j; x++) RANDOMSCRAP(act);
deletesprite(act);
2020-05-07 12:55:04 +00:00
}
}
}
}
}
2020-05-07 12:55:04 +00:00
//---------------------------------------------------------------------------
//
// split out of movestandables
//
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
2020-10-22 17:37:13 +00:00
static void movetripbomb(DDukeActor *actor)
2020-05-07 12:55:04 +00:00
{
auto s = actor->s;
int j, x;
int lTripBombControl = GetGameVar("TRIPBOMB_CONTROL", TRIPBOMB_TRIPWIRE, nullptr, -1);
if (lTripBombControl & TRIPBOMB_TIMER)
2020-05-07 12:55:04 +00:00
{
// we're on a timer....
if (s->extra >= 0)
2020-05-07 12:55:04 +00:00
{
s->extra--;
if (s->extra == 0)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 16;
S_PlayActorSound(LASERTRIP_ARMING, actor);
2020-05-07 12:55:04 +00:00
}
}
}
2020-10-22 17:37:13 +00:00
if (actor->temp_data[2] > 0)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
actor->temp_data[2]--;
if (actor->temp_data[2] == 8)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
S_PlayActorSound(LASERTRIP_EXPLODE, actor);
for (j = 0; j < 5; j++) RANDOMSCRAP(actor);
2020-05-07 12:55:04 +00:00
x = s->extra;
fi.hitradius(actor, gs.tripbombblastradius, x >> 2, x >> 1, x - (x >> 2), x);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
auto spawned = spawn(actor, EXPLOSION2);
if (spawned)
{
spawned->s->ang = s->ang;
spawned->s->xvel = 348;
ssp(spawned, CLIPMASK0);
}
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
2020-05-07 12:55:04 +00:00
{
if (a1->s->picnum == LASERLINE && s->hitag == a1->s->hitag)
a1->s->xrepeat = a1->s->yrepeat = 0;
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:37:13 +00:00
deletesprite(actor);
2020-05-07 12:55:04 +00:00
}
return;
}
else
{
x = s->extra;
s->extra = 1;
int16_t l = s->ang;
2020-10-22 17:37:13 +00:00
j = fi.ifhitbyweapon(actor);
2020-05-07 12:55:04 +00:00
if (j >= 0)
{
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 16;
2020-05-07 12:55:04 +00:00
}
s->extra = x;
s->ang = l;
}
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] < 32)
2020-05-07 12:55:04 +00:00
{
2020-10-23 15:44:45 +00:00
findplayer(actor, &x);
2020-10-22 17:37:13 +00:00
if (x > 768) actor->temp_data[0]++;
else if (actor->temp_data[0] > 16) actor->temp_data[0]++;
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] == 32)
2020-05-07 12:55:04 +00:00
{
int16_t l = s->ang;
2020-10-22 17:37:13 +00:00
s->ang = actor->temp_data[5];
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = s->x; actor->temp_data[4] = s->y;
s->x += bcos(actor->temp_data[5], -9);
s->y += bsin(actor->temp_data[5], -9);
2020-05-07 12:55:04 +00:00
s->z -= (3 << 8);
// Laser fix from EDuke32.
int const oldSectNum = s->sectnum;
int curSectNum = s->sectnum;
updatesectorneighbor(s->x, s->y, &curSectNum, 2048);
2021-08-27 14:38:53 +00:00
changeactorsect(actor, curSectNum);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
DDukeActor* hit;
x = hitasprite(actor, &hit);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
actor->lastvx = x;
2020-05-07 12:55:04 +00:00
s->ang = l;
if (lTripBombControl & TRIPBOMB_TRIPWIRE)
{
// we're on a trip wire
while (x > 0)
{
2020-10-22 17:37:13 +00:00
auto spawned = spawn(actor, LASERLINE);
if (spawned)
2020-05-07 12:55:04 +00:00
{
setsprite(spawned, spawned->s->pos);
spawned->s->hitag = s->hitag;
spawned->temp_data[1] = spawned->s->z;
if (x < 1024)
{
spawned->s->xrepeat = x >> 5;
break;
}
x -= 1024;
s->x += bcos(actor->temp_data[5], -4);
s->y += bsin(actor->temp_data[5], -4);
updatesectorneighbor(s->x, s->y, &curSectNum, 2048);
if (curSectNum == -1)
break;
changeactorsect(actor, curSectNum);
// this is a hack to work around the LASERLINE sprite's art tile offset
changeactorsect(spawned, curSectNum);
}
2020-05-07 12:55:04 +00:00
}
}
2020-10-22 17:37:13 +00:00
actor->temp_data[0]++;
s->x = actor->temp_data[3]; s->y = actor->temp_data[4];
2020-05-07 12:55:04 +00:00
s->z += (3 << 8);
2021-08-27 14:38:53 +00:00
changeactorsect(actor, oldSectNum);
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = 0;
if (hit && lTripBombControl & TRIPBOMB_TRIPWIRE)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 13;
S_PlayActorSound(LASERTRIP_ARMING, actor);
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:37:13 +00:00
else actor->temp_data[2] = 0;
2020-05-07 12:55:04 +00:00
}
2020-10-22 17:37:13 +00:00
if (actor->temp_data[0] == 33)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
actor->temp_data[1]++;
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
actor->temp_data[3] = s->x; actor->temp_data[4] = s->y;
s->x += bcos(actor->temp_data[5], -9);
s->y += bsin(actor->temp_data[5], -9);
2020-05-07 12:55:04 +00:00
s->z -= (3 << 8);
2020-10-22 17:37:13 +00:00
setsprite(actor, s->pos);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
x = hitasprite(actor, nullptr);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
s->x = actor->temp_data[3]; s->y = actor->temp_data[4];
2020-05-07 12:55:04 +00:00
s->z += (3 << 8);
2020-10-22 17:37:13 +00:00
setsprite(actor, s->x, s->y, s->z);
2020-05-07 12:55:04 +00:00
2020-10-22 17:37:13 +00:00
if (actor->lastvx != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:37:13 +00:00
actor->temp_data[2] = 13;
S_PlayActorSound(LASERTRIP_ARMING, actor);
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void movecrack(DDukeActor* actor)
2020-05-07 12:55:04 +00:00
{
auto s = actor->s;
int* t = &actor->temp_data[0];
2020-05-07 12:55:04 +00:00
if (s->hitag > 0)
{
t[0] = s->cstat;
t[1] = s->ang;
int j = fi.ifhitbyweapon(actor);
if (j == FIREEXT || j == RPG || j == RADIUSEXPLOSION || j == SEENINE || j == OOZFILTER)
2020-05-07 12:55:04 +00:00
{
DukeStatIterator it(STAT_STANDABLE);
while (auto a1 = it.Next())
2020-05-07 12:55:04 +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;
2020-05-07 12:55:04 +00:00
}
detonate(actor, EXPLOSION2);
2020-05-07 12:55:04 +00:00
}
else
{
s->cstat = t[0];
s->ang = t[1];
s->extra = 0;
}
}
}
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
static void movefireext(DDukeActor* actor)
2020-05-07 12:55:04 +00:00
{
int j = fi.ifhitbyweapon(actor);
2020-05-07 12:55:04 +00:00
if (j == -1) return;
for (int k = 0; k < 16; k++)
{
2021-11-18 18:04:00 +00:00
auto spawned = EGS(actor->s->sector(), 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);
if(spawned) spawned->s->pal = 2;
2020-05-07 12:55:04 +00:00
}
spawn(actor, EXPLOSION2);
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
S_PlayActorSound(GLASS_HEAVYBREAK, actor);
2020-05-07 12:55:04 +00:00
if (actor->s->hitag > 0)
2020-05-07 12:55:04 +00:00
{
DukeStatIterator it(STAT_STANDABLE);
while (auto a1 = it.Next())
2020-05-07 12:55:04 +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;
2020-05-07 12:55:04 +00:00
}
int x = actor->s->extra;
spawn(actor, EXPLOSION2);
fi.hitradius(actor, gs.pipebombblastradius, x >> 2, x - (x >> 1), x - (x >> 2), x);
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
detonate(actor, EXPLOSION2);
2020-05-07 12:55:04 +00:00
}
else
{
fi.hitradius(actor, gs.seenineblastradius, 10, 15, 20, 25);
deletesprite(actor);
2020-05-07 12:55:04 +00:00
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void moveviewscreen(DDukeActor* actor)
2020-05-07 12:55:04 +00:00
{
const int VIEWSCR_DIST = 8192; // was originally 2048, was increased to this by EDuke32 and RedNukem.
if (actor->s->xrepeat == 0) deletesprite(actor);
2020-05-07 12:55:04 +00:00
else
{
int x;
int p = findplayer(actor, &x);
2020-05-07 12:55:04 +00:00
x = dist(actor, ps[p].GetActor()); // the result from findplayer is not really useful.
if (x >= VIEWSCR_DIST && camsprite == actor)
2020-05-07 12:55:04 +00:00
{
2020-11-04 18:25:49 +00:00
camsprite = nullptr;
actor->s->yvel = 0;
actor->temp_data[0] = 0;
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
// Duke only
//
//---------------------------------------------------------------------------
2020-10-22 17:46:42 +00:00
static void movesidebolt(DDukeActor* actor)
2020-05-07 12:55:04 +00:00
{
auto s = actor->s;
2020-10-22 17:46:42 +00:00
int* t = &actor->temp_data[0];
2020-05-07 12:55:04 +00:00
int x;
auto sectp = s->sector();
2020-05-07 12:55:04 +00:00
findplayer(actor, &x);
2020-05-07 12:55:04 +00:00
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 ((krand() & 1) && sectp->floorpicnum == HURTRAIL)
2020-10-22 17:46:42 +00:00
S_PlayActorSound(SHORT_CIRCUIT, actor);
if (s->picnum == SIDEBOLT1 + 4) s->picnum = SIDEBOLT1;
2020-05-07 12:55:04 +00:00
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 17:46:42 +00:00
static void movebolt(DDukeActor *actor)
2020-05-07 12:55:04 +00:00
{
auto s = actor->s;
2020-10-22 17:46:42 +00:00
int* t = &actor->temp_data[0];
int x;
auto sectp = s->sector();
findplayer(actor, &x);
if (x > 20480) return;
if (t[3] == 0)
t[3] = sectp->floorshade;
CLEAR_THE_BOLT:
if (t[2])
{
t[2]--;
sectp->floorshade = 20;
sectp->ceilingshade = 20;
return;
}
if ((s->xrepeat | s->yrepeat) == 0)
2020-05-07 12:55:04 +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++;
2020-05-07 12:55:04 +00:00
int l = global_random & 7;
s->xrepeat = l + 8;
2020-05-07 12:55:04 +00:00
if (l & 1) s->cstat ^= 2;
if (s->picnum == (BOLT1+1) && (krand()&7) == 0 && sectp->floorpicnum == HURTRAIL)
2020-10-22 17:46:42 +00:00
S_PlayActorSound(SHORT_CIRCUIT,actor);
if (s->picnum==BOLT1+4) s->picnum=BOLT1;
if (s->picnum & 1)
{
sectp->floorshade = 0;
sectp->ceilingshade = 0;
}
else
{
sectp->floorshade = 20;
sectp->ceilingshade = 20;
2020-05-07 12:55:04 +00:00
}
}
//---------------------------------------------------------------------------
//
// this has been broken up into lots of smaller subfunctions
//
//---------------------------------------------------------------------------
void movestandables_d(void)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
DukeStatIterator it(STAT_STANDABLE);
while (auto act = it.Next())
2020-05-07 12:55:04 +00:00
{
int picnum = act->s->picnum;
2020-05-07 12:55:04 +00:00
if (!act->insector())
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
deletesprite(act);
2020-05-07 12:55:04 +00:00
continue;
}
if (picnum >= CRANE && picnum <= CRANE +3)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movecrane(act, CRANE);
2020-05-07 12:55:04 +00:00
}
else if (picnum >= WATERFOUNTAIN && picnum <= WATERFOUNTAIN + 3)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movefountain(act, WATERFOUNTAIN);
2020-05-07 12:55:04 +00:00
}
else if (AFLAMABLE(picnum))
{
2020-10-22 17:51:42 +00:00
moveflammable(act, TIRE, BOX, BLOODPOOL);
2020-05-07 12:55:04 +00:00
}
else if (picnum == TRIPBOMB)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movetripbomb(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum >= CRACK1 && picnum <= CRACK1 + 3)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movecrack(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum == FIREEXT)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movefireext(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum == OOZFILTER || picnum == SEENINE || picnum == SEENINEDEAD || picnum == (SEENINEDEAD + 1))
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
moveooz(act, SEENINE, SEENINEDEAD, OOZFILTER, EXPLOSION2);
2020-05-07 12:55:04 +00:00
}
else if (picnum == MASTERSWITCH)
{
2020-10-22 17:51:42 +00:00
movemasterswitch(act, SEENINE, OOZFILTER);
2020-05-07 12:55:04 +00:00
}
else if (picnum == VIEWSCREEN || picnum == VIEWSCREEN2)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
moveviewscreen(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum == TRASH)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movetrash(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum >= SIDEBOLT1 && picnum <= SIDEBOLT1 + 3)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movesidebolt(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum >= BOLT1 && picnum <= BOLT1 + 3)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movebolt(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum == WATERDRIP)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movewaterdrip(act, WATERDRIP);
2020-05-07 12:55:04 +00:00
}
else if (picnum == DOORSHOCK)
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movedoorshock(act);
2020-05-07 12:55:04 +00:00
}
else if (picnum == TOUCHPLATE)
{
2020-10-22 17:51:42 +00:00
movetouchplate(act, TOUCHPLATE);
2020-05-07 12:55:04 +00:00
}
else if (isIn(picnum, CANWITHSOMETHING, CANWITHSOMETHING2, CANWITHSOMETHING3, CANWITHSOMETHING4))
2020-05-07 12:55:04 +00:00
{
2020-10-22 17:51:42 +00:00
movecanwithsomething(act);
2020-05-07 12:55:04 +00:00
}
else if (isIn(picnum,
2020-05-07 12:55:04 +00:00
EXPLODINGBARREL,
WOODENHORSE,
HORSEONSIDE,
FLOORFLAME,
FIREBARREL,
FIREVASE,
NUKEBARREL,
NUKEBARRELDENTED,
NUKEBARRELLEAKED,
TOILETWATER,
RUBBERCAN,
STEAM,
CEILINGSTEAM,
WATERBUBBLEMAKER))
2020-05-07 12:55:04 +00:00
{
int x;
2020-10-23 15:44:45 +00:00
int p = findplayer(act, &x);
2020-10-22 17:51:42 +00:00
execute(act, p, x);
2020-05-07 12:55:04 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 17:59:38 +00:00
static bool movefireball(DDukeActor* actor)
{
auto s = actor->s;
2020-10-22 17:59:38 +00:00
auto Owner = actor->GetOwner();
if (s->sector()->lotag == 2)
{
2020-10-22 17:59:38 +00:00
deletesprite(actor);
return true;
}
if (!Owner || Owner->s->picnum != FIREBALL)
{
2020-10-22 17:59:38 +00:00
if (actor->temp_data[0] >= 1 && actor->temp_data[0] < 6)
{
2020-10-22 17:59:38 +00:00
float siz = 1.0f - (actor->temp_data[0] * 0.2f);
// This still needs work- it stores an actor reference in a general purpose integer field.
int trail = actor->temp_data[1];
auto ball = spawn(actor, FIREBALL);
if (ball)
{
auto spr = ball->s;
actor->temp_data[1] = ball->GetSpriteIndex();
spr->xvel = s->xvel;
spr->yvel = s->yvel;
spr->zvel = s->zvel;
if (actor->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 = (uint8_t)(s->xrepeat * siz);
spr->cstat = s->cstat;
spr->extra = 0;
FireProj proj = { spr->x, spr->y, spr->z, spr->xvel, spr->yvel, spr->zvel };
fire.Insert(ball->GetSpriteIndex(), proj);
changeactorstat(ball, STAT_PROJECTILE);
}
}
2020-10-22 17:59:38 +00:00
actor->temp_data[0]++;
}
if (s->zvel < 15000)
s->zvel += 200;
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 18:07:05 +00:00
static bool weaponhitsprite(DDukeActor* proj, DDukeActor *targ, bool fireball)
{
auto s = proj->s;
if (s->picnum == FREEZEBLAST && targ->s->pal == 1)
if (badguy(targ) || targ->s->picnum == APLAYER)
{
2020-10-22 18:07:05 +00:00
auto spawned = spawn(targ, TRANSPORTERSTAR);
if (spawned)
{
spawned->s->pal = 1;
spawned->s->xrepeat = 32;
spawned->s->yrepeat = 32;
}
2020-10-22 18:07:05 +00:00
deletesprite(proj);
return true;
}
if (!isWorldTour() || s->picnum != FIREBALL || fireball)
fi.checkhitsprite(targ, proj);
if (targ->s->picnum == APLAYER)
{
int p = targ->s->yvel;
2020-10-22 18:07:05 +00:00
auto Owner = proj->GetOwner();
if (ud.multimode >= 2 && fireball && Owner && Owner->s->picnum == APLAYER)
{
2020-10-22 18:07:05 +00:00
ps[p].numloogs = -1 - s->yvel;
}
2020-10-22 18:07:05 +00:00
S_PlayActorSound(PISTOL_BODYHIT, targ);
if (s->picnum == SPIT)
{
ps[p].horizon.addadjustment(32);
ps[p].sync.actions |= SB_CENTERVIEW;
if (ps[p].loogcnt == 0)
{
2020-10-22 18:07:05 +00:00
if (!S_CheckActorSoundPlaying(ps[p].GetActor(), DUKE_LONGTERM_PAIN))
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].GetActor());
2020-10-22 18:07:05 +00:00
int 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(DDukeActor *proj, walltype* wal, const vec3_t &oldpos)
{
auto s = proj->s;
if (s->picnum != RPG && s->picnum != FREEZEBLAST && s->picnum != SPIT &&
(!isWorldTour() || s->picnum != FIREBALL) &&
(wal->overpicnum == MIRROR || wal->picnum == MIRROR))
{
auto delta = wal->delta();
int k = getangle(delta.x, delta.y);
s->ang = ((k << 1) - s->ang) & 2047;
2020-10-22 18:07:05 +00:00
proj->SetOwner(proj);
spawn(proj, TRANSPORTERSTAR);
return true;
}
else
{
2020-10-22 18:07:05 +00:00
setsprite(proj, oldpos);
fi.checkhitwall(proj, wal, s->x, s->y, s->z, s->picnum);
if (s->picnum == FREEZEBLAST)
{
if (wal->overpicnum != MIRROR && wal->picnum != MIRROR)
{
s->extra >>= 1;
s->yvel--;
}
auto delta = wal->delta();
int k = getangle(delta.x, delta.y);
s->ang = ((k << 1) - s->ang) & 2047;
return true;
}
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 18:07:05 +00:00
static bool weaponhitsector(DDukeActor* proj, const vec3_t& oldpos, bool fireball)
{
auto s = proj->s;
2020-10-22 18:07:05 +00:00
setsprite(proj, oldpos);
if (s->zvel < 0)
{
if (s->sector()->ceilingstat & 1)
if (s->sector()->ceilingpal == 0)
{
2020-10-22 18:07:05 +00:00
deletesprite(proj);
return true;
}
fi.checkhitceiling(s->sector());
}
else if (fireball)
{
2020-10-22 18:07:05 +00:00
auto spawned = spawn(proj, LAVAPOOL);
if (spawned)
{
spawned->SetOwner(proj);
spawned->SetHitOwner(proj);
spawned->s->yvel = s->yvel;
}
2020-10-22 18:07:05 +00:00
deletesprite(proj);
return true;
}
if (s->picnum == FREEZEBLAST)
{
2020-10-22 18:07:05 +00:00
bounce(proj);
ssp(proj, CLIPMASK1);
s->extra >>= 1;
if (s->xrepeat > 8)
s->xrepeat -= 2;
if (s->yrepeat > 8)
s->yrepeat -= 2;
s->yvel--;
return true;
}
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 18:21:21 +00:00
static void weaponcommon_d(DDukeActor* proj)
2020-05-07 12:55:04 +00:00
{
auto s = proj->s;
if (s->picnum == COOLEXPLOSION1)
2020-10-25 06:21:33 +00:00
if (!S_CheckActorSoundPlaying(proj, WIERDSHOT_FLY))
2020-10-22 18:21:21 +00:00
S_PlayActorSound(WIERDSHOT_FLY, proj);
int k, ll;
2020-10-22 18:21:21 +00:00
vec3_t oldpos = s->pos;
if (s->picnum == RPG && s->sector()->lotag == 2)
{
k = s->xvel >> 1;
ll = s->zvel >> 1;
}
else
2020-05-07 12:55:04 +00:00
{
k = s->xvel;
ll = s->zvel;
}
2020-05-07 12:55:04 +00:00
2020-10-22 18:21:21 +00:00
getglobalz(proj);
2020-05-07 12:55:04 +00:00
switch (s->picnum)
{
case RPG:
if (proj->picnum != BOSS2 && s->xrepeat >= 10 && s->sector()->lotag != 2)
2020-05-07 12:55:04 +00:00
{
2020-10-22 18:21:21 +00:00
auto spawned = spawn(proj, SMALLSMOKE);
if (spawned) spawned->s->z += (1 << 8);
}
break;
2020-05-07 12:55:04 +00:00
case FIREBALL:
2020-10-22 18:21:21 +00:00
if (movefireball(proj)) return;
break;
}
Collision coll;
movesprite_ex(proj,
MulScale(k, bcos(s->ang), 14),
MulScale(k, bsin(s->ang), 14), ll, CLIPMASK1, coll);
2020-10-22 18:21:21 +00:00
if (s->picnum == RPG && proj->temp_actor != nullptr)
if (FindDistance2D(s->x - proj->temp_actor->s->x, s->y - proj->temp_actor->s->y) < 256)
coll.setSprite(proj->temp_actor);
2020-05-07 12:55:04 +00:00
if (!s->insector())
{
2020-10-22 18:21:21 +00:00
deletesprite(proj);
return;
}
2020-05-07 12:55:04 +00:00
if (coll.type != kHitSprite && s->picnum != FREEZEBLAST)
{
2020-10-22 18:21:21 +00:00
if (s->z < proj->ceilingz)
{
coll.setSector(s->sectnum);
s->zvel = -1;
}
else
if ((s->z > proj->floorz && s->sector()->lotag != 1) ||
(s->z > proj->floorz + (16 << 8) && s->sector()->lotag == 1))
2020-05-07 12:55:04 +00:00
{
coll.setSector(s->sectnum);
if (s->sector()->lotag != 1)
s->zvel = 1;
2020-05-07 12:55:04 +00:00
}
}
if (s->picnum == FIRELASER)
{
for (k = -3; k < 2; k++)
{
2021-11-18 18:04:00 +00:00
auto spawned = EGS(s->sector(),
s->x + MulScale(k, bcos(s->ang), 9),
s->y + MulScale(k, bsin(s->ang), 9),
s->z + ((k * Sgn(s->zvel)) * abs(s->zvel / 24)), FIRELASER, -40 + (k << 2),
2020-10-22 18:21:21 +00:00
s->xrepeat, s->yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (spawned)
{
spawned->s->cstat = 128;
spawned->s->pal = s->pal;
}
}
}
else if (s->picnum == SPIT) if (s->zvel < 6144)
s->zvel += gs.gravity - 112;
if (coll.type != 0)
{
if (s->picnum == COOLEXPLOSION1)
{
if (coll.type == kHitSprite && coll.actor->s->picnum != APLAYER)
2020-05-07 12:55:04 +00:00
{
return;
2020-05-07 12:55:04 +00:00
}
s->xvel = 0;
s->zvel = 0;
}
2020-05-07 12:55:04 +00:00
bool fireball = (isWorldTour() && s->picnum == FIREBALL && (!proj->GetOwner() || proj->GetOwner()->s->picnum != FIREBALL));
2020-05-07 12:55:04 +00:00
if (coll.type == kHitSprite)
{
if (weaponhitsprite(proj, coll.actor, fireball)) return;
}
else if (coll.type == kHitWall)
{
if (weaponhitwall(proj, coll.wall(), oldpos)) return;
}
else if (coll.type == kHitSector)
{
2020-10-22 18:21:21 +00:00
if (weaponhitsector(proj, oldpos, fireball)) return;
}
2020-05-07 12:55:04 +00:00
if (s->picnum != SPIT)
{
if (s->picnum == RPG)
{
// j is only needed for the hit type mask.
rpgexplode(proj, coll.type, oldpos, EXPLOSION2, EXPLOSION2BOT, -1, RPG_EXPLODE);
}
else if (s->picnum == SHRINKSPARK)
{
2020-10-22 18:21:21 +00:00
spawn(proj, SHRINKEREXPLOSION);
S_PlayActorSound(SHRINKER_HIT, proj);
fi.hitradius(proj, gs.shrinkerblastradius, 0, 0, 0, 0);
}
else if (s->picnum != COOLEXPLOSION1 && s->picnum != FREEZEBLAST && s->picnum != FIRELASER && (!isWorldTour() || s->picnum != FIREBALL))
{
2020-10-22 18:21:21 +00:00
auto k = spawn(proj, EXPLOSION2);
if (k)
2020-05-07 12:55:04 +00:00
{
k->s->xrepeat = k->s->yrepeat = s->xrepeat >> 1;
if (coll.type == kHitSector)
2020-05-07 12:55:04 +00:00
{
if (s->zvel < 0)
{
k->s->cstat |= 8; k->s->z += (72 << 8);
}
2020-05-07 12:55:04 +00:00
}
}
}
if (fireball)
2020-05-07 12:55:04 +00:00
{
2020-10-22 18:21:21 +00:00
auto spawned = spawn(proj, EXPLOSION2);
if (spawned) spawned->s->xrepeat = spawned->s->yrepeat = (short)(s->xrepeat >> 1);
}
}
if (s->picnum != COOLEXPLOSION1)
{
2020-10-22 18:21:21 +00:00
deletesprite(proj);
return;
}
}
if (s->picnum == COOLEXPLOSION1)
{
s->shade++;
if (s->shade >= 40)
{
2020-10-22 18:21:21 +00:00
deletesprite(proj);
return;
}
}
else if (s->picnum == RPG && s->sector()->lotag == 2 && s->xrepeat >= 10 && rnd(140))
2020-10-22 18:21:21 +00:00
spawn(proj, WATERBUBBLE);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void moveweapons_d(void)
{
2020-10-22 18:21:21 +00:00
DukeStatIterator it(STAT_PROJECTILE);
while (auto act = it.Next())
{
if (!act->insector())
{
2020-10-22 18:21:21 +00:00
deletesprite(act);
continue;
}
switch(act->s->picnum)
{
case RADIUSEXPLOSION:
case KNEE:
2020-10-22 18:21:21 +00:00
deletesprite(act);
continue;
case TONGUE:
2020-10-22 18:21:21 +00:00
movetongue(act, TONGUE, INNERJAW);
continue;
case FREEZEBLAST:
if (act->s->yvel < 1 || act->s->extra < 2 || (act->s->xvel|act->s->zvel) == 0)
{
2020-10-22 18:21:21 +00:00
auto spawned = spawn(act,TRANSPORTERSTAR);
if (spawned)
{
spawned->s->pal = 1;
spawned->s->xrepeat = 32;
spawned->s->yrepeat = 32;
}
2020-10-22 18:21:21 +00:00
deletesprite(act);
continue;
2020-05-07 12:55:04 +00:00
}
[[fallthrough]];
case FIREBALL:
// Twentieth Anniversary World Tour
if (act->s->picnum == FIREBALL && !isWorldTour()) break;
[[fallthrough]];
case SHRINKSPARK:
case RPG:
case FIRELASER:
case SPIT:
case COOLEXPLOSION1:
2020-10-22 18:21:21 +00:00
weaponcommon_d(act);
break;
2020-05-07 12:55:04 +00:00
case SHOTSPARK1:
{
int x;
2020-10-23 15:44:45 +00:00
int p = findplayer(act, &x);
2020-10-22 18:21:21 +00:00
execute(act, p, x);
break;
2020-05-07 12:55:04 +00:00
}
}
2020-05-07 12:55:04 +00:00
}
}
2020-05-07 22:03:51 +00:00
//---------------------------------------------------------------------------
//
//
2020-05-07 22:03:51 +00:00
//
//---------------------------------------------------------------------------
void movetransports_d(void)
{
int warpspriteto;
2020-10-22 19:42:02 +00:00
int ll;
2020-10-22 19:42:02 +00:00
DukeStatIterator iti(STAT_TRANSPORT);
while (auto act = iti.Next())
2020-05-07 22:03:51 +00:00
{
auto spr = act->s;
2020-10-22 19:42:02 +00:00
auto Owner = act->GetOwner();
2020-10-22 19:42:02 +00:00
if (Owner == act)
2020-05-07 22:03:51 +00:00
{
continue;
}
2020-10-22 19:42:02 +00:00
auto sectp = spr->sector();
int sectlotag = sectp->lotag;
2020-10-22 19:42:02 +00:00
int onfloorz = act->temp_data[4];
2020-10-22 19:42:02 +00:00
if (act->temp_data[0] > 0) act->temp_data[0]--;
DukeSectIterator itj(act->sector());
2020-10-22 19:42:02 +00:00
while (auto act2 = itj.Next())
2020-05-07 22:03:51 +00:00
{
auto spr2 = act2->s;
2020-11-01 13:56:23 +00:00
switch (spr2->statnum)
2020-05-07 22:03:51 +00:00
{
case STAT_PLAYER:
2020-10-22 19:42:02 +00:00
if (act2->GetOwner())
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
int p = act2->PlayerIndex();
2020-05-07 22:03:51 +00:00
ps[p].on_warping_sector = 1;
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)
{
2020-10-22 19:42:02 +00:00
if (spr->pal == 0)
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
spawn(act, TRANSPORTERBEAM);
S_PlayActorSound(TELEPORTER, act);
2020-05-07 22:03:51 +00:00
}
for (int k = connecthead; k >= 0; k = connectpoint2[k])
if (ps[k].cursectnum == Owner->s->sectnum)
2020-05-07 22:03:51 +00:00
{
ps[k].frag_ps = p;
ps[k].GetActor()->s->extra = 0;
}
ps[p].angle.ang = buildang(Owner->s->ang);
2020-10-22 19:42:02 +00:00
if (Owner->GetOwner() != Owner)
{
2020-10-22 19:42:02 +00:00
act->temp_data[0] = 13;
Owner->temp_data[0] = 13;
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = 13;
}
ps[p].bobposx = ps[p].oposx = ps[p].pos.x = Owner->s->x;
ps[p].bobposy = ps[p].oposy = ps[p].pos.y = Owner->s->y;
ps[p].oposz = ps[p].pos.z = Owner->s->z - gs.playerheight;
changeactorsect(act2, Owner->sector());
2020-11-01 13:56:23 +00:00
ps[p].cursectnum = spr2->sectnum;
2020-10-22 19:42:02 +00:00
if (spr->pal == 0)
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
auto k = spawn(Owner, TRANSPORTERBEAM);
if (k) S_PlayActorSound(TELEPORTER, k);
2020-05-07 22:03:51 +00:00
}
2020-05-07 22:03:51 +00:00
break;
}
}
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
if (onfloorz == 0 && abs(spr->z - ps[p].pos.z) < 6144)
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
2020-05-07 22:03:51 +00:00
{
ps[p].oposx = ps[p].pos.x += Owner->s->x - spr->x;
ps[p].oposy = ps[p].pos.y += Owner->s->y - spr->y;
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
ps[p].pos.z = Owner->s->z - 6144;
else ps[p].pos.z = Owner->s->z + 6144;
ps[p].oposz = ps[p].pos.z;
2020-10-22 19:42:02 +00:00
auto pa = ps[p].GetActor();
pa->s->opos = ps[p].pos;
changeactorsect(act2, Owner->sector());
ps[p].cursectnum = Owner->s->sectnum;
2020-05-07 22:03:51 +00:00
break;
}
int k = 0;
if (onfloorz && sectlotag == ST_1_ABOVE_WATER && ps[p].on_ground && ps[p].pos.z > (sectp->floorz - (16 << 8)) && (PlayerInput(p, SB_CROUCH) || ps[p].poszv > 2048))
// if( onfloorz && sectlotag == 1 && ps[p].pos.z > (sectp->floorz-(6<<8)) )
2020-05-07 22:03:51 +00:00
{
k = 1;
if (screenpeek == p)
{
FX_StopAllSounds();
}
if (ps[p].GetActor()->s->extra > 0)
2020-10-22 19:42:02 +00:00
S_PlayActorSound(DUKE_UNDERWATER, act2);
ps[p].oposz = ps[p].pos.z =
2021-11-20 23:33:17 +00:00
Owner->sector()->ceilingz + (7 << 8);
2020-05-07 22:03:51 +00:00
ps[p].posxv = 4096 - (krand() & 8192);
ps[p].posyv = 4096 - (krand() & 8192);
2020-05-07 22:03:51 +00:00
}
if (onfloorz && sectlotag == ST_2_UNDERWATER && ps[p].pos.z < (sectp->ceilingz + (6 << 8)))
2020-05-07 22:03:51 +00:00
{
k = 1;
// if( spr2->extra <= 0) break;
2020-05-07 22:03:51 +00:00
if (screenpeek == p)
{
FX_StopAllSounds();
}
2020-10-22 19:42:02 +00:00
S_PlayActorSound(DUKE_GASP, act2);
ps[p].oposz = ps[p].pos.z =
2021-11-20 23:33:17 +00:00
Owner->sector()->floorz - (7 << 8);
2020-05-07 22:03:51 +00:00
ps[p].jumping_toggle = 1;
ps[p].jumping_counter = 0;
}
2020-05-07 22:03:51 +00:00
if (k == 1)
{
ps[p].oposx = ps[p].pos.x += Owner->s->x - spr->x;
ps[p].oposy = ps[p].pos.y += Owner->s->y - spr->y;
2020-10-22 19:42:02 +00:00
if (!Owner || Owner->GetOwner() != Owner)
2020-05-07 22:03:51 +00:00
ps[p].transporter_hold = -2;
ps[p].cursectnum = Owner->s->sectnum;
changeactorsect(act2, Owner->sector());
setsprite(ps[p].GetActor(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z + gs.playerheight);
2020-05-07 22:03:51 +00:00
if ((krand() & 255) < 32)
2020-10-22 19:42:02 +00:00
spawn(act2, WATERSPLASH2);
2020-05-07 22:03:51 +00:00
if (sectlotag == 1)
for (int l = 0; l < 9; l++)
{
2020-10-22 19:42:02 +00:00
auto q = spawn(ps[p].GetActor(), WATERBUBBLE);
if (q) q->s->z += krand() & 16383;
}
2020-05-07 22:03:51 +00:00
}
}
break;
2020-05-07 22:03:51 +00:00
case STAT_ACTOR:
2020-11-01 13:56:23 +00:00
switch (spr2->picnum)
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:
2020-11-01 13:56:23 +00:00
if (spr2->extra > 0)
continue;
2020-05-07 22:03:51 +00:00
}
[[fallthrough]];
2020-05-07 22:03:51 +00:00
case STAT_PROJECTILE:
case STAT_MISC:
case STAT_FALLER:
case STAT_DUMMYPLAYER:
2020-11-01 13:56:23 +00:00
ll = abs(spr2->zvel);
2020-05-07 22:03:51 +00:00
{
warpspriteto = 0;
if (ll && sectlotag == 2 && spr2->z < (sectp->ceilingz + ll))
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
if (ll && sectlotag == 1 && spr2->z > (sectp->floorz - ll))
2020-05-07 22:03:51 +00:00
warpspriteto = 1;
2020-10-22 19:42:02 +00:00
if (sectlotag == 0 && (onfloorz || abs(spr2->z - spr->z) < 4096))
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
if ((!Owner || Owner->GetOwner() != Owner) && onfloorz && act->temp_data[0] > 0 && spr2->statnum != STAT_MISC)
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
act->temp_data[0]++;
2020-05-07 22:03:51 +00:00
goto BOLT;
}
warpspriteto = 1;
}
2020-11-01 13:56:23 +00:00
if (warpspriteto) switch (spr2->picnum)
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:
continue;
2020-05-07 22:03:51 +00:00
case PLAYERONWATER:
if (sectlotag == 2)
{
2020-11-01 13:56:23 +00:00
spr2->cstat &= 32767;
2020-05-07 22:03:51 +00:00
break;
}
[[fallthrough]];
2020-05-07 22:03:51 +00:00
default:
2020-11-01 13:56:23 +00:00
if (spr2->statnum == 5 && !(sectlotag == 1 || sectlotag == 2))
2020-05-07 22:03:51 +00:00
break;
[[fallthrough]];
2020-05-07 22:03:51 +00:00
case WATERBUBBLE:
2020-10-22 19:42:02 +00:00
//if( rnd(192) && a2->s.picnum == WATERBUBBLE)
// break;
2020-05-07 22:03:51 +00:00
if (sectlotag > 0)
{
2020-10-22 19:42:02 +00:00
auto k = spawn(act2, WATERSPLASH2);
if (k && sectlotag == 1 && spr2->statnum == 4)
2020-05-07 22:03:51 +00:00
{
k->s->xvel = spr2->xvel >> 1;
k->s->ang = spr2->ang;
2020-05-07 22:03:51 +00:00
ssp(k, CLIPMASK0);
}
}
2020-05-07 22:03:51 +00:00
switch (sectlotag)
{
case 0:
if (onfloorz)
{
if (spr2->statnum == STAT_PROJECTILE || (checkcursectnums(spr->sector()) == -1 && checkcursectnums(Owner->s->sector()) == -1))
2020-05-07 22:03:51 +00:00
{
spr2->x += (Owner->s->x - spr->x);
spr2->y += (Owner->s->y - spr->y);
2021-11-20 23:33:17 +00:00
spr2->z -= spr->z - Owner->sector()->floorz;
spr2->ang = Owner->s->ang;
spr2->backupang();
2020-10-22 19:42:02 +00:00
if (spr->pal == 0)
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
auto k = spawn(act, TRANSPORTERBEAM);
if (k) S_PlayActorSound(TELEPORTER, k);
2020-10-22 19:42:02 +00:00
k = spawn(Owner, TRANSPORTERBEAM);
if (k) S_PlayActorSound(TELEPORTER, k);
2020-05-07 22:03:51 +00:00
}
2020-10-22 19:42:02 +00:00
if (Owner && Owner->GetOwner() == Owner)
2020-05-07 22:03:51 +00:00
{
2020-10-22 19:42:02 +00:00
act->temp_data[0] = 13;
Owner->temp_data[0] = 13;
2020-05-07 22:03:51 +00:00
}
changeactorsect(act2, Owner->sector());
2020-05-07 22:03:51 +00:00
}
}
else
{
spr2->x += (Owner->s->x - spr->x);
spr2->y += (Owner->s->y - spr->y);
spr2->z = Owner->s->z + 4096;
spr2->backupz();
changeactorsect(act2, Owner->sector());
2020-05-07 22:03:51 +00:00
}
break;
case 1:
spr2->x += (Owner->s->x - spr->x);
spr2->y += (Owner->s->y - spr->y);
2021-11-20 23:33:17 +00:00
spr2->z = Owner->sector()->ceilingz + ll;
spr2->backupz();
changeactorsect(act2, Owner->sector());
2020-05-07 22:03:51 +00:00
break;
case 2:
spr2->x += (Owner->s->x - spr->x);
spr2->y += (Owner->s->y - spr->y);
2021-11-20 23:33:17 +00:00
spr2->z = Owner->sector()->floorz - ll;
spr2->backupz();
changeactorsect(act2, Owner->sector());
2020-05-07 22:03:51 +00:00
break;
}
2020-05-07 22:03:51 +00:00
break;
}
}
break;
2020-05-07 22:03:51 +00:00
}
}
BOLT:;
}
}
2020-05-07 12:55:04 +00:00
2020-05-08 22:34:48 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 19:49:29 +00:00
static void greenslime(DDukeActor *actor)
2020-05-08 22:34:48 +00:00
{
auto s = actor->s;
2020-10-22 19:49:29 +00:00
int* t = &actor->temp_data[0];
auto sectp = s->sector();
2020-05-08 22:34:48 +00:00
int j;
// #ifndef isShareware()
2020-05-08 22:34:48 +00:00
if (ud.multimode < 2)
{
if (actor_tog == 1)
{
s->cstat = 32768;
2020-05-08 22:34:48 +00:00
return;
}
else if (actor_tog == 2) s->cstat = 257;
}
// #endif
t[1] += 128;
if (sectp->floorstat & 1)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
int x;
2020-10-23 15:44:45 +00:00
int p = findplayer(actor, &x);
2020-05-08 22:34:48 +00:00
if (x > 20480)
{
2020-10-22 19:49:29 +00:00
actor->timetosleep++;
if (actor->timetosleep > SLEEPTIME)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
actor->timetosleep = 0;
changeactorstat(actor, 2);
2020-05-08 22:34:48 +00:00
return;
}
}
if (t[0] == -5) // FROZEN
{
t[3]++;
if (t[3] > 280)
{
s->pal = 0;
t[0] = 0;
return;
}
2020-10-22 19:49:29 +00:00
makeitfall(actor);
2020-05-08 22:34:48 +00:00
s->cstat = 257;
s->picnum = GREENSLIME + 2;
s->extra = 1;
s->pal = 1;
2020-10-22 19:49:29 +00:00
j = fi.ifhitbyweapon(actor);
if (j >= 0)
2020-05-08 22:34:48 +00:00
{
if (j == FREEZEBLAST)
return;
for (j = 16; j >= 0; j--)
{
2021-11-18 18:04:00 +00:00
auto k = EGS(s->sector(), s->x, s->y, s->z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
k->s->pal = 1;
2020-05-08 22:34:48 +00:00
}
ps[p].actors_killed++;
2020-10-22 19:49:29 +00:00
S_PlayActorSound(GLASS_BREAKING, actor);
deletesprite(actor);
2020-05-08 22:34:48 +00:00
}
else if (x < 1024 && ps[p].quick_kick == 0)
{
j = getincangle(ps[p].angle.ang.asbuild(), getangle(s->x - ps[p].pos.x, s->y - ps[p].pos.y));
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 (ps[p].GetActor()->s->extra < 1)
2020-05-08 22:34:48 +00:00
{
t[0] = 0;
return;
}
2020-10-22 19:49:29 +00:00
setsprite(actor, s->pos);
2020-05-08 22:34:48 +00:00
s->ang = ps[p].angle.ang.asbuild();
2020-05-08 22:34:48 +00:00
if ((PlayerInput(p, SB_FIRE) || (ps[p].quick_kick > 0)) && ps[p].GetActor()->s->extra > 0)
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++)
{
2021-11-18 18:04:00 +00:00
auto j = EGS(s->sector(), s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), actor, 5);
j->s->pal = 6;
2020-05-08 22:34:48 +00:00
}
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_DYING, actor);
S_PlayActorSound(SQUISHED, actor);
2020-05-08 22:34:48 +00:00
if ((krand() & 255) < 32)
{
2020-10-22 19:49:29 +00:00
auto j = spawn(actor, BLOODPOOL);
if (j) j->s->pal = 0;
2020-05-08 22:34:48 +00:00
}
ps[p].actors_killed++;
t[0] = -3;
2020-10-22 19:49:29 +00:00
if (ps[p].somethingonplayer == actor)
ps[p].somethingonplayer = nullptr;
2020-10-22 19:49:29 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
s->z = ps[p].pos.z + ps[p].pyoff - t[2] + (8 << 8);
2020-05-08 22:34:48 +00:00
s->z += -ps[p].horizon.horiz.asq16() >> 12;
2020-05-08 22:34:48 +00:00
if (t[2] > 512)
t[2] -= 128;
if (t[2] < 348)
t[2] += 128;
2020-11-02 23:20:51 +00:00
if (ps[p].newOwner != nullptr)
2020-05-08 22:34:48 +00:00
{
2020-11-02 23:20:51 +00:00
ps[p].newOwner = nullptr;
ps[p].pos.x = ps[p].oposx;
ps[p].pos.y = ps[p].oposy;
ps[p].pos.z = ps[p].oposz;
ps[p].angle.restore();
2020-05-08 22:34:48 +00:00
updatesector(ps[p].pos.x, ps[p].pos.y, &ps[p].cursectnum);
2020-05-08 22:34:48 +00:00
2020-10-22 19:49:29 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto ac = it.Next())
2020-05-08 22:34:48 +00:00
{
if (ac->s->picnum == CAMERA1) ac->s->yvel = 0;
2020-05-08 22:34:48 +00:00
}
}
if (t[3] > 0)
{
static const uint8_t frames[] = { 5,5,6,6,7,7,6,5 };
2020-05-08 22:34:48 +00:00
s->picnum = GREENSLIME + frames[t[3]];
if (t[3] == 5)
{
2020-10-22 19:49:29 +00:00
auto psp = ps[p].GetActor();
psp->s->extra += -(5 + (krand() & 3));
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_ATTACK, actor);
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 + bsin(t[1], -13);
s->yrepeat = 15 + bsin(t[1], -13);
2020-05-08 22:34:48 +00:00
s->x = ps[p].pos.x + ps[p].angle.ang.bcos(-7);
s->y = ps[p].pos.y + ps[p].angle.ang.bsin(-7);
2020-05-08 22:34:48 +00:00
return;
}
else if (s->xvel < 64 && x < 768)
{
if (ps[p].somethingonplayer == nullptr)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
ps[p].somethingonplayer = actor;
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;
}
}
2020-10-22 19:49:29 +00:00
j = fi.ifhitbyweapon(actor);
if (j >= 0)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_DYING, actor);
2020-05-08 22:34:48 +00:00
2020-10-22 19:49:29 +00:00
if (ps[p].somethingonplayer == actor)
ps[p].somethingonplayer = nullptr;
2020-05-08 22:34:48 +00:00
if (j == FREEZEBLAST)
{
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SOMETHINGFROZE, actor);
t[0] = -5; t[3] = 0;
2020-05-08 22:34:48 +00:00
return;
}
ps[p].actors_killed++;
2020-05-08 22:34:48 +00:00
if ((krand() & 255) < 32)
{
2020-10-22 19:49:29 +00:00
auto j = spawn(actor, BLOODPOOL);
if (j) j->s->pal = 0;
2020-05-08 22:34:48 +00:00
}
for (x = 0; x < 8; x++)
{
2021-11-18 18:04:00 +00:00
auto j = EGS(s->sector(), s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), actor, 5);
if (j) j->s->pal = 6;
2020-05-08 22:34:48 +00:00
}
t[0] = -3;
2020-10-22 19:49:29 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
// All weap
if (t[0] == -1) //Shrinking down
{
2020-10-22 19:49:29 +00:00
makeitfall(actor);
2020-05-08 22:34:48 +00:00
s->cstat &= 65535 - 8;
s->picnum = GREENSLIME + 4;
if (s->xrepeat > 32) s->xrepeat -= krand() & 7;
if (s->yrepeat > 16) s->yrepeat -= krand() & 7;
else
{
s->xrepeat = 40;
s->yrepeat = 16;
2020-10-22 19:49:29 +00:00
actor->temp_actor = nullptr;
2020-05-08 22:34:48 +00:00
t[0] = 0;
}
return;
}
2020-10-22 19:49:29 +00:00
else if (t[0] != -2) getglobalz(actor);
2020-05-08 22:34:48 +00:00
if (t[0] == -2) //On top of somebody (an enemy)
{
2020-10-22 19:49:29 +00:00
auto s5 = actor->temp_actor;
makeitfall(actor);
2021-04-04 11:02:26 +00:00
if (s5)
{
s5->s->xvel = 0;
2020-05-08 22:34:48 +00:00
int l = s5->s->ang;
2020-05-08 22:34:48 +00:00
s->z = s5->s->z;
s->x = s5->s->x + bcos(l, -11);
s->y = s5->s->y + bsin(l, -11);
2020-05-08 22:34:48 +00:00
2021-04-04 11:02:26 +00:00
s->picnum = GREENSLIME + 2 + (global_random & 1);
2020-05-08 22:34:48 +00:00
2021-04-04 11:02:26 +00:00
if (s->yrepeat < 64) s->yrepeat += 2;
2020-05-08 22:34:48 +00:00
else
{
2021-04-04 11:02:26 +00:00
if (s->xrepeat < 32) s->xrepeat += 4;
else
{
t[0] = -1;
x = ldist(actor, s5);
if (x < 768) {
s5->s->xrepeat = 0;
2021-04-04 11:02:26 +00:00
}
2020-05-08 22:34:48 +00:00
}
}
}
return;
}
//Check randomly to see of there is an actor near
if (rnd(32))
{
DukeSectIterator it(actor->sector());
2020-10-22 19:49:29 +00:00
while (auto a2 = it.Next())
2020-05-08 22:34:48 +00:00
{
if (gs.actorinfo[a2->s->picnum].flags & SFLAG_GREENSLIMEFOOD)
2020-05-08 22:34:48 +00:00
{
if (ldist(actor, a2) < 768 && (abs(s->z - a2->s->z) < 8192)) //Gulp them
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
actor->temp_actor = a2;
2020-05-08 22:34:48 +00:00
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)
2020-10-22 19:49:29 +00:00
S_PlayActorSound(SLIM_ROAM, actor);
2020-05-08 22:34:48 +00:00
if (t[0] == 2)
{
s->zvel = 0;
s->cstat &= (65535 - 8);
if ((sectp->ceilingstat & 1) || (actor->ceilingz + 6144) < s->z)
2020-05-08 22:34:48 +00:00
{
s->z += 2048;
t[0] = 3;
return;
}
}
else
{
s->cstat |= 8;
2020-10-22 19:49:29 +00:00
makeitfall(actor);
2020-05-08 22:34:48 +00:00
}
2020-10-22 19:49:29 +00:00
if (everyothertime & 1) ssp(actor, CLIPMASK0);
2020-05-08 22:34:48 +00:00
if (s->xvel > 96)
{
s->xvel -= 2;
return;
}
else
{
if (s->xvel < 32) s->xvel += 4;
s->xvel = 64 - bcos(t[1], -9);
2020-05-08 22:34:48 +00:00
s->ang += getincangle(s->ang,
getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y)) >> 3;
2020-05-08 22:34:48 +00:00
// TJR
}
s->xrepeat = 36 + bcos(t[1], -11);
s->yrepeat = 16 + bsin(t[1], -13);
2020-05-08 22:34:48 +00:00
if (rnd(4) && (sectp->ceilingstat & 1) == 0 &&
2020-10-22 19:49:29 +00:00
abs(actor->floorz - actor->ceilingz)
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;
2020-10-22 19:49:29 +00:00
if (s->z < actor->ceilingz + 4096)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
s->z = actor->ceilingz + 4096;
2020-05-08 22:34:48 +00:00
s->xvel = 0;
t[0] = 2;
}
}
if (t[0] == 3)
{
s->picnum = GREENSLIME + 1;
2020-10-22 19:49:29 +00:00
makeitfall(actor);
2020-05-08 22:34:48 +00:00
2020-10-22 19:49:29 +00:00
if (s->z > actor->floorz - (8 << 8))
2020-05-08 22:34:48 +00:00
{
s->yrepeat -= 4;
s->xrepeat += 2;
}
else
{
if (s->yrepeat < (40 - 4)) s->yrepeat += 8;
if (s->xrepeat > 8) s->xrepeat -= 4;
}
2020-10-22 19:49:29 +00:00
if (s->z > actor->floorz - 2048)
2020-05-08 22:34:48 +00:00
{
2020-10-22 19:49:29 +00:00
s->z = actor->floorz - 2048;
2020-05-08 22:34:48 +00:00
t[0] = 0;
s->xvel = 0;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 20:07:09 +00:00
static void flamethrowerflame(DDukeActor *actor)
2020-05-08 22:34:48 +00:00
{
auto s = actor->s;
2020-10-22 20:07:09 +00:00
int* t = &actor->temp_data[0];
auto sectp = s->sector();
2020-10-22 20:07:09 +00:00
int x;
2020-10-23 15:44:45 +00:00
int p = findplayer(actor, &x);
2020-10-22 20:07:09 +00:00
execute(actor, p, x);
2020-05-08 22:34:48 +00:00
t[0]++;
if (sectp->lotag == 2)
2020-05-08 22:34:48 +00:00
{
spawn(actor, EXPLOSION2)->s->shade = 127;
2020-10-22 20:07:09 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
int dax = s->x;
int day = s->y;
int daz = s->z;
int xvel = s->xvel;
2020-05-08 22:34:48 +00:00
2020-10-22 20:07:09 +00:00
getglobalz(actor);
2020-05-08 22:34:48 +00:00
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(actor, EXPLOSION2)->s->shade = 127;
2020-10-22 20:07:09 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
2020-10-22 20:07:09 +00:00
Collision coll;
movesprite_ex(actor, MulScale(xvel, bcos(s->ang), 14),
MulScale(xvel, bsin(s->ang), 14), s->zvel, CLIPMASK1, coll);
2020-05-08 22:34:48 +00:00
if (!s->insector())
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
deletesprite(actor);
2020-05-08 22:34:48 +00:00
return;
}
2020-10-22 20:07:09 +00:00
if (coll.type != kHitSprite)
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
if (s->z < actor->ceilingz)
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
coll.setSector(s->sectnum);
2020-05-08 22:34:48 +00:00
s->zvel = -1;
}
else if ((s->z > actor->floorz && s->sector()->lotag != 1)
|| (s->z > actor->floorz + (16 << 8) && s->sector()->lotag == 1))
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
coll.setSector(s->sectnum);
if (s->sector()->lotag != 1)
2020-05-08 22:34:48 +00:00
s->zvel = 1;
}
}
2020-10-22 20:07:09 +00:00
if (coll.type != 0) {
s->xvel = s->yvel = s->zvel = 0;
2020-10-22 20:07:09 +00:00
if (coll.type == kHitSprite)
2020-05-08 22:34:48 +00:00
{
fi.checkhitsprite(coll.actor, actor);
if (coll.actor->s->picnum == APLAYER)
2020-11-02 18:54:20 +00:00
S_PlayActorSound(PISTOL_BODYHIT, coll.actor);
2020-05-08 22:34:48 +00:00
}
2020-10-22 20:07:09 +00:00
else if (coll.type == kHitWall)
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
setsprite(actor, dax, day, daz);
fi.checkhitwall(actor, coll.wall(), s->x, s->y, s->z, s->picnum);
2020-05-08 22:34:48 +00:00
}
2020-10-22 20:07:09 +00:00
else if (coll.type == kHitSector)
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:07:09 +00:00
setsprite(actor, dax, day, daz);
2020-05-08 22:34:48 +00:00
if (s->zvel < 0)
fi.checkhitceiling(s->sector());
2020-05-08 22:34:48 +00:00
}
if (s->xrepeat >= 10)
{
x = s->extra;
fi.hitradius(actor, gs.rpgblastradius, x >> 2, x >> 1, x - (x >> 2), x);
2020-05-08 22:34:48 +00:00
}
else
{
x = s->extra + (global_random & 3);
fi.hitradius(actor, (gs.rpgblastradius >> 1), x >> 2, x >> 1, x - (x >> 2), x);
2020-05-08 22:34:48 +00:00
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 20:18:47 +00:00
static void heavyhbomb(DDukeActor *actor)
{
auto s = actor->s;
2020-10-22 20:18:47 +00:00
auto t = &actor->temp_data[0];
auto Owner = actor->GetOwner();
auto sectp = s->sector();
2020-10-22 20:18:47 +00:00
int x, l;
if ((s->cstat & 32768))
{
t[2]--;
if (t[2] <= 0)
{
2020-10-22 20:18:47 +00:00
S_PlayActorSound(TELEPORTER, actor);
spawn(actor, TRANSPORTERSTAR);
s->cstat = 257;
}
return;
}
2020-10-23 15:44:45 +00:00
int p = findplayer(actor, &x);
if (x < 1220) s->cstat &= ~257;
else s->cstat |= 257;
if (t[3] == 0)
{
2020-10-22 20:18:47 +00:00
int j = fi.ifhitbyweapon(actor);
if (j >= 0)
{
t[3] = 1;
t[4] = 0;
l = 0;
s->xvel = 0;
goto DETONATEB;
}
}
if (s->picnum != BOUNCEMINE)
{
2020-10-22 20:18:47 +00:00
makeitfall(actor);
if (sectp->lotag != 1 && s->z >= actor->floorz - (FOURSLEIGHT) && s->yvel < 3)
{
if (s->yvel > 0 || (s->yvel == 0 && actor->floorz == sectp->floorz))
2020-10-22 20:18:47 +00:00
S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
s->zvel = -((4 - s->yvel) << 8);
if (s->sector()->lotag == 2)
s->zvel >>= 2;
s->yvel++;
}
if (s->z < actor->ceilingz) // && sectp->lotag != 2 )
{
2020-10-22 20:18:47 +00:00
s->z = actor->ceilingz + (3 << 8);
s->zvel = 0;
}
}
2020-10-22 20:18:47 +00:00
Collision coll;
movesprite_ex(actor,
MulScale(s->xvel, bcos(s->ang), 14),
MulScale(s->xvel, bsin(s->ang), 14),
2020-10-22 20:18:47 +00:00
s->zvel, CLIPMASK0, coll);
if (s->sector()->lotag == 1 && s->zvel == 0)
{
s->z += (32 << 8);
if (t[5] == 0)
{
t[5] = 1;
2020-10-22 20:18:47 +00:00
spawn(actor, WATERSPLASH2);
}
}
else t[5] = 0;
2020-10-22 20:18:47 +00:00
if (t[3] == 0 && (s->picnum == BOUNCEMINE || s->picnum == MORTER) && (coll.type || x < 844))
{
t[3] = 1;
t[4] = 0;
l = 0;
s->xvel = 0;
goto DETONATEB;
}
if ( Owner && Owner->s->picnum == APLAYER)
2020-10-22 20:18:47 +00:00
l = Owner->PlayerIndex();
else l = -1;
if (s->xvel > 0)
{
s->xvel -= 5;
if (sectp->lotag == 2)
s->xvel -= 10;
if (s->xvel < 0)
s->xvel = 0;
if (s->xvel & 8) s->cstat ^= 4;
}
2020-10-22 20:18:47 +00:00
if (coll.type== kHitWall)
{
auto wal = coll.wall();
fi.checkhitwall(actor, wal, s->x, s->y, s->z, s->picnum);
auto delta = wal->delta();
int k = getangle(delta.x, delta.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 = gs.pipebombblastradius; break;
case MORTER: m = gs.morterblastradius; break;
case BOUNCEMINE: m = gs.bouncemineblastradius; break;
}
2020-10-22 20:18:47 +00:00
fi.hitradius(actor, m, x >> 2, x >> 1, x - (x >> 2), x);
spawn(actor, EXPLOSION2);
if (s->zvel == 0) spawn(actor, EXPLOSION2BOT);
S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
for (x = 0; x < 8; x++)
2020-10-22 20:18:47 +00:00
RANDOMSCRAP(actor);
}
if (s->yrepeat)
{
s->yrepeat = 0;
return;
}
if (t[4] > 20)
{
2020-10-22 20:18:47 +00:00
if (Owner != actor || ud.respawn_items == 0)
{
2020-10-22 20:18:47 +00:00
deletesprite(actor);
return;
}
else
{
t[2] = gs.respawnitemtime;
2020-10-22 20:18:47 +00:00
spawn(actor, RESPAWNMARKERRED);
s->cstat = 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].pos.x, ps[p].pos.y, ps[p].pos.z, ps[p].cursectnum))
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < gs.max_ammo_amount[HANDBOMB_WEAPON])
{
2020-10-22 20:18:47 +00:00
if (ud.coop >= 1 && Owner == actor)
{
2020-10-22 20:18:47 +00:00
for (int 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);
2020-10-22 20:18:47 +00:00
S_PlayActorSound(DUKE_GET, ps[p].GetActor());
2020-10-22 20:18:47 +00:00
if (ps[p].gotweapon[HANDBOMB_WEAPON] == 0 || Owner == ps[p].GetActor())
fi.addweapon(&ps[p], HANDBOMB_WEAPON);
if (!Owner || Owner->s->picnum != APLAYER)
{
SetPlayerPal(&ps[p], PalEntry(32, 0, 32, 0));
}
2020-10-22 20:18:47 +00:00
if (Owner != actor || ud.respawn_items == 0)
{
2020-10-22 20:18:47 +00:00
if (Owner == actor && ud.coop >= 1)
return;
2020-10-22 20:18:47 +00:00
deletesprite(actor);
return;
}
else
{
t[2] = gs.respawnitemtime;
2020-10-22 20:18:47 +00:00
spawn(actor, RESPAWNMARKERRED);
s->cstat = 32768;
}
}
if (t[0] < 8) t[0]++;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-05-08 22:34:48 +00:00
void moveactors_d(void)
{
2020-10-22 20:48:51 +00:00
int x;
int sect, p;
unsigned int k;
2020-05-08 22:34:48 +00:00
2020-10-22 20:48:51 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto act = it.Next())
2020-05-08 22:34:48 +00:00
{
auto s = act->s;
2020-05-08 22:34:48 +00:00
sect = s->sectnum;
if (s->xrepeat == 0 || !validSectorIndex(sect))
2020-05-08 22:34:48 +00:00
{
2020-10-22 20:48:51 +00:00
deletesprite(act);
2020-05-08 22:34:48 +00:00
continue;
}
2020-10-22 20:48:51 +00:00
int *t = &act->temp_data[0];
2020-05-08 22:34:48 +00:00
switch (s->picnum)
{
case FLAMETHROWERFLAME:
2020-10-22 20:48:51 +00:00
if (isWorldTour()) flamethrowerflame(act);
2020-05-08 22:34:48 +00:00
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
{
2020-10-22 20:48:51 +00:00
int j = fi.ifhitbyweapon(act);
2020-05-08 22:34:48 +00:00
if (j >= 0)
{
s->cstat = 32 + 128;
k = 1;
2020-10-22 20:48:51 +00:00
DukeStatIterator it(STAT_ACTOR);
while (auto act2 = it.Next())
2020-05-08 22:34:48 +00:00
{
if (act2->s->lotag == s->lotag &&
act2->s->picnum == s->picnum)
2020-05-08 22:34:48 +00:00
{
if ((act2->s->hitag && !(act2->s->cstat & 32)) ||
(!act2->s->hitag && (act2->s->cstat & 32))
2020-05-08 22:34:48 +00:00
)
{
k = 0;
break;
}
}
}
if (k == 1)
{
operateactivators(s->lotag, -1);
2020-11-02 18:54:20 +00:00
fi.operateforcefields(act, s->lotag);
2020-05-08 22:34:48 +00:00
operatemasterswitches(s->lotag);
}
}
}
continue;
case RESPAWNMARKERRED:
case RESPAWNMARKERYELLOW:
case RESPAWNMARKERGREEN:
2020-10-22 20:48:51 +00:00
if (!respawnmarker(act, RESPAWNMARKERYELLOW, RESPAWNMARKERGREEN)) continue;
2020-05-08 22:34:48 +00:00
break;
case HELECOPT:
case DUKECAR:
s->z += s->zvel;
t[0]++;
2020-10-22 20:48:51 +00:00
if (t[0] == 4) S_PlayActorSound(WAR_AMBIENCE2, act);
2020-05-08 22:34:48 +00:00
if (t[0] > (26 * 8))
{
S_PlaySound(RPG_EXPLODE);
2020-10-22 20:48:51 +00:00
for (int j = 0; j < 32; j++)
RANDOMSCRAP(act);
2020-05-08 22:34:48 +00:00
earthquaketime = 16;
2020-10-22 20:48:51 +00:00
deletesprite(act);
2020-05-08 22:34:48 +00:00
continue;
}
else if ((t[0] & 3) == 0)
2020-10-22 20:48:51 +00:00
spawn(act, EXPLOSION2);
ssp(act, CLIPMASK0);
2020-05-08 22:34:48 +00:00
break;
case RAT:
2020-10-22 20:48:51 +00:00
if (!rat(act, true)) continue;
2020-05-08 22:34:48 +00:00
break;
case QUEBALL:
case STRIPEBALL:
2020-10-22 20:48:51 +00:00
if (!queball(act, POCKET, QUEBALL, STRIPEBALL)) continue;
2020-05-08 22:34:48 +00:00
break;
case FORCESPHERE:
2020-10-22 20:48:51 +00:00
forcesphere(act, FORCESPHERE);
2020-05-08 22:34:48 +00:00
continue;
case RECON:
2020-10-22 20:48:51 +00:00
recon(act, EXPLOSION2, FIRELASER, RECO_ATTACK, RECO_PAIN, RECO_ROAM, 10, [](DDukeActor* i)->int { return PIGCOP; });
2020-05-08 22:34:48 +00:00
continue;
case OOZ:
case OOZ2:
2020-10-22 20:48:51 +00:00
ooz(act);
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:
2020-10-22 20:48:51 +00:00
greenslime(act);
2020-05-08 22:34:48 +00:00
continue;
case BOUNCEMINE:
case MORTER:
2020-10-22 20:48:51 +00:00
spawn(act, FRAMEEFFECT1)->temp_data[0] = 3;
[[fallthrough]];
2020-05-08 22:34:48 +00:00
case HEAVYHBOMB:
2020-10-22 20:48:51 +00:00
heavyhbomb(act);
2020-05-08 22:34:48 +00:00
continue;
case REACTORBURNT:
case REACTOR2BURNT:
continue;
case REACTOR:
case REACTOR2:
2020-10-22 20:48:51 +00:00
reactor(act, REACTOR, REACTOR2, REACTORBURNT, REACTOR2BURNT, REACTORSPARK, REACTOR2SPARK);
2020-05-08 22:34:48 +00:00
continue;
case CAMERA1:
2020-10-22 20:48:51 +00:00
camera(act);
2020-05-08 22:34:48 +00:00
continue;
}
// #ifndef VOLOMEONE
2020-10-22 20:48:51 +00:00
if (ud.multimode < 2 && badguy(act))
2020-05-08 22:34:48 +00:00
{
if (actor_tog == 1)
{
s->cstat = 32768;
2020-05-08 22:34:48 +00:00
continue;
}
else if (actor_tog == 2) s->cstat = 257;
}
// #endif
2020-10-23 15:44:45 +00:00
p = findplayer(act, &x);
2020-05-08 22:34:48 +00:00
2020-10-22 20:48:51 +00:00
execute(act, p, x);
2020-05-08 22:34:48 +00:00
}
}
2020-05-09 18:27:06 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-10-22 20:51:51 +00:00
static void fireflyflyingeffect(DDukeActor *actor)
{
2020-10-23 15:44:45 +00:00
int x, p = findplayer(actor, &x);
2020-10-22 20:51:51 +00:00
execute(actor, p, x);
2020-10-22 20:51:51 +00:00
auto Owner = actor->GetOwner();
if (!Owner || Owner->s->picnum != FIREFLY)
{
2020-10-22 20:51:51 +00:00
deletesprite(actor);
return;
}
if (Owner->s->xrepeat >= 24 || Owner->s->pal == 1)
actor->s->cstat |= 0x8000;
else
actor->s->cstat &= ~0x8000;
double dx = Owner->s->x - ps[p].GetActor()->s->x;
double dy = Owner->s->y - ps[p].GetActor()->s->y;
double dist = sqrt(dx * dx + dy * dy);
if (dist != 0.0)
{
dx /= dist;
dy /= dist;
}
actor->s->x = (int) (Owner->s->x - (dx * -10.0));
actor->s->y = (int) (Owner->s->y - (dy * -10.0));
actor->s->z = Owner->s->z + 2048;
if (Owner->s->extra <= 0)
{
2020-10-22 20:51:51 +00:00
deletesprite(actor);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-05-09 18:27:06 +00:00
void moveexplosions_d(void) // STATNUM 5
{
int p;
2020-10-22 20:51:51 +00:00
int x;
2020-05-09 18:27:06 +00:00
2020-10-22 20:51:51 +00:00
DukeStatIterator it(STAT_MISC);
while (auto act = it.Next())
2020-05-09 18:27:06 +00:00
{
auto s = act->s;
2020-05-09 18:27:06 +00:00
if (!s->insector() || s->xrepeat == 0)
2020-05-09 18:27:06 +00:00
{
2020-10-22 20:51:51 +00:00
deletesprite(act);
2020-05-09 18:27:06 +00:00
continue;
}
int* t = &act->temp_data[0];
auto sectp = s->sector();
2020-05-09 18:27:06 +00:00
switch (s->picnum)
{
case FIREFLYFLYINGEFFECT:
2020-10-22 20:51:51 +00:00
if (isWorldTour()) fireflyflyingeffect(act);
continue;
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]++;
2020-10-22 20:51:51 +00:00
auto Owner = act->GetOwner();
2020-05-09 18:27:06 +00:00
if (t[0] == 8) s->picnum = NUKEBUTTON + 1;
2020-10-22 20:51:51 +00:00
else if (t[0] == 16 && Owner)
2020-05-09 18:27:06 +00:00
{
s->picnum = NUKEBUTTON + 2;
2020-10-22 20:51:51 +00:00
ps[Owner->PlayerIndex()].fist_incs = 1;
2020-05-09 18:27:06 +00:00
}
2020-10-22 20:51:51 +00:00
if (Owner && ps[Owner->PlayerIndex()].fist_incs == 26)
2020-05-09 18:27:06 +00:00
s->picnum = NUKEBUTTON + 3;
}
continue;
case FORCESPHERE:
2020-10-22 20:51:51 +00:00
forcesphereexplode(act);
2020-05-09 18:27:06 +00:00
continue;
case WATERSPLASH2:
2020-10-22 20:51:51 +00:00
watersplash2(act);
2020-05-09 18:27:06 +00:00
continue;
case FRAMEEFFECT1:
2020-10-22 20:51:51 +00:00
frameeffect1(act);
2020-05-09 18:27:06 +00:00
continue;
case INNERJAW:
case INNERJAW + 1:
2020-10-23 15:44:45 +00:00
p = findplayer(act, &x);
2020-05-09 18:27:06 +00:00
if (x < 512)
{
SetPlayerPal(&ps[p], PalEntry(32, 32, 0, 0));
ps[p].GetActor()->s->extra -= 4;
2020-05-09 18:27:06 +00:00
}
[[fallthrough]];
2020-05-09 18:27:06 +00:00
case FIRELASER:
if (s->extra != 999)
s->extra = 999;
else
{
2020-10-22 20:51:51 +00:00
deletesprite(act);
2020-05-09 18:27:06 +00:00
continue;
}
break;
case TONGUE:
2020-10-22 20:51:51 +00:00
deletesprite(act);
2020-05-09 18:27:06 +00:00
continue;
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
act->floorz = s->z = getflorzofslopeptr(s->sector(), s->x, s->y);
2020-05-09 18:27:06 +00:00
break;
case MONEY:
case MAIL:
case PAPER:
2020-10-22 20:51:51 +00:00
money(act, BLOODPOOL);
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:
2020-10-22 20:51:51 +00:00
jibs(act, JIBS6, true, false, false, s->picnum == DUKELEG || s->picnum == DUKETORSO || s->picnum == DUKEGUN, false);
2020-05-09 18:27:06 +00:00
continue;
case BLOODPOOL:
case PUKE:
2020-10-22 20:51:51 +00:00
bloodpool(act, s->picnum == PUKE, TIRE);
2020-05-09 18:27:06 +00:00
continue;
case LAVAPOOL:
case ONFIRE:
2020-07-06 13:48:51 +00:00
case ONFIRESMOKE:
2020-05-09 18:27:06 +00:00
case BURNEDCORPSE:
case LAVAPOOLBUBBLE:
case WHISPYSMOKE:
if (!isWorldTour())
continue;
[[fallthrough]];
2020-05-09 18:27:06 +00:00
case BURNING:
case BURNING2:
case FECES:
case WATERBUBBLE:
case SMALLSMOKE:
case EXPLOSION2:
case SHRINKEREXPLOSION:
case EXPLOSION2BOT:
case BLOOD:
case LASERSITE:
case FORCERIPPLE:
case TRANSPORTERSTAR:
case TRANSPORTERBEAM:
2020-10-23 15:44:45 +00:00
p = findplayer(act, &x);
2020-10-22 20:51:51 +00:00
execute(act, p, x);
2020-05-09 18:27:06 +00:00
continue;
case SHELL:
case SHOTGUNSHELL:
shell(act, (sectp->floorz + (24 << 8)) < s->z);
2020-05-09 18:27:06 +00:00
continue;
case GLASSPIECES:
case GLASSPIECES + 1:
case GLASSPIECES + 2:
2020-10-22 20:51:51 +00:00
glasspieces(act);
2020-05-09 18:27:06 +00:00
continue;
}
if (s->picnum >= SCRAP6 && s->picnum <= SCRAP5 + 3)
{
2020-10-22 20:51:51 +00:00
scrap(act, SCRAP1, SCRAP6);
2020-05-09 18:27:06 +00:00
}
}
}
2020-05-10 07:08:02 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void handle_se06_d(DDukeActor* actor)
{
auto s = actor->s;
auto t = &actor->temp_data[0];
2021-11-20 23:33:17 +00:00
auto sc = actor->sector();
int sh = s->hitag;
int 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;
DukeStatIterator it(STAT_EFFECTOR);
while (auto act2 = it.Next())
{
if ((act2->s->lotag == 14) && (sh == act2->s->hitag) && (act2->temp_data[0] == t[0])) // sectnum()
{
act2->s->xvel = s->xvel;
//if( t[4] == 1 )
{
if (act2->temp_data[5] == 0)
act2->temp_data[5] = dist(act2, actor);
int x = Sgn(dist(act2, actor) - act2->temp_data[5]);
if (act2->s->extra)
x = -x;
s->xvel += x;
}
act2->temp_data[4] = t[4];
}
}
handle_se14(actor, true, RPG, JIBS6);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void handle_se28(DDukeActor* actor)
{
auto s = actor->s;
int* t = &actor->temp_data[0];
if (t[5] > 0)
{
t[5]--;
return;
}
if (t[0] == 0)
{
int x;
findplayer(actor, &x);
if (x > 15500)
return;
t[0] = 1;
t[1] = 64 + (krand() & 511);
t[2] = 0;
}
else
{
t[2]++;
if (t[2] > t[1])
{
t[0] = 0;
ps[screenpeek].visibility = ud.const_visibility;
return;
}
else if (t[2] == (t[1] >> 1))
S_PlayActorSound(THUNDER, actor);
else if (t[2] == (t[1] >> 3))
S_PlayActorSound(LIGHTNING_SLAP, actor);
else if (t[2] == (t[1] >> 2))
{
DukeStatIterator it(STAT_DEFAULT);
while (auto act2 = it.Next())
{
if (act2->s->picnum == NATURALLIGHTNING && act2->s->hitag == s->hitag)
act2->s->cstat |= 32768;
}
}
else if (t[2] > (t[1] >> 3) && t[2] < (t[1] >> 2))
{
int j = !!cansee(s->x, s->y, s->z, s->sectnum, ps[screenpeek].pos.x, ps[screenpeek].pos.y, ps[screenpeek].pos.z, ps[screenpeek].cursectnum);
if (rnd(192) && (t[2] & 1))
{
if (j) ps[screenpeek].visibility = 0;
}
else if (j) ps[screenpeek].visibility = ud.const_visibility;
DukeStatIterator it(STAT_DEFAULT);
while (auto act2 = it.Next())
{
if (act2->s->picnum == NATURALLIGHTNING && act2->s->hitag == s->hitag)
{
if (rnd(32) && (t[2] & 1))
{
act2->s->cstat &= 32767;
spawn(act2, SMALLSMOKE);
int x;
2020-10-23 15:44:45 +00:00
int p = findplayer(actor, &x);
auto psa = ps[p].GetActor();
x = ldist(psa, act2);
if (x < 768)
{
2020-10-25 06:21:33 +00:00
if (S_CheckActorSoundPlaying(psa, DUKE_LONGTERM_PAIN) < 1)
S_PlayActorSound(DUKE_LONGTERM_PAIN, psa);
S_PlayActorSound(SHORT_CIRCUIT, psa);
psa->s->extra -= 8 + (krand() & 7);
SetPlayerPal(&ps[p], PalEntry(32, 16, 0, 0));
}
return;
}
else act2->s->cstat |= 32768;
}
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
2020-05-10 07:08:02 +00:00
void moveeffectors_d(void) //STATNUM 3
{
2020-10-22 21:17:51 +00:00
int l;
2020-05-10 07:08:02 +00:00
clearfriction();
2020-10-22 21:17:51 +00:00
DukeStatIterator it(STAT_EFFECTOR);
while (auto act = it.Next())
2020-05-10 07:08:02 +00:00
{
2021-11-20 23:33:17 +00:00
auto sc = act->sector();
switch (act->s->lotag)
2020-05-10 07:08:02 +00:00
{
case SE_0_ROTATING_SECTOR:
2020-10-22 21:17:51 +00:00
handle_se00(act, LASERLINE);
2020-05-10 07:08:02 +00:00
break;
case SE_1_PIVOT: //Nothing for now used as the pivot
2020-10-22 21:17:51 +00:00
handle_se01(act);
2020-05-10 07:08:02 +00:00
break;
case SE_6_SUBWAY:
2020-10-22 21:17:51 +00:00
handle_se06_d(act);
break;
2020-05-10 07:08:02 +00:00
case SE_14_SUBWAY_CAR:
2020-10-22 21:17:51 +00:00
handle_se14(act, true, RPG, JIBS6);
2020-05-10 07:08:02 +00:00
break;
case SE_30_TWO_WAY_TRAIN:
2020-10-22 21:17:51 +00:00
handle_se30(act, JIBS6);
2020-05-10 07:08:02 +00:00
break;
case SE_2_EARTHQUAKE:
2020-10-22 21:17:51 +00:00
handle_se02(act);
2020-05-10 07:08:02 +00:00
break;
//Flashing sector lights after reactor EXPLOSION2
case SE_3_RANDOM_LIGHTS_AFTER_SHOT_OUT:
2020-10-22 21:17:51 +00:00
handle_se03(act);
2020-05-10 07:08:02 +00:00
break;
case SE_4_RANDOM_LIGHTS:
2020-10-22 21:17:51 +00:00
handle_se04(act);
2020-05-10 07:08:02 +00:00
break;
//BOSS
case SE_5_BOSS:
2020-10-22 21:17:51 +00:00
handle_se05(act, FIRELASER);
2020-05-10 07:08:02 +00:00
break;
case SE_8_UP_OPEN_DOOR_LIGHTS:
case SE_9_DOWN_OPEN_DOOR_LIGHTS:
2020-10-22 21:17:51 +00:00
handle_se08(act, false);
2020-05-10 07:08:02 +00:00
break;
case SE_10_DOOR_AUTO_CLOSE:
{
static const int tags[] = { 20, 21, 22, 26, 0};
2020-10-22 21:17:51 +00:00
handle_se10(act, tags);
2020-05-10 07:08:02 +00:00
break;
}
case SE_11_SWINGING_DOOR:
2020-10-22 21:17:51 +00:00
handle_se11(act);
2020-05-10 07:08:02 +00:00
break;
case SE_12_LIGHT_SWITCH:
2020-10-22 21:17:51 +00:00
handle_se12(act);
2020-05-10 07:08:02 +00:00
break;
case SE_13_EXPLOSIVE:
2020-10-22 21:17:51 +00:00
handle_se13(act);
2020-05-10 07:08:02 +00:00
break;
case SE_15_SLIDING_DOOR:
2020-10-22 21:17:51 +00:00
handle_se15(act);
2020-05-10 07:08:02 +00:00
break;
case SE_16_REACTOR:
2020-10-22 21:17:51 +00:00
handle_se16(act, REACTOR, REACTOR2);
2020-05-10 07:08:02 +00:00
break;
case SE_17_WARP_ELEVATOR:
2020-10-22 21:17:51 +00:00
handle_se17(act);
2020-05-10 07:08:02 +00:00
break;
case SE_18_INCREMENTAL_SECTOR_RISE_FALL:
2020-10-22 21:17:51 +00:00
handle_se18(act, true);
2020-05-10 07:08:02 +00:00
break;
case SE_19_EXPLOSION_LOWERS_CEILING:
2020-10-22 21:17:51 +00:00
handle_se19(act, BIGFORCE);
2020-05-10 07:08:02 +00:00
break;
case SE_20_STRETCH_BRIDGE:
2020-10-22 21:17:51 +00:00
handle_se20(act);
2020-05-10 07:08:02 +00:00
break;
case SE_21_DROP_FLOOR:
2020-10-22 21:17:51 +00:00
handle_se21(act);
2020-05-10 07:08:02 +00:00
break;
case SE_22_TEETH_DOOR:
2020-10-22 21:17:51 +00:00
handle_se22(act);
2020-05-10 07:08:02 +00:00
break;
case SE_24_CONVEYOR:
2020-11-27 19:06:38 +00:00
case SE_34:
{
2021-11-06 12:53:18 +00:00
static const int16_t list1[] = { BLOODPOOL, PUKE, FOOTPRINTS, FOOTPRINTS2, FOOTPRINTS3, FOOTPRINTS4, BULLETHOLE, BLOODSPLAT1, BLOODSPLAT2, BLOODSPLAT3, BLOODSPLAT4, -1 };
static const int16_t list2[] = { BOLT1, BOLT1 + 1,BOLT1 + 2, BOLT1 + 3, SIDEBOLT1, SIDEBOLT1 + 1, SIDEBOLT1 + 2, SIDEBOLT1 + 3, -1 };
2021-05-02 17:32:20 +00:00
handle_se24(act, list1, list2, true, TRIPBOMB, LASERLINE, CRANE, 2);
2020-05-10 07:08:02 +00:00
break;
}
2020-11-27 19:06:38 +00:00
case SE_35:
2020-10-22 21:17:51 +00:00
handle_se35(act, SMALLSMOKE, EXPLOSION2);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_25_PISTON: //PISTONS
2020-10-22 21:17:51 +00:00
if (act->temp_data[4] == 0) break;
handle_se25(act, 3, -1, -1);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_26:
2020-10-22 21:17:51 +00:00
handle_se26(act);
2020-05-10 07:08:02 +00:00
break;
case SE_27_DEMO_CAM:
2020-10-22 21:17:51 +00:00
handle_se27(act);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_28_LIGHTNING:
2020-10-22 21:17:51 +00:00
handle_se28(act);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_29_WAVES:
act->s->hitag += 64;
l = MulScale(act->s->yvel, bsin(act->s->hitag), 12);
sc->floorz = act->s->z + l;
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
2020-10-22 21:17:51 +00:00
handle_se31(act, true);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_32_CEILING_RISE_FALL: // True Drop Ceiling
2020-10-22 21:17:51 +00:00
handle_se32(act);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_33_QUAKE_DEBRIS:
2020-05-10 07:08:02 +00:00
if (earthquaketime > 0 && (krand() & 7) == 0)
2020-10-22 21:17:51 +00:00
RANDOMSCRAP(act);
2020-05-10 07:08:02 +00:00
break;
2020-11-27 19:06:38 +00:00
case SE_36_PROJ_SHOOTER:
2020-05-10 07:08:02 +00:00
2020-10-22 21:17:51 +00:00
if (act->temp_data[0])
2020-05-10 07:08:02 +00:00
{
2020-10-22 21:17:51 +00:00
if (act->temp_data[0] == 1)
fi.shoot(act, sc->extra);
2020-10-22 21:17:51 +00:00
else if (act->temp_data[0] == 26 * 5)
act->temp_data[0] = 0;
act->temp_data[0]++;
2020-05-10 07:08:02 +00:00
}
break;
case SE_128_GLASS_BREAKING:
2020-10-22 21:17:51 +00:00
handle_se128(act);
2020-05-10 07:08:02 +00:00
break;
case 130:
2020-10-22 21:17:51 +00:00
handle_se130(act, 80, EXPLOSION2);
2020-05-10 07:08:02 +00:00
break;
case 131:
2020-10-22 21:17:51 +00:00
handle_se130(act, 40, EXPLOSION2);
2020-05-10 07:08:02 +00:00
break;
}
}
//Sloped sin-wave floors!
it.Reset(STAT_EFFECTOR);
2020-10-22 21:17:51 +00:00
while (auto act = it.Next())
2020-05-10 07:08:02 +00:00
{
if (act->s->lotag != SE_29_WAVES) continue;
2021-11-20 23:33:17 +00:00
auto sc = act->sector();
2020-05-10 07:08:02 +00:00
if (sc->wallnum != 4) continue;
auto wal = sc->firstWall() + 2;
alignflorslope(act->s->sectnum, wal->x, wal->y, wal->nextSector()->floorz);
2020-05-10 07:08:02 +00:00
}
}
2020-05-08 22:34:48 +00:00
2020-05-13 22:04:14 +00:00
//---------------------------------------------------------------------------
//
2020-10-22 21:41:07 +00:00
//
2020-05-13 22:04:14 +00:00
//
//---------------------------------------------------------------------------
2020-11-01 14:56:50 +00:00
void move_d(DDukeActor *actor, int playernum, int xvel)
2020-05-13 22:04:14 +00:00
{
auto spr = actor->s;
2020-11-01 14:56:50 +00:00
auto t = actor->temp_data;
2020-05-13 22:04:14 +00:00
int l;
int goalang, angdif;
2020-05-13 22:04:14 +00:00
int daxvel;
2020-11-01 14:56:50 +00:00
int a = spr->hitag;
2020-05-13 22:04:14 +00:00
if (a == -1) a = 0;
2020-11-01 14:56:50 +00:00
t[0]++;
2020-05-13 22:04:14 +00:00
if (a & face_player)
{
2020-11-02 23:20:51 +00:00
if (ps[playernum].newOwner != nullptr)
2020-11-01 14:56:50 +00:00
goalang = getangle(ps[playernum].oposx - spr->x, ps[playernum].oposy - spr->y);
else goalang = getangle(ps[playernum].pos.x - spr->x, ps[playernum].pos.y - spr->y);
2020-11-01 14:56:50 +00:00
angdif = getincangle(spr->ang, goalang) >> 2;
2020-05-13 22:04:14 +00:00
if (angdif > -8 && angdif < 0) angdif = 0;
2020-11-01 14:56:50 +00:00
spr->ang += angdif;
2020-05-13 22:04:14 +00:00
}
if (a & spin)
spr->ang += bsin(t[0] << 3, -6);
2020-05-13 22:04:14 +00:00
if (a & face_player_slow)
{
2020-11-02 23:20:51 +00:00
if (ps[playernum].newOwner != nullptr)
2020-11-01 14:56:50 +00:00
goalang = getangle(ps[playernum].oposx - spr->x, ps[playernum].oposy - spr->y);
else goalang = getangle(ps[playernum].pos.x - spr->x, ps[playernum].pos.y - spr->y);
angdif = Sgn(getincangle(spr->ang, goalang)) << 5;
2020-05-13 22:04:14 +00:00
if (angdif > -32 && angdif < 0)
{
angdif = 0;
2020-11-01 14:56:50 +00:00
spr->ang = goalang;
2020-05-13 22:04:14 +00:00
}
2020-11-01 14:56:50 +00:00
spr->ang += angdif;
2020-05-13 22:04:14 +00:00
}
if ((a & jumptoplayer) == jumptoplayer)
{
2020-11-01 14:56:50 +00:00
if (t[0] < 16)
spr->zvel -= bcos(t[0] << 4, -5);
2020-05-13 22:04:14 +00:00
}
if (a & face_player_smart)
{
2020-10-02 20:14:20 +00:00
int newx, newy;
2020-05-13 22:04:14 +00:00
newx = ps[playernum].pos.x + (ps[playernum].posxv / 768);
newy = ps[playernum].pos.y + (ps[playernum].posyv / 768);
2020-11-01 14:56:50 +00:00
goalang = getangle(newx - spr->x, newy - spr->y);
angdif = getincangle(spr->ang, goalang) >> 2;
2020-05-13 22:04:14 +00:00
if (angdif > -8 && angdif < 0) angdif = 0;
2020-11-01 14:56:50 +00:00
spr->ang += angdif;
2020-05-13 22:04:14 +00:00
}
2020-11-01 14:56:50 +00:00
if (t[1] == 0 || a == 0)
2020-05-13 22:04:14 +00:00
{
if ((badguy(actor) && spr->extra <= 0) || (spr->ox != spr->x) || (spr->oy != spr->y))
2020-05-13 22:04:14 +00:00
{
spr->backupvec2();
2020-11-01 14:56:50 +00:00
setsprite(actor, spr->pos);
2020-05-13 22:04:14 +00:00
}
return;
}
2020-11-01 14:56:50 +00:00
auto moveptr = &ScriptCode[t[1]];
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (a & geth) spr->xvel += (*moveptr - spr->xvel) >> 1;
if (a & getv) spr->zvel += ((*(moveptr + 1) << 4) - spr->zvel) >> 1;
2020-05-13 22:04:14 +00:00
if (a & dodgebullet)
2020-10-22 21:41:07 +00:00
dodge(actor);
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (spr->picnum != APLAYER)
alterang(a, actor, playernum);
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (spr->xvel > -6 && spr->xvel < 6) spr->xvel = 0;
2020-05-13 22:04:14 +00:00
2020-10-22 21:41:07 +00:00
a = badguy(actor);
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (spr->xvel || spr->zvel)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if (a && spr->picnum != ROTATEGUN)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if ((spr->picnum == DRONE || spr->picnum == COMMANDER) && spr->extra > 0)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if (spr->picnum == COMMANDER)
2020-05-13 22:04:14 +00:00
{
actor->floorz = l = getflorzofslopeptr(spr->sector(), spr->x, spr->y);
2020-11-01 14:56:50 +00:00
if (spr->z > (l - (8 << 8)))
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if (spr->z > (l - (8 << 8))) spr->z = l - (8 << 8);
spr->zvel = 0;
2020-05-13 22:04:14 +00:00
}
actor->ceilingz = l = getceilzofslopeptr(spr->sector(), spr->x, spr->y);
2020-11-01 14:56:50 +00:00
if ((spr->z - l) < (80 << 8))
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
spr->z = l + (80 << 8);
spr->zvel = 0;
2020-05-13 22:04:14 +00:00
}
}
else
{
2020-11-01 14:56:50 +00:00
if (spr->zvel > 0)
2020-05-13 22:04:14 +00:00
{
actor->floorz = l = getflorzofslopeptr(spr->sector(), spr->x, spr->y);
2020-11-01 14:56:50 +00:00
if (spr->z > (l - (30 << 8)))
spr->z = l - (30 << 8);
2020-05-13 22:04:14 +00:00
}
else
{
actor->ceilingz = l = getceilzofslopeptr(spr->sector(), spr->x, spr->y);
2020-11-01 14:56:50 +00:00
if ((spr->z - l) < (50 << 8))
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
spr->z = l + (50 << 8);
spr->zvel = 0;
2020-05-13 22:04:14 +00:00
}
}
}
}
2020-11-01 14:56:50 +00:00
else if (spr->picnum != ORGANTIC)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if (spr->zvel > 0 && actor->floorz < spr->z)
spr->z = actor->floorz;
if (spr->zvel < 0)
2020-05-13 22:04:14 +00:00
{
l = getceilzofslopeptr(spr->sector(), spr->x, spr->y);
2020-11-01 14:56:50 +00:00
if ((spr->z - l) < (66 << 8))
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
spr->z = l + (66 << 8);
spr->zvel >>= 1;
2020-05-13 22:04:14 +00:00
}
}
}
}
2020-11-01 14:56:50 +00:00
else if (spr->picnum == APLAYER)
if ((spr->z - actor->ceilingz) < (32 << 8))
spr->z = actor->ceilingz + (32 << 8);
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
daxvel = spr->xvel;
angdif = spr->ang;
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (a && spr->picnum != ROTATEGUN)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if (xvel < 960 && spr->xrepeat > 16)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
daxvel = -(1024 - xvel);
angdif = getangle(ps[playernum].pos.x - spr->x, ps[playernum].pos.y - spr->y);
2020-05-13 22:04:14 +00:00
2020-11-01 14:56:50 +00:00
if (xvel < 512)
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
ps[playernum].posxv = 0;
ps[playernum].posyv = 0;
2020-05-13 22:04:14 +00:00
}
else
{
ps[playernum].posxv = MulScale(ps[playernum].posxv, gs.playerfriction - 0x2000, 16);
ps[playernum].posyv = MulScale(ps[playernum].posyv, gs.playerfriction - 0x2000, 16);
2020-05-13 22:04:14 +00:00
}
}
2020-11-01 14:56:50 +00:00
else if (spr->picnum != DRONE && spr->picnum != SHARK && spr->picnum != COMMANDER)
2020-05-13 22:04:14 +00:00
{
if (spr->oz != spr->z || (ud.multimode < 2 && ud.player_skill < 2))
2020-05-13 22:04:14 +00:00
{
2020-11-01 14:56:50 +00:00
if ((t[0] & 1) || ps[playernum].actorsqu == actor) return;
2020-05-13 22:04:14 +00:00
else daxvel <<= 1;
}
else
{
2020-11-01 14:56:50 +00:00
if ((t[0] & 3) || ps[playernum].actorsqu == actor) return;
2020-05-13 22:04:14 +00:00
else daxvel <<= 2;
}
}
}
2020-10-22 21:41:07 +00:00
Collision coll;
actor->movflag = movesprite_ex(actor,
MulScale(daxvel, bcos(angdif), 14),
MulScale(daxvel, bsin(angdif), 14), spr->zvel, CLIPMASK0, coll);
2020-05-13 22:04:14 +00:00
}
if (a)
{
if (spr->sector()->ceilingstat & 1)
spr->shade += (spr->sector()->ceilingshade - spr->shade) >> 1;
else spr->shade += (spr->sector()->floorshade - spr->shade) >> 1;
2020-05-13 22:04:14 +00:00
if (spr->sector()->floorpicnum == MIRROR)
2020-10-22 21:41:07 +00:00
deletesprite(actor);
2020-05-13 22:04:14 +00:00
}
}
2020-10-22 21:41:07 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void fall_d(DDukeActor *actor, int g_p)
2020-05-14 07:07:07 +00:00
{
fall_common(actor, g_p, JIBS6, DRONE, BLOODPOOL, SHOTSPARK1, SQUISHED, THUD, nullptr);
2020-05-14 07:07:07 +00:00
}
2020-05-14 17:23:36 +00:00
bool spawnweapondebris_d(int picnum, int dnum)
{
return picnum == BLIMP && dnum == SCRAP1;
}
void respawnhitag_d(DDukeActor* actor)
2020-05-14 17:23:36 +00:00
{
switch (actor->s->picnum)
2020-05-14 17:23:36 +00:00
{
case FEM1:
case FEM2:
case FEM3:
case FEM4:
case FEM5:
case FEM6:
case FEM7:
case FEM8:
case FEM9:
case FEM10:
case PODFEM1:
case NAKED1:
case STATUE:
if (actor->s->yvel) fi.operaterespawns(actor->s->yvel);
2020-05-14 17:23:36 +00:00
break;
default:
if (actor->s->hitag >= 0) fi.operaterespawns(actor->s->hitag);
2020-05-14 17:23:36 +00:00
break;
}
}
void checktimetosleep_d(DDukeActor *actor)
2020-05-14 17:23:36 +00:00
{
if (actor->s->statnum == STAT_STANDABLE)
2020-05-14 17:23:36 +00:00
{
switch (actor->s->picnum)
2020-05-14 17:23:36 +00:00
{
case RUBBERCAN:
case EXPLODINGBARREL:
case WOODENHORSE:
case HORSEONSIDE:
case CANWITHSOMETHING:
case FIREBARREL:
case NUKEBARREL:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case TRIPBOMB:
case EGG:
if (actor->timetosleep > 1)
actor->timetosleep--;
else if (actor->timetosleep == 1)
changeactorstat(actor, STAT_ZOMBIEACTOR);
2020-05-14 17:23:36 +00:00
break;
}
}
}
2020-06-23 19:12:15 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void think_d(void)
{
thinktime.Reset();
thinktime.Clock();
recordoldspritepos();
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();
}
2020-05-07 12:55:04 +00:00
END_DUKE_NS