private void Start()
{
if (particle == null)
{
particle = GetComponent <ParticleSystem>();
}
mainm = particle.main;
emitm = particle.emission;
switch (mode)
{
case FireworkControlMode.Once:
mainm.loop = false;
emitm.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1) });
particle.Play();
break;
case FireworkControlMode.Loop:
mainm.loop = true;
emitm.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1) });
mainm.duration = looplength;
particle.Play();
break;
case FireworkControlMode.Random:
mainm.loop = true;
emitm.SetBursts(new ParticleSystem.Burst[0]);
particle.Play();
break;
}
}
public override object WriteTo(object obj)
{
obj = base.WriteTo(obj);
if (obj == null)
{
return(null);
}
ParticleSystem.EmissionModule o = (ParticleSystem.EmissionModule)obj;
if (m_bursts != null)
{
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[m_bursts.Length];
for (int i = 0; i < m_bursts.Length; ++i)
{
if (m_bursts[i] != null)
{
bursts[i] = (ParticleSystem.Burst)m_bursts[i].WriteTo(bursts[i]);
}
}
o.SetBursts(bursts);
}
else
{
o.SetBursts(new ParticleSystem.Burst[0]);
}
return(obj);
}
private void Start()
{
int currentParticleQuality = GraphicsSettings.INSTANCE.CurrentParticleQuality;
float num2 = this.coefficient[currentParticleQuality];
ParticleSystem[] componentsInChildren = base.GetComponentsInChildren <ParticleSystem>();
int index = 0;
while (index < componentsInChildren.Length)
{
ParticleSystem system = componentsInChildren[index];
ParticleSystem.MainModule main = system.main;
main.maxParticles = Mathf.Max(Mathf.Min(main.maxParticles, 1), (int)(main.maxParticles * num2));
ParticleSystem.EmissionModule emission = system.emission;
emission.rateOverTimeMultiplier = Mathf.Max(Mathf.Min(emission.rateOverTimeMultiplier, 1f), (float)((int)(emission.rateOverTimeMultiplier * num2)));
emission.rateOverDistanceMultiplier = Mathf.Max(Mathf.Min(emission.rateOverDistanceMultiplier, 1f), (float)((int)(emission.rateOverDistanceMultiplier * num2)));
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount];
emission.GetBursts(bursts);
int num4 = 0;
while (true)
{
if (num4 >= emission.burstCount)
{
emission.SetBursts(bursts);
index++;
break;
}
bursts[num4].minCount = (short)Mathf.Max((float)Mathf.Min(bursts[num4].minCount, 1), bursts[num4].minCount * num2);
bursts[num4].maxCount = (short)Mathf.Max((float)Mathf.Min(bursts[num4].maxCount, 1), bursts[num4].maxCount * num2);
num4++;
}
}
}
public static void ParticleEmissionSettings(this ParticleSystem PS,
bool enabled = true,
float scalar = 0.0f,
bool RateOverTime = false,
bool Burst = false,
ParticleSystem.Burst[] BurstSettings = null, // Set Externally
AnimationCurve animationCurve = null, // Set Externally
ParticleSystemCurveMode CurveMode = ParticleSystemCurveMode.Constant,
int rate = 0
)
{
ParticleSystem.MinMaxCurve EmissionCurve;
ParticleSystem.EmissionModule emissionModule = PS.emission;
// Emission Settings
emissionModule.enabled = enabled;
if (RateOverTime)
{
EmissionCurve = new ParticleSystem.MinMaxCurve(scalar, animationCurve);
EmissionCurve.mode = CurveMode;
emissionModule.rateOverTime = EmissionCurve;
}
if (Burst)
{
emissionModule.SetBursts(BurstSettings);
}
emissionModule.rateOverTime = rate;
}
// Token: 0x06000DB1 RID: 3505 RVA: 0x00043364 File Offset: 0x00041564
private void Start()
{
this.originalCoinCount = (int)base.GetComponent <EffectComponent>().effectData.genericFloat;
int i = this.originalCoinCount;
for (int j = 0; j < this.coinTiers.Length; j++)
{
CoinBehavior.CoinTier coinTier = this.coinTiers[j];
int num = 0;
while (i >= coinTier.valuePerCoin)
{
i -= coinTier.valuePerCoin;
num++;
}
if (num > 0)
{
ParticleSystem.EmissionModule emission = coinTier.particleSystem.emission;
emission.enabled = true;
emission.SetBursts(new ParticleSystem.Burst[]
{
new ParticleSystem.Burst(0f, (float)num)
});
coinTier.particleSystem.gameObject.SetActive(true);
}
}
}
private void SetCoinParticles()
{
ParticleSystem.EmissionModule coinFxEmission = coinFX.emission;
float f = 0.75f / (coinRewardCount / 5);
coinFxEmission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, 1, coinRewardCount / 2, f) });
SceneActivationBehaviour <GameLogicActivator> .Instance.GameController.CoinsGrantedHandler(coinRewardCount, coinSourceType);
}
private void setcount(ParticleSystem.EmissionModule emission, short[] counts, float scale)
{
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount];
emission.GetBursts(bursts);
for (int i = 0; i < bursts.Length; i++)
{
bursts[i].maxCount = (short)(counts[i] * scale);
}
emission.SetBursts(bursts);
}
void SetLaserGunPositions(ParticleSystem ps, float distance)
{
ParticleSystem.ShapeModule sm = ps.shape;
sm.length = distance - 0.6f; // 0.4 seconds lifetime, speed = 1. Slight extension
ParticleSystem.EmissionModule em = ps.emission;
em.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0f, (short)(distance * 2)) });
ps.Play();
}
private void SetCoinParticles()
{
ParticleSystem.EmissionModule coinFxEmission = coinFX.emission;
int cycles = (int)(coinRewardCount * 0.1f);
float f = WaitTime / (float)cycles;
//print($"PARTICLE CYCLES {cycles} frequency: {f}");
coinFxEmission.SetBursts(new ParticleSystem.Burst[] {
new ParticleSystem.Burst(0, 1, 1, cycles, f)
});
}
public override object WriteTo(object obj)
{
obj = base.WriteTo(obj);
if (obj == null)
{
return(null);
}
ParticleSystem.EmissionModule o = (ParticleSystem.EmissionModule)obj;
if (m_bursts != null)
{
o.SetBursts(m_bursts);
}
else
{
o.SetBursts(new ParticleSystem.Burst[0]);
}
return(obj);
}
public void CreateWeatherEffect()
{
UniStormSystem UniStormSystemObject = FindObjectOfType <UniStormSystem>();
ParticleSystem Temp = Instantiate(WeatherEffect, Vector3.zero, Quaternion.AngleAxis(-90, Vector3.right));
Temp.transform.SetParent(GameObject.Find("UniStorm Effects").transform);
Temp.name = Temp.name.Replace("(Clone)", " (UniStorm)");
ParticleSystem.EmissionModule CurrentEmission = Temp.emission;
CurrentEmission.enabled = true;
CurrentEmission.rateOverTime = new ParticleSystem.MinMaxCurve(0);
CurrentEmission.SetBursts(new ParticleSystem.Burst[] { });
UniStormSystemObject.WeatherEffectsList.Add(Temp);
}
/// /////////////////////////////////////////////////////////
/// Emission
/// /////////////////////////////////////////////////////////
// Set emission
public static void SetEmission(ParticleSystem.EmissionModule emissionModule, float distanceRate, int burstAmount)
{
emissionModule.enabled = true;
emissionModule.rateOverTimeMultiplier = 0f;
emissionModule.rateOverDistanceMultiplier = distanceRate;
// Set burst
if (burstAmount > 0)
{
ParticleSystem.Burst burst = new ParticleSystem.Burst(0.0f, (short)burstAmount, (short)burstAmount, 1, 999f);
ParticleSystem.Burst[] bursts = new [] { burst };
emissionModule.SetBursts(bursts);
}
}
public void TriggerWave(int wave)
{
currentEnemy = 0;
currentWave = wave;
int particleCount = Waves[currentWave].Enemies.Length;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[1];
ParticleSystem.EmissionModule emissions = particlesystem.emission;
emissions.GetBursts(bursts);
bursts[0].minCount = (short)particleCount;
bursts[0].maxCount = (short)particleCount;
emissions.SetBursts(bursts);
particlesystem.Play();
}
public virtual void Start()
{
ParticleSystem myParticleSystem = this.GetComponent <ParticleSystem>();
ParticleSystem.MainModule mainModule = myParticleSystem.main;
ParticleSystem.MinMaxCurve origStartLifetime = mainModule.startLifetime;
ParticleSystem.MinMaxCurve startLifetime = new ParticleSystem.MinMaxCurve(0);
startLifetime.constantMin = 0;
startLifetime.constantMax = origStartLifetime.constantMax;
mainModule.startLifetime = startLifetime;
ParticleSystem.EmissionModule emissionModule = myParticleSystem.emission;
float burstSize = emissionModule.rateOverTime.constantMin * startLifetime.constantMax;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[1];
bursts[0] = new ParticleSystem.Burst(0f, (short)Mathf.RoundToInt(burstSize), (short)Mathf.RoundToInt(burstSize));
emissionModule.SetBursts(bursts);
}
private void MapEmissionParameters(ParticleSystem pSystem, int i)
{
ParticleSystem.EmissionModule emissionModule = pSystem.emission;
try {
emissionModule.enabled = GetBoolParam(i, "emission_enabled");
}
catch (NullReferenceException) {
emissionModule.enabled = false;
return;
}
emissionModule.rateOverTime = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "emission_rateOverTime"));
emissionModule.rateOverDistance = NodeFXUtilities.InterpretStringToCurve(GetStringParam(i, "emission_rateOverDistance"));
emissionModule.SetBursts(NodeFXUtilities.InterpretStringToBurst(GetStringParam(i, "emission_bursts")));
return;
}
private void AddSubEmitter(ref ParticleSystem subPS, ParticleSystemSubEmitterType type,
System.Action <Vector3> callback)
{
// Create SubEmitter object
GameObject go = new GameObject("subemitter-" + type.ToString());
go.transform.parent = transform;
go.transform.localPosition = Vector3.zero;
go.transform.localScale = Vector3.one;
go.transform.localEulerAngles = Vector3.zero;
// Configure SubEmitter particle system
subPS = go.AddComponent <ParticleSystem>();
subPS.Stop();
// go.GetComponent<ParticleSystemRenderer>().material = new Material(Shader.Find("Particles/Additive"));
ParticleSystem.MainModule main = subPS.main;
main.duration = 10f;
main.startLifetime = 10f;
main.startSize = 0f;
main.startSpeed = 0f;
main.maxParticles = ps.main.maxParticles;
main.loop = true;
main.playOnAwake = true;
ParticleSystem.EmissionModule emission = subPS.emission;
emission.rateOverTime = 0f;
emission.SetBursts(new ParticleSystem.Burst[]
{
new ParticleSystem.Burst(0f, 1, 1, 1, 0)
});
ParticleSystem.ShapeModule shape = subPS.shape;
shape.shapeType = ParticleSystemShapeType.Box;
shape.scale = Vector3.zero;
subPS.Play();
// Add SubEmitter callback
SubEmitterHandler handler = go.AddComponent <SubEmitterHandler>();
handler.callback = callback;
// Attach subemitter to to main emitter
ParticleSystem.SubEmittersModule subEmitters = ps.subEmitters;
subEmitters.AddSubEmitter(subPS, type, ParticleSystemSubEmitterProperties.InheritNothing);
subEmitters.enabled = true;
}
void setupEmission(ParticleSystem ps, SystemScrambler ss)
{
ParticleSystem.EmissionModule em = ps.emission;
if (!ss.Enabled [3])
{
return; //Need emission always enabled
}
em.rateOverTime = ss.Floats[32];
//Bursts
ParticleSystem.Burst[] bArray = new ParticleSystem.Burst[ss.Bursts [0]];
for (int i = 0; i < ss.Bursts [0]; i++)
{
short v1 = Convert.ToInt16(ss.Bursts [(i * 3) + 2]);
short v2 = Convert.ToInt16(ss.Bursts [(i * 3) + 3]);
ParticleSystem.Burst b = new ParticleSystem.Burst(
ss.Bursts [(i * 3) + 1], v1, v2);
bArray [i] = b;
}
em.SetBursts(bArray);
}
public void Initialize(int ID)
{
ParticleSystem.EmissionModule emit = ps.emission;
//Material and emission is determined by color, indicated by the ID number mod4
int i = ID % 4;
rend.material = materials[i];
emit.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, (short)(15 + (i * 5)), (short)(15 + (i * 5))) });
ps.Play();
if (AudioManager.RequestKillSound())
{
int c = Random.Range(0, clips.Length);
float p = Random.Range(0.95f, 1.05f);
aud.clip = clips[c];
aud.pitch = p;
aud.Play();
Invoke("RetireSound", 0.8f);
}
}
public void ParticleSelect(AI.Elements SpellType, ParticleSystem SpellPS)
{
ParticleSystem.MainModule Main = SpellPS.main;
ParticleSystem.EmissionModule EM = SpellPS.emission;
ParticleSystem.ColorOverLifetimeModule CLT = SpellPS.colorOverLifetime;
switch (SpellType)
{
case AI.Elements.Fire:
Main.startColor = Color.red;
EM.enabled = true;
EM.SetBursts(new ParticleSystem.Burst[]
{
new ParticleSystem.Burst(2.0f, 1),
new ParticleSystem.Burst(4.0f, 1)
});
Gradient Grad = new Gradient();
CLT.enabled = true;
Grad.SetKeys(new GradientColorKey[] { new GradientColorKey(Color.blue, 0.0f), new GradientColorKey(Color.red, 1.0f) }, new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(0.0f, 1.0f) });
CLT.color = Grad;
break;
case AI.Elements.Water:
break;
case AI.Elements.Electric:
break;
case AI.Elements.Nature:
break;
case AI.Elements.Rock:
break;
default: // Shouldn't hit this case
break;
}
}
public void UpdateParticleSystem()
{
ParticleSystem refSystem = referenceLine.GetComponent <ParticleSystem>();
ParticleSystem.MainModule refSetting = refSystem.main;
ParticleSystem.EmissionModule refEmission = refSystem.emission;
ParticleSystem.RotationOverLifetimeModule refRotationLifeTime = refSystem.rotationOverLifetime;
ParticleSystem.SizeOverLifetimeModule refSizeLifetime = refSystem.sizeOverLifetime;
ParticleSystemRenderer refRenderer = refSystem.GetComponent <ParticleSystemRenderer>();
ParticleSystem.Burst refBurst = refEmission.GetBurst(0);
foreach (Line line in triangleComplex.lines)
{
ParticleSystem particleSystem = line.GetComponent <ParticleSystem>();
ParticleSystem.MainModule particleSettings = particleSystem.main;
ParticleSystem.EmissionModule particleEmission = particleSystem.emission;
ParticleSystem.RotationOverLifetimeModule particleRotationLifeTime = particleSystem.rotationOverLifetime;
ParticleSystem.SizeOverLifetimeModule particleSizeLifetime = particleSystem.sizeOverLifetime;
ParticleSystemRenderer particleRenderer = particleSystem.GetComponent <ParticleSystemRenderer>();
particleSettings.customSimulationSpace = refSetting.customSimulationSpace;
particleSettings.duration = refSetting.duration;
particleSettings.emitterVelocityMode = refSetting.emitterVelocityMode;
particleSettings.flipRotation = refSetting.flipRotation;
particleSettings.gravityModifier = refSetting.gravityModifier;
particleSettings.gravityModifierMultiplier = refSetting.gravityModifierMultiplier;
particleSettings.loop = refSetting.loop;
particleSettings.maxParticles = refSetting.maxParticles;
particleSettings.playOnAwake = refSetting.playOnAwake;
particleSettings.prewarm = refSetting.prewarm;
particleSettings.scalingMode = refSetting.scalingMode;
particleSettings.simulationSpace = refSetting.simulationSpace;
particleSettings.simulationSpeed = refSetting.simulationSpeed;
particleSettings.startColor = refSetting.startColor;
particleSettings.startDelay = refSetting.startDelay;
particleSettings.startDelayMultiplier = refSetting.startDelayMultiplier;
particleSettings.startLifetime = refSetting.startLifetime;
particleSettings.startLifetimeMultiplier = refSetting.startLifetimeMultiplier;
particleSettings.startRotation = refSetting.startRotation;
particleSettings.startRotation3D = refSetting.startRotation3D;
particleSettings.startRotationMultiplier = refSetting.startRotationMultiplier;
particleSettings.startRotationX = refSetting.startRotationX;
particleSettings.startRotationXMultiplier = refSetting.startRotationXMultiplier;
particleSettings.startRotationY = refSetting.startRotationY;
particleSettings.startRotationYMultiplier = refSetting.startRotationYMultiplier;
particleSettings.startRotationZ = refSetting.startRotationZ;
particleSettings.startRotationZMultiplier = refSetting.startRotationZMultiplier;
particleSettings.startSize = refSetting.startSize;
particleSettings.startSize3D = refSetting.startSize3D;
particleSettings.startSizeMultiplier = refSetting.startSizeMultiplier;
particleSettings.startSizeX = refSetting.startSizeX;
particleSettings.startSizeXMultiplier = refSetting.startSizeXMultiplier;
particleSettings.startSizeY = refSetting.startSizeY;
particleSettings.startSizeYMultiplier = refSetting.startSizeYMultiplier;
particleSettings.startSizeZ = refSetting.startSizeZ;
particleSettings.startSizeZMultiplier = refSetting.startSizeZMultiplier;
particleSettings.startSpeed = refSetting.startSpeed;
particleSettings.startSpeedMultiplier = refSetting.startSpeedMultiplier;
particleSettings.stopAction = refSetting.stopAction;
particleSettings.useUnscaledTime = refSetting.useUnscaledTime;
particleEmission.burstCount = refEmission.burstCount;
particleEmission.enabled = refEmission.enabled;
particleEmission.rateOverDistance = refEmission.rateOverDistance;
particleEmission.rateOverDistanceMultiplier = refEmission.rateOverDistanceMultiplier;
particleEmission.rateOverTime = refEmission.rateOverTime;
particleEmission.rateOverTimeMultiplier = refEmission.rateOverTimeMultiplier;
particleRotationLifeTime.enabled = refRotationLifeTime.enabled;
particleRotationLifeTime.separateAxes = refRotationLifeTime.separateAxes;
particleRotationLifeTime.x = refRotationLifeTime.x;
particleRotationLifeTime.xMultiplier = refRotationLifeTime.xMultiplier;
particleRotationLifeTime.y = refRotationLifeTime.y;
particleRotationLifeTime.yMultiplier = refRotationLifeTime.yMultiplier;
particleRotationLifeTime.z = refRotationLifeTime.z;
particleRotationLifeTime.zMultiplier = refRotationLifeTime.zMultiplier;
particleSizeLifetime.enabled = refSizeLifetime.enabled;
particleSizeLifetime.separateAxes = refSizeLifetime.separateAxes;
particleSizeLifetime.size = refSizeLifetime.size;
particleSizeLifetime.sizeMultiplier = refSizeLifetime.sizeMultiplier;
particleSizeLifetime.x = refSizeLifetime.x;
particleSizeLifetime.xMultiplier = refSizeLifetime.xMultiplier;
particleSizeLifetime.y = refSizeLifetime.y;
particleSizeLifetime.yMultiplier = refSizeLifetime.yMultiplier;
particleSizeLifetime.z = refSizeLifetime.z;
particleSizeLifetime.zMultiplier = refSizeLifetime.zMultiplier;
particleRenderer.minParticleSize = refRenderer.minParticleSize;
particleEmission.SetBursts(new ParticleSystem.Burst[] { refBurst });
}
}
/// <summary>Awake message.</summary>
/// <author>Liam Ireland</author>
void Awake()
{
if (constantDampening < 0)
{
constantDampening *= -1.0F;
}
if (!medium)
{
medium = ScriptableObject.CreateInstance <ShockwaveMedium>();
}
particleEmitter = gameObject.AddComponent <ParticleSystem>() as ParticleSystem;
particleEmitter.name = "Particle Emitter";
particleEmitter.playOnAwake = true;
particleEmitter.loop = false;
particleEmitter.startLifetime = startLifetime;
particleEmitter.startSpeed = startSpeed;
particleEmitter.startSize = 0.1F;
particleEmitter.maxParticles = 1000000;
particleEmitter.simulationSpace = ParticleSystemSimulationSpace.World;
//setup the curve something module
//tom did this
ParticleSystem.LimitVelocityOverLifetimeModule limitVelocityModule = particleEmitter.limitVelocityOverLifetime;
limitVelocityModule.enabled = true;
limitVelocityModule.limit = 0F;
limitVelocityModule.dampen = constantDampening;
//setup the shape module
ParticleSystem.ShapeModule shapeModule = particleEmitter.shape;
shapeModule.enabled = true;
shapeModule.shapeType = ParticleSystemShapeType.Sphere;
shapeModule.radius = 0.01F;
shapeModule.randomDirection = true;
//setup the Emission module
ParticleSystem.EmissionModule emissionModule = particleEmitter.emission;
emissionModule.rate = 0;
// if the number of particles is bigger than the number of particles in each burst, split them up into seperate bursts
// (the reason for this is the maximum number of particles in one burst can only be a short (16 bits), using multiple bursts we can get around this (although unity does only limit us to 4 bursts))
if (NumberOfParticles > NoOfParticlesInEachBurst)
{
int numberOfBursts = 0;
if (NumberOfParticles % NoOfParticlesInEachBurst == 0)
{
numberOfBursts = NumberOfParticles / NoOfParticlesInEachBurst;
}
else
{
numberOfBursts = (NumberOfParticles / NoOfParticlesInEachBurst) + 1;
}
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[numberOfBursts];
for (int i = 0; i < numberOfBursts; i++)
{
bursts[i] = new ParticleSystem.Burst(0, NoOfParticlesInEachBurst);
}
emissionModule.SetBursts(bursts);
}
else
{
emissionModule.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0, NoOfParticlesInEachBurst) }); // make the bursts array and create the initiale burst of particles
}
// setup the collision module
ParticleSystem.CollisionModule collisionModule = particleEmitter.collision;
collisionModule.enabled = true;
collisionModule.type = ParticleSystemCollisionType.World;
collisionModule.mode = ParticleSystemCollisionMode.Collision3D;
collisionModule.enableDynamicColliders = true;
collisionModule.enableInteriorCollisions = true;
collisionModule.quality = ParticleSystemCollisionQuality.High; // could perhaps change to help performance
collisionModule.sendCollisionMessages = true;
collisionModule.maxCollisionShapes = 256; // default value
// get the static objects in the scene and set the particle triggers for diffraction - this is no longer used
/*
* Collider[] allColldiers = FindObjectsOfType<Collider>();
* staticColliders = new Collider[allColldiers.Length - FindObjectsOfType<Rigidbody>().Length]; // initialise the staticColliders array to the size of the number of static colliders in the scene
* int counter = 0;
* foreach (Collider collider in allColldiers) // loop through every collider in the scene
* {
* if (!collider.GetComponent<Rigidbody>()) // if the collider does not have a rigidbody
* {
* staticColliders[counter++] = collider; // set the collider to the counter element on the staticColliders array and increment the counter
* }
* }
*/
// set up the triggers for diffraction - this is no longer used
/*
* ParticleSystem.TriggerModule triggers = particleEmitter.trigger; // initialise the same amount of triggers as static colliders
* triggers.enabled = true;
* triggers.exit = ParticleSystemOverlapAction.Callback; // when a particle exits the trigger, call OnParticleTrigger()
* triggers.inside = ParticleSystemOverlapAction.Ignore;
* for (int i=0; i<counter; i++)
* {
* GameObject trigger = new GameObject();
* trigger.name = "Particle Trigger";
* trigger.transform.position = staticColliders[i].transform.position;
* trigger.transform.localScale = new Vector3(staticColliders[i].transform.localScale.x + 0.5F, staticColliders[i].transform.localScale.y + 0.5F, staticColliders[i].transform.localScale.z + 0.5F);
* trigger.AddComponent<BoxCollider>(); // I'm assuming the static colliders have box colliders - they may not - need to fix
* trigger.GetComponent<BoxCollider>().isTrigger = true;
* triggers.SetCollider(i, trigger.GetComponent<BoxCollider>());
* }
*/
}
public void DisableBursts()
{
emissionModule.SetBursts(null, 0);
}
public void Awake()
{
_particleSystem = (gameObject.AddComponent <ParticleSystem>()) as ParticleSystem;
if (gameObject.GetComponent <ParticleSystemRenderer>())
{
_psRenderer = gameObject.GetComponent <ParticleSystemRenderer>();
}
else
{
_psRenderer = (gameObject.AddComponent <ParticleSystemRenderer>()) as ParticleSystemRenderer;
}
_psEmitParams = new ParticleSystem.EmitParams();
_psEmission = _particleSystem.emission;
_psMain = _particleSystem.main;
_psVelocityOverLifetime = _particleSystem.limitVelocityOverLifetime;
_psSizeOverLifetime = _particleSystem.sizeOverLifetime;
_psColorOverLifetime = _particleSystem.colorOverLifetime;
_psShape = _particleSystem.shape;
_psMain.loop = false;
_psMain.startSpeed = 0f;
_psMain.flipRotation = .5f;
_psEmission.rateOverTime = 0;
_psEmission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, 1, 1) });
_psVelocityOverLifetime.enabled = true;
_psVelocityOverLifetime.separateAxes = true;
_psVelocityOverLifetime.limitX = .1f;
_psVelocityOverLifetime.limitY = .1f;
_psVelocityOverLifetime.limitZ = .1f;
_psVelocityOverLifetime.space = ParticleSystemSimulationSpace.World;
_psShape.enabled = true;
_psShape.shapeType = ParticleSystemShapeType.Sphere;
_psShape.radius = 0.1f;
_psRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
_psRenderer.receiveShadows = true;
//Just to start and make sure there is no interference
_psEmission.enabled = false;
_particleSystem.hideFlags = HideFlags.HideAndDontSave;
_psVelocityOverLifetime.dampen = _baseDamping;
_psRenderer.maxParticleSize = maxScreenSize;
_psRenderer.material = material;
_psRenderer.material.color = Color.white;
//Defaulting to a linear curve
if (!useExplicitSizeCurve)
{
SizeOverLifetimeCurve.AddKey(0.0f, 0.1f);
SizeOverLifetimeCurve.AddKey(1.0f, 1.0f);
}
_psSoLMMCurve = new ParticleSystem.MinMaxCurve(2, SizeOverLifetimeCurve);
_psSizeOverLifetime.size = _psSoLMMCurve;
if (explodeOnAwake)
{
Explode();
}
}
public override void OnLoad()
{
base.OnLoad();
equipmentDef.name = "MysticsItems_GateChalice";
ConfigManager.Balance.CreateEquipmentCooldownOption(equipmentDef, "Equipment: Gate Chalice", 60f);
equipmentDef.canDrop = true;
ConfigManager.Balance.CreateEquipmentEnigmaCompatibleOption(equipmentDef, "Equipment: Gate Chalice", false);
ConfigManager.Balance.CreateEquipmentCanBeRandomlyTriggeredOption(equipmentDef, "Equipment: Gate Chalice", false);
equipmentDef.isLunar = true;
equipmentDef.colorIndex = ColorCatalog.ColorIndex.LunarItem;
equipmentDef.pickupModelPrefab = PrepareModel(Main.AssetBundle.LoadAsset <GameObject>("Assets/Equipment/Gate Chalice/Model.prefab"));
equipmentDef.pickupIconSprite = Main.AssetBundle.LoadAsset <Sprite>("Assets/Equipment/Gate Chalice/Icon.png");
Material mat = equipmentDef.pickupModelPrefab.transform.Find("mdlGateChalice").gameObject.GetComponent <MeshRenderer>().sharedMaterial;
HopooShaderToMaterial.Standard.Apply(mat);
HopooShaderToMaterial.Standard.Gloss(mat, 0.5f);
HopooShaderToMaterial.Standard.Emission(mat, 0.02f, new Color(48f / 255f, 127f / 255f, 255f / 255f));
foreach (Transform lightTransform in equipmentDef.pickupModelPrefab.transform.Find("mdlGateChalice").Find("Lights"))
{
SetScalableChildEffect(equipmentDef.pickupModelPrefab, lightTransform.gameObject);
FlickerLight flickerLight = lightTransform.gameObject.AddComponent <FlickerLight>();
flickerLight.light = lightTransform.gameObject.GetComponent <Light>();
flickerLight.sinWaves = new Wave[] {
new Wave {
amplitude = 0.3f,
frequency = 4f
},
new Wave {
amplitude = 0.6f,
frequency = 2f
},
new Wave {
amplitude = 0.9f,
frequency = 1f
}
};
}
itemDisplayPrefab = PrepareItemDisplayModel(PrefabAPI.InstantiateClone(equipmentDef.pickupModelPrefab, equipmentDef.pickupModelPrefab.name + "Display", false));
onSetupIDRS += () =>
{
AddDisplayRule("CommandoBody", "Stomach", new Vector3(-0.09F, 0.1F, -0.102F), new Vector3(5.862F, 140.357F, 1.915F), new Vector3(0.059F, 0.059F, 0.059F));
AddDisplayRule("HuntressBody", "Pelvis", new Vector3(-0.082F, -0.111F, 0.085F), new Vector3(0.679F, 36.762F, 188.148F), new Vector3(0.047F, 0.047F, 0.048F));
AddDisplayRule("Bandit2Body", "Stomach", new Vector3(-0.096F, 0.027F, -0.151F), new Vector3(337.162F, 337.663F, 11.532F), new Vector3(0.04F, 0.04F, 0.04F));
AddDisplayRule("ToolbotBody", "Hip", new Vector3(-1.239F, 0.577F, -1.044F), new Vector3(0F, 180F, 180F), new Vector3(0.349F, 0.349F, 0.349F));
AddDisplayRule("EngiBody", "Pelvis", new Vector3(-0.178F, 0.078F, 0.157F), new Vector3(11.745F, 186.295F, 185.936F), new Vector3(0.047F, 0.047F, 0.047F));
AddDisplayRule("MageBody", "Pelvis", new Vector3(-0.128F, -0.131F, 0.024F), new Vector3(6.286F, 3.408F, 167.572F), new Vector3(0.044F, 0.044F, 0.044F));
AddDisplayRule("MercBody", "Chest", new Vector3(0F, 0.193F, -0.286F), new Vector3(71.925F, 180F, 0F), new Vector3(0.027F, 0.027F, 0.027F));
AddDisplayRule("TreebotBody", "FlowerBase", new Vector3(-0.485F, 0.701F, -0.803F), new Vector3(26.173F, 24.306F, 86.838F), new Vector3(0.061F, 0.061F, 0.061F));
AddDisplayRule("LoaderBody", "Pelvis", new Vector3(-0.216F, -0.016F, -0.022F), new Vector3(342.363F, 183.205F, 159.555F), new Vector3(0.045F, 0.045F, 0.045F));
AddDisplayRule("CrocoBody", "SpineStomach1", new Vector3(0.845F, 0.495F, 1.289F), new Vector3(74.633F, 327.618F, 247.859F), new Vector3(0.361F, 0.361F, 0.361F));
AddDisplayRule("CaptainBody", "Stomach", new Vector3(-0.195F, 0.128F, 0.126F), new Vector3(336.504F, 156.734F, 358.159F), new Vector3(0.041F, 0.041F, 0.041F));
AddDisplayRule("ScavBody", "MuzzleEnergyCannon", new Vector3(0F, 0F, -1.503F), new Vector3(90F, 0F, 0F), new Vector3(2.281F, 2.281F, 2.281F));
AddDisplayRule("EquipmentDroneBody", "GunBarrelBase", new Vector3(0F, 0F, 1.069F), new Vector3(0F, 0F, 0F), new Vector3(0.267F, 0.267F, 0.267F));
if (SoftDependencies.SoftDependenciesCore.itemDisplaysSniper)
{
AddDisplayRule("SniperClassicBody", "Pelvis", new Vector3(0.19432F, 0.18834F, -0.17385F), new Vector3(343.5044F, 339.549F, 357.2065F), new Vector3(0.05181F, 0.05181F, 0.05181F));
}
AddDisplayRule("RailgunnerBody", "Pelvis", new Vector3(0.14878F, -0.03065F, 0.10522F), new Vector3(354.5591F, 180F, 180F), new Vector3(0.05639F, 0.05639F, 0.05639F));
AddDisplayRule("VoidSurvivorBody", "Hand", new Vector3(-0.03581F, 0.28639F, -0.00539F), new Vector3(0F, 0F, 4.98446F), new Vector3(0.09781F, 0.09781F, 0.09781F));
};
visualEffectOnUse = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceOnUseEffect", false);
EffectComponent effectComponent = visualEffectOnUse.AddComponent <EffectComponent>();
effectComponent.soundName = "Play_env_teleporter_active_button";
effectComponent.positionAtReferencedTransform = true;
effectComponent.applyScale = true;
effectComponent.disregardZScale = true;
VFXAttributes vfxAttributes = visualEffectOnUse.AddComponent <VFXAttributes>();
vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Low;
vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.Low;
visualEffectOnUse.AddComponent <DestroyOnTimer>().duration = 2f;
GameObject massSparks = PrefabAPI.InstantiateClone(new GameObject(), "MassSparks", false);
ParticleSystem particleSystem = massSparks.AddComponent <ParticleSystem>();
massSparks.GetComponent <ParticleSystemRenderer>().material = Object.Instantiate(LegacyResourcesAPI.Load <GameObject>("Prefabs/Effects/ActivateRadarTowerEffect").transform.Find("MassSparks").gameObject.GetComponent <ParticleSystemRenderer>().material);
particleSystem.useAutoRandomSeed = true;
ParticleSystem.MainModule mainModule = particleSystem.main;
mainModule.simulationSpace = ParticleSystemSimulationSpace.World;
mainModule.scalingMode = ParticleSystemScalingMode.Local;
mainModule.startLifetime = 5f;
mainModule.duration = 1f;
mainModule.playOnAwake = true;
ParticleSystem.MinMaxCurve particleSpeed = mainModule.startSpeed;
particleSpeed.mode = ParticleSystemCurveMode.TwoConstants;
particleSpeed.constantMin = 10f;
particleSpeed.constantMax = 1000f;
mainModule.startSize = 0.1f;
mainModule.startColor = new Color(48f / 255f, 127f / 255f, 255f / 255f);
mainModule.gravityModifier = 0.3f;
mainModule.maxParticles = 20;
ParticleSystem.EmissionModule emissionModule = particleSystem.emission;
emissionModule.enabled = true;
emissionModule.rateOverTime = 10;
emissionModule.rateOverDistance = 0;
emissionModule.SetBursts(new ParticleSystem.Burst[]
{
new ParticleSystem.Burst
{
time = 0f,
count = 20f,
cycleCount = 1,
repeatInterval = 0.01f,
probability = 1f
}
});
ParticleSystem.ShapeModule shapeModule = particleSystem.shape;
shapeModule.shapeType = ParticleSystemShapeType.Sphere;
massSparks.transform.SetParent(visualEffectOnUse.transform);
MysticsItemsContent.Resources.effectPrefabs.Add(visualEffectOnUse);
visualEffectTeleportOut = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceTeleportOutEffect", false);
effectComponent = visualEffectTeleportOut.AddComponent <EffectComponent>();
vfxAttributes = visualEffectTeleportOut.AddComponent <VFXAttributes>();
vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Always;
vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.Medium;
visualEffectTeleportOut.AddComponent <DestroyOnTimer>().duration = 4f;
GameObject ppHolder = PrefabAPI.InstantiateClone(new GameObject(), "PP", false);
ppHolder.layer = LayerIndex.postProcess.intVal;
ppHolder.AddComponent <MysticsItemsGateChalicePPController>().time = 3f;
PostProcessVolume pp = ppHolder.AddComponent <PostProcessVolume>();
pp.isGlobal = true;
pp.weight = 0f;
pp.priority = 50;
PostProcessProfile ppProfile = ScriptableObject.CreateInstance <PostProcessProfile>();
ppProfile.name = "ppGateChalice";
LensDistortion lensDistortion = ppProfile.AddSettings <LensDistortion>();
lensDistortion.SetAllOverridesTo(true);
lensDistortion.intensity.value = -100f;
lensDistortion.scale.value = 1f;
ColorGrading colorGrading = ppProfile.AddSettings <ColorGrading>();
colorGrading.colorFilter.value = new Color(97f / 255f, 163f / 255f, 239f / 255f);
colorGrading.colorFilter.overrideState = true;
pp.sharedProfile = ppProfile;
ppHolder.transform.SetParent(visualEffectTeleportOut.transform);
MysticsItemsContent.Resources.effectPrefabs.Add(visualEffectTeleportOut);
SceneExitController sceneExitController = sceneExitControllerObject.AddComponent <SceneExitController>();
sceneExitController.useRunNextStageScene = true;
sceneExitControllerObject.AddComponent <MysticsItemsGateChaliceSceneExit>();
itemDestroyEffectPrefab = PrefabAPI.InstantiateClone(new GameObject(), "MysticsItems_GateChaliceItemDestroyEffect", false);
EntityStateMachine entityStateMachine = itemDestroyEffectPrefab.AddComponent <EntityStateMachine>();
entityStateMachine.initialStateType = entityStateMachine.mainStateType = new EntityStates.SerializableEntityStateType(typeof(MysticsItemsGateChaliceItemDestroyEffect));
PickupDisplay pickupDisplay = itemDestroyEffectPrefab.AddComponent <PickupDisplay>();
Rigidbody rigidbody = itemDestroyEffectPrefab.AddComponent <Rigidbody>();
rigidbody.useGravity = false;
rigidbody.drag = 2f;
effectComponent = itemDestroyEffectPrefab.AddComponent <EffectComponent>();
effectComponent.applyScale = true;
effectComponent.soundName = "Play_moonBrother_phase4_itemSuck_returnSingle";
vfxAttributes = itemDestroyEffectPrefab.AddComponent <VFXAttributes>();
vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.High;
vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Always;
Highlight highlight = itemDestroyEffectPrefab.AddComponent <Highlight>();
pickupDisplay.highlight = highlight;
highlight.highlightColor = Highlight.HighlightColor.pickup;
MysticsItemsContent.Resources.effectPrefabs.Add(itemDestroyEffectPrefab);
}
private void SetParticleSystemProps(ParticleEffectContent content, GameObject go, bool stream)
{
ParticleSystem particleSystem = go.GetComponent <ParticleSystem>();
ParticleSystem.MainModule main = particleSystem.main;
main.simulationSpace = content.isLocal ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World;
main.duration = content.duration;
main.startLifetime = content.duration;
main.gravityModifier = content.gravityModifier;
ParticleSystem.ShapeModule shape = particleSystem.shape;
switch (content.shapeType)
{
case ParticleEffectContent.ShapeType.Cone:
shape.shapeType = ParticleSystemShapeType.Cone;
break;
case ParticleEffectContent.ShapeType.Sphere:
shape.shapeType = ParticleSystemShapeType.Sphere;
break;
case ParticleEffectContent.ShapeType.Box:
shape.shapeType = ParticleSystemShapeType.Box;
break;
case ParticleEffectContent.ShapeType.Circle:
shape.shapeType = ParticleSystemShapeType.Circle;
break;
case ParticleEffectContent.ShapeType.Rectangle:
shape.shapeType = ParticleSystemShapeType.Rectangle;
break;
}
shape.scale = Vector3.one * content.shapeSize;
ParticleSystem.EmissionModule emission = particleSystem.emission;
emission.enabled = true;
if (stream)
{
emission.rateOverTime = content.burstCount;
}
else
{
emission.rateOverTime = 0;
emission.SetBursts(
new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, content.burstCount) });
}
ParticleSystem.VelocityOverLifetimeModule velocityOverLifetime = particleSystem.velocityOverLifetime;
velocityOverLifetime.enabled = true;
velocityOverLifetime.speedModifier = content.speed;
ParticleSystem.RotationOverLifetimeModule rotationOverLifetime = particleSystem.rotationOverLifetime;
rotationOverLifetime.enabled = true;
SetRotationOverLifetime(rotationOverLifetime, content.rotationOverLifetime);
ParticleSystem.SizeOverLifetimeModule sizeOverLifetime = particleSystem.sizeOverLifetime;
sizeOverLifetime.enabled = true;
SetSizeOverLifetime(sizeOverLifetime, content.startSize, content.endSize);
ParticleSystem.ColorOverLifetimeModule colorOverLifetime = particleSystem.colorOverLifetime;
colorOverLifetime.enabled = true;
colorOverLifetime.color = ColorTuplesToGradient(content.colorOverLifetime);
ParticleSystemRenderer renderer = go.GetComponent <ParticleSystemRenderer>();
renderer.material = particleMaterial;
}
