716 lines
14 KiB
Text
716 lines
14 KiB
Text
// Gore FX ported over from Soundless Mound, with some edits
|
|
|
|
// Base blood actor
|
|
Class mkBlood : Actor
|
|
{
|
|
Default
|
|
{
|
|
+NOBLOCKMAP;
|
|
+NOGRAVITY;
|
|
+NOTELEPORT;
|
|
+PUFFGETSOWNER;
|
|
}
|
|
action void A_Bleed( int str = 1 )
|
|
{
|
|
if ( !target ) return;
|
|
let b = Spawn("mkBloodSpray",pos);
|
|
Vector2 dirto = target.Vec2To(self).unit();
|
|
b.angle = atan2(dirto.y,dirto.x);
|
|
b.pitch = FRandom[Blood](-60,30);
|
|
b.translation = translation;
|
|
b.target = target;
|
|
b.args[0] = str;
|
|
if ( target.bloodcolor ) b.SetShade(Color(target.bloodcolor.r/2,target.bloodcolor.g/2,target.bloodcolor.b/2));
|
|
else b.SetShade(Color(80,0,0));
|
|
b.CopyBloodColor(target);
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
if ( !CheckNoDelay() || (tics == -1) ) return;
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
TNT1 A 1 NoDelay A_Bleed(3);
|
|
Stop;
|
|
TNT1 A 1 A_Bleed(2);
|
|
Stop;
|
|
TNT1 A 1 A_Bleed(1);
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// a burst of blood attached to a bleeding actor
|
|
Class mkBloodSpray : Actor
|
|
{
|
|
double str;
|
|
int cnt;
|
|
Vector3 attachofs;
|
|
double baseang;
|
|
color shadecol;
|
|
|
|
Default
|
|
{
|
|
+NOBLOCKMAP;
|
|
+NOGRAVITY;
|
|
+NOTELEPORT;
|
|
+NOINTERACTION;
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
if ( !target )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
str = FRandom[Blood](2.,4.)*args[0];
|
|
cnt = Random[Blood](2,3)*args[0];
|
|
attachofs.xy = RotateVector(target.Vec2To(self),-target.angle);
|
|
attachofs.z = pos.z-target.pos.z;
|
|
baseang = angle-target.angle;
|
|
}
|
|
private bool IsTargetFlying()
|
|
{
|
|
if ( !target ) return false;
|
|
if ( !target.bNOGRAVITY && (target.pos.z > target.floorz) && target.TestMobjZ() ) return true;
|
|
if ( ((!target.bNOGRAVITY && target.bBlasted) || (target.health <= 0)) && (target.vel.length() > 10.) ) return true;
|
|
return false;
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( !target )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
Vector3 setofs;
|
|
setofs = (cos(target.angle)*attachofs.x+sin(target.angle)*attachofs.y,sin(target.angle)*attachofs.x-cos(target.angle)*attachofs.y,attachofs.z);
|
|
SetOrigin(level.Vec3Offset(target.pos,setofs),false);
|
|
int sz = max(1,args[0]/2);
|
|
double ang, pt;
|
|
for ( int i=0; i<sz; i++ )
|
|
{
|
|
let d = Spawn("mkBloodDrop",pos);
|
|
d.SetShade(fillcolor);
|
|
d.CopyBloodColor(self);
|
|
ang = baseang+target.angle+FRandom[Blood](-15.,15.)*str;
|
|
pt = pitch+FRandom[Blood](-15.,15.)*str;
|
|
Vector3 dir = (cos(pt)*cos(ang),cos(pt)*sin(ang),-sin(pt));
|
|
d.vel = dir*str*FRandom[Blood](.8,1.8);
|
|
d.scale *= str*.15*FRandom[Blood](.6,1.4);
|
|
}
|
|
bool flying = IsTargetFlying();
|
|
if ( flying ) str *= 1.-(.1/sz);
|
|
else str *= 1.-(.3/sz);
|
|
if ( (str <= .05) || ((cnt-- <= 0) && !flying) ) Destroy();
|
|
}
|
|
}
|
|
|
|
// drop of salsa
|
|
// becomes a decal on crash
|
|
Class mkBloodDrop : Actor
|
|
{
|
|
bool killme;
|
|
bool dead, onceiling;
|
|
mkBloodDrop prevblod, nextblod;
|
|
Sector tracksector;
|
|
int trackplane;
|
|
|
|
Default
|
|
{
|
|
+MISSILE;
|
|
+NOBLOCKMAP;
|
|
+DROPOFF;
|
|
+NOTELEPORT;
|
|
+THRUACTORS;
|
|
+FORCEXYBILLBOARD;
|
|
+ROLLSPRITE;
|
|
+ROLLCENTER;
|
|
+NOINTERACTION;
|
|
Scale .35;
|
|
Radius 2;
|
|
Height 2;
|
|
Mass 1;
|
|
RenderStyle "Shaded";
|
|
}
|
|
// try to reduce overhead as much as possible with this
|
|
override void Tick()
|
|
{
|
|
prev = pos; // for interpolation
|
|
if ( isFrozen() ) return;
|
|
if ( killme ) A_FadeOut(.01);
|
|
if ( dead )
|
|
{
|
|
// do nothing but follow floor movement and eventually fade out
|
|
if ( tracksector )
|
|
{
|
|
double trackz;
|
|
if ( trackplane ) trackz = tracksector.ceilingplane.ZAtPoint(pos.xy)-.1;
|
|
else trackz = tracksector.floorplane.ZAtPoint(pos.xy);
|
|
if ( trackz != pos.z )
|
|
{
|
|
SetZ(trackz);
|
|
UpdateWaterLevel(false);
|
|
}
|
|
}
|
|
if ( (waterlevel > 0) || GetFloorTerrain().isliquid )
|
|
{
|
|
scale *= 1.005;
|
|
A_FadeOut(.01);
|
|
}
|
|
if ( onceiling && (special2 < 200) && (scale.x > .2) )
|
|
{
|
|
if ( special1-- ) return;
|
|
special2 += 10;
|
|
special1 = Random[Blood](20,30)+special2;
|
|
let d = Spawn("mkBloodDrop",Vec3Offset(0,0,-2));
|
|
d.master = self;
|
|
d.SetShade(fillcolor);
|
|
d.CopyBloodColor(self);
|
|
d.scale = Scale*FRandom[Blood](.4,.6);
|
|
}
|
|
return; // we don't need to update states when we're dead
|
|
}
|
|
else
|
|
{
|
|
// gravitational pull
|
|
if ( waterlevel <= 0 ) vel.z -= GetGravity();
|
|
// linetrace-based movement (hopefully more reliable than traditional methods)
|
|
Vector3 dir = vel;
|
|
double spd = vel.length();
|
|
dir /= spd;
|
|
FLineTraceData d;
|
|
double ang = atan2(dir.y,dir.x);
|
|
double pt = asin(-dir.z);
|
|
LineTrace(ang,spd,pt,TRF_THRUACTORS|TRF_THRUHITSCAN,data:d);
|
|
if ( d.HitType == TRACE_HitFloor )
|
|
{
|
|
if ( d.HitTexture == skyflatnum )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
// landed on floor
|
|
SetOrigin(d.HitLocation,true);
|
|
HitFloor();
|
|
A_StartSound("misc/blooddrop",volume:.1);
|
|
if ( master )
|
|
{
|
|
// assume we dropped onto the previous spot
|
|
if ( master.tracer )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
master.tracer = self;
|
|
}
|
|
dead = true;
|
|
if ( d.Hit3DFloor )
|
|
{
|
|
tracksector = d.Hit3DFloor.model;
|
|
trackplane = 1;
|
|
}
|
|
else
|
|
{
|
|
tracksector = d.HitSector;
|
|
trackplane = 0;
|
|
}
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360));
|
|
frame = Random[Blood](5,8);
|
|
return;
|
|
}
|
|
if ( d.HitType == TRACE_HitCeiling )
|
|
{
|
|
if ( (d.HitTexture == skyflatnum) || master )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
// hit the ceiling
|
|
SetOrigin(d.HitLocation-(0,0,1),true);
|
|
A_StartSound("misc/blooddrop",volume:.1);
|
|
dead = true;
|
|
onceiling = true;
|
|
if ( d.Hit3DFloor )
|
|
{
|
|
tracksector = d.Hit3DFloor.model;
|
|
trackplane = 0;
|
|
}
|
|
else
|
|
{
|
|
tracksector = d.HitSector;
|
|
trackplane = 1;
|
|
}
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360),true);
|
|
frame = Random[Blood](5,8);
|
|
return;
|
|
}
|
|
if ( d.HitType == TRACE_HitWall )
|
|
{
|
|
if ( d.HitLine.backsector && (d.HitLine.backsector.GetTexture(1) == skyflatnum) && (d.HitLocation.z >= d.HitLine.backsector.ceilingplane.ZAtPoint(d.HitLocation.xy)) )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
// hit wall
|
|
Vector2 walldir = (-d.HitLine.delta.y,d.HitLine.delta.x).unit();
|
|
if ( d.LineSide ) walldir *= -1;
|
|
SetOrigin(d.HitLocation-walldir*8,true);
|
|
TraceBleedAngle(20,atan2(walldir.y,walldir.x),0);
|
|
A_StartSound("misc/blooddrop",volume:.1);
|
|
Destroy();
|
|
return;
|
|
}
|
|
SetOrigin(level.Vec3Offset(pos,vel),true);
|
|
UpdateWaterLevel();
|
|
if ( waterlevel > 0 ) A_FadeOut();
|
|
scale *= .99;
|
|
if ( scale.x <= 0. )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
}
|
|
if ( !CheckNoDelay() || (tics == -1) ) return;
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
SWWMHandler.QueueBlod(self);
|
|
int jumps = Random[Blood](0,3);
|
|
state dest = ResolveState("Spawn");
|
|
SetState(dest+jumps);
|
|
}
|
|
override void OnDestroy()
|
|
{
|
|
SWWMHandler.DeQueueBlod(self);
|
|
Super.OnDestroy();
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
SBLD ABCD 2;
|
|
Loop;
|
|
}
|
|
}
|
|
|
|
// chunky salsa in the air
|
|
Class mkBloodSmoke : Actor
|
|
{
|
|
Default
|
|
{
|
|
+NOBLOCKMAP;
|
|
+NOGRAVITY;
|
|
+NOINTERACTION;
|
|
+NOTELEPORT;
|
|
+FORCEXYBILLBOARD;
|
|
Scale .5;
|
|
Alpha .35;
|
|
RenderStyle "Shaded";
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
int jumps = Random[Blood](0,19);
|
|
state dest = ResolveState("Spawn");
|
|
SetState(dest+jumps);
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
SetOrigin(level.Vec3Offset(pos,vel),true);
|
|
UpdateWaterLevel();
|
|
if ( waterlevel > 0 ) A_FadeOut();
|
|
A_FadeOut(.03);
|
|
A_SetScale(scale.x*1.02);
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
BSMK ABCDEFGHIJKLMNOPQRST 2;
|
|
Loop;
|
|
}
|
|
}
|
|
|
|
Class mkBloodSmoke2 : mkBloodSmoke
|
|
{
|
|
Default
|
|
{
|
|
Scale .8;
|
|
Alpha 1.;
|
|
}
|
|
}
|
|
|
|
// flying gibs
|
|
// inspired by Lud's Universal Gibs
|
|
Class mkFlyingGib : Actor
|
|
{
|
|
bool killme;
|
|
int lastbleed;
|
|
color shadecol;
|
|
bool bleeding;
|
|
double rollvel;
|
|
mkFlyingGib prevmeat, nextmeat;
|
|
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
frame = Random[Blood](0,5);
|
|
double ang = FRandom[Gibs](0,360);
|
|
double pt = FRandom[Gibs](-60,20);
|
|
Vector3 dir = (cos(pt)*cos(ang),cos(pt)*sin(ang),sin(-pt));
|
|
vel += dir*FRandom[Gibs](5.,20.);
|
|
if ( master )
|
|
{
|
|
vel += master.vel*1.5;
|
|
CopyBloodColor(master);
|
|
}
|
|
rollvel = FRandom[Gibs](10,50)*RandomPick[Gibs](-1,1);
|
|
scale *= FRandom[Gibs](.5,1.5);
|
|
if ( master && master.bloodcolor ) shadecol = Color(master.bloodcolor.r/2,master.bloodcolor.g/2,master.bloodcolor.b/2);
|
|
else shadecol = Color(80,0,0);
|
|
bleeding = true;
|
|
if ( Random[Blood](0,1) ) bXFlip = true;
|
|
SWWMHandler.QueueMeat(self);
|
|
}
|
|
|
|
override void OnDestroy()
|
|
{
|
|
SWWMHandler.DeQueueMeat(self);
|
|
Super.OnDestroy();
|
|
}
|
|
|
|
override void Tick()
|
|
{
|
|
Super.Tick();
|
|
if ( isFrozen() ) return;
|
|
if ( killme ) A_FadeOut(.01);
|
|
if ( CurState == ResolveState("Death2") )
|
|
{
|
|
if ( vel.length() < .1 )
|
|
bleeding = false;
|
|
return;
|
|
}
|
|
roll += rollvel;
|
|
if ( waterlevel > 0 )
|
|
{
|
|
rollvel *= .98;
|
|
vel.xy *= .98;
|
|
return;
|
|
}
|
|
if ( bleeding && !Random[Blood](0,3) )
|
|
{
|
|
let s = Spawn("mkBloodSmoke",pos);
|
|
s.SetShade(shadecol);
|
|
}
|
|
}
|
|
|
|
override bool CanCollideWith(Actor other, bool passive)
|
|
{
|
|
if ( other == master ) return false;
|
|
return true;
|
|
}
|
|
|
|
action void A_Bleed()
|
|
{
|
|
double ang;
|
|
double pt;
|
|
Vector3 dir;
|
|
if ( invoker.lastbleed > level.maptime ) return;
|
|
invoker.lastbleed = level.maptime+5;
|
|
for ( int i=0; i<8; i++ )
|
|
{
|
|
let b = Spawn("mkBloodDrop",pos);
|
|
ang = FRandom[Gibs](0,360);
|
|
pt = FRandom[Gibs](-60,30);
|
|
dir = (cos(pt)*cos(ang),cos(pt)*sin(ang),sin(-pt));
|
|
b.vel = dir*FRandom[Gibs](0.3,2.2)*vel.length();
|
|
b.scale *= 2.0;
|
|
b.SetShade(invoker.shadecol);
|
|
}
|
|
TraceBleedAngle(int(vel.length()),angle+180,-pitch);
|
|
}
|
|
|
|
Default
|
|
{
|
|
Radius 4;
|
|
Height 4;
|
|
Mass 10;
|
|
Scale .65;
|
|
Gravity .5;
|
|
BounceType "Doom";
|
|
BounceFactor .6;
|
|
+MISSILE;
|
|
+DROPOFF;
|
|
+NOBLOCKMAP;
|
|
+USEBOUNCESTATE;
|
|
+BOUNCEONCEILINGS;
|
|
+MOVEWITHSECTOR;
|
|
+THRUACTORS;
|
|
+NOTELEPORT;
|
|
+ROLLSPRITE;
|
|
+ROLLCENTER;
|
|
+INTERPOLATEANGLES;
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
SGIB # 1;
|
|
Wait;
|
|
Bounce:
|
|
SGIB # 0
|
|
{
|
|
A_Bleed();
|
|
A_StartSound("misc/gibhit",CHAN_BODY,CHANF_OVERLAP);
|
|
}
|
|
Goto Spawn;
|
|
Death:
|
|
SGIB # 1 A_JumpIf(pos.z<=floorz,"Death2");
|
|
Wait;
|
|
Death2:
|
|
SGIB # -1
|
|
{
|
|
A_StartSound("misc/gibhit",CHAN_BODY,CHANF_OVERLAP);
|
|
roll = RandomPick[Gibs](0,180)+Random[Gibs](-5,5);
|
|
A_Stop();
|
|
}
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// Manually added gibbing
|
|
Class mkGibber : Actor
|
|
{
|
|
Actor Gibbed;
|
|
int gibcount, gibsize;
|
|
int delay;
|
|
color shadecol;
|
|
|
|
virtual void BurstGibs()
|
|
{
|
|
Actor a;
|
|
double ang, pt;
|
|
Vector3 dir;
|
|
bool dummy;
|
|
for ( int i=0; i<gibsize; i++ )
|
|
{
|
|
a = Spawn("mkBloodSmoke2",pos+(FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](0.,.9)*height));
|
|
a.SetShade(shadecol);
|
|
}
|
|
for ( int i=0; i<2*gibsize; i++ )
|
|
{
|
|
[dummy, a] = A_SpawnItemEx("mkFlyingGib",FRandom[Gibs](-.5,.5)*radius,FRandom[Gibs](-.5,.5)*radius,FRandom[Gibs](.1,.9)*height,flags:SXF_ABSOLUTEANGLE|SXF_USEBLOODCOLOR);
|
|
a.translation = translation;
|
|
a.CopyBloodColor(self);
|
|
a.scale *= scale.x;
|
|
a.master = gibbed;
|
|
}
|
|
for ( int i=0; i<3*gibsize; i++ )
|
|
{
|
|
[dummy, a] = A_SpawnItemEx("mkBloodDrop",FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](0.,.9)*height,flags:SXF_ABSOLUTEANGLE|SXF_USEBLOODCOLOR);
|
|
ang = FRandom[Gibs](0,360);
|
|
pt = FRandom[Gibs](-90,90);
|
|
dir = (cos(pt)*cos(ang),cos(pt)*sin(ang),sin(-pt));
|
|
a.vel = dir*FRandom[Gibs](8.,24.);
|
|
a.scale *= 2.+FRandom[Gibs](.3,1.6);
|
|
a.SetShade(shadecol);
|
|
a.CopyBloodColor(self);
|
|
}
|
|
reactiontime--;
|
|
}
|
|
|
|
override void PostBeginPlay()
|
|
{
|
|
gibsize = int(min(max(radius,height)/15,6));
|
|
reactiontime = int(min(max(radius,height)/10,8));
|
|
if ( gibbed && gibbed.bloodcolor ) shadecol = Color(gibbed.bloodcolor.r/2,gibbed.bloodcolor.g/2,gibbed.bloodcolor.b/2);
|
|
else shadecol = Color(80,0,0);
|
|
if ( gibbed ) CopyBloodColor(gibbed);
|
|
}
|
|
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
if ( !gibbed )
|
|
{
|
|
SetOrigin(level.Vec3Offset(pos,vel),false);
|
|
return;
|
|
}
|
|
SetOrigin(gibbed.pos,false);
|
|
scale = gibbed.scale;
|
|
vel = gibbed.vel;
|
|
if ( delay > 0 )
|
|
{
|
|
delay--;
|
|
return;
|
|
}
|
|
A_StartSound("misc/gibber");
|
|
BurstGibs();
|
|
if ( reactiontime <= 0 )
|
|
Destroy();
|
|
}
|
|
|
|
Default
|
|
{
|
|
+NOBLOCKMAP;
|
|
+NOGRAVITY;
|
|
+NOTELEPORT;
|
|
+DONTSPLASH;
|
|
+NOINTERACTION;
|
|
Radius 32;
|
|
Height 16;
|
|
}
|
|
}
|
|
|
|
// bare actors used for copying blood color to vanilla monsters
|
|
Class GreenBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "Green";
|
|
}
|
|
}
|
|
Class BlueBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "Blue";
|
|
}
|
|
}
|
|
Class PurpleBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "Purple";
|
|
}
|
|
}
|
|
|
|
// bare actor used for extra gib deaths
|
|
Class ExtraGibDeaths : Actor
|
|
{
|
|
StateLabel gibstate;
|
|
|
|
static void GibThis( Actor a, Statelabel st )
|
|
{
|
|
if ( !a ) return;
|
|
let g = ExtraGibDeaths(Spawn("ExtraGibDeaths"));
|
|
g.master = a;
|
|
g.gibstate = st;
|
|
}
|
|
|
|
void A_DoGib()
|
|
{
|
|
if ( !master ) return;
|
|
master.SetState(FindState(gibstate));
|
|
}
|
|
|
|
States
|
|
{
|
|
Spawn:
|
|
TNT1 A 1 NoDelay;
|
|
TNT1 A 1 A_DoGib();
|
|
Stop;
|
|
DemonXDeath:
|
|
SARX A 5;
|
|
SARX B 5 A_XScream();
|
|
SARX C 5 A_NoBlocking();
|
|
SARX DEF 5;
|
|
SARX G -1;
|
|
Stop;
|
|
KnightXDeath:
|
|
BO2X A 5;
|
|
BO2X B 5 A_XScream();
|
|
BO2X C 5;
|
|
BO2X D 5 A_NoBlocking();
|
|
BO2X EFGH 5;
|
|
BO2X I -1;
|
|
Stop;
|
|
BaronXDeath:
|
|
BOSX A 5;
|
|
BOSX B 5 A_XScream();
|
|
BOSX C 5;
|
|
BOSX D 5 A_NoBlocking();
|
|
BOSX EFGH 5;
|
|
BOSX I -1 A_BossDeath();
|
|
Stop;
|
|
CacoXDeath:
|
|
CACX A 5;
|
|
CACX B 5 A_XScream();
|
|
CACX C 5 A_NoBlocking();
|
|
CACX D 4;
|
|
CACX E 3;
|
|
CACX F 4;
|
|
CACX G 5;
|
|
CACX H -1;
|
|
Stop;
|
|
BonerXDeath:
|
|
REVX A 3;
|
|
REVX B 4 A_XScream();
|
|
REVX C 5 A_NoBlocking();
|
|
REVX DE 5;
|
|
REVX F -1;
|
|
Stop;
|
|
VileXDeath:
|
|
VILX A 5;
|
|
VILX B 5 A_XScream();
|
|
VILX C 5 A_NoBlocking();
|
|
VILX DEF 5;
|
|
VILX G -1;
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// corpse thump handler
|
|
Class CorpseFallTracker : Thinker
|
|
{
|
|
Actor mybody;
|
|
double lastvelz;
|
|
bool wasflying;
|
|
|
|
static void TrackBody( Actor b )
|
|
{
|
|
if ( !b ) return;
|
|
let cft = new("CorpseFallTracker");
|
|
cft.ChangeStatNum(STAT_USER);
|
|
cft.mybody = b;
|
|
cft.lastvelz = b.vel.z;
|
|
cft.wasflying = ((b.pos.z>b.floorz)&&b.TestMobjZ());
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( !mybody )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
// play fall thumps
|
|
bool isflying = ((mybody.pos.z>mybody.floorz)&&mybody.TestMobjZ());
|
|
if ( wasflying && !isflying && (lastvelz < -10) )
|
|
mybody.A_StartSound("misc/bodythump",CHAN_DAMAGE,CHANF_OVERLAP);
|
|
wasflying = isflying;
|
|
lastvelz = mybody.vel.z;
|
|
// wait until body is dead on floor and at the last state of animation
|
|
if ( (mybody.Health > 0) || isflying || (mybody.tics != -1) || (mybody.vel.length() > 0) )
|
|
return;
|
|
Destroy();
|
|
}
|
|
}
|