Marisa the Magician
c77504b9a2
Add DE_NONEXPLOSIVE flag to DoExplosion. Treats damage as "not explosive" (This makes detecting what is or isn't an explosive damage source easier).
636 lines
14 KiB
Text
636 lines
14 KiB
Text
// player effects
|
|
|
|
// drop from monsters when using "Demoslayer" fun option
|
|
Class SlayerOrb : Actor abstract
|
|
{
|
|
Class<Actor> tclass;
|
|
|
|
Property TrailClass : tclass;
|
|
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Radius 4;
|
|
Height 8;
|
|
Scale .5;
|
|
BounceFactor .75;
|
|
WallBounceFactor .75;
|
|
Gravity .35;
|
|
PROJECTILE;
|
|
+THRUACTORS;
|
|
-NOGRAVITY;
|
|
+NOTELEPORT;
|
|
+DONTSPLASH;
|
|
+BOUNCEONWALLS;
|
|
+BOUNCEONFLOORS;
|
|
+BOUNCEONCEILINGS;
|
|
+CANBOUNCEWATER;
|
|
+FORCEXYBILLBOARD;
|
|
}
|
|
virtual void PickedUp( int np, PlayerPawn mo )
|
|
{
|
|
}
|
|
override void Tick()
|
|
{
|
|
Vector3 oldp = pos;
|
|
Super.Tick();
|
|
if ( !isFrozen() )
|
|
{
|
|
let t = Spawn(tclass,pos);
|
|
t.scale *= abs(scale.x);
|
|
t.alpha *= alpha;
|
|
scale *= .995;
|
|
alpha = abs(scale.x)*2.;
|
|
if ( abs(scale.x) < .1 )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
}
|
|
int np = -1;
|
|
double mdist = 1000.;
|
|
for ( int i=0; i<MAXPLAYERS; i++ )
|
|
{
|
|
if ( !playeringame[i] || (players[i].Health <= 0) || !players[i].mo || !CheckSight(players[i].mo,SF_IGNOREVISIBILITY|SF_IGNOREWATERBOUNDARY) ) continue;
|
|
double dist = Distance3D(players[i].mo);
|
|
if ( dist > mdist ) continue;
|
|
mdist = dist;
|
|
np = i;
|
|
}
|
|
if ( np == -1 ) return;
|
|
let mo = players[np].mo;
|
|
if ( (GetAge() > 5) && SWWMUtility.BoxIntersect(self,mo,pad:8) )
|
|
{
|
|
PickedUp(np,mo);
|
|
Destroy();
|
|
return;
|
|
}
|
|
if ( isFrozen() ) return;
|
|
Vector3 dirto = level.Vec3Diff(pos,mo.Vec3Offset(0,0,mo.Height/2));
|
|
double distto = dirto.length();
|
|
dirto /= distto;
|
|
double fact = ((1000.-distto)/1000.)**2.;
|
|
vel *= 1.-.05*fact;
|
|
vel += (dirto+(0,0,.1))*fact*2.;
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
SpriteOffset = (0,-4);
|
|
Scale.x *= RandomPick[Junk](-1,-1);
|
|
Scale.y *= RandomPick[Junk](-1,-1);
|
|
}
|
|
}
|
|
Class HealthOrb : SlayerOrb
|
|
{
|
|
Default
|
|
{
|
|
SlayerOrb.TrailClass "HealthOrbTrail";
|
|
}
|
|
override void PickedUp( int np, PlayerPawn mo )
|
|
{
|
|
int flg = CHANF_OVERLAP|CHANF_MAYBE_LOCAL;
|
|
if ( mo.CheckLocalView() ) flg |= CHANF_NOPAUSE;
|
|
mo.A_StartSound("misc/health_pkup",CHAN_ITEM,flg);
|
|
int hp = int(ceil(abs(scale.x*10)));
|
|
mo.GiveBody(hp,100);
|
|
SWWMHandler.HealthFlash(np);
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPF E -1 Bright;
|
|
Stop;
|
|
|
|
}
|
|
}
|
|
Class ArmorOrb : SlayerOrb
|
|
{
|
|
Default
|
|
{
|
|
SlayerOrb.TrailClass "ArmorOrbTrail";
|
|
}
|
|
override void PickedUp( int np, PlayerPawn mo )
|
|
{
|
|
int flg = CHANF_OVERLAP|CHANF_MAYBE_LOCAL;
|
|
if ( mo.CheckLocalView() ) flg |= CHANF_NOPAUSE;
|
|
mo.A_StartSound("misc/armor_pkup",CHAN_ITEM,flg);
|
|
int hp = int(ceil(abs(scale.x*10)));
|
|
let n = mo.FindInventory("ArmorNugget");
|
|
if ( !n )
|
|
{
|
|
n = Inventory(Spawn("ArmorNugget"));
|
|
n.AttachToOwner(mo);
|
|
SWWMLoreLibrary.Add(mo.player,"Nugget");
|
|
n.Amount = 0;
|
|
}
|
|
if ( n.Amount < 100 ) n.Amount = min(n.Amount+hp,100);
|
|
SWWMHandler.ArmorFlash(np);
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPF D -1 Bright;
|
|
Stop;
|
|
|
|
}
|
|
}
|
|
Class AmmoOrb : SlayerOrb
|
|
{
|
|
Default
|
|
{
|
|
SlayerOrb.TrailClass "AmmoOrbTrail";
|
|
}
|
|
override void PickedUp( int np, PlayerPawn mo )
|
|
{
|
|
int flg = CHANF_OVERLAP|CHANF_MAYBE_LOCAL;
|
|
if ( mo.CheckLocalView() ) flg |= CHANF_NOPAUSE;
|
|
mo.A_StartSound("misc/ammo_pkup",CHAN_ITEM,flg);
|
|
int tier = int(ceil(abs(scale.x*10)));
|
|
Class<Inventory> cls = "FabricatorTier1";
|
|
if ( tier >= 4 ) cls = "FabricatorTier3";
|
|
else if ( tier >= 2 ) cls = "FabricatorTier2";
|
|
let f = Inventory(Spawn(cls));
|
|
f.bQUIET = true;
|
|
if ( !f.CallTryPickup(mo) ) f.Destroy();
|
|
mo.player.bonuscount = Inventory.BONUSADD;
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPF A -1 Bright;
|
|
Stop;
|
|
|
|
}
|
|
}
|
|
|
|
Class SlayerOrbTrail : Actor abstract
|
|
{
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Radius .1;
|
|
Height 0.;
|
|
Scale .25;
|
|
Alpha .5;
|
|
+FORCEXYBILLBOARD;
|
|
+NOGRAVITY;
|
|
+NOBLOCKMAP;
|
|
+DONTSPLASH;
|
|
+NOTELEPORT;
|
|
+NOINTERACTION;
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
alpha *= .9;
|
|
scale *= 1.05;
|
|
if ( alpha < .05 ) Destroy();
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
SpriteOffset = (0,-4);
|
|
}
|
|
}
|
|
Class HealthOrbTrail : SlayerOrbTrail
|
|
{
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPS E -1 Bright;
|
|
Stop;
|
|
}
|
|
}
|
|
Class ArmorOrbTrail : SlayerOrbTrail
|
|
{
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPS D -1 Bright;
|
|
Stop;
|
|
}
|
|
}
|
|
Class AmmoOrbTrail : SlayerOrbTrail
|
|
{
|
|
States
|
|
{
|
|
Spawn:
|
|
BLPS A -1 Bright;
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// simple object for moving a dropped item towards the player
|
|
Class SWWMMagItem play
|
|
{
|
|
SWWMMagItem next;
|
|
Inventory item;
|
|
Demolitionist target;
|
|
|
|
bool Tick()
|
|
{
|
|
if ( !target || (target.Health <= 0) ) return true;
|
|
if ( !item || item.Owner || !item.bSPECIAL || item.bINVISIBLE || !SWWMUtility.SphereIntersect(target,item.pos,800) || !target.CheckSight(item,SF_IGNOREVISIBILITY|SF_IGNOREWATERBOUNDARY) ) return true;
|
|
Class<Inventory> cls = item.GetClass();
|
|
if ( item is 'Ammo' ) cls = Ammo(item).GetParentAmmo();
|
|
else if ( item is 'MaGammo' ) cls = MagAmmo(item).GetParentMagAmmo();
|
|
let oi = target.FindInventory(cls);
|
|
if ( !item.bALWAYSPICKUP && oi && (oi.Amount >= oi.MaxAmount) ) return true;
|
|
if ( (item is 'SWWMWeapon') && SWWMWeapon(item).HasSwapWeapon(target) && swwm_swapweapons ) return true;
|
|
if ( (item is 'SWWMDualWeaponGiver') && SWWMDualWeaponGiver(item).HasSwapWeapon(target) && swwm_swapweapons ) return true;
|
|
Vector3 dirto = level.Vec3Diff(item.pos,target.Vec3Offset(0,0,target.height/2));
|
|
double dist = dirto.length();
|
|
if ( SWWMUtility.BoxIntersect(item,target) )
|
|
{
|
|
item.Touch(target);
|
|
return false;
|
|
}
|
|
dirto /= dist;
|
|
double fact = clamp(dist/800.,0.,1.)**.5;
|
|
item.vel *= .75;
|
|
item.vel += dirto*SWWMUtility.Lerp(8.,1.,fact);
|
|
item.A_SoundVolume(CHAN_AMBEXTRA,1.-.8*fact);
|
|
item.A_SoundPitch(CHAN_AMBEXTRA,SWWMUtility.Lerp(2.,.5,fact));
|
|
return false;
|
|
}
|
|
|
|
override void OnDestroy()
|
|
{
|
|
if ( !item ) return;
|
|
if ( item.bSPECIAL )
|
|
item.bNOGRAVITY = item.default.bNOGRAVITY;
|
|
item.A_StopSound(CHAN_AMBEXTRA);
|
|
}
|
|
}
|
|
|
|
Class DashTrail : Actor
|
|
{
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Radius .1;
|
|
Height 0.;
|
|
Scale 0.3;
|
|
+NOGRAVITY;
|
|
+NOBLOCKMAP;
|
|
+DONTSPLASH;
|
|
+NOTELEPORT;
|
|
+NOINTERACTION;
|
|
+MASTERNOSEE;
|
|
FloatBobPhase 0;
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
SetState(FindState("Spawn")+Random[ExploS](0,7));
|
|
if ( waterlevel > 0 ) return;
|
|
let t = Spawn("DashTrail2",level.Vec3Offset(pos,vel*.3));
|
|
t.master = master;
|
|
t.vel = vel*1.2;
|
|
let s = Spawn("SWWMSmoke",level.Vec3Offset(pos,vel*1.6));
|
|
s.vel = vel*.8;
|
|
s.SetShade(Color(1,1,1)*Random[ExploS](64,128));
|
|
s.special1 = Random[ExploS](2,4);
|
|
s.scale *= 1.4;
|
|
s.alpha *= .3;
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
prev = pos;
|
|
SetOrigin(level.Vec3Offset(pos,vel),true);
|
|
UpdateWaterLevel();
|
|
if ( !CheckNoDelay() || (tics == -1) ) return;
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
JFLB ABCDEFGH 1 Bright
|
|
{
|
|
A_FadeOut(.2);
|
|
A_SetScale(scale.x*.95);
|
|
}
|
|
Loop;
|
|
}
|
|
}
|
|
|
|
Class DashTrail2 : Actor
|
|
{
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Radius .1;
|
|
Height 0.;
|
|
Scale 0.2;
|
|
Alpha 0.4;
|
|
+NOGRAVITY;
|
|
+NOBLOCKMAP;
|
|
+DONTSPLASH;
|
|
+NOTELEPORT;
|
|
+NOINTERACTION;
|
|
+MASTERNOSEE;
|
|
FloatBobPhase 0;
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
SetState(FindState("Spawn")+Random[ExploS](0,7));
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
prev = pos;
|
|
SetOrigin(level.Vec3Offset(pos,vel),true);
|
|
UpdateWaterLevel();
|
|
if ( !CheckNoDelay() || (tics == -1) ) return;
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
JFLR ABCDEFGH 1 Bright
|
|
{
|
|
A_FadeOut(.02);
|
|
A_SetScale(scale.x*1.04);
|
|
if ( waterlevel > 0 )
|
|
{
|
|
let b = Spawn("SWWMBubble",pos);
|
|
b.vel = vel;
|
|
b.scale *= scale.x;
|
|
Destroy();
|
|
}
|
|
}
|
|
Loop;
|
|
}
|
|
}
|
|
|
|
Class DemolitionistRadiusShockwaveTail : Actor
|
|
{
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Radius 16;
|
|
Height 8;
|
|
+NOBLOCKMAP;
|
|
+NOGRAVITY;
|
|
+DONTSPLASH;
|
|
+NOTELEPORT;
|
|
+NOINTERACTION;
|
|
}
|
|
override void Tick()
|
|
{
|
|
if ( isFrozen() ) return;
|
|
prev = pos;
|
|
SetOrigin(level.Vec3Offset(pos,vel),true);
|
|
if ( !CheckNoDelay() || (tics == -1) ) return;
|
|
if ( tics > 0 ) tics--;
|
|
while ( !tics )
|
|
{
|
|
if ( !SetState(CurState.NextState) )
|
|
return;
|
|
}
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 A 1
|
|
{
|
|
pitch = min(85,(pitch+2)*1.05);
|
|
A_FadeOut(.02);
|
|
A_SetScale(scale.x*1.08,scale.y);
|
|
vel *= .98;
|
|
}
|
|
Wait;
|
|
}
|
|
}
|
|
|
|
Class DemolitionistRadiusShockwave : Actor
|
|
{
|
|
Actor lasthit;
|
|
|
|
Default
|
|
{
|
|
RenderStyle "Add";
|
|
Speed 15;
|
|
DamageFunction int(200*alpha);
|
|
DamageType "GroundPound";
|
|
Radius 16;
|
|
Height 8;
|
|
Alpha .4;
|
|
XScale .65;
|
|
YScale 3.;
|
|
PROJECTILE;
|
|
+DONTSPLASH;
|
|
+STEPMISSILE;
|
|
+NOEXPLODEFLOOR;
|
|
+FLATSPRITE;
|
|
+RIPPER;
|
|
+BLOODLESSIMPACT;
|
|
-NOGRAVITY;
|
|
}
|
|
override int DoSpecialDamage( Actor target, int damage, Name damagetype )
|
|
{
|
|
if ( target == lasthit ) return 0;
|
|
lasthit = target;
|
|
if ( damage <= 0 ) return damage;
|
|
if ( (target.mass < LARGE_MASS) && !target.bDONTTHRUST )
|
|
{
|
|
target.vel.xy += vel.xy.unit()*(30000./max(50,target.mass))*alpha;
|
|
if ( (target.pos.z <= floorz) || !target.TestMobjZ() )
|
|
target.vel.z += (4000./max(50,target.mass))*alpha;
|
|
}
|
|
return damage;
|
|
}
|
|
States
|
|
{
|
|
Spawn:
|
|
XZW1 A 1
|
|
{
|
|
SetZ(floorz);
|
|
pitch = min(85,(pitch+2)*1.05);
|
|
if ( !Random[ExploS](0,3) )
|
|
Spawn("InvisibleSplasher",Vec3Offset(0,0,2));
|
|
let s = Spawn("DemolitionistRadiusShockwaveTail",pos);
|
|
s.vel = vel*.35;
|
|
s.scale = scale;
|
|
s.alpha = alpha*.4;
|
|
s.angle = angle;
|
|
s.pitch = pitch;
|
|
s.roll = roll;
|
|
A_FadeOut(.015);
|
|
A_SetScale(scale.x*1.08,scale.y);
|
|
vel *= .98;
|
|
}
|
|
Wait;
|
|
Death:
|
|
XZW1 A 1
|
|
{
|
|
SetZ(floorz);
|
|
A_FadeOut(.05);
|
|
A_SetScale(scale.x*1.1,scale.y*.97);
|
|
}
|
|
Wait;
|
|
}
|
|
}
|
|
|
|
Class DemolitionistShockwave : Actor
|
|
{
|
|
Default
|
|
{
|
|
+NOGRAVITY;
|
|
+NOBLOCKMAP;
|
|
+NOTELEPORT;
|
|
+NODAMAGETHRUST;
|
|
+FORCERADIUSDMG;
|
|
+NOINTERACTION;
|
|
Radius .1;
|
|
Height 0.;
|
|
}
|
|
override void PostBeginPlay()
|
|
{
|
|
Super.PostBeginPlay();
|
|
A_QuakeEx(7,7,7,30,0,300+min(special1,50)*4,"",QF_RELATIVE|QF_SCALEDOWN|QF_3D,falloff:200,rollIntensity:1.5);
|
|
if ( target.player != players[consoleplayer] )
|
|
{
|
|
A_StartSound("demolitionist/hardland",CHAN_FOOTSTEP,CHANF_OVERLAP,attenuation:.3);
|
|
A_StartSound("demolitionist/hardland",CHAN_FOOTSTEP,CHANF_OVERLAP,attenuation:.2,pitch:.7);
|
|
A_StartSound("demolitionist/hardland",CHAN_FOOTSTEP,CHANF_OVERLAP,attenuation:.1,pitch:.4);
|
|
}
|
|
SWWMUtility.DoExplosion(self,40+min(special1,120),100000+min(special1*2000,150000),100+min(special1*2,130),80,DE_BLAST|DE_EXTRAZTHRUST|DE_NONEXPLOSIVE,'GroundPound',target);
|
|
for ( int i=0; i<360; i+=5 )
|
|
{
|
|
Vector3 pvel = SWWMUtility.Vec3FromAngles(FRandom[ExploS](0,360),FRandom[ExploS](-90,90))*FRandom[ExploS](1,3);
|
|
let s = Spawn("SWWMSmoke",Vec3Angle(4,i,8));
|
|
s.vel = pvel+SWWMUtility.AngleToVector3(i,7.);
|
|
s.SetShade(Color(1,1,1)*Random[ExploS](64,224));
|
|
s.special1 = Random[ExploS](1,4);
|
|
s.scale *= 1.5;
|
|
s.alpha *= .4;
|
|
}
|
|
if ( pos.z > floorz+16 ) return;
|
|
for ( int i=0; i<360; i+=5 )
|
|
{
|
|
let r = Spawn("DemolitionistRadiusShockwave",Vec3Angle(5,i));
|
|
r.target = target;
|
|
r.angle = i;
|
|
r.vel.xy = AngleToVector(i,r.speed+min(special1*.15,30));
|
|
r.alpha *= .1+min(special1*.03,.9);
|
|
}
|
|
int numpt = Random[ExploS](10,20);
|
|
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("SWWMChip",pos);
|
|
s.vel = pvel;
|
|
}
|
|
let raging = RagekitPower(target.FindInventory("RagekitPower"));
|
|
if ( raging || swwm_omnibust )
|
|
{
|
|
// bust the floor if we can
|
|
let tempme = new("LineTracer"); // gross hack to pass needed data
|
|
int dmg = 40+min(special1,120);
|
|
if ( raging ) dmg *= 8;
|
|
F3DFloor ff;
|
|
for ( int i=0; i<FloorSector.Get3DFloorCount(); i++ )
|
|
{
|
|
if ( !(FloorSector.Get3DFloor(i).top.ZAtPoint(pos.xy) ~== floorz) ) continue;
|
|
ff = FloorSector.Get3DFloor(i);
|
|
break;
|
|
}
|
|
if ( ff ) tempme.Results.ffloor = ff;
|
|
tempme.Results.HitSector = FloorSector;
|
|
tempme.Results.HitType = TRACE_HitFloor;
|
|
BusterWall.Bust(tempme.Results,dmg,target,(0,0,-1),pos.z);
|
|
if ( raging )
|
|
{
|
|
let ps = Spawn("BigPunchSplash",pos);
|
|
ps.damagetype = 'GroundPound';
|
|
ps.target = target;
|
|
ps.special1 = dmg;
|
|
raging.DoHitFX();
|
|
}
|
|
}
|
|
}
|
|
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 140;
|
|
Stop;
|
|
}
|
|
}
|
|
|
|
// not an actual light, just handles the attach/detach
|
|
Class DemolitionistSelfLight : Thinker
|
|
{
|
|
bool oldactive;
|
|
bool oldglow;
|
|
Actor target;
|
|
transient CVar tagcolor;
|
|
|
|
override void Tick()
|
|
{
|
|
if ( !target || !target.player || (target.player.mo != target) || !(target is 'Demolitionist') || (Demolitionist(target).selflight != self) )
|
|
{
|
|
Destroy();
|
|
return;
|
|
}
|
|
if ( !tagcolor ) tagcolor = CVar.GetCVar('swwm_tagcolor',target.player);
|
|
static const Color litecolor[] =
|
|
{
|
|
Color(255,32,48,24), // Green
|
|
Color(255,24,24,48), // Blue
|
|
Color(255,24,48,48), // Cyan
|
|
Color(255,24,48,32), // Dragonfly
|
|
Color(255,48,40,24), // Gold
|
|
Color(255,48,24,48), // Magenta
|
|
Color(255,48,32,24), // Orange
|
|
Color(255,48,40,32), // Peach
|
|
Color(255,48,32,40), // Pink
|
|
Color(255,32,24,48), // Purple
|
|
Color(255,48,24,24), // Red
|
|
Color(255,32,24,48), // Violet
|
|
Color(255,48,48,48), // White
|
|
Color(255,48,48,24) // Yellow
|
|
};
|
|
int idx = tagcolor.GetInt();
|
|
if ( (idx < 0) || (idx >= litecolor.Size()) ) idx = 0;
|
|
bool curactive = !(target.bINVISIBLE || (target.alpha <= double.epsilon));
|
|
// setting the pitch to a value outside [-90,90] makes it auto-update to the actor's own pitch
|
|
// this is undocumented and it's very great and nice and fine that such a thing had to be found out purely by chance
|
|
// how very wonderful /s
|
|
if ( curactive && !oldactive )
|
|
{
|
|
target.A_AttachLight('DemoSelfLight',DynamicLight.PointLight,Color(112,144,176),200,0,DynamicLight.LF_DONTLIGHTSELF|DynamicLight.LF_ATTENUATE|DynamicLight.LF_SPOT,(5,0,target.player?(target.player.viewz-target.pos.z):(target.height*.93)),0,15,60,180);
|
|
target.A_AttachLight('DemoSelfLight2',DynamicLight.PointLight,litecolor[idx],80,0,DynamicLight.LF_DONTLIGHTSELF|DynamicLight.LF_ATTENUATE,(0,0,target.height/2));
|
|
}
|
|
else if ( !curactive && oldactive )
|
|
{
|
|
target.A_AttachLight('DemoSelfLight',DynamicLight.PointLight,0,0,0);
|
|
target.A_AttachLight('DemoSelfLight2',DynamicLight.PointLight,0,0,0);
|
|
}
|
|
oldactive = curactive;
|
|
}
|
|
}
|