// load the needed properties for fireflies particle system
void Start()
{
this.fireFliesEmission = this.firefliesSystem.emission;
this.fireFliesForceOverTime = this.firefliesSystem.forceOverLifetime;
this.fireFliesSizeOverTime = this.firefliesSystem.sizeOverLifetime;
this.fireFliesMain = this.firefliesSystem.main;
this.fireFliesSizeOverTime.enabled = true;
this.fireFliesEmission.enabled = true;
this.fireFliesForceOverTime.enabled = true;
this.fireFliesMain.startLifetime = this.fireFilesLifetimeSeconds;
this.fireFliesEmission.rateOverTime = 0;
this.fireFliesSizeOverTime.separateAxes = false;
this.fireFliesSizeOverTime.x = new ParticleSystem.MinMaxCurve(sizeCurveMultiplier, sizeCurve);
this.fireFliesForceOverTime.x = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, xForceCurve);
this.fireFliesForceOverTime.y = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, yForceCurve);
this.fireFliesForceOverTime.z = new ParticleSystem.MinMaxCurve(forceCurveMultiplier, zForceCurve);
this.fireFliesForceOverTime.randomized = true;
this.fireFliesMain.playOnAwake = false;
this.fireFliesMain.loop = false;
}
void Start()
{
if (StarsSpawnRate == 0)
{
StarsSpawnRate = 1;
}
spawnTime = (1 / StarsSpawnRate);
ps = GetComponent <ParticleSystem>();
ParticleSystemRenderer psr = GetComponent <ParticleSystemRenderer>();
psr.material = StarsMaterial;
ParticleSystem.MainModule psm = ps.main;
psm.startLifetimeMultiplier = StarsLifetime;
psm.startSizeMultiplier = StarsSize;
psm.maxParticles = MaximumStarsNumber;
psm.startSpeedMultiplier = 0;
ParticleSystem.EmissionModule pse = ps.emission;
pse.enabled = false;
ParticleSystem.SizeOverLifetimeModule pss = ps.sizeOverLifetime;
pss.enabled = true;
pss.size = new ParticleSystem.MinMaxCurve(1f, new AnimationCurve(
new Keyframe(0, 0),
new Keyframe(0.5f, 1f),
new Keyframe(1f, 0)));
}
void Start()
{
if (Resources.Load("LaserMaterial/_laser") != null && laserMaterial == null)
{
laserMaterial = (Material)Resources.Load("LaserMaterial/_laser");
}
_ps = GetComponent <ParticleSystem>();
_pr = (ParticleSystemRenderer)GetComponent <Renderer>();
Intensity = 1000;
emmision = _ps.emission;
emmision.enabled = true;
shape = _ps.shape;
sizeOverLifeTime = _ps.sizeOverLifetime;
colorOverLifeTime = _ps.colorOverLifetime;
collision = _ps.collision;
_material = GetComponent <ParticleSystemRenderer>().sharedMaterial;
_pr.material = laserMaterial;
sizeOverLifeTimeCurve.mode = ParticleSystemCurveMode.Constant;
generator = new Generator(this);
tempColor = (Color.r == 0 && Color.g == 0 && Color.b == 0 && Color.a == 0) ? Color.white : Color;
_ps.hideFlags = HideFlags.NotEditable;
_ps.Play();
}
protected override void OnJam()
{
chargingObject.DisableLaserBeam();
ParticleSystem.Particle[] particles = new ParticleSystem.Particle[1];
int p = chargeBall.GetParticles(particles);
chargeBall.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
ParticleSystem.MainModule main = chargeBall.main;
main.duration = timeToCancel;
main.startLifetime = timeToCancel;
main.startSize = particles[0].GetCurrentSize(chargeBall);
// Have the color change.
ParticleSystem.ColorOverLifetimeModule color = chargeBall.colorOverLifetime;
color.enabled = true;
AnimationCurve curve = new AnimationCurve();
curve.AddKey(0f, 1f);
curve.AddKey(1f, 0f);
ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime;
mod.enabled = true;
mod.size = new ParticleSystem.MinMaxCurve(1f, curve);
chargeBall.Play(false);
}
protected virtual void GetParticleSystem()
{
_particleSystem = GetComponentInChildren <ParticleSystem>();
particleRenderer = GetComponentInChildren <ParticleSystemRenderer>();
// Modules - for ease of access
mainModule = _particleSystem.main;
collisionModule = _particleSystem.collision;
colorBySpeedModule = _particleSystem.colorBySpeed;
colorOverTimeModule = _particleSystem.colorOverLifetime;
customDataModule = _particleSystem.customData;
emissionModule = _particleSystem.emission;
externalForcesModule = _particleSystem.externalForces;
forceOverTimeModule = _particleSystem.forceOverLifetime;
inheritVelocityModule = _particleSystem.inheritVelocity;
lightsModule = _particleSystem.lights;
limitVelocityOverTimeModule = _particleSystem.limitVelocityOverLifetime;
noiseModule = _particleSystem.noise;
rotationBySpeedModule = _particleSystem.rotationBySpeed;
sizeBySpeedModule = _particleSystem.sizeBySpeed;
sizeOverTimeModule = _particleSystem.sizeOverLifetime;
trailModule = _particleSystem.trails;
triggerModule = _particleSystem.trigger;
shapeModule = _particleSystem.shape;
velOverTimeModule = _particleSystem.velocityOverLifetime;
}
private void SetupMainThruster()
{
mainThruster = GetComponent <ParticleSystem>();
#region Main Properties
mainThruster.startLifetime = 0.25f;
mainThruster.startSpeed = thrusterStrength;
mainThruster.startSize = 2.5f;
mainThruster.gravityModifier = 9.8f;
mainThruster.simulationSpace = ParticleSystemSimulationSpace.World;
mainThruster.scalingMode = ParticleSystemScalingMode.Shape;
mainThruster.playOnAwake = false;
mainThruster.maxParticles = 0;
#endregion
#region Emission Module
ParticleSystem.EmissionModule emission = mainThruster.emission;
emission.enabled = true;
emission.rate = 0;
#endregion
#region Shape Module
ParticleSystem.ShapeModule shape = mainThruster.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.Cone;
shape.angle = 0;
shape.radius = 0.01f;
#endregion
#region Color Over Lifetime Module
ParticleSystem.ColorOverLifetimeModule colorOverLifetime = mainThruster.colorOverLifetime;
colorOverLifetime.enabled = true;
Gradient gradient = new Gradient();
gradient.SetKeys(new GradientColorKey[] { new GradientColorKey(mainColor, 0.3f), new GradientColorKey(Color.white, 1f) }, new GradientAlphaKey[] { new GradientAlphaKey(1, 0), new GradientAlphaKey(0, 1) });
colorOverLifetime.color = gradient;
#endregion
#region Size Over Lifetime Module
ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = mainThruster.sizeOverLifetime;
sizeOverLifetime.enabled = true;
sizeOverLifetime.separateAxes = false;
AnimationCurve curve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
sizeOverLifetime.size = new ParticleSystem.MinMaxCurve(1, curve);
#endregion
#region Collision Module
ParticleSystem.CollisionModule collision = mainThruster.collision;
collision.enabled = true;
collision.type = ParticleSystemCollisionType.World;
collision.mode = ParticleSystemCollisionMode.Collision2D;
collision.bounce = 0;
collision.radiusScale = 0.5f;
collision.enableInteriorCollisions = false;
collision.sendCollisionMessages = true;
LayerMask layerMask = new LayerMask();
layerMask.value = (1 << LayerMask.NameToLayer("World")) | (1 << LayerMask.NameToLayer("Vehicle") | (1 << LayerMask.NameToLayer("Object")));
collision.collidesWith = layerMask;
#endregion
#region Renderer Module
ParticleSystemRenderer renderer = GetComponent <ParticleSystemRenderer>();
renderer.material = new Material(Resources.Load <Material>("Materials/Particles/Thruster"));
renderer.sortingFudge = 10;
#endregion
}
// Set size over life time. different axis. Increase almost instantly particles after birth
public static void SetSizeOverLifeTime(ParticleSystem.SizeOverLifetimeModule sizeOverLifeTime, Vector3 size)
{
sizeOverLifeTime.enabled = true;
sizeOverLifeTime.separateAxes = true;
sizeOverLifeTime.x = GetCurveSizeOverLifeTime(size.x);
sizeOverLifeTime.y = GetCurveSizeOverLifeTime(size.y);
sizeOverLifeTime.z = GetCurveSizeOverLifeTime(size.z);
}
// Use this for initialization
void Start()
{
initialStartSize = GetComponent <ParticleSystem>().main.startSize;
solm = GetComponent <ParticleSystem>().sizeOverLifetime;
initialSizeOverLifeCurve = solm.size;
solm.enabled = false;
solm.size = initialStartSize;
}
private static void SetupSmallTracerSizeOverLifetime(this ParticleSystem particles)
{
ParticleSystem.SizeOverLifetimeModule mainPsSol = particles.sizeOverLifetime;
mainPsSol.enabled = true;
mainPsSol.separateAxes = true;
mainPsSol.x = 1f;
mainPsSol.y = new ParticleSystem.MinMaxCurve(1f, AnimationCurve.EaseInOut(0f, 1f, 1f, 0f));
mainPsSol.z = 1f;
}
private static void SetSizeOverLifetime(
ParticleSystem.SizeOverLifetimeModule size, float startSize, float endSize)
{
AnimationCurve scaleCurve = new AnimationCurve();
scaleCurve.AddKey(0, startSize);
scaleCurve.AddKey(1, endSize);
size.size = new ParticleSystem.MinMaxCurve(1f, scaleCurve);
}
void Start()
{
PS = this.GetComponent <ParticleSystem>();
myShape = PS.shape;
myColor = PS.colorOverLifetime;
grad = new Gradient();
mySize = PS.sizeOverLifetime;
myRot = PS.rotationOverLifetime;
}
protected override void OnFinishedCharge()
{
ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime;
mod.enabled = false;
ParticleSystem.MainModule main = chargeBall.main;
otherParticles[0].Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
chargeBall.Pause();
chargingObject.EnableLaserBeam();
}
public static void ParticleSizeOverLifetimeSettings(this ParticleSystem PS,
bool enabled = true,
float scalar = 0.0f,
AnimationCurve animationCurve = null // Set Externally
)
{
ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule = PS.sizeOverLifetime;
// Size over Lifetime Settings
ParticleSystem.MinMaxCurve Curve = new ParticleSystem.MinMaxCurve(scalar, animationCurve);
sizeOverLifetimeModule.enabled = enabled;
sizeOverLifetimeModule.size = Curve;
}
void Start()
{
particleSystem = GetComponent <ParticleSystem>() ?? gameObject.AddComponent <ParticleSystem>();
particleSystem.playOnAwake = false;
particleSystem.Stop();
particleSystem.startLifetime = LifeTime;
particleSystem.loop = true;
particleSystem.startColor = StartColor;
particleSystem.simulationSpace = ParticleSystemSimulationSpace.World;
particleSystem.maxParticles = 10240;
particleSystem.gravityModifier = -0.02f;
particleSystem.scalingMode = ParticleSystemScalingMode.Shape;
ParticleSystem.ShapeModule sm = particleSystem.shape;
sm.shapeType = ParticleSystemShapeType.ConeShell;
sm.radius = Radius;
sm.angle = Angle;
sm.length = 1;
sm.randomDirection = true;
sm.enabled = true;
ParticleSystem.SizeOverLifetimeModule sl = particleSystem.sizeOverLifetime;
sl.size = new ParticleSystem.MinMaxCurve(Size, AnimationCurve.Linear(0f, StartSize, LifeTime, EndSize));
sl.enabled = true;
ParticleSystem.RotationOverLifetimeModule rolm = particleSystem.rotationOverLifetime;
rolm.enabled = true;
rolm.x = new ParticleSystem.MinMaxCurve(0, 360);
ParticleSystem.ColorOverLifetimeModule colm = particleSystem.colorOverLifetime;
colm.color = new Gradient()
{
alphaKeys = new GradientAlphaKey[] { new GradientAlphaKey(StartAlpha, StartAlphaTime), new GradientAlphaKey(EndAlpha, EndAlphaTime) },
colorKeys = new GradientColorKey[] { new GradientColorKey(StartColor, StartColorTime), new GradientColorKey(EndColor, EndColorTime) }
};
colm.enabled = true;
ParticleSystem seb = particleSystem.subEmitters.birth0;
seb = GetComponent <ParticleSystem>();
ParticleSystemRenderer particleSystemRenderer = particleSystem.GetComponent <ParticleSystemRenderer>();
particleSystemRenderer.sortMode = ParticleSystemSortMode.Distance;
particleSystemRenderer.sortingFudge = 80;
particleSystemRenderer.receiveShadows = true;
particleSystemRenderer.sharedMaterial = new Material(Shader.Find("Particles/Alpha Blended"));
particleSystemRenderer.sharedMaterial.mainTexture = (ModResource.GetTexture("Rocket Smoke Texture"));
}
public static void DebugSizeOverLifeTime(this ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule)
{
DLog.Log("\n[SizeOverLifetimeModule]");
DLog.Log($"enabled: {sizeOverLifetimeModule.enabled}");
DLog.Log($"separateAxes: {sizeOverLifetimeModule.separateAxes}");
sizeOverLifetimeModule.size.DebugMinMaxCurve("size");
DLog.Log($"sizeMultiplier: {sizeOverLifetimeModule.sizeMultiplier}");
sizeOverLifetimeModule.x.DebugMinMaxCurve("x");
DLog.Log($"xMultiplier: {sizeOverLifetimeModule.xMultiplier}");
sizeOverLifetimeModule.y.DebugMinMaxCurve("y");
DLog.Log($"yMultiplier: {sizeOverLifetimeModule.yMultiplier}");
sizeOverLifetimeModule.z.DebugMinMaxCurve("z");
DLog.Log($"zMultiplier: {sizeOverLifetimeModule.zMultiplier}");
}
public void Configure(SplatterSettings settings)
{
system = GetComponent <ParticleSystem>();
this.settings = settings;
system.maxParticles = settings.maxParticles;
if (settings.removeParticles)
{
#if UNITY_5_3_OR_NEWER
ParticleSystem.SizeOverLifetimeModule solm = system.sizeOverLifetime;
solm.enabled = true;
#endif
system.startLifetime = settings.particleLifetime;
}
ParticleSystemRenderer particleRenderer = (ParticleSystemRenderer)system.GetComponent <Renderer>();
if (particleRenderer != null)
{
if (settings.particleMode == ParticleMode.Circle)
{
particleRenderer.material = (Material)Resources.Load(
settings.multiplyColor? "CircleParticleMultiply" : "CircleParticleAlphaBlend");
}
else if (settings.particleMode == ParticleMode.Square)
{
particleRenderer.material = (Material)Resources.Load(
settings.multiplyColor? "SquareParticleMultiply" : "SquareParticleAlphaBlend");
}
else if (settings.particleMode == ParticleMode.CustomTexture)
{
particleRenderer.material = (Material)Resources.Load(
settings.multiplyColor? "CustomParticleMultiply" : "CustomParticleAlphaBlend");
particleRenderer.material.SetTexture("_MainTex", settings.particleTexture);
}
else if (settings.particleMode == ParticleMode.CustomMaterial)
{
particleRenderer.material = settings.particleMaterial;
}
if (particleRenderer.material == null)
{
Debug.LogError("[SPLATTER SYSTEM] Can't find particle renderer material.");
}
particleRenderer.sortingLayerName = settings.sortingLayerName;
particleRenderer.renderMode = settings.orientation == OrientationMode.Horizontal?
ParticleSystemRenderMode.HorizontalBillboard : ParticleSystemRenderMode.VerticalBillboard;
}
}
protected override void PerformOperation(Flow flow)
{
module = Particle.sizeOverLifetime;
module.separateAxes = SeparateAxes;
if (!SeparateAxes)
{
module.size = flow.GetValue <ParticleSystem.MinMaxCurve>(Size);
}
else
{
module.x = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeX);
module.y = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeY);
module.z = flow.GetValue <ParticleSystem.MinMaxCurve>(SizeZ);
}
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystem.SizeOverLifetimeModule uo = (ParticleSystem.SizeOverLifetimeModule)obj;
enabled = uo.enabled;
size = uo.size;
sizeMultiplier = uo.sizeMultiplier;
x = uo.x;
xMultiplier = uo.xMultiplier;
y = uo.y;
yMultiplier = uo.yMultiplier;
z = uo.z;
zMultiplier = uo.zMultiplier;
separateAxes = uo.separateAxes;
}
protected override object WriteToImpl(object obj)
{
obj = base.WriteToImpl(obj);
ParticleSystem.SizeOverLifetimeModule uo = (ParticleSystem.SizeOverLifetimeModule)obj;
uo.enabled = enabled;
uo.size = size;
uo.sizeMultiplier = sizeMultiplier;
uo.x = x;
uo.xMultiplier = xMultiplier;
uo.y = y;
uo.yMultiplier = yMultiplier;
uo.z = z;
uo.zMultiplier = zMultiplier;
uo.separateAxes = separateAxes;
return(uo);
}
// Update is called once per frame
void Update()
{
//only spawn shield after a small delay
if (!alive)
{
startingTimer -= Time.deltaTime;
if (startingTimer <= 0)
{
SpawnShield();
}
}
if (alive)
{
scaletimer += Time.deltaTime;
//scale up whole transform
if (scaletimer <= maxScale)
{
transform.localScale = new Vector3(transform.localScale.x + scaletimer * scaleSpeed, transform.localScale.y + scaletimer * scaleSpeed, transform.localScale.z + scaletimer * scaleSpeed);
}
else
{
//stay for a period of time them go pop
//shimmer?
if (scaletimer >= aliveTime)
{
particles.Play();
//turn on size over lifetime
ParticleSystem.SizeOverLifetimeModule newSize = particles.sizeOverLifetime;
newSize.enabled = true;
//turn on coolour over lifetime
ParticleSystem.ColorOverLifetimeModule newCol = particles.colorOverLifetime;
newCol.enabled = true;
//TURN OFF COLLIDER
shieldCollider.enabled = false;
Destroy(gameObject, destroyTime);
}
}
}
}
public void Initialize()
{
m_SizeOverLifeTimeModuleReference = m_ParticleSystemReference.sizeOverLifetime;
//MainModule : StartLifeTime
t_DefaultSizeOverLifeTime = m_SizeOverLifeTimeModuleReference.sizeMultiplier;
t_DefaultMaxSizeOverLifeTime = t_DefaultSizeOverLifeTime * maxChangeOfSizeOverLifeTime;
t_DefaultSizeOverLifeTimeOnX = m_SizeOverLifeTimeModuleReference.xMultiplier;
t_DefaultMaxSizeOverLifeTimeOnX = t_DefaultSizeOverLifeTimeOnX * maxChangeOfSizeOverLifeTime;
t_DefaultSizeOverLifeTimeOnY = m_SizeOverLifeTimeModuleReference.xMultiplier;
t_DefaultMaxSizeOverLifeTimeOnY = t_DefaultSizeOverLifeTimeOnY * maxChangeOfSizeOverLifeTime;
t_DefaultSizeOverLifeTimeOnZ = m_SizeOverLifeTimeModuleReference.xMultiplier;
t_DefaultMaxSizeOverLifeTimeOnZ = t_DefaultSizeOverLifeTimeOnZ * maxChangeOfSizeOverLifeTime;
}
private void UpdateCircles()
{
if (centerCircle != null)
{
centerCircle.transform.localScale = Vector2.one * radius * 2;
}
if (concentricCircles != null)
{
ParticleSystem.MainModule concentricCirclesMain = concentricCircles.main;
ParticleSystem.SizeOverLifetimeModule concentricCirclesSizeOverLifeTime = concentricCircles.sizeOverLifetime;
Keyframe[] keyframes = new Keyframe[2];
keyframes[0] = new Keyframe(0, 1);
keyframes[1] = new Keyframe(1, radius * 2 / concentricCirclesMain.startSize.constant);
concentricCirclesSizeOverLifeTime.size = new ParticleSystem.MinMaxCurve(1, new AnimationCurve(keyframes));
}
}
private void MapSizeOverLifetimeParameters(ParticleSystem pSystem, int i)
{
ParticleSystem.SizeOverLifetimeModule sizeOverLifetimeModule = pSystem.sizeOverLifetime
;
try {
sizeOverLifetimeModule.enabled = GetBoolParam(i, "sizeOverLifetime_enabled");
}
catch (NullReferenceException) {
sizeOverLifetimeModule.enabled = false;
return;
}
sizeOverLifetimeModule.separateAxes = GetBoolParam(i, "sizeOverLifetime_separateAxes");
sizeOverLifetimeModule.x = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_x"));
sizeOverLifetimeModule.y = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_y"));
sizeOverLifetimeModule.z = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "sizeOverLifetime_size_z"));
}
protected override void OnCharge()
{
ParticleSystem.MainModule main = chargeBall.main;
main.duration = timeToCharge;
main.startLifetime = timeToCharge;
main.startSize = chargeBallSize;
AnimationCurve curve = new AnimationCurve();
curve.AddKey(0f, 0f);
curve.AddKey(1f, 1f);
ParticleSystem.SizeOverLifetimeModule mod = chargeBall.sizeOverLifetime;
mod.enabled = true;
mod.size = new ParticleSystem.MinMaxCurve(1f, curve);
chargeBall.gameObject.SetActive(true);
chargeBall.Play(true);
}
private static void HitparticlesystemAssign()
{
ParticleSystem ps = new GameObject().AddComponent <ParticleSystem>();
hitParticleSystem = ps;
ParticleSystem.MainModule main = ps.main;
ParticleSystem.EmissionModule emission = ps.emission;
ParticleSystem.ShapeModule shape = ps.shape;
ParticleSystem.RotationOverLifetimeModule rot = ps.rotationOverLifetime;
ParticleSystem.SizeOverLifetimeModule size = ps.sizeOverLifetime;
ParticleSystem.ColorOverLifetimeModule color = ps.colorOverLifetime;
ParticleSystemRenderer rend = ps.GetComponent <ParticleSystemRenderer>();
main.startSize = 3f;
main.startSpeed = 0f;
main.startLifetime = 0.4f;
main.startColor = new ParticleSystem.MinMaxGradient(new Color(0.4f, 0.5f, 0.51f, 1f), new Color(0.56f, 0.53f, 0.8679245f, 1));
main.startRotation = new ParticleSystem.MinMaxCurve(0, 360);
main.simulationSpace = ParticleSystemSimulationSpace.World;
main.loop = false;
emission.enabled = false;
shape.enabled = false;
rot.enabled = true;
rot.z = 360;
size.enabled = true;
size.size = new ParticleSystem.MinMaxCurve(1, new AnimationCurve(new Keyframe[] { new Keyframe(0, 0, 2, 2), new Keyframe(0.8007382f, 1, 0, 0), new Keyframe(1, 0, 0, 0), }));
color.enabled = true;
color.color = new ParticleSystem.MinMaxGradient(new Color(1, 1, 1, 1), new Color(1, 1, 1, 0));
Material mat1 = new Material(Shader.Find("Particles/Additive"))
{
mainTexture = Res.ResourceLoader.GetTexture(129)
};
rend.material = mat1;
}
// Update is called once per frame
void Update()
{
if (pathParticleInst != null && pathParticleInst.activeSelf)
{
instanceActive = true;
instPS = pathParticleInst.GetComponent <ParticleSystem>();
timer = instPS.sizeOverLifetime.sizeMultiplier;
sizeOL = instPS.sizeOverLifetime;
shapeOL = instPS.shape;
if (defaultMultiplier == 0)
{
defaultMultiplier = instPS.sizeOverLifetime.sizeMultiplier;
}
}
else
{
instanceActive = false;
}
if (pathPos >= 1.35f)
{
pathPos = 1.35f;
}
if (target != null)
{
startloc = target.transform.position;
if (pathParticleInst != null)
{
pathParticleInst.SetActive(true);
pathParticleInst.transform.LookAt(endLoc, Vector3.up);
}
if (!instPS.isPlaying)
{
instPS.Play();
}
}
else
{
Debug.Log("No Target!!!");
}
}
static void WriteParticleSystemSizeOverLifetime(ParticleSystem.SizeOverLifetimeModule module)
{
m_writer.Write(module.enabled);
if (!module.enabled)
{
return;
}
m_writer.Write(module.separateAxes);
if (module.separateAxes)
{
WriteMinMaxCurve(module.x);
WriteMinMaxCurve(module.y);
WriteMinMaxCurve(module.z);
}
else
{
WriteMinMaxCurve(module.size);
}
}
void Setup()
{
ParticleSystem.MinMaxCurve minMax = new ParticleSystem.MinMaxCurve(startLifetime.x, startLifetime.y);
//
//MAIN MODULE
ModuleMain = Particules.main;
ModuleMain.startSpeed = startSpeed;
ModuleMain.startLifetime = minMax;
ModuleMain.maxParticles = LimitMax;
//ModuleMain.maxParticles = countValidPoint;
ParticleSystem.MinMaxGradient minMaxGradient = new ParticleSystem.MinMaxGradient(Couleur1, Couleur2);
ModuleMain.startColor = minMaxGradient;
ModuleMain.simulationSpace = ParticleSystemSimulationSpace.World;
//ModuleMain.customSimulationSpace = transform;
ModuleMain.startSize = startSize;
//
// EMISSION MODULE
ModuleEmission = Particules.emission;
ModuleEmission.enabled = true;
ModuleEmission.rateOverTime = RateOverTIme;
//
// SIZE OVER LIFETIME MODULE
ModuleSizeOverLifetime = Particules.sizeOverLifetime;
ModuleSizeOverLifetime.enabled = true;
Keyframe[] KeysMin = { new Keyframe(0, 0), new Keyframe(0.2f, 0.3f), new Keyframe(0.8f, 0.3f), new Keyframe(1, 0) };
Keyframe[] KeysMax = { new Keyframe(0, 0), new Keyframe(0.2f, 1), new Keyframe(0.8f, 1), new Keyframe(1, 0) };
AnimationCurve min = new AnimationCurve(KeysMin);
AnimationCurve max = new AnimationCurve(KeysMax);
ParticleSystem.MinMaxCurve minMaxCurve = new ParticleSystem.MinMaxCurve(1, min, max);
ModuleSizeOverLifetime.size = minMaxCurve;
//
// RENDERER MODULE
ParticleSystemRenderer.material = ParticuleMaterial;
}
public void PlayEMPEffect(EMPEffectReadyEvent e, EMPEffectNode effect, [JoinByTank] TankNode tank, [JoinAll] SingleNode <MapInstanceComponent> map)
{
EMPWaveGraphicsBehaviour behaviour = Object.Instantiate <EMPWaveGraphicsBehaviour>(tank.empWaveGraphicsEffect.EMPWaveAsset, tank.tankVisualRoot.transform.position, tank.tankVisualRoot.transform.rotation, map.component.SceneRoot.transform);
float num2 = effect.empEffect.Radius * 2f;
ParticleSystem waveParticleSystem = behaviour.WaveParticleSystem;
ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = waveParticleSystem.sizeOverLifetime;
ParticleSystem.MinMaxCurve size = sizeOverLifetime.size;
AnimationCurve curve = size.curve;
Keyframe key = curve.keys[0];
key.value = (num2 * 0.152f) / 50f;
curve.MoveKey(0, key);
size.curveMultiplier = num2;
sizeOverLifetime.size = size;
AudioSource waveSound = behaviour.WaveSound;
waveSound.transform.parent = null;
waveSound.Play();
waveParticleSystem.Play();
Object.Destroy(behaviour.gameObject, waveParticleSystem.startLifetime + 0.5f);
Object.Destroy(waveSound.gameObject, waveSound.clip.length + 0.5f);
}
void Start()
{
particleSystem = GetComponent <ParticleSystem>() ?? gameObject.AddComponent <ParticleSystem>();
particleSystem.playOnAwake = false;
particleSystem.Stop();
particleSystem.startLifetime = LifeTime;
particleSystem.scalingMode = ParticleSystemScalingMode.Hierarchy;
ParticleSystem.ShapeModule sm = particleSystem.shape;
sm.shapeType = ParticleSystemShapeType.Cone;
sm.radius = Radius;
sm.angle = Angle;
sm.randomDirection = false;
sm.enabled = true;
ParticleSystem.SizeOverLifetimeModule sl = particleSystem.sizeOverLifetime;
sl.size = new ParticleSystem.MinMaxCurve(Size, AnimationCurve.Linear(0f, StartSize, LifeTime, EndSize));
sl.enabled = true;
ParticleSystem.ColorOverLifetimeModule colm = particleSystem.colorOverLifetime;
colm.color = new Gradient()
{
alphaKeys = new GradientAlphaKey[] { new GradientAlphaKey(1, 0), new GradientAlphaKey(0, LifeTime) },
colorKeys = new GradientColorKey[] { new GradientColorKey(StartColor, ColorStartTime), new GradientColorKey(EndColor, ColorEndTime) }
};
colm.enabled = true;
ParticleSystemRenderer particleSystemRenderer = GetComponent <ParticleSystemRenderer>();
particleSystemRenderer.sharedMaterial = new Material(Shader.Find("Particles/Additive"));
particleSystemRenderer.sharedMaterial.mainTexture = (ModResource.GetTexture("Rocket Fire Texture"));
}
