1525 lines
38 KiB
Text
1525 lines
38 KiB
Text
// Ynykron projectiles and effects (alt-fire)
|
||
|
||
Class YnykronAltTracer : LineTracer
|
||
{
|
||
Actor ignore;
|
||
Array<Line> ShootThroughList;
|
||
Array<WaterHit> WaterHitList;
|
||
|
||
override ETraceStatus TraceCallback()
|
||
{
|
||
// liquid splashes
|
||
if ( Results.CrossedWater )
|
||
{
|
||
let hl = new("WaterHit");
|
||
hl.sect = Results.CrossedWater;
|
||
hl.hitpos = Results.CrossedWaterPos;
|
||
WaterHitList.Push(hl);
|
||
}
|
||
else if ( Results.Crossed3DWater )
|
||
{
|
||
let hl = new("WaterHit");
|
||
hl.sect = Results.Crossed3DWater;
|
||
hl.hitpos = Results.Crossed3DWaterPos;
|
||
WaterHitList.Push(hl);
|
||
}
|
||
if ( Results.HitType == TRACE_HitActor )
|
||
{
|
||
if ( Results.HitActor == ignore ) return TRACE_Skip;
|
||
if ( Results.HitActor.bSHOOTABLE || (Results.HitActor is 'YnykronSingularityHitbox') ) return TRACE_Stop;
|
||
return TRACE_Skip;
|
||
}
|
||
else if ( (Results.HitType == TRACE_HitWall) && (Results.Tier == TIER_Middle) )
|
||
{
|
||
if ( !Results.HitLine.sidedef[1] || (Results.HitLine.Flags&Line.ML_BlockHitscan) )
|
||
return TRACE_Stop;
|
||
ShootThroughList.Push(Results.HitLine);
|
||
return TRACE_Skip;
|
||
}
|
||
return TRACE_Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronHaloTail : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
+FORCEXYBILLBOARD;
|
||
Scale 1.5;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
A_SetScale(scale.x+.5);
|
||
A_FadeOut(.2);
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
MHAL A -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronHalo : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
+FORCEXYBILLBOARD;
|
||
Scale 1.5;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
if ( !target || target.InStateSequence(target.CurState,target.FindState("Death")) )
|
||
{
|
||
Destroy();
|
||
return;
|
||
}
|
||
SetOrigin(target.pos,true);
|
||
A_SetScale(1.5*target.scale.x);
|
||
let h = Spawn("YnykronHaloTail",pos);
|
||
h.scale = scale;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
MHAL A -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class GatherDust : SWWMNonInteractiveActor
|
||
{
|
||
Mixin SWWMMinimalMovingTick;
|
||
|
||
override void PostBeginPlay()
|
||
{
|
||
SetState(FindState("Spawn")+Random[ExploS](0,19));
|
||
Scale *= FRandom[ExploS](.75,1.5);
|
||
Scale.x *= RandomPick[ExploS](-1,1);
|
||
Scale.y *= RandomPick[ExploS](-1,1);
|
||
SetShade(Color(4,3,5)*Random[ExploS](5,20));
|
||
}
|
||
|
||
void A_Gravitate()
|
||
{
|
||
if ( target && !target.InStateSequence(target.CurState,target.FindState("Death")) )
|
||
{
|
||
if ( alpha < .08 ) A_FadeIn(FRandom[ExploS](.0002,.004));
|
||
Vector3 dirto = level.Vec3Diff(pos,target.pos);
|
||
double distto = dirto.length();
|
||
if ( distto < (32.*target.scale.x) )
|
||
{
|
||
// sucked in
|
||
target.specialf2 += FRandom[ExploS](.5,2.);
|
||
Destroy();
|
||
return;
|
||
}
|
||
dirto /= distto;
|
||
double mxdist = 5000.*target.scale.x;
|
||
vel = dirto*25.*(clamp((mxdist-distto)/mxdist,.5,1.)**4.);
|
||
vel += target.vel;
|
||
return;
|
||
}
|
||
vel *= .98;
|
||
A_FadeOut(.002);
|
||
}
|
||
|
||
Default
|
||
{
|
||
RenderStyle "Shaded";
|
||
Alpha 0.;
|
||
Scale 3.;
|
||
+FORCEXYBILLBOARD;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
BSMK ABCDEFGHIJKLMNOPQRST 1 A_Gravitate();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronVoidBeamTail : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
+FORCEXYBILLBOARD;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
A_FadeOut();
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 # -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronVoidBeam : SWWMNonInteractiveActor
|
||
{
|
||
Actor basebeam, prevbeam, nextbeam;
|
||
YnykronTracer t;
|
||
double baseang, basept;
|
||
int angledir, pitchdir;
|
||
int maxlen, curlen, segnum;
|
||
int spreadtimer;
|
||
int maxlife, lifetimer;
|
||
|
||
Default
|
||
{
|
||
DamageType 'YnykronAlt';
|
||
Obituary "$O_YNYKRONALT";
|
||
RenderStyle "Add";
|
||
Alpha 0.;
|
||
Stamina 3;
|
||
+INTERPOLATEANGLES;
|
||
+NODAMAGETHRUST;
|
||
+FOILINVUL;
|
||
}
|
||
|
||
override void PostBeginPlay()
|
||
{
|
||
angle = baseang = FRandom[Ynykron](0,360);
|
||
pitch = basept = FRandom[Ynykron](-90,90);
|
||
angledir = RandomPick[Ynykron](-1,1);
|
||
pitchdir = RandomPick[Ynykron](-1,1);
|
||
maxlen = Random[Ynykron](40,60);
|
||
maxlife = Random[Ynykron](20,30);
|
||
Scale *= FRandom[Ynykron](.75,1.5);
|
||
lifetimer = -1;
|
||
}
|
||
|
||
void A_UpdateBeam()
|
||
{
|
||
if ( !master )
|
||
{
|
||
Destroy();
|
||
return;
|
||
}
|
||
if ( basebeam == self )
|
||
{
|
||
baseang += FRandom[Ynykron](0.,5.)*angledir;
|
||
basept += FRandom[Ynykron](0.,5.)*pitchdir;
|
||
Vector3 ofs = master.scale.x*32.*SWWMUtility.Vec3FromAngles(baseang,basept);
|
||
SetOrigin(level.Vec3Offset(master.pos,ofs),true);
|
||
double da = deltaangle(angle,baseang+FRandom[Ynykron](-5,5)),
|
||
dp = deltaangle(pitch,basept+FRandom[Ynykron](-5,5));
|
||
angle += da*.2;
|
||
pitch += dp*.2;
|
||
if ( lifetimer == -1 )
|
||
{
|
||
A_FadeIn(FRandom[Ynykron](.003,.05));
|
||
if ( Alpha >= .2 )
|
||
{
|
||
Alpha = .2;
|
||
lifetimer = 0;
|
||
}
|
||
}
|
||
else if ( lifetimer == -2 ) A_FadeOut(FRandom[Ynykron](.003,.05));
|
||
else
|
||
{
|
||
lifetimer++;
|
||
if ( lifetimer > maxlife ) lifetimer = -2;
|
||
}
|
||
// check total length
|
||
int cnt = 0;
|
||
for ( YnykronVoidBeam b=self; b; b=YnykronVoidBeam(b.nextbeam) ) cnt++;
|
||
curlen = cnt;
|
||
}
|
||
else if ( !prevbeam )
|
||
{
|
||
Destroy();
|
||
return;
|
||
}
|
||
Vector3 x = SWWMUtility.Vec3FromAngles(angle,pitch);
|
||
if ( !t ) t = new("YnykronTracer");
|
||
t.ShootThroughList.Clear();
|
||
t.WaterHitList.Clear();
|
||
t.HitList.Clear();
|
||
t.Trace(pos,cursector,x,16*scale.x,TRACE_HitSky);
|
||
foreach ( l:t.ShootThroughList )
|
||
{
|
||
l.Activate(target,0,SPAC_PCross);
|
||
l.Activate(target,0,SPAC_Impact);
|
||
}
|
||
foreach ( hit:t.hitlist )
|
||
{
|
||
// yoink
|
||
SWWMUtility.DoKnockback(hit.HitActor,-hit.x,80000*scale.x*alpha);
|
||
}
|
||
spreadtimer++;
|
||
if ( (t.Results.HitType != TRACE_HitNone) || (segnum > maxlen) || (spreadtimer < stamina) )
|
||
{
|
||
// trigger walls
|
||
if ( t.Results.HitType == TRACE_HitWall )
|
||
t.Results.HitLine.RemoteActivate(target,t.Results.Side,SPAC_Impact,t.Results.HitPos);
|
||
// end of the line
|
||
if ( nextbeam ) nextbeam.Destroy();
|
||
if ( basebeam == self ) frame = 3;
|
||
else frame = 2;
|
||
}
|
||
else
|
||
{
|
||
if ( basebeam == self ) frame = 0;
|
||
else frame = 1;
|
||
// spawn (or relocate) next beam
|
||
if ( !nextbeam )
|
||
{
|
||
nextbeam = Spawn("YnykronVoidBeam",level.Vec3Offset(pos,x*16*scale.x));
|
||
nextbeam.angle = atan2(t.Results.HitVector.y,t.Results.HitVector.x);
|
||
nextbeam.pitch = asin(-t.Results.HitVector.z);
|
||
}
|
||
else nextbeam.SetOrigin(level.Vec3Offset(pos,x*16*scale.x),true);
|
||
nextbeam.target = target;
|
||
nextbeam.master = master;
|
||
YnykronVoidBeam(nextbeam).basebeam = basebeam;
|
||
YnykronVoidBeam(nextbeam).prevbeam = self;
|
||
YnykronVoidBeam(nextbeam).maxlen = maxlen;
|
||
YnykronVoidBeam(nextbeam).segnum = segnum+1;
|
||
nextbeam.alpha = alpha*(1.-(segnum/double(maxlen)));
|
||
nextbeam.scale = scale;
|
||
nextbeam.frame = 1;
|
||
Vector3 newdir = t.Results.HitVector;
|
||
newdir = (newdir+.4*SWWMUtility.Vec3FromAngles(FRandom[Ynykron](0,360),FRandom[Ynykron](-90,90))).unit();
|
||
double da = deltaangle(nextbeam.angle,atan2(newdir.y,newdir.x)),
|
||
dp = deltaangle(nextbeam.pitch,asin(-newdir.z));
|
||
nextbeam.angle += da*.2;
|
||
nextbeam.pitch += dp*.2;
|
||
}
|
||
let h = Spawn("YnykronVoidBeamTail",pos);
|
||
h.angle = angle;
|
||
h.pitch = pitch;
|
||
h.alpha = alpha*2.;
|
||
h.scale = scale;
|
||
h.frame = frame;
|
||
}
|
||
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 # 1 Bright A_UpdateBeam();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronLightningImpact : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
Obituary "$O_YNYKRONALT";
|
||
DamageType "Electric";
|
||
+FOILINVUL;
|
||
+FORCERADIUSDMG;
|
||
+NODAMAGETHRUST;
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Super.PostBeginPlay();
|
||
SWWMUtility.DoExplosion(self,400,120000,100,40);
|
||
A_QuakeEx(3,3,3,12,0,800,"",QF_RELATIVE|QF_SCALEDOWN|QF_3D,falloff:300,rollIntensity:.4);
|
||
A_SprayDecal("ShockMark",-172);
|
||
int numpt = Random[ExploS](8,16);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](3,12);
|
||
let s = Spawn("SWWMSmoke",pos);
|
||
s.vel = pvel;
|
||
s.SetShade(Color(1,1,1)*Random[ExploS](64,224));
|
||
s.special1 = Random[ExploS](1,4);
|
||
s.scale *= 2.;
|
||
s.alpha *= .4;
|
||
}
|
||
numpt = Random[ExploS](5,10);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](2,12);
|
||
let s = Spawn("SWWMSpark",pos);
|
||
s.vel = pvel;
|
||
}
|
||
numpt = Random[ExploS](10,15);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](2,24);
|
||
let s = Spawn("SWWMChip",pos);
|
||
s.vel = pvel;
|
||
}
|
||
Destroy();
|
||
}
|
||
}
|
||
|
||
Class YnykronLightningArc : SWWMNonInteractiveActor
|
||
{
|
||
Vector3 nextpos, nextdir;
|
||
Vector3 destpos;
|
||
|
||
void A_Trace()
|
||
{
|
||
let t = new("CandyBeamTracer");
|
||
t.hitlist.Clear();
|
||
Vector3 x, y, z;
|
||
[x, y, z] = SWWMUtility.GetAxes(angle,pitch,roll);
|
||
t.ShootThroughList.Clear();
|
||
t.Trace(pos,CurSector,x,speed,TRACE_HitSky);
|
||
foreach ( l:t.ShootThroughList )
|
||
{
|
||
l.Activate(target,0,SPAC_PCross);
|
||
l.Activate(target,0,SPAC_Impact);
|
||
}
|
||
foreach ( hit:t.hitlist )
|
||
{
|
||
if ( !hit.hitactor ) continue;
|
||
SWWMUtility.DoKnockback(hit.hitactor,-hit.x,GetMissileDamage(0,0)*1000);
|
||
let p = SWWMPuff.Setup(hit.hitlocation,hit.x,self,target,hit.hitactor);
|
||
hit.hitactor.DamageMobj(p,target,GetMissileDamage(0,0),'Electric',DMG_THRUSTLESS|DMG_INFLICTOR_IS_PUFF);
|
||
}
|
||
Vector3 normal = SWWMUtility.GetLineTracerHitNormal(t.Results), dir = t.Results.HitVector;
|
||
if ( t.Results.HitType != TRACE_HitNone )
|
||
{
|
||
if ( t.Results.HitType != TRACE_HasHitSky )
|
||
{
|
||
if ( t.Results.HitType == TRACE_HitWall ) t.Results.HitLine.RemoteActivate(target,t.Results.Side,SPAC_Impact,t.Results.HitPos);
|
||
let s = Spawn("YnykronLightningImpact",level.Vec3Offset(t.Results.HitPos,normal*8));
|
||
s.target = target;
|
||
s.angle = atan2(normal.y,normal.x);
|
||
s.pitch = asin(-normal.z);
|
||
if ( swwm_omnibust ) BusterWall.Bust(t.Results,GetMissileDamage(0,0),target,t.Results.HitVector,t.Results.HitPos.z);
|
||
}
|
||
nextpos = t.Results.HitPos;
|
||
bAMBUSH = true;
|
||
speed = t.Results.Distance; // shortens in minimap
|
||
return;
|
||
}
|
||
nextpos = level.Vec3Offset(pos,x*speed);
|
||
double a = FRandom[Ynykron](0,360), s = FRandom[Ynykron](0.,.8);
|
||
dir = SWWMUtility.ConeSpread(dir,y,z,a,s);
|
||
if ( !special1 )
|
||
{
|
||
destpos = level.Vec3Offset(pos,x*10000);
|
||
// calculate the closest strike point to home in onto
|
||
Vector3 strikepoints[32];
|
||
double closest = 10000.;
|
||
for ( int i=0; i<32; i++ )
|
||
{
|
||
a = FRandom[Ynykron](0,360);
|
||
s = FRandom[Ynykron](.2,1.);
|
||
Vector3 tdir = SWWMUtility.ConeSpread(dir,y,z,a,s);
|
||
FLineTraceData d;
|
||
LineTrace(atan2(tdir.y,tdir.x),10000,asin(-tdir.z),TRF_THRUACTORS,data:d);
|
||
strikepoints[i] = d.HitLocation;
|
||
if ( d.Distance < closest )
|
||
{
|
||
destpos = strikepoints[i];
|
||
closest = d.Distance;
|
||
}
|
||
}
|
||
}
|
||
Vector3 dirto = level.Vec3Diff(nextpos,destpos);
|
||
double dist = dirto.length();
|
||
if ( dist > 10 )
|
||
{
|
||
dirto /= dist;
|
||
dir = (dir+.8*dirto*(clamp(1.-(dist/1500.),0.,1.)**1.5)).unit();
|
||
}
|
||
nextdir = dir;
|
||
}
|
||
void A_Spread( Sound arcsnd )
|
||
{
|
||
Vector3 tdir = level.Vec3Diff(pos,nextpos);
|
||
if ( (GetClass() == 'YnykronLightningArc') && !Random[Ynykron](0,3) )
|
||
{
|
||
for ( int i=0; i<3; i++ )
|
||
{
|
||
let r = Spawn("YnykronLightningArcSub",level.Vec3Offset(pos,tdir*FRandom[Ynykron](0,1)));
|
||
Vector3 x, y, z;
|
||
[x, y, z] = SWWMUtility.GetAxes(angle,pitch,roll);
|
||
double a = FRandom[Ynykron](0,360), s = FRandom[Sparkster](0.,1.);
|
||
Vector3 sdir = SWWMUtility.ConeSpread(x,y,z,a,s);
|
||
r.angle = atan2(sdir.y,sdir.x);
|
||
r.pitch = asin(-sdir.z);
|
||
r.target = target;
|
||
r.special1 = 1;
|
||
YnykronLightningArc(r).destpos = destpos;
|
||
r.ReactionTime += Random[Ynykron](-3,3);
|
||
}
|
||
}
|
||
if ( arcsnd != "" ) A_StartSound(arcsnd,CHAN_WEAPON);
|
||
if ( ((ReactionTime > 0) && (special1 > ReactionTime)) || bAMBUSH ) return;
|
||
let b = Spawn(GetClass(),nextpos);
|
||
b.angle = atan2(nextdir.y,nextdir.x);
|
||
b.pitch = asin(-nextdir.z);
|
||
b.target = target;
|
||
b.special1 = special1+1;
|
||
YnykronLightningArc(b).destpos = destpos;
|
||
b.SetState(b.FindState("Trailer"));
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Super.PostBeginPlay();
|
||
frame = Random[Ynykron](0,11);
|
||
}
|
||
Default
|
||
{
|
||
Obituary "$O_YNYKRONALT";
|
||
RenderStyle "Add";
|
||
DamageFunction 1000;
|
||
Speed 128;
|
||
Alpha 2.;
|
||
+FOILINVUL;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 # 0 Bright;
|
||
XZW1 # 1 Bright A_Trace();
|
||
XZW1 # 1 Bright A_Spread("ynykron/vortexarc");
|
||
XZW1 # 1 Bright A_FadeOut();
|
||
Wait;
|
||
Trailer:
|
||
XZW2 # 0 Bright;
|
||
XZW2 # 1 Bright A_Trace();
|
||
XZW2 # 1 Bright A_Spread("ynykron/vortexarc");
|
||
XZW2 # 1 Bright A_FadeOut();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronLightningArcSub : YnykronLightningArc
|
||
{
|
||
Default
|
||
{
|
||
DamageFunction 250;
|
||
Speed 32;
|
||
ReactionTime 10;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 # 0 Bright;
|
||
XZW1 # 1 Bright A_Trace();
|
||
XZW1 # 1 Bright A_Spread("");
|
||
XZW1 # 1 Bright A_FadeOut();
|
||
Wait;
|
||
Trailer:
|
||
XZW2 # 0 Bright;
|
||
XZW2 # 1 Bright A_Trace();
|
||
XZW2 # 1 Bright A_Spread("");
|
||
XZW2 # 1 Bright A_FadeOut();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronCloud : SWWMNonInteractiveActor
|
||
{
|
||
Vector3 gx, gy, gz;
|
||
double phase;
|
||
Vector3 dirto;
|
||
double frightening; // lightning flash
|
||
Color basecol;
|
||
double rollvel;
|
||
|
||
override void Tick()
|
||
{
|
||
prev = pos;
|
||
Super.Tick();
|
||
}
|
||
|
||
void FlashPlayer( int str, double rad )
|
||
{
|
||
if ( !SWWMUtility.InPlayerFOV(players[consoleplayer],self,rad) ) return;
|
||
let mo = players[consoleplayer].Camera;
|
||
double dist = Distance3D(mo);
|
||
str = int(str*(1.-(dist/rad)));
|
||
SWWMHandler.DoFlash(mo,Color(str,255,255,255),1);
|
||
SWWMHandler.DoFlash(mo,Color(str/2,240,224,255),10);
|
||
}
|
||
|
||
override void PostBeginPlay()
|
||
{
|
||
SetState(FindState("Spawn")+Random[ExploS](0,19));
|
||
Scale *= FRandom[ExploS](.75,1.5);
|
||
Scale.x *= RandomPick[ExploS](-1,1);
|
||
Scale.y *= RandomPick[ExploS](-1,1);
|
||
if ( master ) Scale *= master.scale.x;
|
||
// orbit axes
|
||
[gx, gy, gz] = SWWMUtility.GetAxes(FRandom[ExploS](0,360),FRandom[ExploS](-90,90),FRandom[ExploS](-90,90));
|
||
specialf1 = FRandom[ExploS](200,400);
|
||
scale *= specialf1/200.;
|
||
specialf2 = FRandom[ExploS](3.,8.)*RandomPick[ExploS](-1,1);
|
||
special2 = Random[ExploS](10,40);
|
||
basecol = Color(4,3,5)*Random[ExploS](5,20);
|
||
SetShade(basecol);
|
||
rollvel = FRandom[ExploS](.5,3.)*RandomPick[ExploS](-1,1);
|
||
}
|
||
|
||
void A_Gravitate()
|
||
{
|
||
if ( frightening > 0. )
|
||
{
|
||
alpha = max(frightening,.3);
|
||
int str = int(RandomPick[ExploS](255,240,192,254,248,128,160,204)*frightening);
|
||
Color litecol = Color(min(255,basecol.r+str),min(255,basecol.g+str),min(255,basecol.b+str));
|
||
SetShade(litecol);
|
||
frightening *= .96;
|
||
if ( frightening < .1 )
|
||
{
|
||
frightening = 0.;
|
||
SetShade(basecol);
|
||
}
|
||
}
|
||
roll += rollvel;
|
||
if ( master && !master.InStateSequence(master.CurState,master.FindState("Death")) )
|
||
{
|
||
if ( special1 == 0 )
|
||
{
|
||
A_FadeIn(FRandom[ExploS](.001,.002));
|
||
if ( alpha > .3 ) special1 = 1;
|
||
}
|
||
else if ( special1 > 0 )
|
||
{
|
||
special1++;
|
||
if ( special1 >= special2 )
|
||
special1 = -1;
|
||
}
|
||
else if ( special1 == -1 ) A_FadeOut(FRandom[ExploS](.003,.006));
|
||
dirto = level.Vec3Diff(pos,master.pos);
|
||
double distto = dirto.length();
|
||
dirto /= distto;
|
||
// orbit
|
||
Vector3 orbitdir = SWWMUtility.CircleOffset(gx,gy,phase,(specialf1+32)*master.scale.x);
|
||
SetOrigin(level.Vec3Offset(master.pos,orbitdir),true);
|
||
phase += FRandom[ExploS](.12,.24)*specialf2*(1.-specialf1/600.);
|
||
return;
|
||
}
|
||
SetOrigin(level.Vec3Offset(pos,-dirto*3.*abs(specialf2)),true);
|
||
specialf2 *= .98;
|
||
A_FadeOut(.005);
|
||
}
|
||
|
||
Default
|
||
{
|
||
DamageType 'YnykronAlt';
|
||
Obituary "$O_YNYKRONALT";
|
||
RenderStyle "Shaded";
|
||
Alpha 0.;
|
||
Scale 3.;
|
||
+FORCEXYBILLBOARD;
|
||
+ROLLSPRITE;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
BSMK ABCDEFGHIJKLMNOPQRST 1 A_Gravitate();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronLightningLight : PaletteLight
|
||
{
|
||
Default
|
||
{
|
||
Tag "WhiteExpl";
|
||
ReactionTime 12;
|
||
Args 0,0,0,500;
|
||
}
|
||
}
|
||
Class YnykronLightningLight2 : PaletteLight
|
||
{
|
||
Default
|
||
{
|
||
Tag "WhiteExpl";
|
||
ReactionTime 10;
|
||
Args 0,0,0,300;
|
||
}
|
||
}
|
||
|
||
Class SimpleMoveTracer : LineTracer
|
||
{
|
||
override ETraceStatus TraceCallback()
|
||
{
|
||
if ( Results.HitType == TRACE_HitActor ) return TRACE_Skip;
|
||
else if ( (Results.HitType == TRACE_HitWall) && (Results.Tier == TIER_Middle) )
|
||
{
|
||
if ( !Results.HitLine.sidedef[1] || (Results.HitLine.Flags&Line.ML_BLOCKPROJECTILE) )
|
||
return TRACE_Stop;
|
||
return TRACE_Skip;
|
||
}
|
||
return TRACE_Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronSingularityRing : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
Scale 4.;
|
||
+FORCEXYBILLBOARD;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XRG4 AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXX 1 Bright A_SetScale(scale.x*1.05);
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronVoidExplLight : PaletteLight
|
||
{
|
||
Default
|
||
{
|
||
Tag "Purple";
|
||
ReactionTime 60;
|
||
Args 0,0,0,1200;
|
||
}
|
||
}
|
||
|
||
Class YnykronVoidSparkleTrail : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
XScale 6.;
|
||
+FORCEXYBILLBOARD;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
A_SetScale(scale.x*.95,scale.y);
|
||
A_FadeOut(.04);
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 A -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronVoidSparkle : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
+ROLLSPRITE;
|
||
+ROLLCENTER;
|
||
+FORCEXYBILLBOARD;
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Scale *= FRandom[ExploS](.75,1.5);
|
||
specialf1 = FRandom[ExploS](.95,.98);
|
||
specialf2 = FRandom[ExploS](.005,.015);
|
||
vel = SWWMUtility.Vec3FromAngles(angle,pitch)*FRandom[ExploS](4,32);
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
A_SetScale(scale.x*specialf1);
|
||
A_FadeOut(specialf2);
|
||
Vector3 dir = vel;
|
||
double magvel = dir.length();
|
||
magvel *= .99;
|
||
if ( magvel > 0. )
|
||
{
|
||
dir /= magvel;
|
||
dir += .2*SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90));
|
||
vel = dir.unit()*magvel;
|
||
}
|
||
Vector3 newpos = level.Vec3Offset(pos,vel);
|
||
if ( (newpos.z < floorz) || (newpos.z >= ceilingz) )
|
||
{
|
||
vel.z *= -1;
|
||
newpos = level.Vec3Offset(pos,vel);
|
||
}
|
||
if ( !level.IsPointInLevel(newpos) )
|
||
{
|
||
vel.xy *= -1;
|
||
newpos = level.Vec3Offset(pos,vel);
|
||
}
|
||
dir = level.Vec3Diff(newpos,pos);
|
||
double len = dir.length();
|
||
if ( (len > 0.) && (alpha > .1) )
|
||
{
|
||
dir /= len;
|
||
let t = Spawn("YnykronVoidSparkleTrail",newpos);
|
||
t.alpha = alpha*.5;
|
||
t.scale.x *= scale.x;
|
||
t.speed = len;
|
||
[t.angle, t.pitch, t.scale.y] = SWWMUtility.CalcYBeam(dir,len);
|
||
}
|
||
SetOrigin(newpos,true);
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
MOPF A -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
Class YnykronSingularityExplosionArm : Actor
|
||
{
|
||
Default
|
||
{
|
||
PROJECTILE;
|
||
+THRUACTORS;
|
||
+BOUNCEONWALLS;
|
||
+BOUNCEONFLOORS;
|
||
+BOUNCEONCEILINGS;
|
||
+NODAMAGETHRUST;
|
||
+FORCERADIUSDMG;
|
||
-NOGRAVITY;
|
||
+NOFRICTION;
|
||
Gravity 0.35;
|
||
BounceFactor 1.0;
|
||
Radius 2;
|
||
Height 4;
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Super.PostBeginPlay();
|
||
reactiontime = Random[ExploS](10,20);
|
||
double ang, pt;
|
||
ang = FRandom[ExploS](0,360);
|
||
pt = FRandom[ExploS](-90,90);
|
||
vel = SWWMUtility.Vec3FromAngles(ang,pt)*FRandom[ExploS](20.,40.);
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
TNT1 A 1
|
||
{
|
||
A_CountDown();
|
||
if ( !(reactiontime%2) )
|
||
{
|
||
Spawn("YnykronSingularityExplosionTrail",pos);
|
||
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](1,5);
|
||
let s = Spawn("SWWMHalfSmoke",pos);
|
||
s.SetShade(Color(1,1,1)*Random[ExploS](128,160)+Color(28,0,31));
|
||
s.A_SetRenderStyle(s.alpha*(.1+.4*(ReactionTime/15.)),STYLE_AddShaded);
|
||
s.vel = pvel+vel*.2;
|
||
s.special1 = Random[ExploS](1,3);
|
||
s.scale *= 2.4;
|
||
}
|
||
}
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronSingularityExplosionTrail : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
RenderStyle "Add";
|
||
+FORCEXYBILLBOARD;
|
||
Scale 3.;
|
||
Alpha .2;
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Super.PostBeginPlay();
|
||
Scale *= FRandom[ExploS](0.8,1.1);
|
||
Scale.x *= RandomPick[ExploS](-1,1);
|
||
Scale.y *= RandomPick[ExploS](-1,1);
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XEX4 ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ 1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronSingularityExplosion : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
Obituary "$O_YNYKRONALT";
|
||
DamageType "YnykronAlt";
|
||
RenderStyle "Add";
|
||
Scale 5.;
|
||
+NODAMAGETHRUST;
|
||
+FORCERADIUSDMG;
|
||
+FORCEXYBILLBOARD;
|
||
+FOILINVUL;
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
Super.PostBeginPlay();
|
||
if ( !Random[ExploS](0,5) )
|
||
A_StartSound("ynykron/impact",CHAN_VOICE);
|
||
SWWMUtility.DoExplosion(self,10000,5000,400,200);
|
||
A_SprayDecal("WumboRocketBlast",-172);
|
||
Scale *= FRandom[ExploS](0.8,1.1);
|
||
Scale.x *= RandomPick[ExploS](-1,1);
|
||
Scale.y *= RandomPick[ExploS](-1,1);
|
||
int numpt = Random[ExploS](2,4);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](4,20);
|
||
let s = Spawn("SWWMSmoke",pos);
|
||
s.vel = pvel;
|
||
s.SetShade(Color(1,1,1)*Random[ExploS](128,160)+Color(28,0,31));
|
||
s.A_SetRenderStyle(.2,STYLE_AddShaded);
|
||
s.special1 = Random[ExploS](2,5);
|
||
s.scale *= 8.;
|
||
}
|
||
numpt = Random[ExploS](0,4);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
double ang = FRandom[ExploS](0,360);
|
||
double pt = FRandom[ExploS](-90,90);
|
||
double ofs = FRandom[ExploS](0.,30.);
|
||
let s = Spawn("YnykronVoidSparkle",level.Vec3Offset(pos,ofs*SWWMUtility.Vec3FromAngles(ang,pt)));
|
||
s.angle = ang;
|
||
s.pitch = pt;
|
||
}
|
||
numpt = Random[ExploS](-1,3);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
let s = Spawn("YnykronSingularityExplosionArm",pos);
|
||
s.target = target;
|
||
}
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XEX4 AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\ 1 Bright A_SetScale(scale.x*1.01,scale.y*1.01);
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronSingularityHitbox : SWWMNonInteractiveActor
|
||
{
|
||
Default
|
||
{
|
||
-NOBLOCKMAP;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( !target || !target.InStateSequence(target.CurState,target.FindState("Spawn")) )
|
||
{
|
||
Destroy();
|
||
return;
|
||
}
|
||
A_SetSize(32.*target.scale.x,64.*target.scale.y);
|
||
SetOrigin(target.Vec3Offset(0,0,-height*.5),true);
|
||
}
|
||
override bool CanCollideWith( Actor other, bool passive )
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
Class YnykronSingularity : SWWMNonInteractiveActor
|
||
{
|
||
const MAXBEAMS = 10;
|
||
const MAXCLOUDS = 300;
|
||
|
||
Actor beamers[MAXBEAMS];
|
||
Actor clouds[MAXCLOUDS];
|
||
|
||
const MION_CONST = 48538.; // miön v-force compression constant (approximate)
|
||
const YNON_CONST = .043738; // ÿnon v-force field constant (approximate)
|
||
const AXAN_CONST = 27.2761; // axan u-force field constant (approximate)
|
||
const GOAL_MASS = 26741.; // mass required to compensate Ynykron altfire negative energy release (-2.4×10¹⁵ J, approximately)
|
||
|
||
double critmass; // actual mass required (cummulative with absorbed vortices)
|
||
|
||
int litetimer;
|
||
|
||
transient SimpleMoveTracer mt;
|
||
|
||
override void PostBeginPlay()
|
||
{
|
||
let g = Spawn("YnykronHalo",pos);
|
||
g.target = self;
|
||
A_StartSound("ynykron/vortex",CHAN_BODY,CHANF_LOOP,1.,.6);
|
||
A_StartSound("ynykron/wind",CHAN_ITEM,CHANF_LOOP,1.,.0);
|
||
A_StartSound("ynykron/hit",CHAN_VOICE,CHANF_OVERLAP,1.,.0);
|
||
// initial mass and radius
|
||
specialf1 = scale.x;
|
||
specialf2 = scale.x*scale.x*MION_CONST;
|
||
critmass = GOAL_MASS;
|
||
litetimer = level.maptime+Random[Ynykron](180,240);
|
||
let h = Spawn("YnykronSingularityHitbox",pos);
|
||
h.target = self;
|
||
}
|
||
|
||
// lightweight tick, we don't need anything else other than states
|
||
override void Tick()
|
||
{
|
||
prev = pos;
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
Vector3 newpos;
|
||
if ( !mt ) mt = new("SimpleMoveTracer");
|
||
Vector3 dir = vel;
|
||
double dist = vel.length();
|
||
dir /= dist;
|
||
mt.Trace(pos,CurSector,dir,dist,0);
|
||
if ( mt.Results.HitType == TRACE_HitNone ) newpos = level.Vec3Offset(pos,vel);
|
||
else newpos = level.Vec3Offset(mt.Results.HitPos,-mt.Results.HitVector);
|
||
if ( level.IsPointInLevel(newpos) )
|
||
SetOrigin(newpos,true);
|
||
if ( !CheckNoDelay() || (tics == -1) ) return;
|
||
if ( tics > 0 ) tics--;
|
||
while ( !tics )
|
||
{
|
||
if ( !SetState(CurState.NextState) )
|
||
return;
|
||
}
|
||
}
|
||
|
||
override String GetObituary( Actor victim, Actor inflictor, Name mod, bool playerattack )
|
||
{
|
||
if ( mod == 'Ynykron' )
|
||
return StringTable.Localize("$O_YNYKRON");
|
||
return Super.GetObituary(victim,inflictor,mod,playerattack);
|
||
}
|
||
|
||
void A_SingularityTick()
|
||
{
|
||
// gather dust particles (minor "background" mass gain)
|
||
int numpt = int(max(4,20*scale.x));
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
double ang = FRandom[ExploS](0,360);
|
||
double pt = FRandom[ExploS](-90,90);
|
||
FLineTraceData d;
|
||
double dst = FRandom[ExploS](1500,2000)*scale.x;
|
||
LineTrace(ang,dst,pt,TRF_THRUACTORS|TRF_THRUHITSCAN,data:d);
|
||
Vector3 norm = SWWMUtility.GetLineTraceHitNormal(d);
|
||
let gd = Spawn("GatherDust",level.Vec3Offset(d.HitLocation,norm*8));
|
||
gd.target = self;
|
||
}
|
||
// storm clouds
|
||
for ( int i=0; i<MAXCLOUDS; i++ )
|
||
{
|
||
if ( clouds[i] && (clouds[i].special1 > -1) ) continue;
|
||
clouds[i] = Spawn("YnykronCloud",pos);
|
||
clouds[i].target = target;
|
||
clouds[i].master = self;
|
||
}
|
||
// check dense cloud formations for lightning
|
||
if ( level.maptime > litetimer )
|
||
{
|
||
int which = Random[Ynykron](0,MAXCLOUDS-1);
|
||
if ( clouds[which] )
|
||
{
|
||
Array<Actor> contacts;
|
||
Array<double> dists;
|
||
contacts.Clear();
|
||
dists.Clear();
|
||
for ( int i=0; i<MAXCLOUDS; i++ )
|
||
{
|
||
if ( !clouds[i] || (i == which) || (clouds[i].Alpha < .1) ) continue;
|
||
double dist = clouds[which].Distance3D(clouds[i]);
|
||
if ( dist > (200*scale.x) ) continue;
|
||
contacts.Push(clouds[i]);
|
||
dists.Push(dist);
|
||
}
|
||
if ( (contacts.Size() > 12) && !Random[Ynykron](0,5) )
|
||
{
|
||
Spawn("YnykronLightningLight",clouds[which].pos);
|
||
Spawn("YnykronLightningLight2",clouds[which].pos);
|
||
A_StartSound("ynykron/vortexflash",CHAN_WEAPON,CHANF_OVERLAP,1.,0.,FRandom[Ynykron](.9,1.1));
|
||
YnykronCloud(clouds[which]).frightening = 1.;
|
||
YnykronCloud(clouds[which]).FlashPlayer(200,3000);
|
||
for ( int i=0; i<contacts.Size(); i++ )
|
||
YnykronCloud(contacts[i]).frightening = (1.-dists[i]/(200*scale.x))**.5;
|
||
litetimer = level.maptime+Random[Ynykron](120,240);
|
||
SWWMUtility.DoExplosion(clouds[which],1200,40000,500,150);
|
||
// lightning arcs
|
||
int numpt = Random[Ynykron](0,3);
|
||
Vector3 dirto = level.Vec3Diff(pos,clouds[which].pos);
|
||
dirto /= dirto.length();
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
let l = Spawn("YnykronLightningArc",clouds[which].pos);
|
||
l.angle = atan2(dirto.y,dirto.x)+FRandom[Ynykron](-5,5);
|
||
l.pitch = asin(-dirto.z)+FRandom[Ynykron](-5,5);
|
||
l.target = target;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// ol' crazy purple beams from original
|
||
for ( int i=0; i<MAXBEAMS; i++ )
|
||
{
|
||
if ( beamers[i] || Random[Ynykron](0,40) ) continue;
|
||
beamers[i] = Spawn("YnykronVoidBeam",pos);
|
||
YnykronVoidBeam(beamers[i]).basebeam = beamers[i];
|
||
beamers[i].target = target;
|
||
beamers[i].master = self;
|
||
}
|
||
// suck in reachable targets
|
||
let hnd = SWWMHandler(EventHandler.Find("SWWMHandler"));
|
||
if ( hnd )
|
||
{
|
||
foreach ( a:hnd.SuckableActors )
|
||
{
|
||
if ( !a ) continue;
|
||
if ( a.bDORMANT || (a.Health <= 0) || (a == self) || !SWWMUtility.SphereIntersect(a,pos,20000.*scale.x) || !CheckSight(a,SF_IGNOREVISIBILITY|SF_IGNOREWATERBOUNDARY) )
|
||
continue;
|
||
if ( (a is 'Inventory') && !a.bDROPPED ) // must be a dropped pickup
|
||
continue;
|
||
if ( a.player && (a.player.cheats&CF_NOCLIP2) ) // for safety
|
||
continue;
|
||
if ( (a is 'YnykronSingularity') && a.bNOBLOCKMAP ) // dead singularity, ignore
|
||
continue;
|
||
double capmass = a.mass;
|
||
// succ
|
||
if ( SWWMUtility.SphereIntersect(a,pos,32.*scale.x) )
|
||
{
|
||
// merge with other vortices
|
||
if ( a is 'YnykronSingularity' )
|
||
{
|
||
critmass += YnykronSingularity(a).critmass;
|
||
specialf2 += a.specialf2;
|
||
a.Destroy();
|
||
continue;
|
||
}
|
||
// don't delet inventory
|
||
if ( a is 'Inventory' )
|
||
continue;
|
||
// delet missile
|
||
if ( a.bMISSILE )
|
||
{
|
||
specialf2 += 5.;
|
||
a.Destroy();
|
||
continue;
|
||
}
|
||
// voodoo dolls just get erased (how convenient)
|
||
// otherwise instantly vaporize the fucker
|
||
if ( a.player && (a.player.mo != a) ) a.Destroy();
|
||
else if ( a.CountInv("GrilledCheeseSandwich") > 0 )
|
||
{
|
||
// force use the sandwich, warp to safe spot
|
||
let gc = GrilledCheeseSandwich(a.FindInventory("GrilledCheeseSandwich"));
|
||
gc.SafeTeleport(true);
|
||
a.A_StartSound(gc.UseSound,CHAN_ITEMEXTRA);
|
||
gc.DoTheThing(true);
|
||
gc.Amount--;
|
||
}
|
||
else if ( !a.FindInventory("GrilledCheeseSafeguard") )
|
||
a.DamageMobj(self,target,int.max,'Ynykron',DMG_FORCED|DMG_THRUSTLESS);
|
||
if ( a && (a.Health <= 0) )
|
||
{
|
||
if ( a.player )
|
||
{
|
||
if ( a == target )
|
||
{
|
||
SWWMUtility.MarkAchievement("oopsie",a.player);
|
||
target = PlayerGone.FeckOff(a);
|
||
}
|
||
else PlayerGone.FeckOff(a);
|
||
}
|
||
if ( a.FindState("YnykronAltDeath",true) )
|
||
a.SetStateLabel("YnykronAltDeath"); // dedicated state
|
||
else
|
||
{
|
||
// poof away manually
|
||
a.bINVISIBLE = true;
|
||
a.A_ChangeLinkFlags(false); // remove from blockmap, should guarantee archviles not raising this
|
||
IDontFeelSoGood.DeletThis(a,true); // ensures corpse is deleted too
|
||
}
|
||
if ( target && a.FindInventory("EndgameBossMarker") )
|
||
SWWMUtility.MarkAchievement("ligma",target.player);
|
||
}
|
||
if ( !a || (a.Health <= 0) )
|
||
specialf2 += min(100.,capmass*.6); // partial absorption
|
||
continue;
|
||
}
|
||
capmass = max(50.,a.mass);
|
||
Vector3 dirto = level.Vec3Diff(a.Vec3Offset(0,0,a.Height/2),pos);
|
||
double dist = dirto.length();
|
||
dirto /= dist;
|
||
// rip
|
||
if ( a && a.bSHOOTABLE && SWWMUtility.SphereIntersect(a,pos,200.*scale.x) )
|
||
a.DamageMobj(self,target,int(clamp(10.-dist*.05,0.,5.)),'YnykronAlt',DMG_FORCED|DMG_THRUSTLESS);
|
||
if ( !a ) continue;
|
||
// weak gravitational force as per v-field (approximate)
|
||
double grav = (3.*YNON_CONST*specialf2*capmass)/(dist**.5);
|
||
// strong gravitational force as per u-field (approximate)
|
||
grav += (4.*AXAN_CONST*specialf2*capmass)/(dist**2.);
|
||
// account for ground friction
|
||
if ( a.pos.z <= a.floorz )
|
||
{
|
||
double frict, movef;
|
||
[frict, movef] = a.GetFriction();
|
||
grav *= movef;
|
||
if ( !a.player ) dirto.z += .1;
|
||
}
|
||
if ( a.mass < LARGE_MASS )
|
||
{
|
||
// v-force field compression (very rough approximation)
|
||
a.vel *= max(.0,1.-.03*(grav*grav)/(MION_CONST*MION_CONST));
|
||
a.vel += dirto*grav/(capmass*GameTicRate);
|
||
}
|
||
}
|
||
}
|
||
// push away from nearby geometry
|
||
double pushdist = 50+32*scale.x;
|
||
for ( int i=0; i<8; i++ )
|
||
{
|
||
double ang = FRandom[ExploS](0,360);
|
||
double pt = FRandom[ExploS](-90,90);
|
||
FLineTraceData d;
|
||
if ( !LineTrace(ang,pushdist,pt,TRF_THRUACTORS|TRF_THRUHITSCAN,data:d) ) continue;
|
||
double mag = pushdist-d.Distance;
|
||
vel -= SWWMUtility.Vec3FromAngles(ang,pt)*.02*mag;
|
||
}
|
||
double magvel = vel.length();
|
||
Vector3 dir;
|
||
if ( magvel <= double.epsilon ) dir = SWWMUtility.Vec3FromAngles(angle,pitch);
|
||
else dir = vel/magvel;
|
||
// wander
|
||
dir = (dir+SWWMUtility.Vec3FromAngles(FRandom[Ynykron](0,360),FRandom[Ynykron](-90,90))*FRandom[Ynykron](.05,.2)).unit();
|
||
magvel *= .93;
|
||
if ( magvel > 5. ) magvel *= .95;
|
||
if ( magvel > 20. ) magvel *= .65;
|
||
if ( magvel < .1 ) magvel = .1;
|
||
vel = magvel*dir;
|
||
// calculate target scale based on radius of event horizon
|
||
specialf1 = (specialf2/MION_CONST)**.5;
|
||
// shift to target scale
|
||
// hopefully this supports interpolation someday
|
||
double diffscale = specialf1-scale.x;
|
||
if ( abs(diffscale) <= .01 ) A_SetScale(specialf1);
|
||
else A_SetScale(scale.x+diffscale*.3);
|
||
// detonate if we reach critical mass
|
||
if ( specialf2 >= critmass )
|
||
SetStateLabel("Death");
|
||
}
|
||
|
||
void FlashPlayer( int str, double rad )
|
||
{
|
||
if ( !SWWMUtility.InPlayerFOV(players[consoleplayer],self,rad) ) return;
|
||
let mo = players[consoleplayer].Camera;
|
||
double dist = Distance3D(mo);
|
||
str = int(str*(1.-(dist/rad)));
|
||
SWWMHandler.DoFlash(mo,Color(str,255,255,255),3);
|
||
SWWMHandler.DoFlash(mo,Color(str/2,240,224,255),30);
|
||
}
|
||
void A_SingularityBlast()
|
||
{
|
||
A_ChangeLinkFlags(true); // unlink from blockmap
|
||
A_AlertMonsters(0,AMF_EMITFROMTARGET);
|
||
SWWMUtility.DoExplosion(self,int.max,500000,800,400);
|
||
A_QuakeEx(8,8,8,100,0,65535,"",QF_RELATIVE|QF_SCALEDOWN,falloff:65535,rollIntensity:1.6);
|
||
A_StopAllSounds();
|
||
A_StartSound("ynykron/vortexend",CHAN_VOICE,attenuation:0.);
|
||
FlashPlayer(250,9000);
|
||
vel *= 0;
|
||
// kill off any leftover beams
|
||
for ( int i=0; i<MAXBEAMS; i++ )
|
||
{
|
||
if ( !beamers[i] ) continue;
|
||
YnykronVoidBeam(beamers[i]).maxlife = 0;
|
||
}
|
||
Spawn("YnykronSingularityRing",pos);
|
||
Spawn("YnykronVoidExplLight",pos);
|
||
int numpt = Random[ExploS](60,80);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
let s = Spawn("YnykronVoidSparkle",pos);
|
||
s.angle = FRandom[ExploS](0,360);
|
||
s.pitch = FRandom[ExploS](-90,90);
|
||
s.scale *= 8.;
|
||
s.alpha *= 5.;
|
||
}
|
||
}
|
||
void A_SingularityExtraBlast()
|
||
{
|
||
special1++;
|
||
if ( special1 > 60 )
|
||
{
|
||
if ( IsActorPlayingSound(CHAN_VOICE,-1) ) return;
|
||
for ( int i=0; i<MAXBEAMS; i++ ) if ( beamers[i] ) return;
|
||
Destroy();
|
||
return;
|
||
}
|
||
double factor = (60-special1)/60.;
|
||
double invfct = 1.-factor;
|
||
SWWMUtility.DoExplosion(self,0,-50000*factor,4000*invfct);
|
||
FlashPlayer(int(min(100*factor,250)),10000);
|
||
FLineTraceData d;
|
||
Vector3 HitNormal;
|
||
Vector3 origin;
|
||
double ang, pt;
|
||
int numpt = clamp((60-special1)/4,2,12);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
double totaldist = 30+(special1**2.5)*.1;
|
||
ang = FRandom[ExploS](0,360);
|
||
pt = FRandom[ExploS](-90,90);
|
||
origin = pos;
|
||
while ( totaldist > 0 )
|
||
{
|
||
LineTrace(ang,totaldist,pt,TRF_THRUACTORS|TRF_ABSPOSITION,origin.z,origin.x,origin.y,d);
|
||
HitNormal = SWWMUtility.GetLineTraceHitNormal(d);
|
||
totaldist -= d.Distance;
|
||
if ( totaldist > 0 )
|
||
{
|
||
Vector3 bounced = d.HitDir-(1.2*hitnormal*(d.HitDir dot HitNormal));
|
||
ang = atan2(bounced.y,bounced.x);
|
||
pt = asin(-bounced.z);
|
||
origin = d.HitLocation+hitnormal;
|
||
}
|
||
}
|
||
let p = Spawn("YnykronSingularityExplosion",d.HitLocation+hitnormal*4);
|
||
p.angle = atan2(hitnormal.y,hitnormal.x);
|
||
p.pitch = asin(-hitnormal.z);
|
||
p.target = target;
|
||
p.scale *= 1.+special1/40.;
|
||
}
|
||
}
|
||
|
||
Default
|
||
{
|
||
DamageType 'YnykronAlt';
|
||
Obituary "$O_YNYKRONALT";
|
||
+MISSILE;
|
||
Scale .4;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 A 1 BRIGHT A_SingularityTick();
|
||
Wait;
|
||
Death:
|
||
TNT1 A 0 A_SingularityBlast();
|
||
TNT1 A 1 A_SingularityExtraBlast();
|
||
Wait;
|
||
}
|
||
}
|
||
|
||
Class YnykronAltBeam : SWWMNonInteractiveActor
|
||
{
|
||
bool nospread;
|
||
|
||
void TraceOut()
|
||
{
|
||
Vector3 x = SWWMUtility.Vec3FromAngles(angle,pitch);
|
||
let t = new("YnykronAltTracer");
|
||
t.ignore = target;
|
||
t.ShootThroughList.Clear();
|
||
t.WaterHitList.Clear();
|
||
t.Trace(pos,cursector,x,speed,TRACE_HitSky);
|
||
foreach ( l:t.ShootThroughList )
|
||
{
|
||
l.Activate(target,0,SPAC_PCross);
|
||
l.Activate(target,0,SPAC_Impact);
|
||
}
|
||
foreach ( w:t.WaterHitList )
|
||
{
|
||
let b = Spawn("InvisibleSplasher",w.hitpos);
|
||
b.target = target;
|
||
b.A_CheckTerrain();
|
||
}
|
||
for ( int i=0; i<t.Results.Distance; i+=16 )
|
||
{
|
||
if ( Random[Ynykron](0,2) ) continue;
|
||
let b = Spawn("SWWMHalfSmoke",level.Vec3Offset(pos,x*i));
|
||
b.Scale *= FRandom[Ynykron](1.6,2.8);
|
||
b.special1 = Random[Ynykron](3,5);
|
||
b.A_SetRenderStyle(b.alpha*.3,STYLE_Subtract);
|
||
b.vel += x*FRandom[Ynykron](-.2,.4);
|
||
}
|
||
if ( t.Results.HitType == TRACE_HasHitSky )
|
||
{
|
||
// goodbye
|
||
nospread = true;
|
||
speed = t.Results.Distance; // shortens in minimap
|
||
return;
|
||
}
|
||
if ( t.Results.HitType != TRACE_HitNone )
|
||
{
|
||
// hit something
|
||
Vector3 norm = SWWMUtility.GetLineTracerHitNormal(t.Results);
|
||
if ( t.Results.HitType == TRACE_HitWall ) t.Results.HitLine.RemoteActivate(tracer,t.Results.Side,SPAC_Impact,t.Results.HitPos);
|
||
let b = Spawn("YnykronSingularity",level.Vec3Offset(t.Results.HitPos,norm*16));
|
||
b.target = target;
|
||
b.angle = atan2(norm.y,norm.x);
|
||
b.pitch = asin(-norm.z);
|
||
nospread = true;
|
||
speed = t.Results.Distance; // shortens in minimap
|
||
return;
|
||
}
|
||
if ( special1 >= 25600 )
|
||
{
|
||
// end of the line, dissipate
|
||
int numpt = Random[Ynykron](16,24);
|
||
for ( int i=0; i<numpt; i++ )
|
||
{
|
||
let b = Spawn("SWWMSmoke",level.Vec3Offset(pos,x*speed));
|
||
b.Scale *= FRandom[Ynykron](.6,1.8);
|
||
b.special1 = Random[Ynykron](1,2);
|
||
b.A_SetRenderStyle(.3,STYLE_Subtract);
|
||
b.vel += x*FRandom[Ynykron](0.,5.);
|
||
}
|
||
nospread = true;
|
||
return;
|
||
}
|
||
}
|
||
void SpreadOut()
|
||
{
|
||
if ( nospread ) return;
|
||
Vector3 x = SWWMUtility.Vec3FromAngles(angle,pitch);
|
||
// propagate
|
||
let next = Spawn("YnykronAltBeam",level.Vec3Offset(pos,x*speed));
|
||
next.angle = atan2(x.y,x.x);
|
||
next.pitch = asin(-x.z);
|
||
next.roll = roll;
|
||
next.target = target;
|
||
next.master = master;
|
||
next.special1 = special1+int(speed);
|
||
next.SetStateLabel("TrailSpawn");
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
special2 = Random[Ynykron](-1,0);
|
||
TraceOut();
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() ) return;
|
||
A_FadeOut(FRandom[Ynykron](.01,.02));
|
||
special2++;
|
||
if ( special2 == 1 )
|
||
SpreadOut();
|
||
if ( !CheckNoDelay() || (tics == -1) ) return;
|
||
if ( tics > 0 ) tics--;
|
||
while ( !tics )
|
||
{
|
||
if ( !SetState(CurState.NextState) )
|
||
return;
|
||
}
|
||
}
|
||
|
||
Default
|
||
{
|
||
RenderStyle "Subtract";
|
||
Alpha .4;
|
||
Speed 64;
|
||
+FORCEXYBILLBOARD;
|
||
+ROLLSPRITE;
|
||
+ROLLCENTER;
|
||
}
|
||
States
|
||
{
|
||
Spawn:
|
||
XZW1 A -1 Bright NoDelay
|
||
{
|
||
return FindState("StarterDev")+Random[Ynykron](0,3)*2;
|
||
}
|
||
Stop;
|
||
TrailSpawn:
|
||
XZW2 A -1 Bright
|
||
{
|
||
return FindState("TrailerDev")+Random[Ynykron](0,3)*2;
|
||
}
|
||
Stop;
|
||
StarterDev:
|
||
#### # 50 Bright;
|
||
XZW1 B -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW1 C -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW1 D -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW1 E -1 Bright;
|
||
Stop;
|
||
TrailerDev:
|
||
#### # 50 Bright;
|
||
XZW2 B -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW2 C -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW2 D -1 Bright;
|
||
Stop;
|
||
#### # 50 Bright;
|
||
XZW2 E -1 Bright;
|
||
Stop;
|
||
}
|
||
}
|
||
|
||
Class YnykronAltShot : SWWMNonInteractiveActor
|
||
{
|
||
void FlashPlayer( int str, double rad )
|
||
{
|
||
if ( !SWWMUtility.InPlayerFOV(players[consoleplayer],self,rad) ) return;
|
||
let mo = players[consoleplayer].Camera;
|
||
double dist = Distance3D(mo);
|
||
str = int(str*(1.-(dist/rad)));
|
||
SWWMHandler.DoFlash(mo,Color(str,255,255,255),5);
|
||
SWWMHandler.DoFlash(mo,Color(str/2,0,0,0),15);
|
||
}
|
||
override void PostBeginPlay()
|
||
{
|
||
A_QuakeEx(4,4,4,80,0,65535,"",QF_RELATIVE|QF_SCALEDOWN,falloff:65535,rollIntensity:.8);
|
||
A_StartSound("ynykron/altbeam",CHAN_VOICE,CHANF_DEFAULT,1.,0.);
|
||
FlashPlayer(240,8000);
|
||
let b = Spawn("YnykronAltBeam",pos);
|
||
b.target = target;
|
||
b.angle = angle;
|
||
b.pitch = pitch;
|
||
}
|
||
override void Tick()
|
||
{
|
||
if ( freezetics > 0 )
|
||
{
|
||
freezetics--;
|
||
return;
|
||
}
|
||
if ( isFrozen() || IsActorPlayingSound(CHAN_VOICE,-1) ) return;
|
||
Destroy();
|
||
}
|
||
}
|