1011 lines
24 KiB
Text
1011 lines
24 KiB
Text
// Gore FX ported over from Soundless Mound, with some edits
|
|
|
|
// Base blood actor
|
|
Class mkBlood : SWWMNonInteractiveActor
|
|
{
|
|
Default
|
|
{
|
|
+PUFFGETSOWNER;
|
|
}
|
|
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);
|
|
int numpt = Random[Blood](2,4)+str*2;
|
|
double sstr = (2.5+str)/3.;
|
|
Vector3 vdir = SWWMUtility.Vec3FromAngles(b.angle,b.pitch);
|
|
TextureID pufftex[8];
|
|
for ( int i=0; i<8; i++ ) pufftex[i] = TexMan.CheckForTexture("graphics/Particles/xpuff"..i..".png");
|
|
FSpawnParticleParams puff;
|
|
puff.color1 = b.fillcolor;
|
|
puff.style = STYLE_Shaded;
|
|
puff.accel = (0,0,-.25);
|
|
puff.startalpha = .75;
|
|
puff.fadestep = -1;
|
|
puff.pos = pos;
|
|
for ( int i=0; i<numpt; i++ )
|
|
{
|
|
Vector3 ndir = (vdir+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.5).unit()*FRandom[Blood](.2,2.)*sstr;
|
|
for ( double j=1.; j>=.5; j-=.125 )
|
|
{
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.lifetime = int(12*sstr);
|
|
puff.size = 2.*str*FRandom[Blood](.6,1.4)*j;
|
|
puff.vel = ndir*j;
|
|
puff.sizestep = -.02*sstr*j;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
let s = mkBloodSmoke(SWWMStaticSprite.SpawnAt('mkBloodSmoke',pos));
|
|
s.scolor = b.fillcolor;
|
|
s.scale *= .4*str;
|
|
s.thickness = str-1;
|
|
}
|
|
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 : SWWMNonInteractiveActor
|
|
{
|
|
double str;
|
|
int cnt;
|
|
Vector3 attachofs;
|
|
double baseang;
|
|
color shadecol;
|
|
|
|
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 ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
Vector3 setofs = SWWMUtility.RotateVector3(attachofs,target.angle);
|
|
SetOrigin(level.Vec3Offset(target.pos,setofs),false);
|
|
int sz = max(1,args[0]/2);
|
|
double ang, pt;
|
|
int cnt = sz-Random[Blood](0,4);
|
|
for ( int i=0; i<cnt; 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 = SWWMUtility.Vec3FromAngles(ang,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.-(.15/sz);
|
|
else str *= 1.-(.4/sz);
|
|
if ( (str <= .05) || ((cnt-- <= 0) && !flying) ) Destroy();
|
|
}
|
|
}
|
|
|
|
// drop of salsa
|
|
// becomes a decal on crash
|
|
Class mkBloodDrop : SWWMNonInteractiveActor
|
|
{
|
|
bool killme;
|
|
bool dead, onceiling;
|
|
mkBloodDrop prevblod, nextblod;
|
|
Sector tracksector;
|
|
int trackplane;
|
|
transient TextureID pufftex[8];
|
|
FSpawnParticleParams puff;
|
|
|
|
Default
|
|
{
|
|
+MISSILE;
|
|
+FORCEXYBILLBOARD;
|
|
+ROLLSPRITE;
|
|
+ROLLCENTER;
|
|
Scale .35;
|
|
Mass 1;
|
|
RenderStyle 'Translucent';
|
|
}
|
|
// try to reduce overhead as much as possible with this
|
|
override void Tick()
|
|
{
|
|
prev = pos; // for interpolation
|
|
if ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
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
|
|
{
|
|
if ( !pufftex[0] )
|
|
{
|
|
for ( int i=0; i<8; i++ ) pufftex[i] = TexMan.CheckForTexture("graphics/Particles/xpuff"..i..".png");
|
|
puff.color1 = fillcolor;
|
|
puff.style = STYLE_Shaded;
|
|
puff.fadestep = -1;
|
|
}
|
|
// 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;
|
|
Vector3 newpos = pos;
|
|
newpos.z = clamp(newpos.z,floorz,ceilingz);
|
|
double ang = atan2(dir.y,dir.x);
|
|
double pt = asin(-dir.z);
|
|
LineTrace(ang,spd,pt,TRF_THRUACTORS|TRF_THRUHITSCAN|TRF_ABSPOSITION,newpos.z,newpos.x,newpos.y,d);
|
|
if ( d.HitType != TRACE_HitNone )
|
|
{
|
|
Vector3 hitnormal = SWWMUtility.GetLineTraceHitNormal(d);
|
|
newpos = d.HitLocation+hitnormal;
|
|
}
|
|
else newpos = level.Vec3Offset(newpos,vel);
|
|
newpos.z = clamp(newpos.z,floorz,ceilingz);
|
|
Vector3 ndiff = level.Vec3Diff(newpos,pos);
|
|
double ndist = ndiff.length();
|
|
ndiff /= ndist;
|
|
puff.lifetime = 10;
|
|
puff.startalpha = .5*alpha;
|
|
puff.sizestep = -1.*scale.x;
|
|
puff.accel = (0,0,-.5);
|
|
for ( int i=0; i<ndist; i++ )
|
|
{
|
|
if ( Random[Blood](0,2) ) continue;
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 10.*scale.x*FRandom[Blood](.6,1.4);
|
|
puff.pos = level.Vec3Offset(pos,ndiff*i);
|
|
puff.vel = vel*.1+(FRandom[Blood](-.1,.1),FRandom[Blood](-.1,.1),FRandom[Blood](-.1,.1));
|
|
level.SpawnParticle(puff);
|
|
}
|
|
SetOrigin(newpos,true);
|
|
if ( (d.HitType == TRACE_HitFloor) || (pos.z <= floorz) )
|
|
{
|
|
// hacky workaround
|
|
if ( !d.HitSector )
|
|
{
|
|
d.HitSector = floorsector;
|
|
d.HitTexture = floorsector.GetTexture(0);
|
|
}
|
|
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 )
|
|
{
|
|
Vector3 floordir;
|
|
if ( d.Hit3DFloor ) floordir = -d.Hit3DFloor.model.ceilingplane.Normal;
|
|
else floordir = d.HitSector.floorplane.Normal;
|
|
int numpt = Random[Blood](2,4);
|
|
puff.lifetime = 20;
|
|
puff.startalpha = .5*alpha;
|
|
puff.pos = pos;
|
|
puff.accel = (0,0,-.25);
|
|
for ( int i=0; i<numpt; i++ )
|
|
{
|
|
Vector3 ndir = (floordir+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.5).unit()*FRandom[Blood](.5,8.);
|
|
for ( double j=1.; j>=.5; j-=.125 )
|
|
{
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 10.*scale.x*FRandom[Blood](.6,1.4)*j;
|
|
puff.pos = pos;
|
|
puff.vel = ndir*j;
|
|
puff.sizestep = -1.*scale.x*j;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
Destroy();
|
|
return;
|
|
}
|
|
master.tracer = self;
|
|
}
|
|
bMISSILE = false;
|
|
dead = true;
|
|
Vector3 floordir;
|
|
if ( d.Hit3DFloor )
|
|
{
|
|
tracksector = d.Hit3DFloor.model;
|
|
trackplane = 1;
|
|
floordir = -d.Hit3DFloor.model.ceilingplane.Normal;
|
|
}
|
|
else
|
|
{
|
|
tracksector = d.HitSector;
|
|
trackplane = 0;
|
|
floordir = d.HitSector.floorplane.Normal;
|
|
}
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360));
|
|
A_SetRenderStyle(1.,STYLE_Shaded);
|
|
frame = Random[Blood](5,12);
|
|
int numpt = Random[Blood](4,8);
|
|
puff.lifetime = 20;
|
|
puff.startalpha = .5*alpha;
|
|
puff.pos = pos;
|
|
puff.accel = (0,0,-.25);
|
|
for ( int i=0; i<numpt; i++ )
|
|
{
|
|
Vector3 ndir = (floordir+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.5).unit()*FRandom[Blood](.5,8.);
|
|
for ( double j=1.; j>=.5; j-=.125 )
|
|
{
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 10.*scale.x*FRandom[Blood](.6,1.4)*j;
|
|
puff.vel = ndir*j;
|
|
puff.sizestep = -1.*scale.x*j;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
vel *= 0;
|
|
return;
|
|
}
|
|
if ( (d.HitType == TRACE_HitCeiling) || (pos.z >= ceilingz) )
|
|
{
|
|
// hacky workaround
|
|
if ( !d.HitSector )
|
|
{
|
|
d.HitSector = ceilingsector;
|
|
d.HitTexture = ceilingsector.GetTexture(1);
|
|
}
|
|
if ( (d.HitTexture == skyflatnum) || master )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
// hit the ceiling
|
|
SetOrigin(d.HitLocation-(0,0,1),true);
|
|
A_StartSound("misc/blooddrop",volume:.1);
|
|
bMISSILE = false;
|
|
dead = true;
|
|
onceiling = true;
|
|
Vector3 floordir;
|
|
if ( d.Hit3DFloor )
|
|
{
|
|
tracksector = d.Hit3DFloor.model;
|
|
trackplane = 0;
|
|
floordir = -d.Hit3DFloor.model.floorplane.Normal;
|
|
}
|
|
else
|
|
{
|
|
tracksector = d.HitSector;
|
|
trackplane = 1;
|
|
floordir = d.HitSector.ceilingplane.Normal;
|
|
}
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360),true);
|
|
A_SetRenderStyle(1.,STYLE_Shaded);
|
|
frame = Random[Blood](13,20);
|
|
int numpt = Random[Blood](4,8);
|
|
puff.lifetime = 20;
|
|
puff.startalpha = .5*alpha;
|
|
puff.pos = pos;
|
|
puff.accel = (0,0,-.25);
|
|
for ( int i=0; i<numpt; i++ )
|
|
{
|
|
Vector3 ndir = (floordir+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.5).unit()*FRandom[Blood](.5,8.);
|
|
for ( double j=1.; j>=.5; j-=.125 )
|
|
{
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 10.*scale.x*FRandom[Blood](.6,1.4)*j;
|
|
puff.vel = ndir*j;
|
|
puff.sizestep = -1.*scale.x*j;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
vel *= 0;
|
|
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);
|
|
int numpt = Random[Blood](4,8);
|
|
puff.lifetime = 20;
|
|
puff.startalpha = .5*alpha;
|
|
puff.pos = pos;
|
|
puff.accel = (0,0,-.25);
|
|
for ( int i=0; i<numpt; i++ )
|
|
{
|
|
Vector3 ndir = (-(walldir.x,walldir.y,0)+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.5).unit()*FRandom[Blood](.5,8.);
|
|
for ( double j=1.; j>=.5; j-=.125 )
|
|
{
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 10.*scale.x*FRandom[Blood](.6,1.4)*j;
|
|
puff.vel = ndir*j;
|
|
puff.sizestep = -1.*scale.x*j;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
Destroy();
|
|
return;
|
|
}
|
|
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 : SWWMStaticSprite
|
|
{
|
|
int thickness;
|
|
|
|
override void SetupSprite()
|
|
{
|
|
texture = TexMan.CheckForTexture(String.Format("MSMK%c0",0x41+Random[Blood](0,7)));
|
|
Scale = (.5,.5);
|
|
Alpha = .35;
|
|
SetRenderStyle(STYLE_Shaded);
|
|
scolor = gameinfo.defaultbloodcolor;
|
|
Flags |= SPF_ROLL;
|
|
bCheckWater = true;
|
|
bWallStop = true;
|
|
}
|
|
|
|
override void OnTick()
|
|
{
|
|
if ( lastwater ) alpha = max(0.,alpha-.1);
|
|
alpha = max(0.,alpha-(.04/max(1.,thickness)));
|
|
scale *= 1.+(.04/max(1.,thickness));
|
|
vel *= 1.-(.04/max(1.,thickness));
|
|
if ( alpha <= 0. ) Destroy();
|
|
}
|
|
}
|
|
|
|
// flying gibs
|
|
Class mkFlyingGib : Actor
|
|
{
|
|
Mixin SWWMMissileFix;
|
|
|
|
bool killme;
|
|
int lastbleed;
|
|
color shadecol;
|
|
bool bleeding;
|
|
double rollvel, pitchvel;
|
|
mkFlyingGib prevmeat, nextmeat;
|
|
Vector3 oldpos;
|
|
TextureID pufftex[8];
|
|
FSpawnParticleParams puff;
|
|
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
for ( int i=0; i<8; i++ ) pufftex[i] = TexMan.CheckForTexture("graphics/Particles/xpuff"..i..".png");
|
|
puff.style = STYLE_Shaded;
|
|
puff.lifetime = 40;
|
|
puff.accel = (0,0,-.25);
|
|
puff.fadestep = -1;
|
|
frame = Random[Blood](0,7);
|
|
double ang = FRandom[Gibs](0,360);
|
|
double pt = FRandom[Gibs](-60,20);
|
|
Vector3 dir = SWWMUtility.Vec3FromAngles(ang,pt);
|
|
vel += dir*FRandom[Gibs](4.,8.);
|
|
if ( master )
|
|
{
|
|
vel += master.vel;
|
|
CopyBloodColor(master);
|
|
}
|
|
rollvel = FRandom[Gibs](10,50)*RandomPick[Gibs](-1,1)*clamp(vel.length()/10.,.25,4.);
|
|
pitchvel = FRandom[Gibs](10,50)*RandomPick[Gibs](-1,1)*clamp(vel.length()/10.,.25,4.);
|
|
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);
|
|
puff.color1 = shadecol;
|
|
bleeding = true;
|
|
if ( Random[Blood](0,1) ) bXFlip = true;
|
|
SWWMHandler.QueueMeat(self);
|
|
}
|
|
|
|
override void OnDestroy()
|
|
{
|
|
SWWMHandler.DeQueueMeat(self);
|
|
Super.OnDestroy();
|
|
}
|
|
|
|
override void Tick()
|
|
{
|
|
oldpos = pos;
|
|
Super.Tick();
|
|
if ( isFrozen() || (freezetics > 0) ) return;
|
|
if ( killme ) A_FadeOut(.01);
|
|
if ( CurState == ResolveState('Death2') )
|
|
{
|
|
if ( vel.length() < .1 )
|
|
bleeding = false;
|
|
return;
|
|
}
|
|
roll += rollvel;
|
|
pitch += pitchvel;
|
|
if ( waterlevel > 0 )
|
|
{
|
|
rollvel *= .99;
|
|
pitchvel *= .99;
|
|
return;
|
|
}
|
|
if ( !bleeding ) return;
|
|
Vector3 ndiff = level.Vec3Diff(pos,oldpos);
|
|
double ndist = ndiff.length();
|
|
ndiff /= ndist;
|
|
for ( int i=0; i<ndist; i++ )
|
|
{
|
|
if ( Random[Blood](0,2) ) continue;
|
|
puff.texture = pufftex[Random[Blood](0,7)];
|
|
puff.size = 20.*scale.x*FRandom[Blood](.6,1.4);
|
|
puff.pos = level.Vec3Offset(oldpos,ndiff*i);
|
|
puff.vel = vel*.1+(FRandom[Blood](-.1,.1),FRandom[Blood](-.1,.1),FRandom[Blood](-.1,.1));
|
|
puff.startalpha = .5*alpha;
|
|
puff.sizestep = -.5*scale.x;
|
|
level.SpawnParticle(puff);
|
|
}
|
|
}
|
|
|
|
override bool CanCollideWith(Actor other, bool passive)
|
|
{
|
|
if ( other == master ) return false;
|
|
return true;
|
|
}
|
|
|
|
void A_Bleed()
|
|
{
|
|
if ( vel.length() < .5 ) ExplodeMissile(null,null);
|
|
else
|
|
{
|
|
Vector3 dir = vel;
|
|
double spd = dir.length();
|
|
dir /= spd;
|
|
dir = (dir+SWWMUtility.Vec3FromAngles(FRandom[Blood](0,360),FRandom[Blood](-90,90))*.3).unit();
|
|
vel = dir*spd;
|
|
}
|
|
rollvel = FRandom[Gibs](10,50)*RandomPick[Gibs](-1,1)*clamp(vel.length()/10.,.25,4.);
|
|
pitchvel = FRandom[Gibs](10,50)*RandomPick[Gibs](-1,1)*clamp(vel.length()/10.,.25,4.);
|
|
if ( lastbleed > level.maptime ) return;
|
|
lastbleed = level.maptime+5;
|
|
TraceBleedAngle(int(vel.length()),angle+180,-pitch);
|
|
}
|
|
|
|
Default
|
|
{
|
|
Radius 4;
|
|
Height 4;
|
|
Mass 10;
|
|
Scale .75;
|
|
Gravity .5;
|
|
BounceType 'Doom';
|
|
BounceFactor .2;
|
|
+MISSILE;
|
|
+DROPOFF;
|
|
+NOBLOCKMAP;
|
|
+USEBOUNCESTATE;
|
|
+CANBOUNCEWATER;
|
|
-BOUNCEAUTOOFF;
|
|
+MOVEWITHSECTOR;
|
|
+THRUACTORS;
|
|
+NOTELEPORT;
|
|
+ROLLSPRITE;
|
|
+ROLLCENTER;
|
|
+INTERPOLATEANGLES;
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 # 1;
|
|
Wait;
|
|
Bounce:
|
|
XZW1 # 0
|
|
{
|
|
A_Bleed();
|
|
A_StartSound("misc/gibhit",CHAN_BODY,CHANF_OVERLAP);
|
|
// gib stuck!
|
|
if ( (floorz >= ceilingz) || !level.IsPointInLevel(pos) )
|
|
Destroy();
|
|
}
|
|
Goto Spawn;
|
|
Death:
|
|
XZW1 # 1 A_JumpIf(pos.z<=floorz,'Death2');
|
|
Wait;
|
|
Death2:
|
|
XZW1 # -1
|
|
{
|
|
A_StartSound("misc/gibhit",CHAN_BODY,CHANF_OVERLAP);
|
|
pitch = Random[Gibs](-5,5);
|
|
if ( abs(roll) < abs(180-roll) ) roll = Random[Gibs](-5,5);
|
|
else roll = Random[Gibs](175,185);
|
|
A_Stop();
|
|
// floor drop
|
|
let b = Spawn('mkBloodDrop',pos);
|
|
b.scale *= 2.0;
|
|
b.SetShade(shadecol);
|
|
}
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// Manually added gibbing
|
|
Class mkGibber : SWWMNonInteractiveActor
|
|
{
|
|
Actor Gibbed;
|
|
int gibcount, gibsize;
|
|
int delay;
|
|
color shadecol;
|
|
meta Class<Actor> gibtype; // allow custom gib types (will be used for monster pack)
|
|
bool psnd;
|
|
bool mksplat;
|
|
|
|
Property GibType: gibtype;
|
|
|
|
virtual void BurstGibs()
|
|
{
|
|
double ang, pt;
|
|
Vector3 dir;
|
|
int bloodthrottle = 0, gibthrottle = 0;
|
|
let hnd = SWWMHandler(EventHandler.Find('SWWMHandler'));
|
|
if ( hnd )
|
|
{
|
|
if ( hnd.oldmaxblood != 0 )
|
|
bloodthrottle = max((hnd.blods_realcnt-hnd.oldmaxblood)/100,0);
|
|
if ( hnd.oldmaxgibs != 0 )
|
|
gibthrottle = max((hnd.meats_realcnt-hnd.oldmaxgibs)/100,0);
|
|
}
|
|
for ( int i=0; i<gibsize; i++ )
|
|
{
|
|
if ( bloodthrottle && (!i || (i%bloodthrottle)) ) continue;
|
|
let a = mkBloodSmoke(SWWMStaticSprite.SpawnAt('mkBloodSmoke',pos+(FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](0.,.9)*height)));
|
|
a.scale = (.5,.5);
|
|
a.alpha = 1.;
|
|
ang = FRandom[Gibs](0,360);
|
|
pt = FRandom[Gibs](-90,90);
|
|
dir = SWWMUtility.Vec3FromAngles(ang,pt);
|
|
a.vel = vel*.1;
|
|
if ( a.vel.length() > 2. ) a.vel = a.vel.unit()*2.;
|
|
a.vel += dir*FRandom[Gibs](.2,.8);
|
|
a.scolor = shadecol;
|
|
a.thickness = Random[Gibs](1,3);
|
|
}
|
|
for ( int i=0; i<gibsize; i++ )
|
|
{
|
|
if ( gibthrottle && (!i || (i%gibthrottle)) ) continue;
|
|
let [b, a] = A_SpawnItemEx(gibtype,FRandom[Gibs](-.5,.5)*radius,FRandom[Gibs](-.5,.5)*radius,FRandom[Gibs](.1,.9)*height,flags:SXF_ABSOLUTEANGLE|SXF_USEBLOODCOLOR);
|
|
if ( !b ) continue;
|
|
a.translation = translation;
|
|
a.CopyBloodColor(self);
|
|
a.scale *= scale.x;
|
|
a.master = gibbed;
|
|
if ( special1 )
|
|
{
|
|
ang = FRandom[Gibs](0,360);
|
|
pt = FRandom[Gibs](-90,90);
|
|
dir = SWWMUtility.Vec3FromAngles(ang,pt);
|
|
a.vel += dir*FRandom[Gibs](4.,8.);
|
|
a.vel.z += 16.;
|
|
}
|
|
}
|
|
for ( int i=0; i<gibsize; i++ )
|
|
{
|
|
if ( bloodthrottle && (!i || (i%bloodthrottle)) ) continue;
|
|
let [b, a] = A_SpawnItemEx('mkBloodDrop',FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](-.8,.8)*radius,FRandom[Gibs](0.,.9)*height,flags:SXF_ABSOLUTEANGLE|SXF_USEBLOODCOLOR);
|
|
if ( !b ) continue;
|
|
ang = FRandom[Gibs](0,360);
|
|
pt = FRandom[Gibs](-90,90);
|
|
dir = SWWMUtility.Vec3FromAngles(ang,pt);
|
|
a.vel = dir*FRandom[Gibs](8.,24.);
|
|
a.vel += vel*.1;
|
|
a.scale *= 2.+FRandom[Gibs](.3,1.6);
|
|
a.SetShade(shadecol);
|
|
a.CopyBloodColor(self);
|
|
}
|
|
reactiontime--;
|
|
}
|
|
|
|
override void PostBeginPlay()
|
|
{
|
|
gibsize = int(min(max(radius,height)/8,12));
|
|
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 ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
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;
|
|
}
|
|
if ( !psnd )
|
|
{
|
|
A_StartSound("misc/gibber",CHAN_VOICE,CHANF_OVERLAP);
|
|
psnd = true;
|
|
}
|
|
if ( mksplat )
|
|
{
|
|
let s = Spawn('mkBloodBlast',pos);
|
|
s.SetShade(shadecol);
|
|
s.master = gibbed;
|
|
mksplat = false;
|
|
}
|
|
BurstGibs();
|
|
if ( reactiontime <= 0 )
|
|
Destroy();
|
|
}
|
|
|
|
Default
|
|
{
|
|
Radius 32;
|
|
Height 16;
|
|
mkGibber.GibType 'mkFlyingGib';
|
|
}
|
|
}
|
|
|
|
// for exploding Cyberdemon/Spider
|
|
Class mkBloodBlast : SWWMNonInteractiveActor
|
|
{
|
|
override void Tick()
|
|
{
|
|
if ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
if ( fz != pos.z ) SetOrigin((pos.x,pos.y,fz),true);
|
|
if ( (waterlevel > 0) || GetFloorTerrain().isliquid )
|
|
A_FadeOut();
|
|
if ( !master ) A_FadeOut(.01);
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
SetZ(fz);
|
|
prev.z = fz;
|
|
A_QueueCorpse();
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360));
|
|
}
|
|
default
|
|
{
|
|
RenderStyle 'Shaded';
|
|
StencilColor "80 00 00";
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 A -1;
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// bare actors used for copying blood color to vanilla monsters
|
|
Class GreenBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "40 80 30";
|
|
}
|
|
}
|
|
Class BlueBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "00 00 A0";
|
|
}
|
|
}
|
|
Class PurpleBloodReference : Actor
|
|
{
|
|
Default
|
|
{
|
|
BloodColor "70 10 A0";
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
let b = mybody.Spawn('mkBloodPool',mybody.pos);
|
|
Color shadecol;
|
|
if ( mybody.bloodcolor ) shadecol = Color(mybody.bloodcolor.r/2,mybody.bloodcolor.g/2,mybody.bloodcolor.b/2);
|
|
else shadecol = Color(80,0,0);
|
|
mkBloodPool(b).stepcol = shadecol;
|
|
b.master = mybody;
|
|
b.A_SetScale(mybody.default.radius/16.);
|
|
// futureproofing hack (heh)
|
|
let mtype = SWWMUtility.GetParentClassBefore(mybody.GetClass(),'Actor');
|
|
if ( mtype.GetClassName() == 'SWWMMonster' )
|
|
{
|
|
b.A_SetRenderStyle(1.,STYLE_Shaded);
|
|
b.SetShade(shadecol);
|
|
}
|
|
else b.translation = mybody.bloodtranslation;
|
|
Destroy();
|
|
}
|
|
}
|
|
|
|
// Blood pool
|
|
Class mkBloodPool : SWWMNonInteractiveActor
|
|
{
|
|
double basesz, sz, accel;
|
|
Color stepcol;
|
|
mkBloodPool prevpool, nextpool;
|
|
bool bRaised; // dead body was revived, fade out faster
|
|
|
|
Property BaseAccel : accel;
|
|
|
|
override void OnDestroy()
|
|
{
|
|
Super.OnDestroy();
|
|
if ( prevpool )
|
|
{
|
|
prevpool.nextpool = nextpool;
|
|
if ( nextpool ) nextpool.prevpool = prevpool;
|
|
}
|
|
let hnd = SWWMHandler(EventHandler.Find('SWWMHandler'));
|
|
if ( !hnd || (hnd.bloodpools != self) ) return;
|
|
hnd.bloodpools = nextpool;
|
|
}
|
|
|
|
override void PostBeginPlay()
|
|
{
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
SetZ(fz);
|
|
prev.z = fz;
|
|
basesz = scale.x;
|
|
sz = .01;
|
|
A_SetScale(sz);
|
|
A_QueueCorpse();
|
|
SWWMUtility.SetToSlope(self,FRandom[Blood](0,360));
|
|
let hnd = SWWMHandler(EventHandler.Find('SWWMHandler'));
|
|
if ( !hnd ) return;
|
|
nextpool = hnd.bloodpools;
|
|
hnd.bloodpools = self;
|
|
if ( nextpool ) nextpool.prevpool = self;
|
|
}
|
|
|
|
override void Tick()
|
|
{
|
|
if ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
if ( fz != pos.z ) SetOrigin((pos.x,pos.y,fz),true);
|
|
if ( (waterlevel > 0) || GetFloorTerrain().isliquid )
|
|
A_FadeOut();
|
|
if ( !master ) A_FadeOut(.01);
|
|
else if ( (master.Health > 0) || bRaised )
|
|
{
|
|
bRaised = true;
|
|
A_FadeOut();
|
|
}
|
|
if ( accel <= 0. ) return;
|
|
sz += accel;
|
|
double fact = min(special1++/1200.,1.);
|
|
accel = SWWMUtility.Lerp(default.accel,0.,fact*fact);
|
|
A_SetScale(basesz*sz);
|
|
A_SetSize(50.*basesz*sz);
|
|
}
|
|
|
|
Default
|
|
{
|
|
Radius 1;
|
|
Height 1;
|
|
StencilColor "80 00 00";
|
|
mkBloodPool.BaseAccel .0006;
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 A -1;
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// Bloody footsteps for player
|
|
// (Spawning handled also by player)
|
|
Class mkBloodStep : SWWMNonInteractiveActor
|
|
{
|
|
override void PostBeginPlay()
|
|
{
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
SetZ(fz);
|
|
prev.z = fz;
|
|
}
|
|
|
|
override void Tick()
|
|
{
|
|
if ( freezetics > 0 )
|
|
{
|
|
freezetics--;
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
double fz = CurSector.floorplane.ZAtPoint(pos.xy);
|
|
if ( fz != pos.z ) SetOrigin((pos.x,pos.y,fz),true);
|
|
if ( (waterlevel > 0) || GetFloorTerrain().isliquid )
|
|
A_FadeOut();
|
|
special1++;
|
|
// start fading out after one whole minute
|
|
if ( special1 > 2100 ) A_FadeOut(.01);
|
|
}
|
|
|
|
Default
|
|
{
|
|
RenderStyle 'Shaded';
|
|
StencilColor "80 00 00";
|
|
}
|
|
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 A -1;
|
|
Stop;
|
|
}
|
|
}
|