Пример #1
0
global func BlueExplosionEffect(int level, int x, int y)
{
	var glimmer =
	{
		Prototype = Particles_Glimmer(),
		R = PV_Random(100, 150),
		G = PV_Random(100, 150),
		B = PV_Random(200, 255)
	};
	var fire =
	{
		Prototype = Particles_Fire(),
		R = PV_Random(100, 150),
		G = PV_Random(100, 150),
		B = PV_Random(200, 255),
		Size = PV_Random(level/2, level/3)
	};
	var smoke =
	{
		Prototype = Particles_SmokeTrail(),
		R = PV_Linear(PV_Random(100, 150), 0),
		G = PV_Linear(PV_Random(100, 150), 0),
		B = PV_Linear(PV_Random(200, 255), 0),
		Size = PV_Random(level - 5, level + 5)
	};
	// Blast particle.
	CreateParticle("SmokeDirty", x, y, PV_Random(-2, 2), PV_Random(-2, 2), PV_Random(20, 40), smoke, 10);
	CreateParticle("MagicFire", x, y, PV_Random(-20, 20), PV_Random(-20, 20), PV_Random(5, 10), fire, 20);
	if(!GBackLiquid(x,y)) CreateParticle("SphereSpark", x, y, PV_Random(-100, 100), PV_Random(-100, 100), PV_Random(5, 36 * 3), glimmer, level);

	if(GBackLiquid(x,y)) CastObjects(Fx_Bubble, level * 4 / 10, level, x, y);
	return;
}
Пример #2
0
func FxParticlesStop(object target, proplist effect, int reason, bool temporary)
{
	if(temporary)
		return;

	SetSolidMask();
	
	var props = 
	{
		Size = PV_Linear(4, 0),
	    ForceY = GetGravity(),
		Stretch = PV_Speed(1000, 500),
		Rotation = PV_Direction(),
		OnCollision = PC_Die(),
		CollisionVertex = 0,
	    R = 100,
	    G = 100,
	    B = 100,
		BlitMode = GFX_BLIT_Additive,
	};
	CreateParticle("Smoke", 0, 0, PV_Random(-10 , 10), PV_Random(-10, 20), 50, props, 10);
	
	var smoke = 
	{
		ForceX = PV_Wind(200 - 180),
		DampingX = 900, DampingY = 900,
		Alpha = PV_Linear(255, 0),
		R = 100, G = 100, B = 100,
		Size = PV_Linear(PV_Random(4, 10), PV_Random(20, 30)),
		Phase = PV_Random(0, 15)
	};
	CreateParticle("Smoke", PV_Random(-5,5), PV_Random(-5,5), PV_Random(-15, 15), PV_Random(-15, 15), 30, smoke, 15);
}
Пример #3
0
func FxLifeStop(object target, proplist effect, int reason, bool temporary)
{
	if(temporary)
		return;
	
	var prt = {
		Size = 15,
		Alpha = PV_Linear(255, 0),
		Rotation = PV_Step(15, PV_Random(0, 360)),
		ForceY = GetGravity()
	};
	CreateParticle("SawbladePrt", 0, 0, PV_Random(-35, 35), PV_Random(-35, 5), 40, prt, 6);
	
	var prt2 =	{
		Size = PV_Linear(2, 0),
	    ForceY = GetGravity(),
		Stretch = PV_Speed(1000, 500),
		Rotation = PV_Direction(),
	    R = 255,
	    G = PV_Linear(128,32),
	    B = PV_Random(0, 128, 2),
	    Alpha = PV_Random(255,0,3),
		BlitMode = GFX_BLIT_Additive,
	};
	
	CreateParticle("Flash", 0, 0, PV_Random(-35, 35), PV_Random(-35, 5), 70, prt2, 20);
	
	Sound("sawblade_destroyed", false, 50);
	RemoveObject();
}
Пример #4
0
func Intro_PlaneHit()
{
	// Plane hit ground! Continue sequence.
	Sound("Objects::Plane::PlaneCrash", true);
	SetR(-90);
	var particles = Particles_Smoke(true);
	particles.Size = PV_Linear(PV_Random(20, 60), PV_Random(50, 100));
	CreateParticle("Smoke", PV_Random(-30,30), PV_Random(-30,30), PV_Random(-60, 60), PV_Random(-20,0), PV_Random(200, 500), particles, 20);
	particles.Size = PV_Linear(PV_Random(50, 80), PV_Random(100, 200));
	CreateParticle("Smoke", PV_Random(-30,30), PV_Random(-30,30), PV_Random(-20, 20), PV_Random(-20,0), PV_Random(100, 200), particles, 20);
	for (var iplr=0,plr; iplr<GetPlayerCount(C4PT_User); ++iplr)
	{
		plr = GetPlayerByIndex(iplr, C4PT_User);
		var icrew=0,crew;
		while (crew=GetCrew(plr, icrew++))
		{
			crew->Exit(0,-5, 0, Random(1)+1, Random(5)-6);
			crew->SetAction("Tumble");
		}
	}
	SetMeshMaterial("CrashedAirplane");
	this.MeshTransformation=Trans_Mul(Trans_Rotate(10,0,2,1), Airplane.MeshTransformation);
	this.Hit = this.intro_seq.plane_Hit;
	this.intro_seq.plane_crashed = true;
	this.intro_seq->ScheduleNext(50);
	return true;
}
Пример #5
0
func CreateMuzzleFlash(int x, int y, int angle, int size)
{
	// main muzzle flash
	CreateParticle("MuzzleFlash", x, y, 0, 0, 10, {Prototype = Particles_MuzzleFlash(), Size = size, Rotation = angle});
	// and some additional little sparks
	var xdir = Sin(angle, size * 2);
	var ydir = -Cos(angle, size * 2);
	CreateParticle("StarFlash", x, y, PV_Random(xdir - size, xdir + size), PV_Random(ydir - size, ydir + size), PV_Random(5, 15), Particles_Glimmer(), size);
}
Пример #6
0
protected func SmokeTrail() {
  Smoke(0, 0, 2);
  Smoke(0, -5, Random(3));
  var i = Random(20);
  while (i--) {
    var c = (20+Random(41))/2;
    CreateParticle("PxSpark", Random(11)-5, Random(11)-5, 0, 0, c,
      RGBa(255, Random(100), c*4, 128));
  }
  CreateParticle("PxSpark", 0, 0, 0, 0, 20,
    RGBa(255, 155, 0, 128));
  //Bitte hier Schaden für Wipfe setzen
  //*99/100 = Grenzwertig stark, *98/100=Meistens 0 Schaden
  SetYDir(GetYDir(this, 1000)*982/1000, this, 1000);
}
Пример #7
0
void Emitter::Update(double elapsed)
{	
	Array<int> deleteParticles;

	if (emitting) 
	{
		int nParticles = (minrate + (maxrate - minrate) * (float)rand() / RAND_MAX) * elapsed;	
        for (int i = 0; i < nParticles; i++) 
            particles.Add(CreateParticle());        
	}	    

    for (int i = 0; i < particles.Size(); i++) 
	{
		particles[i]->Update(elapsed);

		for (uint8 a = 0; a < affectors.Size(); a++)
			if (affectors[a]->IsCollide(particles[i])) affectors[a]->AffectParticle(particles[i]);

        if ( particles[i]->GetLifetime() <= 0 )
            deleteParticles.Add(i);
	}

    for (int i = 0; i < deleteParticles.Size(); i++ ) 
    {    		
		for (uint8 a = 0; a < affectors.Size(); a++)
			affectors[a]->DeleteAffectedParticle(particles[i]);

		particles.RemoveAt(i);
	}
							
}
//-----------------------------------------------------------------------------
// The animation events will create particles on the attachment points
//-----------------------------------------------------------------------------
void C_EnvParticleScript::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
	// Handle events to create + destroy particles
	switch( event )
	{
	case CL_EVENT_SPRITEGROUP_CREATE:
		{
			char pAttachmentName[256];
			char pSpriteName[256];
			int nArgs = sscanf( options, "%255s %255s", pAttachmentName, pSpriteName );
			if ( nArgs == 2 )
			{
				CreateParticle( pAttachmentName, pSpriteName );
			}
		}
		return;

	case CL_EVENT_SPRITEGROUP_DESTROY:
		{
			char pAttachmentName[256];
			int nArgs = sscanf( options, "%255s", pAttachmentName );
			if ( nArgs == 1 )
			{
				DestroyAllParticles( pAttachmentName );
			}
		}
		return;
	}

	// Fall back
	BaseClass::FireEvent( origin, angles, event, options );
}
Пример #9
0
void NNParticleSystem::Update( float dTime )
{
	NNObject::Update( dTime );

	if ( mIsCreate == true )
	{
		mTimer += dTime;
		if ( mTimer >= 1.f/mCreateParticlePerSecond)
		{
			for (int i=0; i< 2*dTime*mCreateParticlePerSecond/(mMinLifeTime+mMaxLifeTime); i++ )
			{
				CreateParticle();
			}
			mTimer = 0.f;
		}
	}

	for (auto& iter=mParticleList.begin(); iter!=mParticleList.end(); iter++ )
	{
		(*iter)->Update( dTime );
		if ( (*iter)->GetNowLifeTime() > (*iter)->GetLifeTime() )
		{
			delete *iter;
			iter = mParticleList.erase( iter );
			if ( iter == mParticleList.end() )
			{
				break;
			}
		}
	}
}
Пример #10
0
void dfParticleSystem::Update()
{
	dfComponent::Init();
	
	if(active)
	{
		timer += dfDeltaTime;

		if(timer > nextParticleTime && numParticles < maxActiveParticles)
		{
			CreateParticle();
			nextParticleTime =  minSecondsBetweenParticles + (dfRand() * (maxSecondsBetweenParticles - minSecondsBetweenParticles));
		}
	}

	for(int i = 0; i < numParticles; i++)
	{
		if(particles[i].color.x == 1 && particles[i].color.y == 1 && particles[i].color.z == 1)
			int fut = 4;

		if(!particles[i].dead)
		{
			UpdateParticle(particles[i], i);
		}
	}
}
Пример #11
0
func InitEffect()
{
    Sound("Fire::Fireball", false, 100, nil, nil, nil, 200);
    Sound("Fire::FuseLoop", false, 20, nil, 1, nil, 200);
    SetLightRange(30, 70);
    SetLightColor(RGB(100, 100, 255));

    var snow =
    {
        R = 200,
        G = 200,
        B = 255,
        Alpha = PV_Linear(255, 0),
        Size = PV_Random(0, 2),
        CollisionVertex = 0,
        OnCollision = PC_Stop(),
        ForceX = PV_Random(-5, 5, 10),
        ForceY = PV_Gravity(100),
        DampingX = 900, DampingY = 900
    };

    trail_particles =
    {
        R = PV_Random(200, 255), G = PV_Random(200, 255), B = 255,
        Prototype = Particles_FireTrail(),
        Size = PV_Linear(10, 0),
        BlitMode = nil,
        Rotation = PV_Random(0, 360),
        BlitMode = GFX_BLIT_Additive
    };

    CreateParticle("StarFlash", 0, 0, PV_Random(-30, 30), PV_Random(-30, 30), 100, snow, 100);
}
Пример #12
0
func Initialize()
{
  var iTimeout,pWipf;
  SetGamma(RGB(15,15,15),RGB(118,118,118),RGB(215,215,215));
  SetSkyParallax(0,15,17,0,0,0,0); 
  //Handgemacht... ;)
  Meeresrauschen(170);
  Meeresrauschen(1100);
  Meeresrauschen(2060);
  Meeresrauschen(2900);
  Meeresrauschen(3800);
  Meeresrauschen(4800);
  Meeresrauschen(5700);
  Moewen(900);
  Moewen(2300);
  Moewen(3900);
  Moewen(5000);
  //Nebel platzieren
  for(var i;i<260;++i) 
    CreateParticle("Fog",Random(LandscapeWidth()),Random(LandscapeHeight()*2/3),RandomX(3,9),0,RandomX(1000,1500));
  //Wipfe platzieren
  while(pWipf=FindObject(WIPF,0,0,0,0,0,0,0,0,pWipf)) {
    iTimeout=0;
    while(Stuck(pWipf)||GetMaterial(GetX(pWipf),GetY(pWipf))!=Material("Tunnel")) {
      SetPosition(Random(LandscapeWidth()),RandomX(LandscapeHeight()*2/3,LandscapeHeight()),pWipf);
      if(iTimeout++ > 50000) { RemoveObject(pWipf); break; }
    }
  }  
  ScriptGo(1);
}
Пример #13
0
VParticleWallmark* VWallmarkManager::CreateWallmark(
    VTextureObject *pTexture, VIS_TransparencyType eBlending,
    const hkvVec3& vCenter, const hkvMat3 &alignment,
    VColorRef color, float fLifetime, float fFadeOutTime, bool bApplyDeferredLighting)
{
  VISION_PROFILE_FUNCTION(PROFILING_WALLMARK_CREATION);
  VParticleWallmark* p = CreateParticle(pTexture,eBlending,bApplyDeferredLighting,vCenter,true);
  p->pos[0] = vCenter.x;
  p->pos[1] = vCenter.y;
  p->pos[2] = vCenter.z;
  p->color = color;
  
  hkvVec3 normal = alignment.getAxis(0);
  hkvVec3 right = alignment.getAxis(1);
  hkvVec3 up = alignment.getAxis(2);
  p->size = up.getLength()*2.f;
  normal.normalizeIfNotZero();
  p->normal[0] = normal.x;
  p->normal[1] = normal.y;
  p->normal[2] = normal.z;
  p->distortion[0] = right.x*2.f;
  p->distortion[1] = right.y*2.f;
  p->distortion[2] = right.z*2.f;

  p->velocity[0] = fLifetime + fFadeOutTime;
  p->velocity[1] = fFadeOutTime;
  p->velocity[2] = (float)color.a; // original alpha (255 based)
  return p;
}
Пример #14
0
func CheckForEnemies(Size)
{
	for(var o in FindObjects(Find_Distance(Size), Find_Func("CanBeHit", this)))
	{
		if(o->GetOwner() == GetOwner() || GetEffect("BallHitCD", o))
			continue;
		
		o->AddBallHitEffect();
		o->Fling(0, -2);
		AddEffect("BallHitCD", o, 1, 15);
		
		var trailparticles =
		{
			Prototype = Particles_ElectroSpark2(),
			Size = PV_Linear(PV_Random(5,15),0),
			BlitMode = GFX_BLIT_Additive,
			Rotation = PV_Random(0,360),
			R = pR,
			G = pG,
			B = pB,
		};
		
		CreateParticle("Lightning", o->GetX() - GetX(), o->GetY() - GetY(), 0, 0, 10, trailparticles, 5);
		
		WeaponDamage(o, SpellDamage);
		Sound("Ball::ball_hit", false, 50);
	}
}
Пример #15
0
global func CreateBurnMark(int iX, int iY, int iLevel, int Count) 
{
  var boom;
  if(!ObjectCount(BOOM)) boom = CreateObject(BOOM,0,0,-1);
  else boom = FindObject(BOOM);
  
  var angle=Random(360/Count); //variablen für die überprüfung
  var type;
  for(var z; z < Count; z++)
	{
    angle += Max(1,360/Count);

    // Check: Sky or Solid/Liquid
    var x = iX+Cos(angle,iLevel);
    var y = iY+Sin(angle,iLevel);
    if((GetMaterialVal("Density","Material",GetMaterial(x,y)) != 0) || (GetMaterial(x,y) == -1))
      continue;

    type = 1+Random(3);
    var size = BurnMarkCheck(angle,RandomX(iLevel/2,iLevel*2),iX,iY);
    var sin = Sin(angle,(size-iLevel)/2+iLevel+Random(3));
    var cos = Cos(angle,(size-iLevel)/2+iLevel+Random(3));

    CreateParticle("BurnMark",iX+cos,iY+sin,Cos(angle+RandomX(-5,5),50),Sin(angle+RandomX(-5,5),50),size*5+Random(25),RGBa(0,0,0,64),boom,1); 
  }
}
Пример #16
0
func FxDischargeStart(object target, proplist effect, int temporary)
{
	for(var i = 0; i < 360; i+= 10)
	{
		var props = {
			Size = PV_Linear(4, 0),
			Stretch = 10000,
			Rotation = i + 180,
		    R = pR,
		    G = pG,
		    B = pB,
			BlitMode = GFX_BLIT_Additive,
		};
		
		var x = Sin(i, DischargeSize + RandomX(-2, 2));
		var y = -Cos(i, DischargeSize + RandomX(-2, 2));
		
		var rnd = RandomX(4,20);
		var xdir = Sin(i + 180, rnd);
		var ydir = -Cos(i + 180, rnd);
		
		CreateParticle("Flash", x, y, xdir, ydir, 25, props, 1);
	}
	
}
Пример #17
0
func ChargeEffect(proplist params)
{
	var a = params.new_angle;
	var x = Sin(a, 10, 10);
	var y = -Cos(a, 10, 10);

	CreateParticle("Shockwave2", x, y, PV_Random(-10,10), PV_Random(-15, 5), 20, chargeprt, 1);
}
Пример #18
0
func FxPointingStart(object target, int index, int temp, int plr, object obj, string msg) {
	SetVisibility(VIS_Owner, target);
	CreateParticle("PSpark", 0, 0, 0, 0, 500, GetClrModulation(), this, true);
	EffectVar(0, target, index) = plr;
	EffectVar(1, target, index) = obj;
	EffectVar(2, target, index) = msg;
	return true;
}
Пример #19
0
global func FxFireScorchingTimer(object target, proplist effect, int time)
{
	if (time >= effect.duration) { RemoveObject(); return FX_Execute_Kill; }
	// particles
	var wind = BoundBy(GetWind(), -5, 5);
	CreateParticle("SmokeDirty", PV_Random(-5, 5), PV_Random(-5, 5), wind, -effect.strength/8, PV_Random(20, 40), Particles_SmokeTrail(), 2);
	return FX_OK;
}
Пример #20
0
func ContactBottom()
{
	inherited(...);
	var particle = Particles_Spark();
	particle.R = 0xff;
	particle.G = 0xff;
	particle.B = PV_Random(150,200);
	CreateParticle("MagicSpark", 0,ReturnHeight()/2-1, PV_Random(-10,10), PV_Random(-10,10), PV_Random(10,50), particle, 15);
  Sound("Hits::LightMetalHit?", false, 20);
}
Пример #21
0
func FxMoveToTimer(object target, proplist fx, int time)
{
	if(!master)
	{
		KillBall();
		return;
	}
		
	if(GetEffect("Blocked", this))
	{
		ox=GetX();
		oy=GetY();
		return;
	}
	
	DrawParticleLine("Flash", 0, 0, ox-GetX(), oy-GetY(), 1, 0, 0, 15, movetrailparticles);

	if(time%7 == 0)
	{
		for(var i = 0; i < 360; i+=5)
		{
			CreateParticle("Flash", Sin(i, 3), -Cos(i, 5), 0, 0, 10, moveparticle2, 2);
		}
	}

	MoveToPos(fx.x, fx.y);
	
	ox=GetX();
	oy=GetY();
	
	var dst = Distance(GetX(), GetY(), fx.x, fx.y);
	if(dst < 5)
	{
		SetXDir(0);
		SetYDir(0);
		CheckForEnemies(AttackSize);
		Idle();
		
		CreateParticle("StarSpark", 0, 0, 0, 0, 10, moveparticle, 5);
		
		return -1;
	}
}
Пример #22
0
Particles::Particles(int _NumParticles, Vector2 pPosition, Vector2 pForce, float pLifespan, Texture pTexture)
{
	numParticles = _NumParticles;

	for(int i = 0; i< numParticles; ++i)
	{
		CreateParticle(i, pPosition, pForce, pLifespan, pTexture);
	}

}
Пример #23
0
func Launch(object clonk, int x, int y)
{
	CreateParticle("Smoke", PV_Random(-5,5), PV_Random(-10,10), PV_Random(-5,5), 0, 30, Particles_Smoke(), 20);
	clonk.Visibility = VIS_Owner;
	clonk->SetClrModulation(RGBa(255,255,255,50));
	clonk->Sound("vanish", false, 50);
	
	var fx = AddEffect("ShadowWalk", clonk, 20, 1, nil, GetID());
	fx.dur = Dur;
	RemoveObject();
}
Пример #24
0
func ContactBottom()
{
	inherited(...);
	var particle = Particles_Spark();
	particle.R = 0xff;
	particle.G = 0xff;
	particle.B = PV_Random(150,200);
	CreateParticle("Dust", 0,10, PV_Random(-3,3), PV_Random(-3,3), PV_Random(5,8), particle, 15);
	
//	CreateParticle(,0, 10, RandomX(-3,3),RandomX(-3,3),RandomX(50,75),DoRGBaValue(-7183302,128,0));
	Sound("Clonk::Action::Dig::Dig?");
}
Пример #25
0
global func FxSmokeTrailTimer(object pTarget, int iEffectNumber, int iEffectTime)
{
  var iStrength = EffectVar(0, pTarget, iEffectNumber);
  var iAStr = EffectVar(1, pTarget, iEffectNumber);
  var iX = EffectVar(2, pTarget, iEffectNumber);
  var iY = EffectVar(3, pTarget, iEffectNumber);
  var iXDir = EffectVar(4, pTarget, iEffectNumber);
  var iYDir = EffectVar(5, pTarget, iEffectNumber);

  iAStr = Max(1,iAStr-iAStr/10+Random(2));
  iAStr--;
  iYDir += GetGravity()*2/3;
  iYDir += GetWind(iX,iY)/20;

  var xdir = iXDir*iAStr/iStrength;
  var ydir = iYDir*iAStr/iStrength;

  // Neu: Random
  iX += RandomX(-3,3);
  iY += RandomX(-3,3);
  
  // zuerst zeichnen
  CreateParticle("Smoke3",iX,iY,RandomX(-2,2),RandomX(-2,2)-3,20+iAStr*8,RGBa(128,128,128,55+35*iAStr/iStrength));
  CreateParticle("Blast",iX,iY,0,0,10+iAStr*8,RGBa(250,100+Random(100),100,160));

  // dann nächste position berechnen
  iX += xdir/100;
  iY += ydir/100;
  
  if(GBackSemiSolid(iX,iY))
    return -1;
  if(iAStr <= 1)
    return -1;
    
  EffectVar(1, pTarget, iEffectNumber) = iAStr;
  EffectVar(2, pTarget, iEffectNumber) = iX;
  EffectVar(3, pTarget, iEffectNumber) = iY;
  EffectVar(5, pTarget, iEffectNumber) = iYDir;
}
void Explosion::InitParticles(cResourceHandle* textureParticle) {
	mTextureParticle = textureParticle;
	lfTimeUntilNextStep = 0;
	lfColorTime = 0;
	mfAngle = 0;
	mvParticleSysPos.LoadIdentity();
	for(int i = 0; i < NUM_PARTICLES; i++) {
		CreateParticle(particles + i);
	}
	for(int i = 0; i < 5 / STEP_TIME; i++) {
		StepParticles();
	}
}
Пример #27
0
void ParticleSystem::Update( double delta )
{
	for( unsigned int i = 0; i < mParticles.size(); i++ )
	{
		mParticles[i].Update( delta );

		// if particle's life time has been depleated replace with a new particle
		if( mParticles[i].GetLifeTime() <= 0.0 )
		{
			mParticles[i] = CreateParticle();
		}
	}
}
Пример #28
0
func JumpEffect(object clonk, dir)
{
	var from;
	var to;

	if (dir == "Up")
	{
		from = 50; 
		to = 130;
	}
	if (dir == "Left")
	{
		from = -30; 
		to = 50;
	}
	if (dir == "Right")
	{
		from = 130; 
		to = 210;
	}
	if (dir == "Down")
	{
		from = 230; 
		to = 310;
	}

	clonk->Sound("time_hit", false, 30);

	for(var i = from; i < to; i+=5)
	{
		var r = 10;
		var x = clonk->GetX() + Cos(i, r);
		var y = clonk->GetY() + Sin(i, r);
		
		var angle = Angle(0,0,Cos(i, r),Sin(i, r));
		
		var trailparticles =
		{
			Prototype = Particles_ElectroSpark2(),
			Size = PV_Linear(10,0),
			Rotation = angle,
			R = 255,
			G = 165,
			B = 50,
			OnCollision = PC_Bounce(),
		};
	
		CreateParticle("Lightning", x, y, Cos(i, r), Sin(i, r), 10, trailparticles);
	}
}
Пример #29
0
func JumpEffect(object clonk, dir)
{
	var from;
	var to;

	if (dir == "Up")
	{
		from = 50; 
		to = 130;
	}
	if (dir == "Left")
	{
		from = -30; 
		to = 50;
	}
	if (dir == "Right")
	{
		from = 130; 
		to = 210;
	}
	if (dir == "Down")
	{
		from = 230; 
		to = 310;
	}

	Sound("hookjump", false, 30);

	for(var i = from; i < to; i+=5)
	{
		var r = 10;
		var x = clonk->GetX() + Cos(i, r);
		var y = clonk->GetY() + Sin(i, r);
		
		var angle = Angle(0,0,Cos(i, r),Sin(i, r));
		
		var trailparticles =
		{
			//Prototype = Particles_ElectroSpark2(),
			Size = PV_Linear(10,0),
			Rotation = angle,
			R = 150,
			G = 150,
			B = 150,
			OnCollision = PC_Bounce(),
		};
	
		CreateParticle("Shockwave", x, y, Cos(i, r + RandomX(-1,1)), Sin(i, r + RandomX(-1, 1)), 10, trailparticles);
	}
}
Пример #30
0
// Timer during movement: Draw tail
func Drawing()
{
	var x=GetX(), y=GetY();
	var vx=x-last_x, vy=y-last_y;
	last_x = x; last_y = y;
	var v=Distance(vx,vy);
	if (!v) return;
	var s1=v;
	var s2=4;
	var dx1=vx*s1/v, dy1=vy*s1/v, dx2=vy*s2/v, dy2=-vx*s2/v;
	x -= dx1; y -= dy1;
	DrawMaterialQuad("Gold-gold", x+dx1+dx2,y+dy1+dy2, x+dx1-dx2,y+dy1-dy2, x-dx1-dx2,y-dy1-dy2, x-dx1+dx2,y-dy1+dy2, true);
	CreateParticle("MagicSpark", 0,0, PV_Random(-vx*2-15,-vx*2+15), PV_Random(-vy*2-15,-vy*2+15), PV_Random(30,80), Particles_Colored(Particles_Spark(),GetPlayerColor(GetOwner())), 3);
	return true;
}