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.
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
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"
|
2020-07-03 21:56:14 +00:00
|
|
|
#include "names_d.h"
|
2020-06-29 21:36:06 +00:00
|
|
|
#include "serializer.h"
|
2020-10-21 17:14:41 +00:00
|
|
|
#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;
|
|
|
|
|
2020-06-29 21:36:06 +00:00
|
|
|
static FSerializer& Serialize(FSerializer& arc, const char* key, FireProj& p, FireProj* def)
|
|
|
|
{
|
|
|
|
if (arc.BeginObject(key))
|
|
|
|
{
|
|
|
|
arc("x", p.x)
|
|
|
|
("y", p.y)
|
|
|
|
("z", p.z)
|
|
|
|
("xv", p.xv)
|
|
|
|
("yv", p.yv)
|
|
|
|
("zv", p.zv)
|
|
|
|
.EndObject();
|
|
|
|
}
|
|
|
|
return arc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SerializeActorGlobals(FSerializer& arc)
|
|
|
|
{
|
|
|
|
if (arc.isWriting() && fire.CountUsed() == 0) return;
|
|
|
|
bool res = arc.BeginArray("FireProj");
|
|
|
|
if (arc.isReading())
|
|
|
|
{
|
|
|
|
fire.Clear();
|
|
|
|
if (!res) return;
|
|
|
|
auto length = arc.ArraySize() / 2;
|
|
|
|
int key;
|
|
|
|
FireProj value;
|
|
|
|
|
|
|
|
for (int i = 0; i < length; i++)
|
|
|
|
{
|
|
|
|
Serialize(arc, nullptr, key, nullptr);
|
|
|
|
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
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
bool ceilingspace_d(int sectnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
if( (sector[sectnum].ceilingstat&1) && sector[sectnum].ceilingpal == 0 )
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
switch(sector[sectnum].ceilingpicnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
case MOONSKY1:
|
|
|
|
case BIGORBIT1:
|
|
|
|
return 1;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
bool floorspace_d(int sectnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
if( (sector[sectnum].floorstat&1) && sector[sectnum].ceilingpal == 0 )
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
switch(sector[sectnum].floorpicnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +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
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void check_fta_sounds_d(int i)
|
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
auto spri = &sprite[i];
|
|
|
|
if (spri->extra > 0) switch (spri->picnum)
|
2020-05-16 10:47:01 +00:00
|
|
|
{
|
|
|
|
case LIZTROOPONTOILET:
|
|
|
|
case LIZTROOPJUSTSIT:
|
|
|
|
case LIZTROOPSHOOT:
|
|
|
|
case LIZTROOPJETPACK:
|
|
|
|
case LIZTROOPDUCKING:
|
|
|
|
case LIZTROOPRUNNING:
|
|
|
|
case LIZTROOP:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PRED_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case LIZMAN:
|
|
|
|
case LIZMANSPITTING:
|
|
|
|
case LIZMANFEEDING:
|
|
|
|
case LIZMANJUMP:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(CAPT_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case PIGCOP:
|
|
|
|
case PIGCOPDIVE:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PIG_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case RECON:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(RECO_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case DRONE:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(DRON_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case COMMANDER:
|
|
|
|
case COMMANDERSTAYPUT:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(COMM_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case ORGANTIC:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TURR_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case OCTABRAIN:
|
|
|
|
case OCTABRAINSTAYPUT:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(OCTA_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case BOSS1:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlaySound(BOS1_RECOG);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case BOSS2:
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->pal == 1)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlaySound(BOS2_RECOG);
|
|
|
|
else S_PlaySound(WHIPYOURASS);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case BOSS3:
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->pal == 1)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlaySound(BOS3_RECOG);
|
|
|
|
else S_PlaySound(RIPHEADNECK);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case BOSS4:
|
|
|
|
case BOSS4STAYPUT:
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->pal == 1)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlaySound(BOS4_RECOG);
|
|
|
|
S_PlaySound(BOSS4_FIRSTSEE);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
case GREENSLIME:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SLIM_RECOG, i);
|
2020-05-16 10:47:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-07 12:55:04 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
void addweapon_d(struct player_struct *p, int weapon)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
if ( p->gotweapon[weapon] == 0 )
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
p->gotweapon.Set(weapon);
|
2020-05-07 20:30:19 +00:00
|
|
|
if(weapon == SHRINKER_WEAPON)
|
2020-05-07 12:55:04 +00:00
|
|
|
p->gotweapon.Set(GROW_WEAPON);
|
|
|
|
}
|
|
|
|
|
|
|
|
p->random_club_frame = 0;
|
|
|
|
|
|
|
|
if (p->holster_weapon == 0)
|
|
|
|
{
|
|
|
|
p->weapon_pos = -1;
|
|
|
|
p->last_weapon = p->curr_weapon;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p->weapon_pos = 10;
|
|
|
|
p->holster_weapon = 0;
|
|
|
|
p->last_weapon = -1;
|
|
|
|
}
|
|
|
|
|
2020-09-16 11:01:09 +00:00
|
|
|
p->okickback_pic = p->kickback_pic = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
#ifdef EDUKE
|
2020-05-07 20:30:19 +00:00
|
|
|
if(p->curr_weapon != weapon)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int snum;
|
2020-05-07 12:55:04 +00:00
|
|
|
snum = sprite[p->i].yvel;
|
|
|
|
|
2020-05-13 15:39:30 +00:00
|
|
|
SetGameVarID(g_iWeaponVarID,weapon, snum, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (p->curr_weapon >= 0)
|
|
|
|
{
|
2020-05-13 15:39:30 +00:00
|
|
|
SetGameVarID(g_iWorksLikeVarID, aplWeaponWorksLike[weapon][snum], snum, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-05-13 15:39:30 +00:00
|
|
|
SetGameVarID(g_iWorksLikeVarID, -1, snum, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-05-13 15:39:30 +00:00
|
|
|
SetGameVarID(g_iReturnVarID, 0, snum, -1);
|
2020-05-07 12:55:04 +00:00
|
|
|
OnEvent(EVENT_CHANGEWEAPON, p->i, snum, -1);
|
|
|
|
if (GetGameVarID(g_iReturnVarID, -1, snum) == 0)
|
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
p->curr_weapon = weapon;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2020-05-07 20:30:19 +00:00
|
|
|
p->curr_weapon = weapon;
|
2020-05-07 12:55:04 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
switch (weapon)
|
|
|
|
{
|
|
|
|
case KNEE_WEAPON:
|
|
|
|
case TRIPBOMB_WEAPON:
|
|
|
|
case HANDREMOTE_WEAPON:
|
2020-05-07 20:30:19 +00:00
|
|
|
case HANDBOMB_WEAPON:
|
2020-05-07 12:55:04 +00:00
|
|
|
break;
|
2020-05-07 20:30:19 +00:00
|
|
|
case SHOTGUN_WEAPON:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SHOTGUN_COCK, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
break;
|
2020-05-07 20:30:19 +00:00
|
|
|
case PISTOL_WEAPON:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(INSERT_CLIP, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
break;
|
2020-05-07 20:30:19 +00:00
|
|
|
default:
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SELECT_WEAPON, p->i);
|
2020-05-07 12:55:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
bool ifsquished(int i, int p)
|
|
|
|
{
|
|
|
|
if (isRR()) return false; // this function is a no-op in RR's source.
|
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
auto spri = &sprite[i];
|
2020-10-12 19:30:12 +00:00
|
|
|
auto ht = &hittype[i];
|
2020-05-07 12:55:04 +00:00
|
|
|
bool squishme = false;
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->picnum == APLAYER && ud.clipping)
|
2020-05-07 12:55:04 +00:00
|
|
|
return false;
|
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
auto& sc = sector[spri->sectnum];
|
2020-05-07 12:55:04 +00:00
|
|
|
int floorceildist = sc.floorz - sc.ceilingz;
|
|
|
|
|
|
|
|
if (sc.lotag != ST_23_SWINGING_DOOR)
|
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->pal == 1)
|
2020-05-07 12:55:04 +00:00
|
|
|
squishme = floorceildist < (32 << 8) && (sc.lotag & 32768) == 0;
|
|
|
|
else
|
|
|
|
squishme = floorceildist < (12 << 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (squishme)
|
|
|
|
{
|
|
|
|
FTA(QUOTE_SQUISHED, &ps[p]);
|
|
|
|
|
|
|
|
if (badguy(&sprite[i]))
|
2020-10-12 18:59:08 +00:00
|
|
|
spri->xvel = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->pal == 1)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 19:30:12 +00:00
|
|
|
ht->picnum = SHOTSPARK1;
|
|
|
|
ht->extra = 1;
|
2020-05-07 12:55:04 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int hp4)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
walltype* wal;
|
|
|
|
int d, q, x1, y1;
|
|
|
|
int sectcnt, sectend, dasect, startwall, endwall, nextsect;
|
2020-10-21 20:04:39 +00:00
|
|
|
short p, x, sect;
|
2020-05-07 12:55:04 +00:00
|
|
|
static const uint8_t statlist[] = { STAT_DEFAULT, STAT_ACTOR, STAT_STANDABLE, STAT_PLAYER, STAT_FALLER, STAT_ZOMBIEACTOR, STAT_MISC };
|
|
|
|
short tempshort[MAXSECTORS]; // originally hijacked a global buffer which is bad. Q: How many do we really need? RedNukem says 64.
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
auto spri = &actor->s;
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-24 20:41:14 +00:00
|
|
|
if(spri->picnum == RPG && spri->xrepeat < 11) goto SKIPWALLCHECK;
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-24 20:41:14 +00:00
|
|
|
if(spri->picnum != SHRINKSPARK)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 20:41:14 +00:00
|
|
|
tempshort[0] = spri->sectnum;
|
|
|
|
dasect = spri->sectnum;
|
2020-05-07 12:55:04 +00:00
|
|
|
sectcnt = 0; sectend = 1;
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-05-07 12:55:04 +00:00
|
|
|
do
|
|
|
|
{
|
|
|
|
dasect = tempshort[sectcnt++];
|
2020-10-24 20:41:14 +00:00
|
|
|
if (((sector[dasect].ceilingz - spri->z) >> 8) < r)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 20:41:14 +00:00
|
|
|
d = abs(wall[sector[dasect].wallptr].x - spri->x) + abs(wall[sector[dasect].wallptr].y - spri->y);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (d < r)
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitceiling(dasect);
|
2020-05-07 12:55:04 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// ouch...
|
2020-10-24 20:41:14 +00:00
|
|
|
d = abs(wall[wall[wall[sector[dasect].wallptr].point2].point2].x - spri->x) + abs(wall[wall[wall[sector[dasect].wallptr].point2].point2].y - spri->y);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (d < r)
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitceiling(dasect);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
startwall = sector[dasect].wallptr;
|
|
|
|
endwall = startwall + sector[dasect].wallnum;
|
|
|
|
for (x = startwall, wal = &wall[startwall]; x < endwall; x++, wal++)
|
2020-10-24 20:41:14 +00:00
|
|
|
if ((abs(wal->x - spri->x) + abs(wal->y - spri->y)) < r)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
nextsect = wal->nextsector;
|
|
|
|
if (nextsect >= 0)
|
|
|
|
{
|
|
|
|
for (dasect = sectend - 1; dasect >= 0; dasect--)
|
|
|
|
if (tempshort[dasect] == nextsect) break;
|
|
|
|
if (dasect < 0) tempshort[sectend++] = nextsect;
|
|
|
|
}
|
2020-10-24 20:41:14 +00:00
|
|
|
x1 = (((wal->x + wall[wal->point2].x) >> 1) + spri->x) >> 1;
|
|
|
|
y1 = (((wal->y + wall[wal->point2].y) >> 1) + spri->y) >> 1;
|
2020-05-07 12:55:04 +00:00
|
|
|
updatesector(x1, y1, §);
|
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))
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.checkhitwall(actor->GetIndex(), x, wal->x, wal->y, spri->z, spri->picnum);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
} while (sectcnt < sectend);
|
|
|
|
}
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-05-07 12:55:04 +00:00
|
|
|
SKIPWALLCHECK:
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
q = -(16 << 8) + (krand() & ((32 << 8) - 1));
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
auto Owner = actor->GetOwner();
|
2020-05-07 12:55:04 +00:00
|
|
|
for (x = 0; x < 7; x++)
|
|
|
|
{
|
2020-10-21 20:04:39 +00:00
|
|
|
DukeStatIterator itj(statlist[x]);
|
|
|
|
while (auto act2 = itj.Next())
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:04:39 +00:00
|
|
|
auto spri2 = &act2->s;
|
|
|
|
if (isWorldTour() && Owner)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:04:39 +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
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
if (spri->picnum == FLAMETHROWERFLAME && ((Owner->s.picnum == FIREFLY && spri2->picnum == FIREFLY) || (Owner->s.picnum == BOSS5 && spri2->picnum == BOSS5)))
|
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))
|
2020-10-21 20:04:39 +00:00
|
|
|
if (dist(actor, act2) < r)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:04:39 +00:00
|
|
|
if (badguy(act2) && !cansee(spri2->x, spri2->y, spri2->z + q, spri2->sectnum, spri->x, spri->y, spri->z + q, spri->sectnum))
|
2020-10-12 19:30:12 +00:00
|
|
|
continue;
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.checkhitsprite(act2->GetIndex(), actor->GetIndex());
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-21 20:04:39 +00:00
|
|
|
else if (spri2->extra >= 0 && act2 != actor && (spri2->picnum == TRIPBOMB || badguy(act2) || spri2->picnum == QUEBALL || spri2->picnum == STRIPEBALL || (spri2->cstat & 257) || spri2->picnum == DUKELYINGDEAD))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:04:39 +00:00
|
|
|
if (spri->picnum == SHRINKSPARK && spri2->picnum != SHARK && (act2 == Owner || spri2->xrepeat < 24))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
continue;
|
|
|
|
}
|
2020-10-21 20:04:39 +00:00
|
|
|
if (spri->picnum == MORTER && act2 == Owner)
|
2020-05-07 20:30:19 +00:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-24 20:41:14 +00:00
|
|
|
if (spri2->picnum == APLAYER) spri2->z -= PHEIGHT;
|
2020-10-21 20:04:39 +00:00
|
|
|
d = dist(actor, act2);
|
2020-10-24 20:41:14 +00:00
|
|
|
if (spri2->picnum == APLAYER) spri2->z += PHEIGHT;
|
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;
|
2020-05-07 20:30:19 +00:00
|
|
|
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
|
|
|
}
|
2020-05-07 20:30:19 +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;
|
2020-10-21 20:04:39 +00:00
|
|
|
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;
|
2020-05-07 20:30:19 +00:00
|
|
|
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-05-07 20:30:19 +00:00
|
|
|
}
|
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 20:30:19 +00:00
|
|
|
{
|
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
|
|
|
|
2020-10-21 20:04:39 +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)
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.checkhitsprite(act2->GetIndex(), actor->GetIndex());
|
2020-05-07 20:30:19 +00:00
|
|
|
}
|
2020-10-24 20:41:14 +00:00
|
|
|
else if (spri->extra == 0) act2->extra = 0;
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
if (spri2->picnum != RADIUSEXPLOSION && Owner && Owner->s.statnum < MAXSTATUS)
|
2020-05-07 20:30:19 +00:00
|
|
|
{
|
2020-10-24 20:41:14 +00:00
|
|
|
if (spri2->picnum == APLAYER)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 20:41:14 +00:00
|
|
|
p = spri2->yvel;
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-10-21 20:04:39 +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-05-07 20:30:19 +00:00
|
|
|
}
|
2020-10-12 19:30:12 +00:00
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
if (ps[p].newowner >= 0)
|
|
|
|
{
|
|
|
|
clearcamera(&ps[p]);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-21 20:04:39 +00:00
|
|
|
act2->SetHitOwner(actor->GetOwner());
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-24 07:31:15 +00:00
|
|
|
|
|
|
|
int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, unsigned int cliptype, Collision &result)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
int daz, h, oldx, oldy;
|
|
|
|
short retval, dasectnum, cd;
|
|
|
|
|
2020-10-24 07:31:15 +00:00
|
|
|
auto spri = &actor->s;
|
|
|
|
int bg = badguy(actor);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->statnum == 5 || (bg && spri->xrepeat < 4))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 18:59:08 +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)
|
2020-10-24 07:31:15 +00:00
|
|
|
setsprite(actor, spri->x, spri->y, spri->z);
|
|
|
|
return result.setNone();
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
dasectnum = spri->sectnum;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
daz = spri->z;
|
2020-10-24 07:31:15 +00:00
|
|
|
h = ((tileHeight(spri->picnum) * spri->yrepeat) << 1);
|
2020-05-07 12:55:04 +00:00
|
|
|
daz -= h;
|
|
|
|
|
|
|
|
if (bg)
|
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
oldx = spri->x;
|
|
|
|
oldy = spri->y;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->xrepeat > 60)
|
|
|
|
retval = clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 1024L, (4 << 8), (4 << 8), cliptype);
|
2020-05-07 12:55:04 +00:00
|
|
|
else
|
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
if (spri->picnum == LIZMAN)
|
2020-05-07 12:55:04 +00:00
|
|
|
cd = 292;
|
2020-10-24 07:31:15 +00:00
|
|
|
else if (actorflag(actor->GetIndex(), SFLAG_BADGUY))
|
2020-10-12 18:59:08 +00:00
|
|
|
cd = spri->clipdist << 2;
|
2020-05-07 12:55:04 +00:00
|
|
|
else
|
|
|
|
cd = 192;
|
|
|
|
|
2020-10-12 18:59:08 +00:00
|
|
|
retval = clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), cd, (4 << 8), (4 << 8), cliptype);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// conditional code from hell...
|
|
|
|
if (dasectnum < 0 || (dasectnum >= 0 &&
|
2020-10-24 07:31:15 +00:00
|
|
|
((actor->actorstayput >= 0 && actor->actorstayput != dasectnum) ||
|
2020-10-12 18:59:08 +00:00
|
|
|
((spri->picnum == BOSS2) && spri->pal == 0 && sector[dasectnum].lotag != 3) ||
|
|
|
|
((spri->picnum == BOSS1 || spri->picnum == BOSS2) && sector[dasectnum].lotag == ST_1_ABOVE_WATER) ||
|
|
|
|
(sector[dasectnum].lotag == ST_1_ABOVE_WATER && (spri->picnum == LIZMAN || (spri->picnum == LIZTROOP && spri->zvel == 0)))
|
2020-05-07 20:30:19 +00:00
|
|
|
))
|
|
|
|
)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
spri->x = oldx;
|
|
|
|
spri->y = oldy;
|
|
|
|
if (sector[dasectnum].lotag == ST_1_ABOVE_WATER && spri->picnum == LIZMAN)
|
|
|
|
spri->ang = (krand()&2047);
|
2020-10-24 07:31:15 +00:00
|
|
|
else if ((actor->temp_data[0]&3) == 1 && spri->picnum != COMMANDER)
|
2020-10-12 18:59:08 +00:00
|
|
|
spri->ang = (krand()&2047);
|
2020-10-24 07:31:15 +00:00
|
|
|
setsprite(actor,oldx,oldy,spri->z);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (dasectnum < 0) dasectnum = 0;
|
2020-10-24 07:31:15 +00:00
|
|
|
return result.setSector(dasectnum);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-24 19:36:27 +00:00
|
|
|
if ((retval & kHitTypeMask) > kHitSector && (actor->cgg == 0)) spri->ang += 768;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-24 07:31:15 +00:00
|
|
|
if (spri->statnum == STAT_PROJECTILE)
|
2020-05-07 12:55:04 +00:00
|
|
|
retval =
|
2020-10-12 18:59:08 +00:00
|
|
|
clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 8L, (4 << 8), (4 << 8), cliptype);
|
2020-05-07 12:55:04 +00:00
|
|
|
else
|
|
|
|
retval =
|
2020-10-12 18:59:08 +00:00
|
|
|
clipmove(&spri->x, &spri->y, &daz, &dasectnum, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), (int)(spri->clipdist << 2), (4 << 8), (4 << 8), cliptype);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dasectnum >= 0)
|
2020-10-12 18:59:08 +00:00
|
|
|
if ((dasectnum != spri->sectnum))
|
2020-10-24 07:31:15 +00:00
|
|
|
changespritesect(actor, dasectnum);
|
2020-10-12 18:59:08 +00:00
|
|
|
daz = spri->z + ((zchange * TICSPERFRAME) >> 3);
|
2020-10-24 07:31:15 +00:00
|
|
|
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
|
2020-10-12 18:59:08 +00:00
|
|
|
spri->z = daz;
|
2020-10-24 07:31:15 +00:00
|
|
|
else if (retval == 0)
|
|
|
|
return result.setSector(dasectnum);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-24 07:31:15 +00:00
|
|
|
return result.setFromEngine(retval);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
2020-05-07 20:30:19 +00:00
|
|
|
//
|
2020-05-07 12:55:04 +00:00
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-24 07:35:43 +00:00
|
|
|
void lotsofmoney_d(DDukeActor *actor, short n)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 07:35:43 +00:00
|
|
|
lotsofstuff(actor, n, MONEY);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-10-24 07:35:43 +00:00
|
|
|
void lotsofmail_d(DDukeActor *actor, short n)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 07:35:43 +00:00
|
|
|
lotsofstuff(actor, n, MAIL);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-10-24 07:35:43 +00:00
|
|
|
void lotsofpaper_d(DDukeActor *actor, short n)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 07:35:43 +00:00
|
|
|
lotsofstuff(actor, n, PAPER);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
void guts_d(spritetype* s, short gtype, short n, short p)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
int gutz, floorz;
|
|
|
|
int i=0, j;
|
|
|
|
int sx, sy;
|
|
|
|
uint8_t pal;
|
|
|
|
|
|
|
|
if (badguy(s) && s->xrepeat < 16)
|
|
|
|
sx = sy = 8;
|
|
|
|
else sx = sy = 32;
|
|
|
|
|
|
|
|
gutz = s->z - (8 << 8);
|
|
|
|
floorz = getflorzofslope(s->sectnum, s->x, s->y);
|
|
|
|
|
|
|
|
if (gutz > (floorz - (8 << 8)))
|
|
|
|
gutz = floorz - (8 << 8);
|
|
|
|
|
2020-10-21 22:05:08 +00:00
|
|
|
gutz += actorinfo[s->picnum].gutsoffset;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
|
|
|
if (badguy(s) && s->pal == 6)
|
|
|
|
pal = 6;
|
2020-07-29 15:28:02 +00:00
|
|
|
else if (s->picnum != LIZTROOP) // EDuke32 transfers the palette unconditionally, I'm not sure that's such a good idea.
|
|
|
|
pal = 0;
|
|
|
|
else
|
|
|
|
pal = s->pal;
|
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???
|
2020-10-12 20:00:19 +00:00
|
|
|
i = EGS(s->sectnum, s->x + (r5 & 255) - 128, s->y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].i, 5);
|
|
|
|
auto si = &sprite[i];
|
|
|
|
if (si->picnum == JIBS2)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 20:00:19 +00:00
|
|
|
si->xrepeat >>= 2;
|
|
|
|
si->yrepeat >>= 2;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
if (pal != 0)
|
2020-10-12 20:00:19 +00:00
|
|
|
si->pal = pal;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
2020-10-12 19:15:54 +00:00
|
|
|
//
|
2020-05-07 12:55:04 +00:00
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
void movefta_d(void)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
int x, px, py, sx, sy;
|
2020-10-12 19:30:12 +00:00
|
|
|
short p, psect, ssect;
|
2020-10-12 18:59:08 +00:00
|
|
|
int i, j;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
StatIterator iti(STAT_ZOMBIEACTOR);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
while ((i = iti.NextIndex()) >= 0)
|
|
|
|
{
|
2020-10-12 18:59:08 +00:00
|
|
|
auto s = &sprite[i];
|
2020-10-12 19:15:54 +00:00
|
|
|
auto ht = &hittype[i];
|
2020-05-07 12:55:04 +00:00
|
|
|
p = findplayer(s, &x);
|
|
|
|
|
|
|
|
ssect = psect = s->sectnum;
|
|
|
|
|
|
|
|
if (sprite[ps[p].i].extra > 0)
|
|
|
|
{
|
|
|
|
if (x < 30000)
|
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
ht->timetosleep++;
|
|
|
|
if (ht->timetosleep >= (x >> 8))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
if (badguy(s))
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
int r1 = krand();
|
|
|
|
int r2 = krand();
|
|
|
|
j = cansee(sx, sy, s->z - (r2 % (52 << 8)), s->sectnum, px, py, ps[p].oposz - (r1 % (32 << 8)), ps[p].cursectnum);
|
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);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
|
|
|
|
if (j) switch(s->picnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
case RUBBERCAN:
|
|
|
|
case EXPLODINGBARREL:
|
|
|
|
case WOODENHORSE:
|
|
|
|
case HORSEONSIDE:
|
|
|
|
case CANWITHSOMETHING:
|
|
|
|
case CANWITHSOMETHING2:
|
|
|
|
case CANWITHSOMETHING3:
|
|
|
|
case CANWITHSOMETHING4:
|
|
|
|
case FIREBARREL:
|
|
|
|
case FIREVASE:
|
|
|
|
case NUKEBARREL:
|
|
|
|
case NUKEBARRELDENTED:
|
|
|
|
case NUKEBARRELLEAKED:
|
|
|
|
case TRIPBOMB:
|
|
|
|
if (sector[s->sectnum].ceilingstat&1)
|
2020-05-07 12:55:04 +00:00
|
|
|
s->shade = sector[s->sectnum].ceilingshade;
|
|
|
|
else s->shade = sector[s->sectnum].floorshade;
|
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
ht->timetosleep = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
changespritestat(i, STAT_STANDABLE);
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2020-10-12 19:15:54 +00:00
|
|
|
ht->timetosleep = 0;
|
2020-05-16 10:47:01 +00:00
|
|
|
fi.check_fta_sounds(i);
|
2020-05-07 12:55:04 +00:00
|
|
|
changespritestat(i, STAT_ACTOR);
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-12 19:15:54 +00:00
|
|
|
else ht->timetosleep = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
2020-05-07 20:30:19 +00:00
|
|
|
if (badguy(s))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
if (sector[s->sectnum].ceilingstat & 1)
|
|
|
|
s->shade = sector[s->sectnum].ceilingshade;
|
|
|
|
else s->shade = sector[s->sectnum].floorshade;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
int ifhitsectors_d(int sectnum)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
StatIterator it(STAT_MISC);
|
|
|
|
int i;
|
|
|
|
while((i = it.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
auto s = &sprite[i];
|
|
|
|
if (s->picnum == EXPLOSION2 && sectnum == s->sectnum)
|
2020-05-07 20:30:19 +00:00
|
|
|
return i;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
int ifhitbyweapon_d(DDukeActor *actor)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
short p;
|
|
|
|
auto spri = &actor->s;
|
|
|
|
auto hitowner = actor->GetHitOwner();
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
if (actor->extra >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (spri->extra >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (spri->picnum == APLAYER)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (ud.god && actor->picnum != SHRINKSPARK) return -1;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
p = spri->yvel;
|
2020-10-21 19:41:14 +00:00
|
|
|
|
|
|
|
if (hitowner &&
|
|
|
|
hitowner->s.picnum == APLAYER &&
|
2020-05-07 12:55:04 +00:00
|
|
|
ud.coop == 1 &&
|
|
|
|
ud.ffire == 0)
|
|
|
|
return -1;
|
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
spri->extra -= actor->extra;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
if (hitowner)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (spri->extra <= 0 && actor->picnum != FREEZEBLAST)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
spri->extra = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
ps[p].wackedbyactor = hitowner;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
if (hitowner->s.picnum == APLAYER && p != hitowner->PlayerIndex())
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
ps[p].frag_ps = hitowner->PlayerIndex();
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-21 19:41:14 +00:00
|
|
|
actor->SetHitOwner(ps[p].GetActor());
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
switch(actor->picnum)
|
2020-05-07 20:30:19 +00:00
|
|
|
{
|
|
|
|
case RADIUSEXPLOSION:
|
|
|
|
case RPG:
|
|
|
|
case HYDRENT:
|
|
|
|
case HEAVYHBOMB:
|
|
|
|
case SEENINE:
|
|
|
|
case OOZFILTER:
|
|
|
|
case EXPLODINGBARREL:
|
|
|
|
ps[p].posxv +=
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra*(sintable[(actor->ang+512)&2047]) << 2;
|
2020-05-07 20:30:19 +00:00
|
|
|
ps[p].posyv +=
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra*(sintable[actor->ang&2047]) << 2;
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ps[p].posxv +=
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra*(sintable[(actor->ang+512)&2047]) << 1;
|
2020-05-07 20:30:19 +00:00
|
|
|
ps[p].posyv +=
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra*(sintable[actor->ang&2047]) << 1;
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (actor->extra == 0)
|
|
|
|
if (actor->picnum == SHRINKSPARK && spri->xrepeat < 24)
|
2020-05-07 12:55:04 +00:00
|
|
|
return -1;
|
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
if (isWorldTour() && actor->picnum == FIREFLY && spri->xrepeat < 48)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
if (actor->picnum != RADIUSEXPLOSION && actor->picnum != RPG)
|
2020-05-07 12:55:04 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
spri->extra -= actor->extra;
|
2020-10-21 19:41:14 +00:00
|
|
|
auto Owner = actor->GetOwner();
|
|
|
|
if (spri->picnum != RECON && Owner && Owner->s.statnum < MAXSTATUS)
|
|
|
|
actor->SetOwner(hitowner);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra = -1;
|
|
|
|
return actor->picnum;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (ud.multimode < 2 || !isWorldTour()
|
2020-10-24 08:45:30 +00:00
|
|
|
|| actor->picnum != FLAMETHROWERFLAME
|
|
|
|
|| actor->extra >= 0
|
|
|
|
|| spri->extra > 0
|
|
|
|
|| spri->picnum != APLAYER
|
2020-10-21 19:41:14 +00:00
|
|
|
|| ps[actor->PlayerIndex()].numloogs > 0
|
|
|
|
|| hitowner == nullptr)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra = -1;
|
2020-05-07 12:55:04 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2020-10-12 19:15:54 +00:00
|
|
|
else
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
p = actor->PlayerIndex();
|
2020-10-24 08:45:30 +00:00
|
|
|
spri->extra = 0;
|
2020-10-21 19:41:14 +00:00
|
|
|
ps[p].wackedbyactor = hitowner;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
if (hitowner->s.picnum == APLAYER && hitowner != ps[p].GetActor())
|
|
|
|
ps[p].frag_ps = hitowner->PlayerIndex(); // set the proper player index here - this previously set the sprite index...
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-21 19:41:14 +00:00
|
|
|
actor->SetHitOwner(ps[p].GetActor());
|
2020-10-24 08:45:30 +00:00
|
|
|
actor->extra = -1;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
|
|
|
return FLAMETHROWERFLAME;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
void movefallers_d(void)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 20:00:19 +00:00
|
|
|
short sect;
|
|
|
|
int i, j, x;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-12 20:00:19 +00:00
|
|
|
StatIterator iti(STAT_FALLER);
|
|
|
|
while ((i = iti.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 20:00:19 +00:00
|
|
|
auto s = &sprite[i];
|
|
|
|
auto ht = &hittype[i];
|
2020-05-07 12:55:04 +00:00
|
|
|
|
|
|
|
sect = s->sectnum;
|
|
|
|
|
2020-10-12 20:00:19 +00:00
|
|
|
if (ht->temp_data[0] == 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
s->z -= (16 << 8);
|
2020-10-12 20:00:19 +00:00
|
|
|
ht->temp_data[1] = s->ang;
|
2020-05-07 12:55:04 +00:00
|
|
|
x = s->extra;
|
2020-10-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]);
|
2020-10-12 20:00:19 +00:00
|
|
|
if (j >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +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-12 20:00:19 +00:00
|
|
|
ht->temp_data[0] = 1;
|
|
|
|
StatIterator itj(STAT_FALLER);
|
|
|
|
while ((j = itj.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-12 20:00:19 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->hitag == s->hitag)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
hittype[j].temp_data[0] = 1;
|
2020-10-12 20:00:19 +00:00
|
|
|
sj->cstat &= (65535 - 64);
|
|
|
|
if (sj->picnum == CEILINGSTEAM || sj->picnum == STEAM)
|
|
|
|
sj->cstat |= 32768;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-12 20:00:19 +00:00
|
|
|
ht->extra = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
s->extra = x;
|
|
|
|
}
|
|
|
|
}
|
2020-10-12 20:00:19 +00:00
|
|
|
s->ang = ht->temp_data[1];
|
2020-05-07 12:55:04 +00:00
|
|
|
s->z += (16 << 8);
|
|
|
|
}
|
2020-10-12 20:00:19 +00:00
|
|
|
else if (ht->temp_data[0] == 1)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
if (s->lotag > 0)
|
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
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)
|
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
s->xvel -= 8;
|
|
|
|
ssp(i,CLIPMASK0);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-14 10:14:03 +00:00
|
|
|
if (fi.floorspace(s->sectnum)) x = 0;
|
2020-05-07 12:55:04 +00:00
|
|
|
else
|
|
|
|
{
|
2020-05-14 10:14:03 +00:00
|
|
|
if (fi.ceilingspace(s->sectnum))
|
2020-05-07 12:55:04 +00:00
|
|
|
x = gc / 6;
|
|
|
|
else
|
|
|
|
x = gc;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->z < (sector[sect].floorz - FOURSLEIGHT))
|
|
|
|
{
|
|
|
|
s->zvel += x;
|
|
|
|
if (s->zvel > 6144)
|
|
|
|
s->zvel = 6144;
|
|
|
|
s->z += s->zvel;
|
|
|
|
}
|
|
|
|
if ((sector[sect].floorz - s->z) < (16 << 8))
|
|
|
|
{
|
|
|
|
j = 1 + (krand() & 7);
|
|
|
|
for (x = 0; x < j; x++) RANDOMSCRAP(s, i);
|
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-12 20:00:19 +00:00
|
|
|
|
2020-05-07 12:55:04 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// split out of movestandables
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Duke only
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void movetripbomb(int i)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
2020-05-07 20:30:19 +00:00
|
|
|
int j, x;
|
|
|
|
int lTripBombControl = GetGameVar("TRIPBOMB_CONTROL", TRIPBOMB_TRIPWIRE, -1, -1);
|
|
|
|
if (lTripBombControl & TRIPBOMB_TIMER)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
// we're on a timer....
|
|
|
|
if (s->extra >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
s->extra--;
|
|
|
|
if (s->extra == 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
hittype[i].temp_data[2] = 16;
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(LASERTRIP_ARMING, i);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-05-07 20:30:19 +00:00
|
|
|
if (hittype[i].temp_data[2] > 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
hittype[i].temp_data[2]--;
|
|
|
|
if (hittype[i].temp_data[2] == 8)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(LASERTRIP_EXPLODE, i);
|
2020-05-07 12:55:04 +00:00
|
|
|
for (j = 0; j < 5; j++) RANDOMSCRAP(s, i);
|
|
|
|
x = s->extra;
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], tripbombblastradius, x >> 2, x >> 1, x - (x >> 2), x);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-05-15 20:59:13 +00:00
|
|
|
j = fi.spawn(i, EXPLOSION2);
|
2020-05-07 12:55:04 +00:00
|
|
|
sprite[j].ang = s->ang;
|
|
|
|
sprite[j].xvel = 348;
|
|
|
|
ssp(j, CLIPMASK0);
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_MISC);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
if (sprite[j].picnum == LASERLINE && s->hitag == sprite[j].hitag)
|
|
|
|
sprite[j].xrepeat = sprite[j].yrepeat = 0;
|
|
|
|
}
|
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x = s->extra;
|
|
|
|
s->extra = 1;
|
|
|
|
int16_t l = s->ang;
|
2020-10-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (j >= 0)
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[2] = 16;
|
|
|
|
}
|
|
|
|
s->extra = x;
|
|
|
|
s->ang = l;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hittype[i].temp_data[0] < 32)
|
|
|
|
{
|
|
|
|
findplayer(s, &x);
|
|
|
|
if (x > 768) hittype[i].temp_data[0]++;
|
|
|
|
else if (hittype[i].temp_data[0] > 16) hittype[i].temp_data[0]++;
|
|
|
|
}
|
|
|
|
if (hittype[i].temp_data[0] == 32)
|
|
|
|
{
|
|
|
|
int16_t l = s->ang;
|
|
|
|
s->ang = hittype[i].temp_data[5];
|
|
|
|
|
|
|
|
hittype[i].temp_data[3] = s->x; hittype[i].temp_data[4] = s->y;
|
|
|
|
s->x += sintable[(hittype[i].temp_data[5] + 512) & 2047] >> 9;
|
|
|
|
s->y += sintable[(hittype[i].temp_data[5]) & 2047] >> 9;
|
|
|
|
s->z -= (3 << 8);
|
2020-07-27 15:52:17 +00:00
|
|
|
|
|
|
|
// Laser fix from EDuke32.
|
|
|
|
int16_t const oldSectNum = s->sectnum;
|
|
|
|
int16_t curSectNum = s->sectnum;
|
|
|
|
|
|
|
|
updatesectorneighbor(s->x, s->y, &curSectNum, 1024, 2048);
|
|
|
|
changespritesect(i, curSectNum);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
|
|
|
int16_t m;
|
|
|
|
x = hitasprite(i, &m);
|
|
|
|
|
|
|
|
hittype[i].lastvx = x;
|
|
|
|
|
|
|
|
s->ang = l;
|
|
|
|
|
|
|
|
int k = 0;
|
|
|
|
|
|
|
|
if (lTripBombControl & TRIPBOMB_TRIPWIRE)
|
|
|
|
{
|
|
|
|
// we're on a trip wire
|
|
|
|
while (x > 0)
|
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
j = fi.spawn(i, LASERLINE);
|
2020-05-07 12:55:04 +00:00
|
|
|
setsprite(j, sprite[j].x, sprite[j].y, sprite[j].z);
|
|
|
|
sprite[j].hitag = s->hitag;
|
|
|
|
hittype[j].temp_data[1] = sprite[j].z;
|
|
|
|
|
|
|
|
if (x < 1024)
|
|
|
|
{
|
|
|
|
sprite[j].xrepeat = x >> 5;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
x -= 1024;
|
2020-07-27 15:52:17 +00:00
|
|
|
|
|
|
|
s->x += sintable[(hittype[i].temp_data[5] + 512) & 2047] >> 4;
|
|
|
|
s->y += sintable[(hittype[i].temp_data[5]) & 2047] >> 4;
|
|
|
|
updatesectorneighbor(s->x, s->y, &curSectNum, 1024, 2048);
|
|
|
|
|
|
|
|
if (curSectNum == -1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
changespritesect(i, curSectNum);
|
|
|
|
|
|
|
|
// this is a hack to work around the LASERLINE sprite's art tile offset
|
|
|
|
changespritesect(j, curSectNum);
|
|
|
|
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hittype[i].temp_data[0]++;
|
|
|
|
s->x = hittype[i].temp_data[3]; s->y = hittype[i].temp_data[4];
|
|
|
|
s->z += (3 << 8);
|
2020-07-27 15:52:17 +00:00
|
|
|
changespritesect(i, oldSectNum);
|
2020-05-07 12:55:04 +00:00
|
|
|
hittype[i].temp_data[3] = 0;
|
|
|
|
if (m >= 0 && lTripBombControl & TRIPBOMB_TRIPWIRE)
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[2] = 13;
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(LASERTRIP_ARMING, i);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
else hittype[i].temp_data[2] = 0;
|
|
|
|
}
|
|
|
|
if (hittype[i].temp_data[0] == 33)
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[1]++;
|
|
|
|
|
|
|
|
|
|
|
|
hittype[i].temp_data[3] = s->x; hittype[i].temp_data[4] = s->y;
|
|
|
|
s->x += sintable[(hittype[i].temp_data[5] + 512) & 2047] >> 9;
|
|
|
|
s->y += sintable[(hittype[i].temp_data[5]) & 2047] >> 9;
|
|
|
|
s->z -= (3 << 8);
|
|
|
|
setsprite(i, s->x, s->y, s->z);
|
|
|
|
|
|
|
|
int16_t m;
|
|
|
|
x = hitasprite(i, &m);
|
|
|
|
|
|
|
|
s->x = hittype[i].temp_data[3]; s->y = hittype[i].temp_data[4];
|
|
|
|
s->z += (3 << 8);
|
|
|
|
setsprite(i, s->x, s->y, s->z);
|
|
|
|
|
|
|
|
if (hittype[i].lastvx != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[2] = 13;
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(LASERTRIP_ARMING, i);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void movecrack(int i)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
if (s->hitag > 0)
|
|
|
|
{
|
|
|
|
t[0] = s->cstat;
|
|
|
|
t[1] = s->ang;
|
2020-10-21 19:41:14 +00:00
|
|
|
int j = fi.ifhitbyweapon(&hittype[i]);
|
2020-05-07 20:30:19 +00:00
|
|
|
if (j == FIREEXT || j == RPG || j == RADIUSEXPLOSION || j == SEENINE || j == OOZFILTER)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-14 18:09:49 +00:00
|
|
|
StatIterator it(STAT_STANDABLE);
|
2020-10-14 18:02:05 +00:00
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (s->hitag == sj->hitag && (sj->picnum == OOZFILTER || sj->picnum == SEENINE))
|
|
|
|
if (sj->shade != -32)
|
|
|
|
sj->shade = -32;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-05-07 20:30:19 +00:00
|
|
|
detonate(i, 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(int i)
|
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
int j = fi.ifhitbyweapon(&hittype[i]);
|
2020-05-07 12:55:04 +00:00
|
|
|
if (j == -1) return;
|
|
|
|
|
|
|
|
auto s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
|
|
|
|
for (int k = 0; k < 16; k++)
|
|
|
|
{
|
|
|
|
j = EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sprite[i].z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (sprite[i].zvel >> 2), i, 5);
|
|
|
|
sprite[j].pal = 2;
|
|
|
|
}
|
|
|
|
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, EXPLOSION2);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PIPEBOMB_EXPLODE, i);
|
|
|
|
S_PlayActorSound(GLASS_HEAVYBREAK, i);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
|
|
|
if (s->hitag > 0)
|
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_STANDABLE);
|
|
|
|
int j;
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (s->hitag == sj->hitag && (sj->picnum == OOZFILTER || sj->picnum == SEENINE))
|
|
|
|
if (sj->shade != -32)
|
|
|
|
sj->shade = -32;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int x = s->extra;
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, EXPLOSION2);
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], pipebombblastradius, x >> 2, x - (x >> 1), x - (x >> 2), x);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PIPEBOMB_EXPLODE, i);
|
2020-05-07 20:30:19 +00:00
|
|
|
detonate(i, EXPLOSION2);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], seenineblastradius, 10, 15, 20, 25);
|
2020-05-07 12:55:04 +00:00
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void moveviewscreen(int i)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
if (s->xrepeat == 0) deletesprite(i);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int x;
|
|
|
|
findplayer(s, &x);
|
|
|
|
|
|
|
|
if (x < 2048)
|
|
|
|
{
|
|
|
|
#if 0
|
2020-05-10 07:08:02 +00:00
|
|
|
if (sprite[i].yvel == 1)
|
2020-05-07 12:55:04 +00:00
|
|
|
camsprite = i;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else if (camsprite != -1 && hittype[i].temp_data[0] == 1)
|
|
|
|
{
|
|
|
|
camsprite = -1;
|
|
|
|
s->yvel = 0;
|
|
|
|
hittype[i].temp_data[0] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Duke only
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void movesidebolt(int i)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int x;
|
|
|
|
int sect = s->sectnum;
|
|
|
|
|
|
|
|
auto p = findplayer(s, &x);
|
|
|
|
if (x > 20480) return;
|
|
|
|
|
|
|
|
CLEAR_THE_BOLT2:
|
|
|
|
if (t[2])
|
|
|
|
{
|
|
|
|
t[2]--;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((s->xrepeat | s->yrepeat) == 0)
|
|
|
|
{
|
|
|
|
s->xrepeat = t[0];
|
|
|
|
s->yrepeat = t[1];
|
|
|
|
}
|
|
|
|
if ((krand() & 8) == 0)
|
|
|
|
{
|
|
|
|
t[0] = s->xrepeat;
|
|
|
|
t[1] = s->yrepeat;
|
|
|
|
t[2] = global_random & 4;
|
|
|
|
s->xrepeat = s->yrepeat = 0;
|
|
|
|
goto CLEAR_THE_BOLT2;
|
|
|
|
}
|
|
|
|
s->picnum++;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// content of l was undefined.
|
|
|
|
if (l & 1) s->cstat ^= 2;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if ((krand() & 1) && sector[sect].floorpicnum == HURTRAIL)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SHORT_CIRCUIT, i);
|
2020-05-07 20:30:19 +00:00
|
|
|
|
|
|
|
if (s->picnum == SIDEBOLT1 + 4) s->picnum = SIDEBOLT1;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
static void movebolt(int i)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
2020-05-07 20:30:19 +00:00
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int x;
|
|
|
|
int sect = s->sectnum;
|
|
|
|
|
|
|
|
auto p = findplayer(s, &x);
|
|
|
|
if (x > 20480) return;
|
|
|
|
|
|
|
|
if (t[3] == 0)
|
|
|
|
t[3] = sector[sect].floorshade;
|
|
|
|
|
|
|
|
CLEAR_THE_BOLT:
|
|
|
|
if (t[2])
|
|
|
|
{
|
|
|
|
t[2]--;
|
|
|
|
sector[sect].floorshade = 20;
|
|
|
|
sector[sect].ceilingshade = 20;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((s->xrepeat | s->yrepeat) == 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-05-07 20:30:19 +00:00
|
|
|
s->xrepeat = t[0];
|
|
|
|
s->yrepeat = t[1];
|
|
|
|
}
|
|
|
|
else if ((krand() & 8) == 0)
|
|
|
|
{
|
|
|
|
t[0] = s->xrepeat;
|
|
|
|
t[1] = s->yrepeat;
|
|
|
|
t[2] = global_random & 4;
|
|
|
|
s->xrepeat = s->yrepeat = 0;
|
|
|
|
goto CLEAR_THE_BOLT;
|
|
|
|
}
|
|
|
|
s->picnum++;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
int l = global_random & 7;
|
|
|
|
s->xrepeat = l + 8;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
if (l & 1) s->cstat ^= 2;
|
|
|
|
|
|
|
|
if (s->picnum == (BOLT1+1) && (krand()&7) == 0 && sector[sect].floorpicnum == HURTRAIL)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SHORT_CIRCUIT,i);
|
2020-05-07 20:30:19 +00:00
|
|
|
|
|
|
|
if (s->picnum==BOLT1+4) s->picnum=BOLT1;
|
|
|
|
|
|
|
|
if (s->picnum & 1)
|
|
|
|
{
|
|
|
|
sector[sect].floorshade = 0;
|
|
|
|
sector[sect].ceilingshade = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sector[sect].floorshade = 20;
|
|
|
|
sector[sect].ceilingshade = 20;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// this has been broken up into lots of smaller subfunctions
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
void movestandables_d(void)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_STANDABLE);
|
|
|
|
int i;
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
int picnum = s->picnum;
|
|
|
|
|
|
|
|
if (s->sectnum < 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
hittype[i].bposx = s->x;
|
|
|
|
hittype[i].bposy = s->y;
|
|
|
|
hittype[i].bposz = s->z;
|
|
|
|
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
if (picnum >= CRANE && picnum <= CRANE +3)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-24 08:37:20 +00:00
|
|
|
movecrane(&hittype[i], CRANE);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum >= WATERFOUNTAIN && picnum <= WATERFOUNTAIN + 3)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 19:46:39 +00:00
|
|
|
movefountain(&hittype[i], WATERFOUNTAIN);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (AFLAMABLE(picnum))
|
|
|
|
{
|
2020-10-21 19:46:39 +00:00
|
|
|
moveflammable(&hittype[i], TIRE, BOX, BLOODPOOL);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == TRIPBOMB)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
movetripbomb(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum >= CRACK1 && picnum <= CRACK1 + 3)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
movecrack(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == FIREEXT)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
movefireext(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == OOZFILTER || picnum == SEENINE || picnum == SEENINEDEAD || picnum == (SEENINEDEAD + 1))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:22:12 +00:00
|
|
|
moveooz(&hittype[i], SEENINE, SEENINEDEAD, OOZFILTER, EXPLOSION2);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (picnum == MASTERSWITCH)
|
|
|
|
{
|
2020-10-21 20:17:25 +00:00
|
|
|
movemasterswitch(&hittype[i], SEENINE, OOZFILTER);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == VIEWSCREEN || picnum == VIEWSCREEN2)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
moveviewscreen(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == TRASH)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:17:25 +00:00
|
|
|
movetrash(&hittype[i]);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum >= SIDEBOLT1 && picnum <= SIDEBOLT1 + 3)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
movesidebolt(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum >= BOLT1 && picnum <= BOLT1 + 3)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
movebolt(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == WATERDRIP)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:17:25 +00:00
|
|
|
movewaterdrip(&hittype[i], WATERDRIP);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (picnum == DOORSHOCK)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:17:25 +00:00
|
|
|
movedoorshock(&hittype[i]);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (picnum == TOUCHPLATE)
|
|
|
|
{
|
2020-10-21 20:22:12 +00:00
|
|
|
movetouchplate(&hittype[i], TOUCHPLATE);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
else if (isIn(picnum, CANWITHSOMETHING, CANWITHSOMETHING2, CANWITHSOMETHING3, CANWITHSOMETHING4))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-21 20:22:12 +00:00
|
|
|
movecanwithsomething(&hittype[i]);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:30:19 +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,
|
2020-05-07 20:30:19 +00:00
|
|
|
WATERBUBBLEMAKER))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
int x;
|
|
|
|
int p = findplayer(s, &x);
|
|
|
|
execute(i, p, x);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-18 07:45:41 +00:00
|
|
|
static bool movefireball(int i)
|
2020-10-17 17:53:04 +00:00
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
auto ht = &hittype[i];
|
|
|
|
|
|
|
|
if (sector[s->sectnum].lotag == 2)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sprite[s->owner].picnum != FIREBALL)
|
|
|
|
{
|
|
|
|
if (ht->temp_data[0] >= 1 && ht->temp_data[0] < 6)
|
|
|
|
{
|
|
|
|
float siz = 1.0f - (ht->temp_data[0] * 0.2f);
|
|
|
|
int trail = ht->temp_data[1];
|
|
|
|
int j = ht->temp_data[1] = fi.spawn(i, FIREBALL);
|
|
|
|
|
|
|
|
auto spr = &sprite[j];
|
|
|
|
spr->xvel = s->xvel;
|
|
|
|
spr->yvel = s->yvel;
|
|
|
|
spr->zvel = s->zvel;
|
|
|
|
if (ht->temp_data[0] > 1)
|
|
|
|
{
|
|
|
|
FireProj* proj = fire.CheckKey(trail);
|
|
|
|
if (proj != nullptr)
|
|
|
|
{
|
|
|
|
spr->x = proj->x;
|
|
|
|
spr->y = proj->y;
|
|
|
|
spr->z = proj->z;
|
|
|
|
spr->xvel = proj->xv;
|
|
|
|
spr->yvel = proj->yv;
|
|
|
|
spr->zvel = proj->zv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spr->yrepeat = spr->xrepeat = (short)(sprite[i].xrepeat * siz);
|
|
|
|
spr->cstat = sprite[i].cstat;
|
|
|
|
spr->extra = 0;
|
|
|
|
|
|
|
|
FireProj proj = { spr->x, spr->y, spr->z, spr->xvel, spr->yvel, spr->zvel };
|
|
|
|
fire.Insert(j, proj);
|
|
|
|
changespritestat((short)j, (short)4);
|
|
|
|
}
|
|
|
|
ht->temp_data[0]++;
|
|
|
|
}
|
|
|
|
if (s->zvel < 15000)
|
|
|
|
s->zvel += 200;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-18 07:45:41 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static bool weaponhitsprite(int i, int j, bool fireball)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
|
|
|
|
if (s->picnum == FREEZEBLAST && sprite[j].pal == 1)
|
|
|
|
if (badguy(&sprite[j]) || sprite[j].picnum == APLAYER)
|
|
|
|
{
|
|
|
|
j = fi.spawn(i, TRANSPORTERSTAR);
|
|
|
|
sprite[j].pal = 1;
|
|
|
|
sprite[j].xrepeat = 32;
|
|
|
|
sprite[j].yrepeat = 32;
|
|
|
|
|
|
|
|
deletesprite(i);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isWorldTour() || s->picnum != FIREBALL || fireball)
|
|
|
|
fi.checkhitsprite(j, i);
|
|
|
|
|
|
|
|
if (sprite[j].picnum == APLAYER)
|
|
|
|
{
|
|
|
|
int p = sprite[j].yvel;
|
|
|
|
|
|
|
|
if (ud.multimode >= 2 && fireball && sprite[s->owner].picnum == APLAYER)
|
|
|
|
{
|
|
|
|
ps[p].numloogs = -1 - sprite[i].yvel;
|
|
|
|
}
|
|
|
|
|
|
|
|
S_PlayActorSound(PISTOL_BODYHIT, j);
|
|
|
|
|
|
|
|
if (s->picnum == SPIT)
|
|
|
|
{
|
|
|
|
ps[p].horizon.addadjustment(32);
|
|
|
|
ps[p].sync.actions |= SB_CENTERVIEW;
|
|
|
|
|
|
|
|
if (ps[p].loogcnt == 0)
|
|
|
|
{
|
|
|
|
if (!S_CheckActorSoundPlaying(ps[p].i, DUKE_LONGTERM_PAIN))
|
|
|
|
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].i);
|
|
|
|
|
|
|
|
j = 3 + (krand() & 3);
|
|
|
|
ps[p].numloogs = j;
|
|
|
|
ps[p].loogcnt = 24 * 4;
|
|
|
|
for (int x = 0; x < j; x++)
|
|
|
|
{
|
|
|
|
ps[p].loogiex[x] = krand() % 320;
|
|
|
|
ps[p].loogiey[x] = krand() % 200;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static bool weaponhitwall(int i, int j, const vec3_t &oldpos)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
|
|
|
|
if (s->picnum != RPG && s->picnum != FREEZEBLAST && s->picnum != SPIT &&
|
|
|
|
(!isWorldTour() || s->picnum != FIREBALL) &&
|
|
|
|
(wall[j].overpicnum == MIRROR || wall[j].picnum == MIRROR))
|
|
|
|
{
|
|
|
|
int k = getangle(
|
|
|
|
wall[wall[j].point2].x - wall[j].x,
|
|
|
|
wall[wall[j].point2].y - wall[j].y);
|
|
|
|
s->ang = ((k << 1) - s->ang) & 2047;
|
|
|
|
s->owner = i;
|
|
|
|
fi.spawn(i, TRANSPORTERSTAR);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
setsprite(i, &oldpos);
|
|
|
|
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
|
|
|
|
|
|
|
|
if (s->picnum == FREEZEBLAST)
|
|
|
|
{
|
|
|
|
if (wall[j].overpicnum != MIRROR && wall[j].picnum != MIRROR)
|
|
|
|
{
|
|
|
|
s->extra >>= 1;
|
|
|
|
s->yvel--;
|
|
|
|
}
|
|
|
|
|
|
|
|
int k = getangle(
|
|
|
|
wall[wall[j].point2].x - wall[j].x,
|
|
|
|
wall[wall[j].point2].y - wall[j].y);
|
|
|
|
s->ang = ((k << 1) - s->ang) & 2047;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static bool weaponhitsector(int i, const vec3_t& oldpos, bool fireball)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
|
|
|
|
setsprite(i, &oldpos);
|
|
|
|
|
|
|
|
if (s->zvel < 0)
|
|
|
|
{
|
|
|
|
if (sector[s->sectnum].ceilingstat & 1)
|
|
|
|
if (sector[s->sectnum].ceilingpal == 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
fi.checkhitceiling(s->sectnum);
|
|
|
|
}
|
|
|
|
else if (fireball)
|
|
|
|
{
|
|
|
|
int j = fi.spawn(i, LAVAPOOL);
|
|
|
|
sprite[j].owner = sprite[i].owner;
|
|
|
|
sprite[j].yvel = sprite[i].yvel;
|
|
|
|
hittype[j].owner = sprite[i].owner;
|
|
|
|
deletesprite(i);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->picnum == FREEZEBLAST)
|
|
|
|
{
|
2020-10-21 20:29:35 +00:00
|
|
|
bounce(&hittype[i]);
|
2020-10-18 07:45:41 +00:00
|
|
|
ssp(i, CLIPMASK1);
|
|
|
|
s->extra >>= 1;
|
|
|
|
if (s->xrepeat > 8)
|
|
|
|
s->xrepeat -= 2;
|
|
|
|
if (s->yrepeat > 8)
|
|
|
|
s->yrepeat -= 2;
|
|
|
|
s->yvel--;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
|
2020-10-17 17:53:04 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
2020-10-18 06:38:29 +00:00
|
|
|
//
|
2020-10-17 17:53:04 +00:00
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-18 07:45:41 +00:00
|
|
|
static void weaponcommon_d(int i)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
auto s = &sprite[i];
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
if (s->picnum == COOLEXPLOSION1)
|
|
|
|
if (!S_CheckSoundPlaying(i, WIERDSHOT_FLY))
|
|
|
|
S_PlayActorSound(WIERDSHOT_FLY, i);
|
|
|
|
|
|
|
|
int p = -1;
|
|
|
|
int k, ll;
|
2020-10-18 07:45:41 +00:00
|
|
|
auto oldpos = s->pos;
|
2020-10-18 06:38:29 +00:00
|
|
|
|
|
|
|
if (s->picnum == RPG && sector[s->sectnum].lotag == 2)
|
|
|
|
{
|
|
|
|
k = s->xvel >> 1;
|
|
|
|
ll = s->zvel >> 1;
|
|
|
|
}
|
|
|
|
else
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
k = s->xvel;
|
|
|
|
ll = s->zvel;
|
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
getglobalz(i);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
switch (s->picnum)
|
|
|
|
{
|
|
|
|
case RPG:
|
|
|
|
if (hittype[i].picnum != BOSS2 && s->xrepeat >= 10 && sector[s->sectnum].lotag != 2)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
int j = fi.spawn(i, SMALLSMOKE);
|
|
|
|
sprite[j].z += (1 << 8);
|
|
|
|
}
|
|
|
|
break;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
case FIREBALL:
|
|
|
|
if (movefireball(i)) return;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
int j = fi.movesprite(i,
|
|
|
|
(k * (sintable[(s->ang + 512) & 2047])) >> 14,
|
2020-10-18 07:45:41 +00:00
|
|
|
(k * (sintable[s->ang & 2047])) >> 14, ll, CLIPMASK1);
|
2020-05-07 20:30:19 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
if (s->picnum == RPG && s->yvel >= 0)
|
|
|
|
if (FindDistance2D(s->x - sprite[s->yvel].x, s->y - sprite[s->yvel].y) < 256)
|
2020-10-18 07:45:41 +00:00
|
|
|
j = kHitSprite | s->yvel;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
if (s->sectnum < 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 07:45:41 +00:00
|
|
|
if ((j & kHitTypeMask) != kHitSprite && s->picnum != FREEZEBLAST)
|
2020-10-18 06:38:29 +00:00
|
|
|
{
|
|
|
|
if (s->z < hittype[i].ceilingz)
|
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
j = kHitSector | (s->sectnum);
|
2020-10-18 06:38:29 +00:00
|
|
|
s->zvel = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if ((s->z > hittype[i].floorz && sector[s->sectnum].lotag != 1) ||
|
|
|
|
(s->z > hittype[i].floorz + (16 << 8) && sector[s->sectnum].lotag == 1))
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
j = kHitSector | (s->sectnum);
|
2020-10-18 06:38:29 +00:00
|
|
|
if (sector[s->sectnum].lotag != 1)
|
|
|
|
s->zvel = 1;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->picnum == FIRELASER)
|
|
|
|
{
|
|
|
|
for (k = -3; k < 2; k++)
|
|
|
|
{
|
|
|
|
int x = EGS(s->sectnum,
|
|
|
|
s->x + ((k * sintable[(s->ang + 512) & 2047]) >> 9),
|
|
|
|
s->y + ((k * sintable[s->ang & 2047]) >> 9),
|
|
|
|
s->z + ((k * ksgn(s->zvel)) * abs(s->zvel / 24)), FIRELASER, -40 + (k << 2),
|
|
|
|
s->xrepeat, s->yrepeat, 0, 0, 0, s->owner, 5);
|
|
|
|
|
|
|
|
sprite[x].cstat = 128;
|
|
|
|
sprite[x].pal = s->pal;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (s->picnum == SPIT) if (s->zvel < 6144)
|
|
|
|
s->zvel += gc - 112;
|
|
|
|
|
|
|
|
if (j != 0)
|
|
|
|
{
|
|
|
|
if (s->picnum == COOLEXPLOSION1)
|
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
if ((j & kHitTypeMask) == kHitSprite && sprite[j & kHitIndexMask].picnum != APLAYER)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
return;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
s->xvel = 0;
|
|
|
|
s->zvel = 0;
|
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
bool fireball = (isWorldTour() && s->picnum == FIREBALL && sprite[s->owner].picnum != FIREBALL);
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 07:45:41 +00:00
|
|
|
if ((j & kHitTypeMask) == kHitSprite)
|
2020-10-18 06:38:29 +00:00
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
j &= kHitIndexMask;
|
|
|
|
if (weaponhitsprite(i, j, fireball)) return;
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
2020-10-18 07:45:41 +00:00
|
|
|
else if ((j & kHitTypeMask) == kHitWall)
|
2020-10-18 06:38:29 +00:00
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
j &= kHitIndexMask;
|
|
|
|
if (weaponhitwall(i, j, oldpos)) return;
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
2020-10-18 07:45:41 +00:00
|
|
|
else if ((j & kHitTypeMask) == kHitSector)
|
2020-10-18 06:38:29 +00:00
|
|
|
{
|
2020-10-18 07:45:41 +00:00
|
|
|
if (weaponhitsector(i, oldpos, fireball)) return;
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-10-18 06:38:29 +00:00
|
|
|
if (s->picnum != SPIT)
|
|
|
|
{
|
|
|
|
if (s->picnum == RPG)
|
|
|
|
{
|
2020-10-18 08:42:26 +00:00
|
|
|
// j is only needed for the hit type mask.
|
2020-10-21 20:29:35 +00:00
|
|
|
rpgexplode(&hittype[i], j, oldpos, EXPLOSION2, EXPLOSION2BOT, -1, RPG_EXPLODE);
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
|
|
|
else if (s->picnum == SHRINKSPARK)
|
|
|
|
{
|
|
|
|
fi.spawn(i, SHRINKEREXPLOSION);
|
|
|
|
S_PlayActorSound(SHRINKER_HIT, i);
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], shrinkerblastradius, 0, 0, 0, 0);
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
|
|
|
else if (s->picnum != COOLEXPLOSION1 && s->picnum != FREEZEBLAST && s->picnum != FIRELASER && (!isWorldTour() || s->picnum != FIREBALL))
|
|
|
|
{
|
|
|
|
k = fi.spawn(i, EXPLOSION2);
|
|
|
|
sprite[k].xrepeat = sprite[k].yrepeat = s->xrepeat >> 1;
|
2020-10-18 07:45:41 +00:00
|
|
|
if ((j & kHitTypeMask) == kHitSector)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
|
|
|
if (s->zvel < 0)
|
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
sprite[k].cstat |= 8; sprite[k].z += (72 << 8);
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
|
|
|
if (fireball)
|
2020-05-07 12:55:04 +00:00
|
|
|
{
|
2020-10-18 06:38:29 +00:00
|
|
|
j = fi.spawn(i, EXPLOSION2);
|
|
|
|
sprite[j].xrepeat = sprite[j].yrepeat = (short)(s->xrepeat >> 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (s->picnum != COOLEXPLOSION1)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (s->picnum == COOLEXPLOSION1)
|
|
|
|
{
|
|
|
|
s->shade++;
|
|
|
|
if (s->shade >= 40)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (s->picnum == RPG && sector[s->sectnum].lotag == 2 && s->xrepeat >= 10 && rnd(140))
|
|
|
|
fi.spawn(i, WATERBUBBLE);
|
|
|
|
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void moveweapons_d(void)
|
|
|
|
{
|
|
|
|
StatIterator it(STAT_PROJECTILE);
|
|
|
|
int i;
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
|
|
|
{
|
|
|
|
auto s = &sprite[i];
|
|
|
|
|
|
|
|
if (s->sectnum < 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
hittype[i].bposx = s->x;
|
|
|
|
hittype[i].bposy = s->y;
|
|
|
|
hittype[i].bposz = s->z;
|
|
|
|
|
|
|
|
switch(s->picnum)
|
|
|
|
{
|
|
|
|
case RADIUSEXPLOSION:
|
|
|
|
case KNEE:
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
case TONGUE:
|
2020-10-21 20:29:35 +00:00
|
|
|
movetongue(&hittype[i], TONGUE, INNERJAW);
|
2020-10-18 06:38:29 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case FREEZEBLAST:
|
|
|
|
if (s->yvel < 1 || s->extra < 2 || (s->xvel|s->zvel) == 0)
|
|
|
|
{
|
|
|
|
int j = fi.spawn(i,TRANSPORTERSTAR);
|
|
|
|
sprite[j].pal = 1;
|
|
|
|
sprite[j].xrepeat = 32;
|
|
|
|
sprite[j].yrepeat = 32;
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
case FIREBALL:
|
|
|
|
// Twentieth Anniversary World Tour
|
2020-10-20 21:21:38 +00:00
|
|
|
if (s->picnum == FIREBALL && !isWorldTour()) break;
|
2020-10-18 06:38:29 +00:00
|
|
|
case SHRINKSPARK:
|
|
|
|
case RPG:
|
|
|
|
case FIRELASER:
|
|
|
|
case SPIT:
|
|
|
|
case COOLEXPLOSION1:
|
|
|
|
weaponcommon_d(i);
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
2020-05-07 12:55:04 +00:00
|
|
|
|
2020-05-07 20:30:19 +00:00
|
|
|
case SHOTSPARK1:
|
2020-10-18 06:38:29 +00:00
|
|
|
{
|
|
|
|
int x;
|
|
|
|
int p = findplayer(s, &x);
|
|
|
|
execute(i, p, x);
|
2020-05-07 20:30:19 +00:00
|
|
|
break;
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
2020-10-18 06:38:29 +00:00
|
|
|
}
|
2020-05-07 12:55:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
2020-10-12 18:45:08 +00:00
|
|
|
//
|
2020-05-07 22:03:51 +00:00
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void movetransports_d(void)
|
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int warpspriteto;
|
2020-10-12 18:45:08 +00:00
|
|
|
int ll, onfloorz, q;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
StatIterator iti(STAT_TRANSPORT);
|
|
|
|
while ((i = iti.NextIndex()) >= 0)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
auto spri = &sprite[i];
|
|
|
|
auto hiti = &hittype[i];
|
|
|
|
auto spriowner = spri->owner < 0? nullptr : &sprite[spri->owner];
|
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
int sect = spri->sectnum;
|
|
|
|
int sectlotag = sector[sect].lotag;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (spri->owner == i)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
onfloorz = hiti->temp_data[4];
|
|
|
|
|
|
|
|
if (hiti->temp_data[0] > 0) hiti->temp_data[0]--;
|
|
|
|
|
|
|
|
SectIterator itj(sect);
|
|
|
|
while ((j = itj.NextIndex()) >= 0)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
auto sprj = &sprite[j];
|
|
|
|
auto hitj = &hittype[j];
|
|
|
|
|
|
|
|
switch (sprj->statnum)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
case STAT_PLAYER: // Player
|
|
|
|
|
|
|
|
if (sprj->owner != -1)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int p = sprj->yvel;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].on_warping_sector = 1;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
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-12 18:45:08 +00:00
|
|
|
if (spri->pal == 0)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, TRANSPORTERBEAM);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TELEPORTER, i);
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
for (int k = connecthead; k >= 0; k = connectpoint2[k])
|
2020-10-12 18:45:08 +00:00
|
|
|
if (ps[k].cursectnum == spriowner->sectnum)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
ps[k].frag_ps = p;
|
|
|
|
sprite[ps[k].i].extra = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ps[p].angle.ang = buildang(spriowner->ang);
|
|
|
|
|
|
|
|
if (spriowner->owner != spri->owner)
|
|
|
|
{
|
|
|
|
hiti->temp_data[0] = 13;
|
|
|
|
hittype[spri->owner].temp_data[0] = 13;
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].transporter_hold = 13;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
ps[p].bobposx = ps[p].oposx = ps[p].posx = spriowner->x;
|
|
|
|
ps[p].bobposy = ps[p].oposy = ps[p].posy = spriowner->y;
|
|
|
|
ps[p].oposz = ps[p].posz = spriowner->z - PHEIGHT;
|
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
|
|
|
ps[p].cursectnum = sprj->sectnum;
|
|
|
|
|
|
|
|
if (spri->pal == 0)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int k = fi.spawn(spri->owner, TRANSPORTERBEAM);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TELEPORTER, k);
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
if (onfloorz == 0 && abs(spri->z - ps[p].posz) < 6144)
|
2020-08-28 20:51:05 +00:00
|
|
|
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
|
|
|
|
(ps[p].jetpack_on && (PlayerInput(p, SB_CROUCH) ^ !!ps[p].crouch_toggle)))
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
ps[p].oposx = ps[p].posx += spriowner->x - spri->x;
|
|
|
|
ps[p].oposy = ps[p].posy += spriowner->y - spri->y;
|
|
|
|
|
2020-08-28 20:51:05 +00:00
|
|
|
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
|
2020-10-12 18:45:08 +00:00
|
|
|
ps[p].posz = spriowner->z - 6144;
|
|
|
|
else ps[p].posz = spriowner->z + 6144;
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].oposz = ps[p].posz;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
hittype[ps[p].i].bposx = ps[p].posx;
|
|
|
|
hittype[ps[p].i].bposy = ps[p].posy;
|
|
|
|
hittype[ps[p].i].bposz = ps[p].posz;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
|
|
|
ps[p].cursectnum = spriowner->sectnum;
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-10-12 19:15:54 +00:00
|
|
|
int k = 0;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-08-28 20:51:05 +00:00
|
|
|
if (onfloorz && sectlotag == ST_1_ABOVE_WATER && ps[p].on_ground && ps[p].posz > (sector[sect].floorz - (16 << 8)) && (PlayerInput(p, SB_CROUCH) || ps[p].poszv > 2048))
|
2020-10-12 18:45:08 +00:00
|
|
|
// if( onfloorz && sectlotag == 1 && ps[p].posz > (sector[sect].floorz-(6<<8)) )
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
|
|
|
k = 1;
|
|
|
|
if (screenpeek == p)
|
|
|
|
{
|
|
|
|
FX_StopAllSounds();
|
|
|
|
}
|
|
|
|
if (sprite[ps[p].i].extra > 0)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(DUKE_UNDERWATER, j);
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].oposz = ps[p].posz =
|
2020-10-12 18:45:08 +00:00
|
|
|
sector[spriowner->sectnum].ceilingz + (7 << 8);
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].posxv = 4096 - (krand() & 8192);
|
|
|
|
ps[p].posyv = 4096 - (krand() & 8192);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
if (onfloorz && sectlotag == ST_2_UNDERWATER && ps[p].posz < (sector[sect].ceilingz + (6 << 8)))
|
|
|
|
{
|
|
|
|
k = 1;
|
2020-10-12 18:45:08 +00:00
|
|
|
// if( sprj->extra <= 0) break;
|
2020-05-07 22:03:51 +00:00
|
|
|
if (screenpeek == p)
|
|
|
|
{
|
|
|
|
FX_StopAllSounds();
|
|
|
|
}
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(DUKE_GASP, j);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].oposz = ps[p].posz =
|
2020-10-12 18:45:08 +00:00
|
|
|
sector[spriowner->sectnum].floorz - (7 << 8);
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].jumping_toggle = 1;
|
|
|
|
ps[p].jumping_counter = 0;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
if (k == 1)
|
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
ps[p].oposx = ps[p].posx += spriowner->x - spri->x;
|
|
|
|
ps[p].oposy = ps[p].posy += spriowner->y - spri->y;
|
|
|
|
|
|
|
|
if (spriowner->owner != spri->owner)
|
2020-05-07 22:03:51 +00:00
|
|
|
ps[p].transporter_hold = -2;
|
2020-10-12 18:45:08 +00:00
|
|
|
ps[p].cursectnum = spriowner->sectnum;
|
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
2020-05-07 22:03:51 +00:00
|
|
|
setsprite(ps[p].i, ps[p].posx, ps[p].posy, ps[p].posz + PHEIGHT);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
setpal(&ps[p]);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
if ((krand() & 255) < 32)
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(j, WATERSPLASH2);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
if (sectlotag == 1)
|
2020-10-12 19:15:54 +00:00
|
|
|
for (int l = 0; l < 9; l++)
|
2020-10-12 18:45:08 +00:00
|
|
|
{
|
|
|
|
q = fi.spawn(ps[p].i, WATERBUBBLE);
|
|
|
|
sprite[q].z += krand() & 16383;
|
|
|
|
}
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
case STAT_ACTOR:
|
2020-10-12 18:45:08 +00:00
|
|
|
switch (sprj->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-10-12 18:45:08 +00:00
|
|
|
if (sprj->extra > 0)
|
|
|
|
continue;
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
|
|
|
case STAT_PROJECTILE:
|
|
|
|
case STAT_MISC:
|
|
|
|
case STAT_FALLER:
|
|
|
|
case STAT_DUMMYPLAYER:
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
ll = abs(sprj->zvel);
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
|
|
|
warpspriteto = 0;
|
2020-10-12 18:45:08 +00:00
|
|
|
if (ll && sectlotag == 2 && sprj->z < (sector[sect].ceilingz + ll))
|
2020-05-07 22:03:51 +00:00
|
|
|
warpspriteto = 1;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
if (ll && sectlotag == 1 && sprj->z > (sector[sect].floorz - ll))
|
2020-05-07 22:03:51 +00:00
|
|
|
warpspriteto = 1;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
if (sectlotag == 0 && (onfloorz || abs(sprj->z - spri->z) < 4096))
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
if (spriowner->owner != spri->owner && onfloorz && hiti->temp_data[0] > 0 && sprj->statnum != 5)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
hiti->temp_data[0]++;
|
2020-05-07 22:03:51 +00:00
|
|
|
goto BOLT;
|
|
|
|
}
|
|
|
|
warpspriteto = 1;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
if (warpspriteto) switch (sprj->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:
|
2020-10-12 18:45:08 +00:00
|
|
|
continue;
|
2020-05-07 22:03:51 +00:00
|
|
|
case PLAYERONWATER:
|
|
|
|
if (sectlotag == 2)
|
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
sprj->cstat &= 32767;
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2020-10-12 18:45:08 +00:00
|
|
|
if (sprj->statnum == 5 && !(sectlotag == 1 || sectlotag == 2))
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
case WATERBUBBLE:
|
2020-10-12 18:45:08 +00:00
|
|
|
//if( rnd(192) && sprj->picnum == WATERBUBBLE)
|
|
|
|
// break;
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
if (sectlotag > 0)
|
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int k = fi.spawn(j, WATERSPLASH2);
|
2020-10-12 18:45:08 +00:00
|
|
|
if (sectlotag == 1 && sprj->statnum == 4)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
sprite[k].xvel = sprj->xvel >> 1;
|
|
|
|
sprite[k].ang = sprj->ang;
|
2020-05-07 22:03:51 +00:00
|
|
|
ssp(k, CLIPMASK0);
|
|
|
|
}
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
switch (sectlotag)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
if (onfloorz)
|
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
if (sprj->statnum == 4 || (checkcursectnums(sect) == -1 && checkcursectnums(spriowner->sectnum) == -1))
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
sprj->x += (spriowner->x - spri->x);
|
|
|
|
sprj->y += (spriowner->y - spri->y);
|
|
|
|
sprj->z -= spri->z - sector[spriowner->sectnum].floorz;
|
|
|
|
sprj->ang = spriowner->ang;
|
|
|
|
|
|
|
|
hitj->bposx = sprj->x;
|
|
|
|
hitj->bposy = sprj->y;
|
|
|
|
hitj->bposz = sprj->z;
|
|
|
|
|
|
|
|
if (spri->pal == 0)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 19:15:54 +00:00
|
|
|
int k = fi.spawn(i, TRANSPORTERBEAM);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TELEPORTER, k);
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
k = fi.spawn(spri->owner, TRANSPORTERBEAM);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TELEPORTER, k);
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
if (spriowner->owner != spri->owner)
|
2020-05-07 22:03:51 +00:00
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
hiti->temp_data[0] = 13;
|
|
|
|
hittype[spri->owner].temp_data[0] = 13;
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-12 18:45:08 +00:00
|
|
|
sprj->x += (spriowner->x - spri->x);
|
|
|
|
sprj->y += (spriowner->y - spri->y);
|
|
|
|
sprj->z = spriowner->z + 4096;
|
|
|
|
|
|
|
|
hitj->bposx = sprj->x;
|
|
|
|
hitj->bposy = sprj->y;
|
|
|
|
hitj->bposz = sprj->z;
|
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
2020-05-07 22:03:51 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
2020-10-12 18:45:08 +00:00
|
|
|
sprj->x += (spriowner->x - spri->x);
|
|
|
|
sprj->y += (spriowner->y - spri->y);
|
|
|
|
sprj->z = sector[spriowner->sectnum].ceilingz + ll;
|
|
|
|
|
|
|
|
hitj->bposx = sprj->x;
|
|
|
|
hitj->bposy = sprj->y;
|
|
|
|
hitj->bposz = sprj->z;
|
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2020-10-12 18:45:08 +00:00
|
|
|
sprj->x += (spriowner->x - spri->x);
|
|
|
|
sprj->y += (spriowner->y - spri->y);
|
|
|
|
sprj->z = sector[spriowner->sectnum].floorz - ll;
|
|
|
|
|
|
|
|
hitj->bposx = sprj->x;
|
|
|
|
hitj->bposy = sprj->y;
|
|
|
|
hitj->bposz = sprj->z;
|
|
|
|
|
|
|
|
changespritesect(j, spriowner->sectnum);
|
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-10-12 18:45:08 +00:00
|
|
|
|
2020-05-07 22:03:51 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2020-10-12 18:45:08 +00:00
|
|
|
|
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
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void greenslime(int i)
|
|
|
|
{
|
|
|
|
spritetype* s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int sect = s->sectnum;
|
|
|
|
int j;
|
|
|
|
|
2020-10-11 09:39:51 +00:00
|
|
|
// #ifndef isShareware()
|
2020-05-08 22:34:48 +00:00
|
|
|
if (ud.multimode < 2)
|
|
|
|
{
|
|
|
|
if (actor_tog == 1)
|
|
|
|
{
|
|
|
|
s->cstat = (short)32768;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (actor_tog == 2) s->cstat = 257;
|
|
|
|
}
|
|
|
|
// #endif
|
|
|
|
|
|
|
|
t[1] += 128;
|
|
|
|
|
|
|
|
if (sector[sect].floorstat & 1)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int x;
|
|
|
|
int p = findplayer(s, &x);
|
|
|
|
|
|
|
|
if (x > 20480)
|
|
|
|
{
|
|
|
|
hittype[i].timetosleep++;
|
|
|
|
if (hittype[i].timetosleep > SLEEPTIME)
|
|
|
|
{
|
|
|
|
hittype[i].timetosleep = 0;
|
|
|
|
changespritestat(i, 2);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[0] == -5) // FROZEN
|
|
|
|
{
|
|
|
|
t[3]++;
|
|
|
|
if (t[3] > 280)
|
|
|
|
{
|
|
|
|
s->pal = 0;
|
|
|
|
t[0] = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
makeitfall(i);
|
|
|
|
s->cstat = 257;
|
|
|
|
s->picnum = GREENSLIME + 2;
|
|
|
|
s->extra = 1;
|
|
|
|
s->pal = 1;
|
2020-10-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]); if (j >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
if (j == FREEZEBLAST)
|
|
|
|
return;
|
|
|
|
for (j = 16; j >= 0; j--)
|
|
|
|
{
|
|
|
|
int k = EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sprite[i].z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), i, 5);
|
|
|
|
sprite[k].pal = 1;
|
|
|
|
}
|
2020-07-27 18:53:31 +00:00
|
|
|
ps[p].actors_killed++;
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(GLASS_BREAKING, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
else if (x < 1024 && ps[p].quick_kick == 0)
|
|
|
|
{
|
2020-10-07 12:13:21 +00:00
|
|
|
j = getincangle(ps[p].angle.ang.asbuild(), getangle(sprite[i].x - ps[p].posx, sprite[i].y - ps[p].posy));
|
2020-05-08 22:34:48 +00:00
|
|
|
if (j > -128 && j < 128)
|
|
|
|
ps[p].quick_kick = 14;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (x < 1596)
|
|
|
|
s->cstat = 0;
|
|
|
|
else s->cstat = 257;
|
|
|
|
|
|
|
|
if (t[0] == -4) //On the player
|
|
|
|
{
|
|
|
|
if (sprite[ps[p].i].extra < 1)
|
|
|
|
{
|
|
|
|
t[0] = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
setsprite(i, s->x, s->y, s->z);
|
|
|
|
|
2020-10-07 12:13:21 +00:00
|
|
|
s->ang = ps[p].angle.ang.asbuild();
|
2020-05-08 22:34:48 +00:00
|
|
|
|
2020-08-28 20:51:05 +00:00
|
|
|
if ((PlayerInput(p, SB_FIRE) || (ps[p].quick_kick > 0)) && sprite[ps[p].i].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++)
|
|
|
|
{
|
|
|
|
j = EGS(sect, s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), i, 5);
|
|
|
|
sprite[j].pal = 6;
|
|
|
|
}
|
|
|
|
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SLIM_DYING, i);
|
|
|
|
S_PlayActorSound(SQUISHED, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
if ((krand() & 255) < 32)
|
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
j = fi.spawn(i, BLOODPOOL);
|
2020-05-08 22:34:48 +00:00
|
|
|
sprite[j].pal = 0;
|
|
|
|
}
|
|
|
|
ps[p].actors_killed++;
|
|
|
|
t[0] = -3;
|
2020-10-17 09:10:12 +00:00
|
|
|
if (ps[p].somethingonplayer == &hittype[i])
|
|
|
|
ps[p].somethingonplayer = nullptr;
|
2020-05-08 22:34:48 +00:00
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->z = ps[p].posz + ps[p].pyoff - t[2] + (8 << 8);
|
|
|
|
|
2020-10-07 06:12:37 +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;
|
|
|
|
|
|
|
|
if (ps[p].newowner >= 0)
|
|
|
|
{
|
|
|
|
ps[p].newowner = -1;
|
|
|
|
ps[p].posx = ps[p].oposx;
|
|
|
|
ps[p].posy = ps[p].oposy;
|
|
|
|
ps[p].posz = ps[p].oposz;
|
2020-10-07 12:13:21 +00:00
|
|
|
ps[p].angle.restore();
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
updatesector(ps[p].posx, ps[p].posy, &ps[p].cursectnum);
|
|
|
|
setpal(&ps[p]);
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_ACTOR);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
if (sprite[j].picnum == CAMERA1) sprite[j].yvel = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[3] > 0)
|
|
|
|
{
|
|
|
|
short frames[] = { 5,5,6,6,7,7,6,5 };
|
|
|
|
|
|
|
|
s->picnum = GREENSLIME + frames[t[3]];
|
|
|
|
|
|
|
|
if (t[3] == 5)
|
|
|
|
{
|
|
|
|
sprite[ps[p].i].extra += -(5 + (krand() & 3));
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SLIM_ATTACK, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (t[3] < 7) t[3]++;
|
|
|
|
else t[3] = 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s->picnum = GREENSLIME + 5;
|
|
|
|
if (rnd(32))
|
|
|
|
t[3] = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->xrepeat = 20 + (sintable[t[1] & 2047] >> 13);
|
|
|
|
s->yrepeat = 15 + (sintable[t[1] & 2047] >> 13);
|
|
|
|
|
2020-10-07 12:13:21 +00:00
|
|
|
s->x = ps[p].posx + (sintable[(ps[p].angle.ang.asbuild() + 512) & 2047] >> 7);
|
|
|
|
s->y = ps[p].posy + (sintable[ps[p].angle.ang.asbuild() & 2047] >> 7);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (s->xvel < 64 && x < 768)
|
|
|
|
{
|
2020-10-17 09:10:12 +00:00
|
|
|
if (ps[p].somethingonplayer == nullptr)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
2020-10-17 09:10:12 +00:00
|
|
|
ps[p].somethingonplayer = &hittype[i];
|
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-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]); if (j >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SLIM_DYING, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
2020-10-17 09:10:12 +00:00
|
|
|
if (ps[p].somethingonplayer == &hittype[i])
|
|
|
|
ps[p].somethingonplayer = nullptr;
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if (j == FREEZEBLAST)
|
|
|
|
{
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SOMETHINGFROZE, i); t[0] = -5; t[3] = 0;
|
2020-05-08 22:34:48 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-07-27 18:53:31 +00:00
|
|
|
ps[p].actors_killed++;
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if ((krand() & 255) < 32)
|
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
j = fi.spawn(i, BLOODPOOL);
|
2020-05-08 22:34:48 +00:00
|
|
|
sprite[j].pal = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (x = 0; x < 8; x++)
|
|
|
|
{
|
|
|
|
j = EGS(sect, s->x, s->y, s->z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (s->zvel >> 2), i, 5);
|
|
|
|
sprite[j].pal = 6;
|
|
|
|
}
|
|
|
|
t[0] = -3;
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// All weap
|
|
|
|
if (t[0] == -1) //Shrinking down
|
|
|
|
{
|
|
|
|
makeitfall(i);
|
|
|
|
|
|
|
|
s->cstat &= 65535 - 8;
|
|
|
|
s->picnum = GREENSLIME + 4;
|
|
|
|
|
2020-05-12 11:43:24 +00:00
|
|
|
// if(s->yrepeat > 62)
|
2020-05-14 10:14:03 +00:00
|
|
|
// fi.guts(s,JIBS6,5,myconnectindex);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if (s->xrepeat > 32) s->xrepeat -= krand() & 7;
|
|
|
|
if (s->yrepeat > 16) s->yrepeat -= krand() & 7;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s->xrepeat = 40;
|
|
|
|
s->yrepeat = 16;
|
|
|
|
t[5] = -1;
|
|
|
|
t[0] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (t[0] != -2) getglobalz(i);
|
|
|
|
|
|
|
|
if (t[0] == -2) //On top of somebody (an enemy)
|
|
|
|
{
|
|
|
|
makeitfall(i);
|
|
|
|
sprite[t[5]].xvel = 0;
|
|
|
|
|
|
|
|
int l = sprite[t[5]].ang;
|
|
|
|
|
|
|
|
s->z = sprite[t[5]].z;
|
|
|
|
s->x = sprite[t[5]].x + (sintable[(l + 512) & 2047] >> 11);
|
|
|
|
s->y = sprite[t[5]].y + (sintable[l & 2047] >> 11);
|
|
|
|
|
|
|
|
s->picnum = GREENSLIME + 2 + (global_random & 1);
|
|
|
|
|
|
|
|
if (s->yrepeat < 64) s->yrepeat += 2;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (s->xrepeat < 32) s->xrepeat += 4;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
t[0] = -1;
|
|
|
|
x = ldist(s, &sprite[t[5]]);
|
|
|
|
if (x < 768) {
|
|
|
|
sprite[t[5]].xrepeat = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Check randomly to see of there is an actor near
|
|
|
|
if (rnd(32))
|
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
SectIterator it(sect);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
switch (sprite[j].picnum)
|
|
|
|
{
|
|
|
|
case LIZTROOP:
|
|
|
|
case LIZMAN:
|
|
|
|
case PIGCOP:
|
|
|
|
case NEWBEAST:
|
2020-05-10 07:08:02 +00:00
|
|
|
if (ldist(s, &sprite[j]) < 768 && (abs(s->z - sprite[j].z) < 8192)) //Gulp them
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
t[5] = j;
|
|
|
|
t[0] = -2;
|
|
|
|
t[1] = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Moving on the ground or ceiling
|
|
|
|
|
|
|
|
if (t[0] == 0 || t[0] == 2)
|
|
|
|
{
|
|
|
|
s->picnum = GREENSLIME;
|
|
|
|
|
|
|
|
if ((krand() & 511) == 0)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(SLIM_ROAM, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if (t[0] == 2)
|
|
|
|
{
|
|
|
|
s->zvel = 0;
|
|
|
|
s->cstat &= (65535 - 8);
|
|
|
|
|
|
|
|
if ((sector[sect].ceilingstat & 1) || (hittype[i].ceilingz + 6144) < s->z)
|
|
|
|
{
|
|
|
|
s->z += 2048;
|
|
|
|
t[0] = 3;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s->cstat |= 8;
|
|
|
|
makeitfall(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (everyothertime & 1) ssp(i, CLIPMASK0);
|
|
|
|
|
|
|
|
if (s->xvel > 96)
|
|
|
|
{
|
|
|
|
s->xvel -= 2;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (s->xvel < 32) s->xvel += 4;
|
|
|
|
s->xvel = 64 - (sintable[(t[1] + 512) & 2047] >> 9);
|
|
|
|
|
|
|
|
s->ang += getincangle(s->ang,
|
|
|
|
getangle(ps[p].posx - s->x, ps[p].posy - s->y)) >> 3;
|
|
|
|
// TJR
|
|
|
|
}
|
|
|
|
|
|
|
|
s->xrepeat = 36 + (sintable[(t[1] + 512) & 2047] >> 11);
|
|
|
|
s->yrepeat = 16 + (sintable[t[1] & 2047] >> 13);
|
|
|
|
|
|
|
|
if (rnd(4) && (sector[sect].ceilingstat & 1) == 0 &&
|
2020-05-10 07:08:02 +00:00
|
|
|
abs(hittype[i].floorz - hittype[i].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;
|
|
|
|
if (s->z < hittype[i].ceilingz + 4096)
|
|
|
|
{
|
|
|
|
s->z = hittype[i].ceilingz + 4096;
|
|
|
|
s->xvel = 0;
|
|
|
|
t[0] = 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[0] == 3)
|
|
|
|
{
|
|
|
|
s->picnum = GREENSLIME + 1;
|
|
|
|
|
|
|
|
makeitfall(i);
|
|
|
|
|
|
|
|
if (s->z > hittype[i].floorz - (8 << 8))
|
|
|
|
{
|
|
|
|
s->yrepeat -= 4;
|
|
|
|
s->xrepeat += 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (s->yrepeat < (40 - 4)) s->yrepeat += 8;
|
|
|
|
if (s->xrepeat > 8) s->xrepeat -= 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->z > hittype[i].floorz - 2048)
|
|
|
|
{
|
|
|
|
s->z = hittype[i].floorz - 2048;
|
|
|
|
t[0] = 0;
|
|
|
|
s->xvel = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-09 09:44:50 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void flamethrowerflame(int i)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
spritetype* s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int sect = s->sectnum;
|
|
|
|
int x, j;
|
|
|
|
int p = findplayer(s, &x);
|
|
|
|
execute(i, p, x);
|
|
|
|
t[0]++;
|
|
|
|
if (sector[sect].lotag == 2)
|
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
sprite[fi.spawn(i, EXPLOSION2)].shade = 127;
|
2020-05-08 22:34:48 +00:00
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dax = s->x;
|
|
|
|
int day = s->y;
|
|
|
|
int daz = s->z;
|
2020-09-07 19:38:17 +00:00
|
|
|
int xvel = s->xvel;
|
|
|
|
int zvel = s->zvel;
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
getglobalz(i);
|
|
|
|
|
|
|
|
int ds = t[0] / 6;
|
|
|
|
if (s->xrepeat < 80)
|
|
|
|
s->yrepeat = s->xrepeat += ds;
|
|
|
|
s->clipdist += ds;
|
|
|
|
if (t[0] <= 2)
|
|
|
|
t[3] = krand() % 10;
|
|
|
|
if (t[0] > 30)
|
|
|
|
{
|
2020-05-15 20:59:13 +00:00
|
|
|
sprite[fi.spawn(i, EXPLOSION2)].shade = 127;
|
2020-05-08 22:34:48 +00:00
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-07 19:38:17 +00:00
|
|
|
j = fi.movesprite(i, (xvel * (sintable[(s->ang + 512) & 2047])) >> 14,
|
|
|
|
(xvel * (sintable[s->ang & 2047])) >> 14, s->zvel, CLIPMASK1);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if (s->sectnum < 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((j & kHitTypeMask) != kHitSprite)
|
|
|
|
{
|
|
|
|
if (s->z < hittype[i].ceilingz)
|
|
|
|
{
|
|
|
|
j = kHitSector | (s->sectnum);
|
|
|
|
s->zvel = -1;
|
|
|
|
}
|
|
|
|
else if ((s->z > hittype[i].floorz && sector[s->sectnum].lotag != 1)
|
|
|
|
|| (s->z > hittype[i].floorz + (16 << 8) && sector[s->sectnum].lotag == 1))
|
|
|
|
{
|
|
|
|
j = kHitSector | (s->sectnum);
|
|
|
|
if (sector[s->sectnum].lotag != 1)
|
|
|
|
s->zvel = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (j != 0) {
|
2020-09-07 19:38:17 +00:00
|
|
|
s->xvel = s->yvel = s->zvel = 0;
|
2020-05-08 22:34:48 +00:00
|
|
|
if ((j & kHitTypeMask) == kHitSprite)
|
|
|
|
{
|
|
|
|
j &= (MAXSPRITES - 1);
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitsprite((short)j, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
if (sprite[j].picnum == APLAYER)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(j, PISTOL_BODYHIT);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
else if ((j & kHitTypeMask) == kHitWall)
|
|
|
|
{
|
|
|
|
j &= (MAXWALLS - 1);
|
|
|
|
setsprite(i, dax, day, daz);
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
else if ((j & kHitTypeMask) == kHitSector)
|
|
|
|
{
|
|
|
|
setsprite(i, dax, day, daz);
|
|
|
|
if (s->zvel < 0)
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitceiling(s->sectnum);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->xrepeat >= 10)
|
|
|
|
{
|
|
|
|
x = s->extra;
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], rpgblastradius, x >> 2, x >> 1, x - (x >> 2), x);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x = s->extra + (global_random & 3);
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], (rpgblastradius >> 1), x >> 2, x >> 1, x - (x >> 2), x);
|
2020-05-08 22:34:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-09 09:44:50 +00:00
|
|
|
static void heavyhbomb(int i)
|
|
|
|
{
|
|
|
|
spritetype* s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int sect = s->sectnum;
|
|
|
|
int x, j, l;
|
|
|
|
|
|
|
|
if ((s->cstat & 32768))
|
|
|
|
{
|
|
|
|
t[2]--;
|
|
|
|
if (t[2] <= 0)
|
|
|
|
{
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(TELEPORTER, i);
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, TRANSPORTERSTAR);
|
2020-05-09 09:44:50 +00:00
|
|
|
s->cstat = 257;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int p = findplayer(s, &x);
|
|
|
|
|
|
|
|
if (x < 1220) s->cstat &= ~257;
|
|
|
|
else s->cstat |= 257;
|
|
|
|
|
|
|
|
if (t[3] == 0)
|
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]);
|
2020-05-09 09:44:50 +00:00
|
|
|
if (j >= 0)
|
|
|
|
{
|
|
|
|
t[3] = 1;
|
|
|
|
t[4] = 0;
|
|
|
|
l = 0;
|
|
|
|
s->xvel = 0;
|
|
|
|
goto DETONATEB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->picnum != BOUNCEMINE)
|
|
|
|
{
|
|
|
|
makeitfall(i);
|
|
|
|
|
|
|
|
if (sector[sect].lotag != 1 && s->z >= hittype[i].floorz - (FOURSLEIGHT) && s->yvel < 3)
|
|
|
|
{
|
|
|
|
if (s->yvel > 0 || (s->yvel == 0 && hittype[i].floorz == sector[sect].floorz))
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PIPEBOMB_BOUNCE, i);
|
2020-05-09 09:44:50 +00:00
|
|
|
s->zvel = -((4 - s->yvel) << 8);
|
|
|
|
if (sector[s->sectnum].lotag == 2)
|
|
|
|
s->zvel >>= 2;
|
|
|
|
s->yvel++;
|
|
|
|
}
|
|
|
|
if (s->z < hittype[i].ceilingz) // && sector[sect].lotag != 2 )
|
|
|
|
{
|
|
|
|
s->z = hittype[i].ceilingz + (3 << 8);
|
|
|
|
s->zvel = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-14 10:14:03 +00:00
|
|
|
j = fi.movesprite(i,
|
2020-05-09 09:44:50 +00:00
|
|
|
(s->xvel * (sintable[(s->ang + 512) & 2047])) >> 14,
|
|
|
|
(s->xvel * (sintable[s->ang & 2047])) >> 14,
|
|
|
|
s->zvel, CLIPMASK0);
|
|
|
|
|
|
|
|
if (sector[sprite[i].sectnum].lotag == 1 && s->zvel == 0)
|
|
|
|
{
|
|
|
|
s->z += (32 << 8);
|
|
|
|
if (t[5] == 0)
|
|
|
|
{
|
|
|
|
t[5] = 1;
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, WATERSPLASH2);
|
2020-05-09 09:44:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else t[5] = 0;
|
|
|
|
|
|
|
|
if (t[3] == 0 && (s->picnum == BOUNCEMINE || s->picnum == MORTER) && (j || x < 844))
|
|
|
|
{
|
|
|
|
t[3] = 1;
|
|
|
|
t[4] = 0;
|
|
|
|
l = 0;
|
|
|
|
s->xvel = 0;
|
|
|
|
goto DETONATEB;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sprite[s->owner].picnum == APLAYER)
|
|
|
|
l = sprite[s->owner].yvel;
|
|
|
|
else l = -1;
|
|
|
|
|
|
|
|
if (s->xvel > 0)
|
|
|
|
{
|
|
|
|
s->xvel -= 5;
|
|
|
|
if (sector[sect].lotag == 2)
|
|
|
|
s->xvel -= 10;
|
|
|
|
|
|
|
|
if (s->xvel < 0)
|
|
|
|
s->xvel = 0;
|
|
|
|
if (s->xvel & 8) s->cstat ^= 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((j & 49152) == 32768)
|
|
|
|
{
|
|
|
|
j &= (MAXWALLS - 1);
|
|
|
|
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.checkhitwall(i, j, s->x, s->y, s->z, s->picnum);
|
2020-05-09 09:44:50 +00:00
|
|
|
|
|
|
|
int k = getangle(
|
|
|
|
wall[wall[j].point2].x - wall[j].x,
|
|
|
|
wall[wall[j].point2].y - wall[j].y);
|
|
|
|
|
|
|
|
s->ang = ((k << 1) - s->ang) & 2047;
|
|
|
|
s->xvel >>= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DETONATEB:
|
|
|
|
|
|
|
|
bool bBoom = false;
|
|
|
|
if ((l >= 0 && ps[l].hbomb_on == 0) || t[3] == 1)
|
|
|
|
bBoom = true;
|
|
|
|
if (isNamWW2GI() && s->picnum == HEAVYHBOMB)
|
|
|
|
{
|
|
|
|
s->extra--;
|
|
|
|
if (s->extra <= 0)
|
|
|
|
bBoom = true;
|
|
|
|
}
|
|
|
|
if (bBoom)
|
|
|
|
{
|
|
|
|
t[4]++;
|
|
|
|
|
|
|
|
if (t[4] == 2)
|
|
|
|
{
|
|
|
|
x = s->extra;
|
|
|
|
int m = 0;
|
|
|
|
switch (s->picnum)
|
|
|
|
{
|
|
|
|
case HEAVYHBOMB: m = pipebombblastradius; break;
|
|
|
|
case MORTER: m = morterblastradius; break;
|
|
|
|
case BOUNCEMINE: m = bouncemineblastradius; break;
|
|
|
|
}
|
|
|
|
|
2020-10-21 20:04:39 +00:00
|
|
|
fi.hitradius(&hittype[i], m, x >> 2, x >> 1, x - (x >> 2), x);
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, EXPLOSION2);
|
2020-05-09 09:44:50 +00:00
|
|
|
if (s->zvel == 0)
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, EXPLOSION2BOT);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(PIPEBOMB_EXPLODE, i);
|
2020-05-09 09:44:50 +00:00
|
|
|
for (x = 0; x < 8; x++)
|
|
|
|
RANDOMSCRAP(s, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->yrepeat)
|
|
|
|
{
|
|
|
|
s->yrepeat = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[4] > 20)
|
|
|
|
{
|
|
|
|
if (s->owner != i || ud.respawn_items == 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
t[2] = respawnitemtime;
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, RESPAWNMARKERRED);
|
2020-05-09 09:44:50 +00:00
|
|
|
s->cstat = (short)32768;
|
|
|
|
s->yrepeat = 9;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (s->picnum == HEAVYHBOMB && x < 788 && t[0] > 7 && s->xvel == 0)
|
|
|
|
if (cansee(s->x, s->y, s->z - (8 << 8), s->sectnum, ps[p].posx, ps[p].posy, ps[p].posz, ps[p].cursectnum))
|
|
|
|
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < max_ammo_amount[HANDBOMB_WEAPON])
|
|
|
|
{
|
|
|
|
if (ud.coop >= 1 && s->owner == i)
|
|
|
|
{
|
|
|
|
for (j = 0; j < ps[p].weapreccnt; j++)
|
|
|
|
if (ps[p].weaprecs[j] == s->picnum)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ps[p].weapreccnt < 255) // DukeGDX has 16 here.
|
|
|
|
ps[p].weaprecs[ps[p].weapreccnt++] = s->picnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
addammo(HANDBOMB_WEAPON, &ps[p], 1);
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(DUKE_GET, ps[p].i);
|
2020-05-09 09:44:50 +00:00
|
|
|
|
|
|
|
if (ps[p].gotweapon[HANDBOMB_WEAPON] == 0 || s->owner == ps[p].i)
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.addweapon(&ps[p], HANDBOMB_WEAPON);
|
2020-05-09 09:44:50 +00:00
|
|
|
|
|
|
|
if (sprite[s->owner].picnum != APLAYER)
|
|
|
|
{
|
|
|
|
SetPlayerPal(&ps[p], PalEntry(32, 0, 32, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->owner != i || ud.respawn_items == 0)
|
|
|
|
{
|
|
|
|
if (s->owner == i && ud.coop >= 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
t[2] = respawnitemtime;
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, RESPAWNMARKERRED);
|
2020-05-09 09:44:50 +00:00
|
|
|
s->cstat = (short)32768;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[0] < 8) t[0]++;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-08 22:34:48 +00:00
|
|
|
void moveactors_d(void)
|
|
|
|
{
|
2020-05-09 09:44:50 +00:00
|
|
|
int x, * t;
|
2020-05-08 22:34:48 +00:00
|
|
|
short j, sect, p;
|
|
|
|
spritetype* s;
|
|
|
|
unsigned short k;
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_ACTOR);
|
|
|
|
int i;
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
|
|
|
s = &sprite[i];
|
|
|
|
|
|
|
|
sect = s->sectnum;
|
|
|
|
|
|
|
|
if (s->xrepeat == 0 || sect < 0 || sect >= MAXSECTORS)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
t = &hittype[i].temp_data[0];
|
|
|
|
|
|
|
|
hittype[i].bposx = s->x;
|
|
|
|
hittype[i].bposy = s->y;
|
|
|
|
hittype[i].bposz = s->z;
|
|
|
|
|
|
|
|
|
|
|
|
switch (s->picnum)
|
|
|
|
{
|
|
|
|
case FLAMETHROWERFLAME:
|
|
|
|
if (isWorldTour()) flamethrowerflame(i);
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case DUCK:
|
|
|
|
case TARGET:
|
|
|
|
if (s->cstat & 32)
|
|
|
|
{
|
|
|
|
t[0]++;
|
|
|
|
if (t[0] > 60)
|
|
|
|
{
|
|
|
|
t[0] = 0;
|
|
|
|
s->cstat = 128 + 257 + 16;
|
|
|
|
s->extra = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-21 19:41:14 +00:00
|
|
|
j = fi.ifhitbyweapon(&hittype[i]);
|
2020-05-08 22:34:48 +00:00
|
|
|
if (j >= 0)
|
|
|
|
{
|
|
|
|
s->cstat = 32 + 128;
|
|
|
|
k = 1;
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_ACTOR);
|
|
|
|
int j;
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->lotag == s->lotag &&
|
|
|
|
sj->picnum == s->picnum)
|
2020-05-08 22:34:48 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
if ((sj->hitag && !(sj->cstat & 32)) ||
|
|
|
|
(!sj->hitag && (sj->cstat & 32))
|
2020-05-08 22:34:48 +00:00
|
|
|
)
|
|
|
|
{
|
|
|
|
k = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (k == 1)
|
|
|
|
{
|
|
|
|
operateactivators(s->lotag, -1);
|
2020-05-14 10:14:03 +00:00
|
|
|
fi.operateforcefields(i, s->lotag);
|
2020-05-08 22:34:48 +00:00
|
|
|
operatemasterswitches(s->lotag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case RESPAWNMARKERRED:
|
|
|
|
case RESPAWNMARKERYELLOW:
|
|
|
|
case RESPAWNMARKERGREEN:
|
2020-10-21 20:34:45 +00:00
|
|
|
if (!respawnmarker(&hittype[i], RESPAWNMARKERYELLOW, RESPAWNMARKERGREEN)) continue;
|
2020-05-08 22:34:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HELECOPT:
|
|
|
|
case DUKECAR:
|
|
|
|
|
|
|
|
s->z += s->zvel;
|
|
|
|
t[0]++;
|
|
|
|
|
2020-07-25 07:32:54 +00:00
|
|
|
if (t[0] == 4) S_PlayActorSound(WAR_AMBIENCE2, i);
|
2020-05-08 22:34:48 +00:00
|
|
|
|
|
|
|
if (t[0] > (26 * 8))
|
|
|
|
{
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlaySound(RPG_EXPLODE);
|
2020-05-08 22:34:48 +00:00
|
|
|
for (j = 0; j < 32; j++)
|
|
|
|
RANDOMSCRAP(s, i);
|
|
|
|
earthquaketime = 16;
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else if ((t[0] & 3) == 0)
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(i, EXPLOSION2);
|
2020-05-08 22:34:48 +00:00
|
|
|
ssp(i, CLIPMASK0);
|
|
|
|
break;
|
|
|
|
case RAT:
|
2020-10-21 20:34:45 +00:00
|
|
|
if (!rat(&hittype[i], true)) continue;
|
2020-05-08 22:34:48 +00:00
|
|
|
break;
|
|
|
|
case QUEBALL:
|
|
|
|
case STRIPEBALL:
|
2020-10-21 20:34:45 +00:00
|
|
|
if (!queball(&hittype[i], POCKET, QUEBALL, STRIPEBALL)) continue;
|
2020-05-08 22:34:48 +00:00
|
|
|
break;
|
|
|
|
case FORCESPHERE:
|
2020-10-21 20:59:56 +00:00
|
|
|
forcesphere(&hittype[i], FORCESPHERE);
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case RECON:
|
2020-10-21 20:59:56 +00:00
|
|
|
recon(&hittype[i], EXPLOSION2, FIRELASER, RECO_ATTACK, RECO_PAIN, RECO_ROAM, 10, [](DDukeActor* i)->int { return PIGCOP; });
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case OOZ:
|
|
|
|
case OOZ2:
|
2020-10-21 21:04:14 +00:00
|
|
|
ooz(&hittype[i]);
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case GREENSLIME:
|
|
|
|
case GREENSLIME + 1:
|
|
|
|
case GREENSLIME + 2:
|
|
|
|
case GREENSLIME + 3:
|
|
|
|
case GREENSLIME + 4:
|
|
|
|
case GREENSLIME + 5:
|
|
|
|
case GREENSLIME + 6:
|
|
|
|
case GREENSLIME + 7:
|
|
|
|
greenslime(i);
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case BOUNCEMINE:
|
|
|
|
case MORTER:
|
2020-05-15 20:59:13 +00:00
|
|
|
j = fi.spawn(i, FRAMEEFFECT1);
|
2020-05-08 22:34:48 +00:00
|
|
|
hittype[j].temp_data[0] = 3;
|
|
|
|
|
|
|
|
case HEAVYHBOMB:
|
2020-05-09 09:44:50 +00:00
|
|
|
heavyhbomb(i);
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case REACTORBURNT:
|
|
|
|
case REACTOR2BURNT:
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case REACTOR:
|
|
|
|
case REACTOR2:
|
2020-10-21 21:04:14 +00:00
|
|
|
reactor(&hittype[i], REACTOR, REACTOR2, REACTORBURNT, REACTOR2BURNT, REACTORSPARK, REACTOR2SPARK);
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
|
2020-05-14 19:42:11 +00:00
|
|
|
case CAMERA1:
|
2020-10-21 21:04:14 +00:00
|
|
|
camera(&hittype[i]);
|
2020-05-08 22:34:48 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// #ifndef VOLOMEONE
|
|
|
|
if (ud.multimode < 2 && badguy(s))
|
|
|
|
{
|
|
|
|
if (actor_tog == 1)
|
|
|
|
{
|
|
|
|
s->cstat = (short)32768;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else if (actor_tog == 2) s->cstat = 257;
|
|
|
|
}
|
|
|
|
// #endif
|
|
|
|
|
|
|
|
p = findplayer(s, &x);
|
|
|
|
|
|
|
|
execute(i, p, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2020-05-09 18:27:06 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-10 07:28:13 +00:00
|
|
|
static void fireflyflyingeffect(int i)
|
|
|
|
{
|
|
|
|
spritetype* s = &sprite[i];
|
|
|
|
auto t = &hittype[i].temp_data[0];
|
|
|
|
int x, p = findplayer(s, &x);
|
|
|
|
execute(i, p, x);
|
|
|
|
|
|
|
|
auto owner = &sprite[s->owner];
|
|
|
|
if (owner->picnum != FIREFLY)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (owner->xrepeat >= 24 || owner->pal == 1)
|
|
|
|
s->cstat |= 0x8000;
|
|
|
|
else
|
|
|
|
s->cstat &= ~0x8000;
|
|
|
|
|
|
|
|
double dx = owner->x - sprite[ps[p].i].x;
|
|
|
|
double dy = owner->y - sprite[ps[p].i].y;
|
|
|
|
double dist = sqrt(dx * dx + dy * dy);
|
|
|
|
if (dist != 0.0)
|
|
|
|
{
|
|
|
|
dx /= dist;
|
|
|
|
dy /= dist;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->x = (int) (owner->x - (dx * -10.0));
|
|
|
|
s->y = (int) (owner->y - (dy * -10.0));
|
|
|
|
s->z = owner->z + 2048;
|
|
|
|
|
|
|
|
if (owner->extra <= 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-09 18:27:06 +00:00
|
|
|
void moveexplosions_d(void) // STATNUM 5
|
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
int sect, p;
|
2020-05-09 18:27:06 +00:00
|
|
|
int x, * t;
|
|
|
|
spritetype* s;
|
|
|
|
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_MISC);
|
|
|
|
int i;
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
2020-05-09 18:27:06 +00:00
|
|
|
{
|
|
|
|
t = &hittype[i].temp_data[0];
|
|
|
|
s = &sprite[i];
|
|
|
|
sect = s->sectnum;
|
|
|
|
|
|
|
|
if (sect < 0 || s->xrepeat == 0)
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
hittype[i].bposx = s->x;
|
|
|
|
hittype[i].bposy = s->y;
|
|
|
|
hittype[i].bposz = s->z;
|
|
|
|
|
|
|
|
switch (s->picnum)
|
|
|
|
{
|
2020-05-10 07:28:13 +00:00
|
|
|
case FIREFLYFLYINGEFFECT:
|
|
|
|
if (isWorldTour()) fireflyflyingeffect(i);
|
|
|
|
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]++;
|
|
|
|
if (t[0] == 8) s->picnum = NUKEBUTTON + 1;
|
|
|
|
else if (t[0] == 16)
|
|
|
|
{
|
|
|
|
s->picnum = NUKEBUTTON + 2;
|
|
|
|
ps[sprite[s->owner].yvel].fist_incs = 1;
|
|
|
|
}
|
|
|
|
if (ps[sprite[s->owner].yvel].fist_incs == 26)
|
|
|
|
s->picnum = NUKEBUTTON + 3;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case FORCESPHERE:
|
2020-10-21 21:11:06 +00:00
|
|
|
forcesphereexplode(&hittype[i]);
|
2020-05-09 18:27:06 +00:00
|
|
|
continue;
|
|
|
|
case WATERSPLASH2:
|
2020-10-21 21:11:06 +00:00
|
|
|
watersplash2(&hittype[i]);
|
2020-05-09 18:27:06 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case FRAMEEFFECT1:
|
2020-10-21 21:11:06 +00:00
|
|
|
frameeffect1(&hittype[i]);
|
2020-05-09 18:27:06 +00:00
|
|
|
continue;
|
|
|
|
case INNERJAW:
|
|
|
|
case INNERJAW + 1:
|
|
|
|
|
|
|
|
p = findplayer(s, &x);
|
|
|
|
if (x < 512)
|
|
|
|
{
|
|
|
|
SetPlayerPal(&ps[p], PalEntry(32, 32, 0, 0));
|
|
|
|
sprite[ps[p].i].extra -= 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
case FIRELASER:
|
|
|
|
if (s->extra != 999)
|
|
|
|
s->extra = 999;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TONGUE:
|
|
|
|
deletesprite(i);
|
|
|
|
continue;
|
|
|
|
case MONEY + 1:
|
|
|
|
case MAIL + 1:
|
|
|
|
case PAPER + 1:
|
|
|
|
hittype[i].floorz = s->z = getflorzofslope(s->sectnum, s->x, s->y);
|
|
|
|
break;
|
|
|
|
case MONEY:
|
|
|
|
case MAIL:
|
|
|
|
case PAPER:
|
2020-10-21 21:11:06 +00:00
|
|
|
money(&hittype[i], 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-21 21:18:24 +00:00
|
|
|
jibs(&hittype[i], 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-21 21:18:24 +00:00
|
|
|
bloodpool(&hittype[i], 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;
|
|
|
|
|
|
|
|
case BURNING:
|
|
|
|
case BURNING2:
|
|
|
|
case FECES:
|
|
|
|
case WATERBUBBLE:
|
|
|
|
case SMALLSMOKE:
|
|
|
|
case EXPLOSION2:
|
|
|
|
case SHRINKEREXPLOSION:
|
|
|
|
case EXPLOSION2BOT:
|
|
|
|
case BLOOD:
|
|
|
|
case LASERSITE:
|
|
|
|
case FORCERIPPLE:
|
|
|
|
case TRANSPORTERSTAR:
|
|
|
|
case TRANSPORTERBEAM:
|
|
|
|
p = findplayer(s, &x);
|
|
|
|
execute(i, p, x);
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case SHELL:
|
|
|
|
case SHOTGUNSHELL:
|
2020-10-21 21:18:24 +00:00
|
|
|
shell(&hittype[i], (sector[sect].floorz + (24 << 8)) < s->z);
|
2020-05-09 18:27:06 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case GLASSPIECES:
|
|
|
|
case GLASSPIECES + 1:
|
|
|
|
case GLASSPIECES + 2:
|
2020-10-21 21:18:24 +00:00
|
|
|
glasspieces(&hittype[i]);
|
2020-05-09 18:27:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->picnum >= SCRAP6 && s->picnum <= SCRAP5 + 3)
|
|
|
|
{
|
2020-10-21 21:18:24 +00:00
|
|
|
scrap(&hittype[i], SCRAP1, SCRAP6);
|
2020-05-09 18:27:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-10 07:08:02 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void moveeffectors_d(void) //STATNUM 3
|
|
|
|
{
|
|
|
|
int q = 0, l, x, st, j, * t;
|
2020-10-14 18:49:43 +00:00
|
|
|
int p, sh;
|
2020-05-10 07:08:02 +00:00
|
|
|
short k;
|
|
|
|
spritetype* s;
|
|
|
|
sectortype* sc;
|
|
|
|
walltype* wal;
|
|
|
|
|
|
|
|
clearfriction();
|
|
|
|
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_EFFECTOR);
|
|
|
|
int i;
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
|
|
|
s = &sprite[i];
|
|
|
|
|
|
|
|
sc = §or[s->sectnum];
|
|
|
|
st = s->lotag;
|
|
|
|
sh = s->hitag;
|
|
|
|
|
|
|
|
t = &hittype[i].temp_data[0];
|
|
|
|
|
|
|
|
switch (st)
|
|
|
|
{
|
|
|
|
case SE_0_ROTATING_SECTOR:
|
2020-10-21 21:39:12 +00:00
|
|
|
handle_se00(&hittype[i], LASERLINE);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_1_PIVOT: //Nothing for now used as the pivot
|
2020-10-21 21:39:12 +00:00
|
|
|
handle_se01(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_6_SUBWAY:
|
2020-10-14 18:02:05 +00:00
|
|
|
{
|
2020-05-10 07:08:02 +00:00
|
|
|
k = sc->extra;
|
|
|
|
|
|
|
|
if (t[4] > 0)
|
|
|
|
{
|
|
|
|
t[4]--;
|
|
|
|
if (t[4] >= (k - (k >> 3)))
|
|
|
|
s->xvel -= (k >> 5);
|
|
|
|
if (t[4] > ((k >> 1) - 1) && t[4] < (k - (k >> 3)))
|
|
|
|
s->xvel = 0;
|
|
|
|
if (t[4] < (k >> 1))
|
|
|
|
s->xvel += (k >> 5);
|
|
|
|
if (t[4] < ((k >> 1) - (k >> 3)))
|
|
|
|
{
|
|
|
|
t[4] = 0;
|
|
|
|
s->xvel = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else s->xvel = k;
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_EFFECTOR);
|
|
|
|
int j;
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if ((sj->lotag == 14) && (sh == sj->hitag) && (hittype[j].temp_data[0] == t[0]))
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
sj->xvel = s->xvel;
|
2020-05-12 11:43:24 +00:00
|
|
|
// if( t[4] == 1 )
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
|
|
|
if (hittype[j].temp_data[5] == 0)
|
2020-10-14 18:02:05 +00:00
|
|
|
hittype[j].temp_data[5] = dist(sj, s);
|
|
|
|
x = sgn(dist(sj, s) - hittype[j].temp_data[5]);
|
|
|
|
if (sj->extra)
|
2020-05-10 07:08:02 +00:00
|
|
|
x = -x;
|
|
|
|
s->xvel += x;
|
|
|
|
}
|
|
|
|
hittype[j].temp_data[4] = t[4];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
x = 0;
|
2020-10-14 18:02:05 +00:00
|
|
|
}
|
2020-05-10 07:08:02 +00:00
|
|
|
case SE_14_SUBWAY_CAR:
|
2020-10-21 21:56:46 +00:00
|
|
|
handle_se14(&hittype[i], true, RPG, JIBS6);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_30_TWO_WAY_TRAIN:
|
2020-10-21 22:00:43 +00:00
|
|
|
handle_se30(&hittype[i], JIBS6);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
case SE_2_EARTHQUAKE:
|
2020-10-21 22:10:43 +00:00
|
|
|
handle_se02(&hittype[i]);
|
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-21 22:10:43 +00:00
|
|
|
handle_se03(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_4_RANDOM_LIGHTS:
|
2020-10-21 22:10:43 +00:00
|
|
|
handle_se04(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
//BOSS
|
|
|
|
case SE_5_BOSS:
|
2020-10-21 22:14:54 +00:00
|
|
|
handle_se05(&hittype[i], 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-21 22:14:54 +00:00
|
|
|
handle_se08(&hittype[i], 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-21 22:14:54 +00:00
|
|
|
handle_se10(&hittype[i], tags);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SE_11_SWINGING_DOOR:
|
2020-10-21 22:20:47 +00:00
|
|
|
handle_se11(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_12_LIGHT_SWITCH:
|
2020-10-21 22:20:47 +00:00
|
|
|
handle_se12(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_13_EXPLOSIVE:
|
2020-10-21 22:20:47 +00:00
|
|
|
handle_se13(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_15_SLIDING_DOOR:
|
2020-10-21 22:25:11 +00:00
|
|
|
handle_se15(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_16_REACTOR:
|
2020-10-21 22:25:11 +00:00
|
|
|
handle_se16(&hittype[i], REACTOR, REACTOR2);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_17_WARP_ELEVATOR:
|
2020-10-21 22:25:11 +00:00
|
|
|
handle_se17(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_18_INCREMENTAL_SECTOR_RISE_FALL:
|
2020-10-21 22:30:22 +00:00
|
|
|
handle_se18(&hittype[i], true);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_19_EXPLOSION_LOWERS_CEILING:
|
2020-10-21 22:30:22 +00:00
|
|
|
handle_se19(&hittype[i], BIGFORCE);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_20_STRETCH_BRIDGE:
|
2020-10-21 22:35:30 +00:00
|
|
|
handle_se20(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_21_DROP_FLOOR:
|
2020-10-21 22:35:30 +00:00
|
|
|
handle_se21(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_22_TEETH_DOOR:
|
2020-10-21 22:35:30 +00:00
|
|
|
handle_se22(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_24_CONVEYOR:
|
|
|
|
case 34:
|
2020-10-14 18:49:43 +00:00
|
|
|
{
|
2020-10-21 22:50:01 +00:00
|
|
|
static int16_t list1[] = { BLOODPOOL, PUKE, FOOTPRINTS, FOOTPRINTS2, FOOTPRINTS3, FOOTPRINTS4, BULLETHOLE, BLOODSPLAT1, BLOODSPLAT2, BLOODSPLAT3, BLOODSPLAT4, -1 };
|
|
|
|
static int16_t list2[] = { BOLT1, BOLT1 + 1,BOLT1 + 2, BOLT1 + 3, SIDEBOLT1, SIDEBOLT1 + 1, SIDEBOLT1 + 2, SIDEBOLT1 + 3, -1 };
|
|
|
|
handle_se24(&hittype[i], list1, list2, TRIPBOMB, LASERLINE, CRANE, 2);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
2020-10-14 18:49:43 +00:00
|
|
|
}
|
2020-05-10 07:08:02 +00:00
|
|
|
case 35:
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se35(&hittype[i], SMALLSMOKE, EXPLOSION2);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 25: //PISTONS
|
2020-10-21 22:59:42 +00:00
|
|
|
if (hittype[i].temp_data[4] == 0) break;
|
|
|
|
handle_se25(&hittype[i], 3, -1, -1);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 26:
|
2020-10-21 22:35:30 +00:00
|
|
|
handle_se26(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SE_27_DEMO_CAM:
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se27(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
case 28:
|
|
|
|
if (t[5] > 0)
|
|
|
|
{
|
|
|
|
t[5]--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hittype[i].temp_data[0] == 0)
|
|
|
|
{
|
|
|
|
p = findplayer(s, &x);
|
|
|
|
if (x > 15500)
|
|
|
|
break;
|
|
|
|
hittype[i].temp_data[0] = 1;
|
|
|
|
hittype[i].temp_data[1] = 64 + (krand() & 511);
|
|
|
|
hittype[i].temp_data[2] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[2]++;
|
|
|
|
if (hittype[i].temp_data[2] > hittype[i].temp_data[1])
|
|
|
|
{
|
|
|
|
hittype[i].temp_data[0] = 0;
|
|
|
|
ps[screenpeek].visibility = ud.const_visibility;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 1))
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(THUNDER, i);
|
2020-05-10 07:08:02 +00:00
|
|
|
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 3))
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(LIGHTNING_SLAP, i);
|
2020-05-10 07:08:02 +00:00
|
|
|
else if (hittype[i].temp_data[2] == (hittype[i].temp_data[1] >> 2))
|
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_DEFAULT);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
|
|
|
if (sprite[j].picnum == NATURALLIGHTNING && sprite[j].hitag == s->hitag)
|
|
|
|
sprite[j].cstat |= 32768;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (hittype[i].temp_data[2] > (hittype[i].temp_data[1] >> 3) && hittype[i].temp_data[2] < (hittype[i].temp_data[1] >> 2))
|
|
|
|
{
|
|
|
|
if (cansee(s->x, s->y, s->z, s->sectnum, ps[screenpeek].posx, ps[screenpeek].posy, ps[screenpeek].posz, ps[screenpeek].cursectnum))
|
|
|
|
j = 1;
|
|
|
|
else j = 0;
|
|
|
|
|
|
|
|
if (rnd(192) && (hittype[i].temp_data[2] & 1))
|
|
|
|
{
|
|
|
|
if (j)
|
|
|
|
ps[screenpeek].visibility = 0;
|
|
|
|
}
|
|
|
|
else if (j)
|
|
|
|
ps[screenpeek].visibility = ud.const_visibility;
|
|
|
|
|
2020-10-14 18:02:05 +00:00
|
|
|
StatIterator it(STAT_DEFAULT);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->picnum == NATURALLIGHTNING && sj->hitag == s->hitag)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
|
|
|
if (rnd(32) && (hittype[i].temp_data[2] & 1))
|
|
|
|
{
|
2020-10-14 18:02:05 +00:00
|
|
|
sj->cstat &= 32767;
|
2020-05-15 20:59:13 +00:00
|
|
|
fi.spawn(j, SMALLSMOKE);
|
2020-05-10 07:08:02 +00:00
|
|
|
|
|
|
|
p = findplayer(s, &x);
|
2020-10-14 18:02:05 +00:00
|
|
|
x = ldist(&sprite[ps[p].i], sj);
|
2020-05-10 07:08:02 +00:00
|
|
|
if (x < 768)
|
|
|
|
{
|
2020-07-04 19:36:27 +00:00
|
|
|
if (S_CheckSoundPlaying(ps[p].i, DUKE_LONGTERM_PAIN) < 1)
|
2020-07-25 07:32:54 +00:00
|
|
|
S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].i);
|
|
|
|
S_PlayActorSound(SHORT_CIRCUIT, ps[p].i);
|
2020-05-10 07:08:02 +00:00
|
|
|
sprite[ps[p].i].extra -= 8 + (krand() & 7);
|
|
|
|
SetPlayerPal(&ps[p], PalEntry(32, 16, 0, 0));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2020-10-14 18:02:05 +00:00
|
|
|
else sj->cstat |= 32768;
|
2020-05-10 07:08:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 29:
|
|
|
|
s->hitag += 64;
|
|
|
|
l = mulscale12((int)s->yvel, sintable[s->hitag & 2047]);
|
|
|
|
sc->floorz = s->z + l;
|
|
|
|
break;
|
|
|
|
case 31: // True Drop Floor
|
|
|
|
if (t[0] == 1)
|
|
|
|
{
|
|
|
|
// Choose dir
|
|
|
|
|
|
|
|
if (t[3] > 0)
|
|
|
|
{
|
|
|
|
t[3]--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t[2] == 1) // Retract
|
|
|
|
{
|
|
|
|
if (sprite[i].ang != 1536)
|
|
|
|
{
|
|
|
|
if (abs(sc->floorz - s->z) < sprite[i].yvel )
|
|
|
|
{
|
|
|
|
sc->floorz = s->z;
|
|
|
|
t[2] = 0;
|
|
|
|
t[0] = 0;
|
|
|
|
t[3] = s->hitag;
|
|
|
|
callsound(s->sectnum, i);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = sgn(s->z - sc->floorz) * sprite[i].yvel ;
|
|
|
|
sc->floorz += l;
|
|
|
|
|
2020-10-14 18:49:43 +00:00
|
|
|
SectIterator it(s->sectnum);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->picnum == APLAYER && sj->owner >= 0)
|
|
|
|
if (ps[sj->yvel].on_ground == 1)
|
|
|
|
ps[sj->yvel].posz += l;
|
|
|
|
if (sj->zvel == 0 && sj->statnum != 3 && sj->statnum != 4)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
hittype[j].bposz = sj->z += l;
|
2020-05-10 07:08:02 +00:00
|
|
|
hittype[j].floorz = sc->floorz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (abs(sc->floorz - t[1]) < sprite[i].yvel )
|
|
|
|
{
|
|
|
|
sc->floorz = t[1];
|
|
|
|
callsound(s->sectnum, i);
|
|
|
|
t[2] = 0;
|
|
|
|
t[0] = 0;
|
|
|
|
t[3] = s->hitag;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = sgn(t[1] - sc->floorz) * sprite[i].yvel ;
|
|
|
|
sc->floorz += l;
|
|
|
|
|
2020-10-14 18:49:43 +00:00
|
|
|
SectIterator it(s->sectnum);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->picnum == APLAYER && sj->owner >= 0)
|
|
|
|
if (ps[sj->yvel].on_ground == 1)
|
|
|
|
ps[sj->yvel].posz += l;
|
|
|
|
if (sj->zvel == 0 && sj->statnum != 3 && sj->statnum != 4)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
hittype[j].bposz = sj->z += l;
|
2020-05-10 07:08:02 +00:00
|
|
|
hittype[j].floorz = sc->floorz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((s->ang & 2047) == 1536)
|
|
|
|
{
|
|
|
|
if (abs(s->z - sc->floorz) < sprite[i].yvel )
|
|
|
|
{
|
|
|
|
callsound(s->sectnum, i);
|
|
|
|
t[0] = 0;
|
|
|
|
t[2] = 1;
|
|
|
|
t[3] = s->hitag;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = sgn(s->z - sc->floorz) * sprite[i].yvel ;
|
|
|
|
sc->floorz += l;
|
|
|
|
|
2020-10-14 18:49:43 +00:00
|
|
|
SectIterator it(s->sectnum);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->picnum == APLAYER && sj->owner >= 0)
|
|
|
|
if (ps[sj->yvel].on_ground == 1)
|
|
|
|
ps[sj->yvel].posz += l;
|
|
|
|
if (sj->zvel == 0 && sj->statnum != 3 && sj->statnum != 4)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
hittype[j].bposz = sj->z += l;
|
2020-05-10 07:08:02 +00:00
|
|
|
hittype[j].floorz = sc->floorz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (abs(sc->floorz - t[1]) < sprite[i].yvel )
|
|
|
|
{
|
|
|
|
t[0] = 0;
|
|
|
|
callsound(s->sectnum, i);
|
|
|
|
t[2] = 1;
|
|
|
|
t[3] = s->hitag;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = sgn(s->z - t[1]) * sprite[i].yvel ;
|
|
|
|
sc->floorz -= l;
|
|
|
|
|
2020-10-14 18:49:43 +00:00
|
|
|
SectIterator it(s->sectnum);
|
|
|
|
while ((j = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
auto sj = &sprite[j];
|
|
|
|
if (sj->picnum == APLAYER && sj->owner >= 0)
|
|
|
|
if (ps[sj->yvel].on_ground == 1)
|
|
|
|
ps[sj->yvel].posz -= l;
|
|
|
|
if (sj->zvel == 0 && sj->statnum != 3 && sj->statnum != 4)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
2020-10-14 18:49:43 +00:00
|
|
|
hittype[j].bposz = sj->z -= l;
|
2020-05-10 07:08:02 +00:00
|
|
|
hittype[j].floorz = sc->floorz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 32: // True Drop Ceiling
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se32(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 33:
|
|
|
|
if (earthquaketime > 0 && (krand() & 7) == 0)
|
|
|
|
RANDOMSCRAP(s, i);
|
|
|
|
break;
|
|
|
|
case 36:
|
|
|
|
|
|
|
|
if (t[0])
|
|
|
|
{
|
|
|
|
if (t[0] == 1)
|
2020-05-16 21:55:21 +00:00
|
|
|
fi.shoot(i, sc->extra);
|
2020-05-10 07:08:02 +00:00
|
|
|
else if (t[0] == 26 * 5)
|
|
|
|
t[0] = 0;
|
|
|
|
t[0]++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 128: //SE to control glass breakage
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se128(&hittype[i]);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 130:
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se130(&hittype[i], 80, EXPLOSION2);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
case 131:
|
2020-10-21 22:40:57 +00:00
|
|
|
handle_se130(&hittype[i], 40, EXPLOSION2);
|
2020-05-10 07:08:02 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Sloped sin-wave floors!
|
2020-10-14 18:02:05 +00:00
|
|
|
it.Reset(STAT_EFFECTOR);
|
|
|
|
while ((i = it.NextIndex()) >= 0)
|
2020-05-10 07:08:02 +00:00
|
|
|
{
|
|
|
|
s = &sprite[i];
|
|
|
|
if (s->lotag != 29) continue;
|
|
|
|
sc = §or[s->sectnum];
|
|
|
|
if (sc->wallnum != 4) continue;
|
|
|
|
wal = &wall[sc->wallptr + 2];
|
|
|
|
alignflorslope(s->sectnum, wal->x, wal->y, sector[wal->nextsector].floorz);
|
|
|
|
}
|
|
|
|
}
|
2020-05-08 22:34:48 +00:00
|
|
|
|
2020-05-13 22:04:14 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void move_d(int g_i, int g_p, int g_x)
|
|
|
|
{
|
|
|
|
auto g_sp = &sprite[g_i];
|
2020-07-06 20:23:18 +00:00
|
|
|
auto g_t = hittype[g_i].temp_data;
|
2020-05-13 22:04:14 +00:00
|
|
|
int l;
|
2020-10-12 19:30:12 +00:00
|
|
|
short goalang, angdif;
|
2020-05-13 22:04:14 +00:00
|
|
|
int daxvel;
|
|
|
|
|
2020-10-12 19:30:12 +00:00
|
|
|
int a = g_sp->hitag;
|
2020-05-13 22:04:14 +00:00
|
|
|
|
|
|
|
if (a == -1) a = 0;
|
|
|
|
|
|
|
|
g_t[0]++;
|
|
|
|
|
|
|
|
if (a & face_player)
|
|
|
|
{
|
|
|
|
if (ps[g_p].newowner >= 0)
|
|
|
|
goalang = getangle(ps[g_p].oposx - g_sp->x, ps[g_p].oposy - g_sp->y);
|
|
|
|
else goalang = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
|
|
|
|
angdif = getincangle(g_sp->ang, goalang) >> 2;
|
|
|
|
if (angdif > -8 && angdif < 0) angdif = 0;
|
|
|
|
g_sp->ang += angdif;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a & spin)
|
|
|
|
g_sp->ang += sintable[((g_t[0] << 3) & 2047)] >> 6;
|
|
|
|
|
|
|
|
if (a & face_player_slow)
|
|
|
|
{
|
|
|
|
if (ps[g_p].newowner >= 0)
|
|
|
|
goalang = getangle(ps[g_p].oposx - g_sp->x, ps[g_p].oposy - g_sp->y);
|
|
|
|
else goalang = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
|
|
|
|
angdif = ksgn(getincangle(g_sp->ang, goalang)) << 5;
|
|
|
|
if (angdif > -32 && angdif < 0)
|
|
|
|
{
|
|
|
|
angdif = 0;
|
|
|
|
g_sp->ang = goalang;
|
|
|
|
}
|
|
|
|
g_sp->ang += angdif;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ((a & jumptoplayer) == jumptoplayer)
|
|
|
|
{
|
|
|
|
if (g_t[0] < 16)
|
|
|
|
g_sp->zvel -= (sintable[(512 + (g_t[0] << 4)) & 2047] >> 5);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a & face_player_smart)
|
|
|
|
{
|
2020-10-02 20:14:20 +00:00
|
|
|
int newx, newy;
|
2020-05-13 22:04:14 +00:00
|
|
|
|
|
|
|
newx = ps[g_p].posx + (ps[g_p].posxv / 768);
|
|
|
|
newy = ps[g_p].posy + (ps[g_p].posyv / 768);
|
|
|
|
goalang = getangle(newx - g_sp->x, newy - g_sp->y);
|
|
|
|
angdif = getincangle(g_sp->ang, goalang) >> 2;
|
|
|
|
if (angdif > -8 && angdif < 0) angdif = 0;
|
|
|
|
g_sp->ang += angdif;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g_t[1] == 0 || a == 0)
|
|
|
|
{
|
|
|
|
if ((badguy(g_sp) && g_sp->extra <= 0) || (hittype[g_i].bposx != g_sp->x) || (hittype[g_i].bposy != g_sp->y))
|
|
|
|
{
|
|
|
|
hittype[g_i].bposx = g_sp->x;
|
|
|
|
hittype[g_i].bposy = g_sp->y;
|
|
|
|
setsprite(g_i, g_sp->x, g_sp->y, g_sp->z);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-15 09:36:46 +00:00
|
|
|
auto moveptr = &ScriptCode[g_t[1]];
|
2020-05-13 22:04:14 +00:00
|
|
|
|
|
|
|
if (a & geth) g_sp->xvel += (*moveptr - g_sp->xvel) >> 1;
|
|
|
|
if (a & getv) g_sp->zvel += ((*(moveptr + 1) << 4) - g_sp->zvel) >> 1;
|
|
|
|
|
|
|
|
if (a & dodgebullet)
|
|
|
|
dodge(g_sp);
|
|
|
|
|
|
|
|
if (g_sp->picnum != APLAYER)
|
|
|
|
alterang(a, g_i, g_p);
|
|
|
|
|
|
|
|
if (g_sp->xvel > -6 && g_sp->xvel < 6) g_sp->xvel = 0;
|
|
|
|
|
|
|
|
a = badguy(g_sp);
|
|
|
|
|
|
|
|
if (g_sp->xvel || g_sp->zvel)
|
|
|
|
{
|
|
|
|
if (a && g_sp->picnum != ROTATEGUN)
|
|
|
|
{
|
|
|
|
if ((g_sp->picnum == DRONE || g_sp->picnum == COMMANDER) && g_sp->extra > 0)
|
|
|
|
{
|
|
|
|
if (g_sp->picnum == COMMANDER)
|
|
|
|
{
|
|
|
|
hittype[g_i].floorz = l = getflorzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
|
|
|
|
if (g_sp->z > (l - (8 << 8)))
|
|
|
|
{
|
|
|
|
if (g_sp->z > (l - (8 << 8))) g_sp->z = l - (8 << 8);
|
|
|
|
g_sp->zvel = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
hittype[g_i].ceilingz = l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
|
|
|
|
if ((g_sp->z - l) < (80 << 8))
|
|
|
|
{
|
|
|
|
g_sp->z = l + (80 << 8);
|
|
|
|
g_sp->zvel = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (g_sp->zvel > 0)
|
|
|
|
{
|
|
|
|
hittype[g_i].floorz = l = getflorzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
|
|
|
|
if (g_sp->z > (l - (30 << 8)))
|
|
|
|
g_sp->z = l - (30 << 8);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
hittype[g_i].ceilingz = l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
|
|
|
|
if ((g_sp->z - l) < (50 << 8))
|
|
|
|
{
|
|
|
|
g_sp->z = l + (50 << 8);
|
|
|
|
g_sp->zvel = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (g_sp->picnum != ORGANTIC)
|
|
|
|
{
|
|
|
|
if (g_sp->zvel > 0 && hittype[g_i].floorz < g_sp->z)
|
|
|
|
g_sp->z = hittype[g_i].floorz;
|
|
|
|
if (g_sp->zvel < 0)
|
|
|
|
{
|
|
|
|
l = getceilzofslope(g_sp->sectnum, g_sp->x, g_sp->y);
|
|
|
|
if ((g_sp->z - l) < (66 << 8))
|
|
|
|
{
|
|
|
|
g_sp->z = l + (66 << 8);
|
|
|
|
g_sp->zvel >>= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (g_sp->picnum == APLAYER)
|
|
|
|
if ((g_sp->z - hittype[g_i].ceilingz) < (32 << 8))
|
|
|
|
g_sp->z = hittype[g_i].ceilingz + (32 << 8);
|
|
|
|
|
|
|
|
daxvel = g_sp->xvel;
|
|
|
|
angdif = g_sp->ang;
|
|
|
|
|
|
|
|
if (a && g_sp->picnum != ROTATEGUN)
|
|
|
|
{
|
|
|
|
if (g_x < 960 && g_sp->xrepeat > 16)
|
|
|
|
{
|
|
|
|
|
|
|
|
daxvel = -(1024 - g_x);
|
|
|
|
angdif = getangle(ps[g_p].posx - g_sp->x, ps[g_p].posy - g_sp->y);
|
|
|
|
|
|
|
|
if (g_x < 512)
|
|
|
|
{
|
|
|
|
ps[g_p].posxv = 0;
|
|
|
|
ps[g_p].posyv = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ps[g_p].posxv = mulscale(ps[g_p].posxv, dukefriction - 0x2000, 16);
|
|
|
|
ps[g_p].posyv = mulscale(ps[g_p].posyv, dukefriction - 0x2000, 16);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (g_sp->picnum != DRONE && g_sp->picnum != SHARK && g_sp->picnum != COMMANDER)
|
|
|
|
{
|
|
|
|
if (hittype[g_i].bposz != g_sp->z || (ud.multimode < 2 && ud.player_skill < 2))
|
|
|
|
{
|
2020-10-17 08:30:11 +00:00
|
|
|
if ((g_t[0] & 1) || ps[g_p].actorsqu == &hittype[g_i]) return;
|
2020-05-13 22:04:14 +00:00
|
|
|
else daxvel <<= 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-10-17 08:30:11 +00:00
|
|
|
if ((g_t[0] & 3) || ps[g_p].actorsqu == &hittype[g_i]) return;
|
2020-05-13 22:04:14 +00:00
|
|
|
else daxvel <<= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-14 10:14:03 +00:00
|
|
|
hittype[g_i].movflag = fi.movesprite(g_i,
|
2020-05-13 22:04:14 +00:00
|
|
|
(daxvel * (sintable[(angdif + 512) & 2047])) >> 14,
|
|
|
|
(daxvel * (sintable[angdif & 2047])) >> 14, g_sp->zvel, CLIPMASK0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a)
|
|
|
|
{
|
|
|
|
if (sector[g_sp->sectnum].ceilingstat & 1)
|
|
|
|
g_sp->shade += (sector[g_sp->sectnum].ceilingshade - g_sp->shade) >> 1;
|
|
|
|
else g_sp->shade += (sector[g_sp->sectnum].floorshade - g_sp->shade) >> 1;
|
|
|
|
|
|
|
|
if (sector[g_sp->sectnum].floorpicnum == MIRROR)
|
|
|
|
deletesprite(g_i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-14 07:07:07 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void falladjustz(spritetype* g_sp)
|
|
|
|
{
|
|
|
|
switch (g_sp->picnum)
|
|
|
|
{
|
|
|
|
case OCTABRAIN:
|
|
|
|
case COMMANDER:
|
|
|
|
case DRONE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_sp->z += (24 << 8);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void fall_d(int g_i, int g_p)
|
|
|
|
{
|
|
|
|
fall_common(g_i, g_p, JIBS6, DRONE, BLOODPOOL, SHOTSPARK1, SQUISHED, THUD, nullptr, falladjustz);
|
|
|
|
}
|
|
|
|
|
2020-05-14 17:23:36 +00:00
|
|
|
bool spawnweapondebris_d(int picnum, int dnum)
|
|
|
|
{
|
|
|
|
return picnum == BLIMP && dnum == SCRAP1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void respawnhitag_d(spritetype* g_sp)
|
|
|
|
{
|
|
|
|
switch (g_sp->picnum)
|
|
|
|
{
|
|
|
|
case FEM1:
|
|
|
|
case FEM2:
|
|
|
|
case FEM3:
|
|
|
|
case FEM4:
|
|
|
|
case FEM5:
|
|
|
|
case FEM6:
|
|
|
|
case FEM7:
|
|
|
|
case FEM8:
|
|
|
|
case FEM9:
|
|
|
|
case FEM10:
|
|
|
|
case PODFEM1:
|
|
|
|
case NAKED1:
|
|
|
|
case STATUE:
|
|
|
|
if (g_sp->yvel) fi.operaterespawns(g_sp->yvel);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (g_sp->hitag >= 0) fi.operaterespawns(g_sp->hitag);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void checktimetosleep_d(int g_i)
|
|
|
|
{
|
|
|
|
auto g_sp = &sprite[g_i];
|
|
|
|
if (g_sp->statnum == 6)
|
|
|
|
{
|
|
|
|
switch (g_sp->picnum)
|
|
|
|
{
|
|
|
|
case RUBBERCAN:
|
|
|
|
case EXPLODINGBARREL:
|
|
|
|
case WOODENHORSE:
|
|
|
|
case HORSEONSIDE:
|
|
|
|
case CANWITHSOMETHING:
|
|
|
|
case FIREBARREL:
|
|
|
|
case NUKEBARREL:
|
|
|
|
case NUKEBARRELDENTED:
|
|
|
|
case NUKEBARRELLEAKED:
|
|
|
|
case TRIPBOMB:
|
|
|
|
case EGG:
|
|
|
|
if (hittype[g_i].timetosleep > 1)
|
|
|
|
hittype[g_i].timetosleep--;
|
|
|
|
else if (hittype[g_i].timetosleep == 1)
|
|
|
|
changespritestat(g_i, 2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-23 19:12:15 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
void think_d(void)
|
|
|
|
{
|
|
|
|
thinktime.Reset();
|
|
|
|
thinktime.Clock();
|
2020-09-11 20:54:52 +00:00
|
|
|
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
|