protected void Spark(Color particleColor, int numberOfParticles)
{
var particleMain = explodePS.main;
particleMain.startColor = particleColor;
var newBurst = new ParticleSystem.Burst(0f, numberOfParticles);
explodePS.emission.SetBurst(0, newBurst);
explodePS.Play();
TTTEventsManager.main.SomeoneSparked(gameObject);
}
public override void EmitParticles()
{
particle = GetComponent <ParticleSystem>();
var emission = particle.emission;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount];
emission.GetBursts(bursts);
max = bursts[0].maxCount;
min = bursts[0].minCount;
particle.Emit(Random.Range(min, max));
}
void SetArrowSize()
{
foreach (ParticleSystem ps in particleSystems)
{
var em = ps.emission;
ParticleSystem.Burst mBurst = em.GetBurst(0);
mBurst.count = Mathf.RoundToInt(mBurst.count.constant * EffectController.Instance.SizeMultiplier);
em.SetBurst(0, mBurst);
//em.burstCount = Mathf.RoundToInt(em.burstCount * EffectController.Instance.SizeMultiplier);
}
}
public void SpillBlood(Vector3 collisionPoint, Transform colliderHit, float hitMagnitude)
{
var instance = Instantiate(BloodSplatterEffect, collisionPoint, Quaternion.LookRotation(CalculateRotation(collisionPoint, colliderHit), Vector3.up), colliderHit);
var effect = instance.GetComponent <ParticleSystem>();
short minAmount = (short)(hitMagnitude * 50);
short maxAmount = (short)(hitMagnitude * 500);
var burst = new ParticleSystem.Burst(0, minAmount, maxAmount, 1, 0.01f);
effect.emission.SetBurst(0, burst);
effect.Play();
Destroy(instance, 1);
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystem.Burst uo = (ParticleSystem.Burst)obj;
time = uo.time;
count = uo.count;
minCount = uo.minCount;
maxCount = uo.maxCount;
cycleCount = uo.cycleCount;
repeatInterval = uo.repeatInterval;
probability = uo.probability;
}
/**
*获取生命周期内爆发的粒子总数
*/
private int GetBurstTotal(ParticleSystem comp)
{
int total = 0;
var bursts = new ParticleSystem.Burst[comp.emission.burstCount];
comp.emission.GetBursts(bursts);
foreach (var burst in bursts)
{
total += burst.maxCount;
}
return(total);
}
protected override object WriteToImpl(object obj)
{
obj = base.WriteToImpl(obj);
ParticleSystem.Burst uo = (ParticleSystem.Burst)obj;
uo.time = time;
uo.count = count;
uo.minCount = minCount;
uo.maxCount = maxCount;
uo.cycleCount = cycleCount;
uo.repeatInterval = repeatInterval;
uo.probability = probability;
return(uo);
}
private void Start()
{
// copy components
explosionMask = owner.m_EnemyStats.hitMask;
damage = owner.m_EnemyStats.attackValue;
// get the particle burst info
emission = thisParticle.emission;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[emission.burstCount];
emission.GetBursts(bursts);
min = bursts[0].minCount;
max = bursts[0].maxCount;
transform.parent = null;
}
/// <summary>
/// Play particles at the given position.
/// </summary>
private void PlayParticles(Vector3 position, ParticleSystem selectedParticle)
{
ParticleSystem.Burst spawnBurst = selectedParticle.emission.GetBurst(0);
int spawnCount = Random.Range(spawnBurst.minCount, spawnBurst.maxCount + 1);
position.z = selectedParticle.transform.position.z;
selectedParticle.transform.position = position;
selectedParticle.Emit(new ParticleSystem.EmitParams
{
position = position,
applyShapeToPosition = true
}, spawnCount);
}
/// /////////////////////////////////////////////////////////
/// 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);
}
}
void InstantiateParticleSystem()
{
GameObject particleGO = Instantiate <GameObject>(AsteraX.AsteroidsSO.GetAsteroidParticlePrefab(), transform.position, Quaternion.identity);
ParticleSystem particleSys = particleGO.GetComponent <ParticleSystem>();
ParticleSystem.MainModule main = particleSys.main;
main.startLifetimeMultiplier = size * 0.5f;
ParticleSystem.EmissionModule emitter = particleSys.emission;
ParticleSystem.Burst burst = emitter.GetBurst(0);
ParticleSystem.MinMaxCurve burstCount = burst.count;
burstCount.constant = burstCount.constant * size;
burst.count = burstCount;
emitter.SetBurst(0, burst);
}
/// <summary>
/// Shows sparks coming from the point of collision
/// </summary>
/// <param name="position">Position of collision</param>
/// <param name="damagePercent">How much percent of total HP of damage was inflicted, between 0 and 100</param>
public void collisionEffect(Vector2 position, float damagePercent = 100.0f)
{
if (!Managers.Camera.inView(position))
{
return;//don't display effect if it's not going to show
}
ParticleSystem chosenPS = null;
//Find existing particle system
foreach (ParticleSystem ps in collisionEffectList)
{
if (!ps.isPlaying)
{
chosenPS = ps;
break;
}
}
//Else make a new one
if (chosenPS == null)
{
GameObject ce = GameObject.Instantiate(collisionEffectPrefab);
ce.transform.parent = transform;
ParticleSystem ceps = ce.GetComponent <ParticleSystem>();
collisionEffectList.Add(ceps);
chosenPS = ceps;
}
//Start Speed
{
ParticleSystem.MainModule psmm = chosenPS.main;
ParticleSystem.MinMaxCurve psmmc = psmm.startSpeed;
float speed = (damagePercent * particleStartSpeed) / 100;
speed = Mathf.Max(speed, 0.5f);//make speed at least 1.0f
psmmc.constant = speed;
psmm.startSpeed = psmmc;
}
//Particle Amount
{
int amountOfParticles = (int)((damagePercent * particleAmount) / 100);
amountOfParticles = Mathf.Max(amountOfParticles, 3);//make speed at least 1.0f
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[1]
{
new ParticleSystem.Burst(0, (short)amountOfParticles)
};
chosenPS.emission.SetBursts(bursts);
}
//
chosenPS.gameObject.transform.position = position;
chosenPS.Play();
}
public void SpawnVFX(GameObject VFXSourceGo, Vector3 pos, VFXType vfxType, Vector3 extraVel, float delayTime, float lifetime)
{
if (delayTime == 0)
{
//If same type of vfx happen too fast and multiple times in the same spot then only spawn one of them at this moment
if (lastVFXSnapshots.ContainsKey(vfxType) && (lastVFXSnapshots[vfxType].pos - pos).magnitude < 0.05f && Time.time - lastVFXSnapshots[vfxType].time < smallestSameSpotVFXTimeInterval)
{
return;
}
//Record a specific vfx's snapshot
if (lastVFXSnapshots.ContainsKey(vfxType))
{
lastVFXSnapshots[vfxType] = new VFXSnapshot()
{
time = Time.time, pos = pos
};
}
else
{
lastVFXSnapshots.Add(vfxType, new VFXSnapshot()
{
time = Time.time, pos = pos
});
}
var go = GameObject.Instantiate(VFXSourceGo, pos, Quaternion.identity);
var partSyses = go.GetComponentsInChildren <ParticleSystem>();
foreach (var pSys in partSyses)
{
var emisModule = pSys.emission;
var bursts = new ParticleSystem.Burst[emisModule.burstCount];
emisModule.GetBursts(bursts);
for (int i = 0; i < bursts.Length; i++)
{
bursts[i].maxCount = (short)((float)bursts[i].maxCount * (1f + extraVel.magnitude * 0.5f));
bursts[i].minCount = (short)((float)bursts[i].minCount * (1f + extraVel.magnitude * 0.5f));
}
var main = pSys.main;
main.startSpeedMultiplier = 1f + extraVel.magnitude;
}
Destroy(go, lifetime);
}
else if (delayTime > 0)
{
StartCoroutine(SpawnVFX_Delay(VFXSourceGo, pos, vfxType, extraVel, delayTime, lifetime));
}
}
protected void Spark(Color particleColor, int numberOfParticles)
{
if (explodePS == null)
{
explodePS = GetComponentInChildren <ParticleSystem> ();
}
ParticleSystem.MainModule particleMain = explodePS.main;
particleMain.startColor = particleColor;
var newBurst = new ParticleSystem.Burst(0f, numberOfParticles);
explodePS.emission.SetBurst(0, newBurst);
explodePS.Play();
TTTEventsManager.main.SomeoneSparked(gameObject);
}
public void Set(float effort)
{
ParticleSystem.Burst b = particle.emission.GetBurst(0);
if (effort < sweatThreshold)
{
b.count = 0;
}
else
{
b.count = Mathf.Floor(effort * maxDropCount);
}
b.repeatInterval = maxBurstInterval - (effort * (maxBurstInterval - minBurstInterval));
particle.emission.SetBurst(0, b);
}
public EmissionModuleLoader(ParticleSystem.EmissionModule module)
{
_value = module;
bursts = new CallbackList <BurstLoader>(e =>
{
_value.SetBursts(bursts.Select(b => b.Value).ToArray());
});
ParticleSystem.Burst[] burstArray = new ParticleSystem.Burst[module.burstCount];
module.GetBursts(burstArray);
for (Int32 i = 0; i < module.burstCount; i++)
{
bursts.Add(burstArray[i], i + 1 == module.burstCount);
}
}
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();
}
private JSONObject ParseBurst(ParticleSystem.Burst burst)
{
JSONObject res = new JSONObject(JSONObject.Type.OBJECT);
res.AddField("time", burst.time);
#if UNITY_2017_1_OR_NEWER
res.AddField("count", ParseMinMaxCurve(burst.count));
res.AddField("cycles", burst.cycleCount);
res.AddField("interval", burst.repeatInterval);
#else
res.AddField("count", ParseTwoConstants(burst.maxCount, burst.minCount));
#endif
res.AddField("probability", 1);
return(res);
}
void ParticleEffect()
{
if (particleSystem)
{
var mainModule = particleSystem.main;
var emissionModule = particleSystem.emission;
var internalTime = particleSystem.time;
var thisBurst = new ParticleSystem.Burst(Time.fixedDeltaTime, (short)particleCount, (short)particleCount, 1, 0f);
emissionModule.burstCount = 1;
emissionModule.SetBurst(0, thisBurst);
//emissionModule.rateOverTime = 0.0f;
particleSystem.Play();
}
}
public void PlayDestroyedParticleEffect()
{
float magnitude = (linePoints[1] - linePoints[0]).magnitude;
GameObject instantiated = GameObject.Instantiate(team.resources.tronWallDestroyedPrefab,
(linePoints[1] + linePoints[0]) / 2, transform.rotation);
ParticleSystem ps = instantiated.EnsureComponent <ParticleSystem>();
ParticleSystem.MainModule main = ps.main;
main.startColor = team.teamColor.color;
ParticleSystem.ShapeModule shape = ps.shape;
shape.radius = magnitude * .65f;
ParticleSystem.EmissionModule emission = ps.emission;
ParticleSystem.Burst burst = emission.GetBurst(0);
burst.count = Mathf.Min(magnitude * burst.count.constant, maxParticlesOnDestroy);
emission.SetBurst(0, burst);
ps.Play();
}
public static int GetBurstMax(this ParticleSystem particleSystem)
{
int val = 0;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[particleSystem.emission.burstCount];
particleSystem.emission.GetBursts(bursts);
foreach (ParticleSystem.Burst burst in bursts)
{
val = Mathf.Max(val, burst.maxCount);
val = Mathf.Max(val, burst.minCount);
if (burst.cycleCount == 0 && burst.repeatInterval > 0)
{
val = Mathf.Max(val, Mathf.CeilToInt(1f / burst.repeatInterval) * val);
}
}
return(val);
}
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 OnDestroy()
{
ParticleSystem.MainModule mainMod = ExplosionEffect.main;
mainMod.maxParticles = (int)(this.transform.localScale.x * 10);
//mainMod.startSpeed = this.transform.localScale.x;
ParticleSystem.EmissionModule emissionModule;
emissionModule = ExplosionEffect.emission;
emissionModule.rateOverTime = 0;
ParticleSystem.Burst burst = emissionModule.GetBurst(0);
burst.count = mainMod.maxParticles;
ExplosionEffect.transform.parent = null;
ExplosionEffect.transform.localScale = Vector3.one;
ExplosionEffect.gameObject.SetActive(true);
ExplosionEffect.Play();
}
public void DiamondsPopUpfunction(int numberofdiamonds) // Yeh particle system wala hai
{
ParticleSystem ps = diamondsPop.GetComponent <ParticleSystem>();
//ps.emission.SetBurst(0, new ParticleSystem.Burst(0, numberofdiamonds));
ParticleSystem.Burst bursttt = ps.emission.GetBurst(0);
if (numberofdiamonds < 5)
{
bursttt.count = numberofdiamonds;
}
else
{
bursttt.count = 5;
}
ps.emission.SetBurst(0, bursttt);
GameObject popUpGameObject = (GameObject)Instantiate(diamondsPop, transform.position, transform.rotation);
// Destroy(popUpGameObject, 0.7f);
}
// パーティクルエミッション格納
void SetEmission()
{
SetParam(ref m_saveData.emission.rateOverTime, m_particle.emission.rateOverTime);
int burstsNum = m_particle.emission.burstCount;
if (burstsNum != 0)
{
m_saveData.emission.bursts = new Burst[burstsNum];
ParticleSystem.Burst[] burst = new ParticleSystem.Burst[burstsNum];
m_particle.emission.GetBursts(burst);
for (int i = 0; i < burstsNum; ++i)
{
m_saveData.emission.bursts[i].minCount = burst[i].minCount;
m_saveData.emission.bursts[i].maxCount = burst[i].maxCount;
m_saveData.emission.bursts[i].time = burst[i].time;
}
}
}
public void OnCollisionEnter(Collision collision)
{
PlayerState.CollisionEnter(collision);
float force = 20f;
////float forceOffset = 0.1f;
// If we hit the floor
float dotProduct = Vector3.Dot(collision.contacts[0].normal, Vector3.up);
if (dotProduct > 0.9f && dotProduct < 1.1f)
{
ParticleSystem ps = transform.GetChild((int)PlayerChildren.LandingParticles).GetComponent <ParticleSystem>();
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[ps.emission.burstCount];
ps.emission.GetBursts(bursts);
bursts[0].minCount = (short)Mathf.Lerp(2.0f, 6.0f, (collision.relativeVelocity.magnitude / 150.0f));
bursts[0].maxCount = (short)Mathf.Lerp(3.0f, 8.0f, (collision.relativeVelocity.magnitude / 150.0f));
ps.emission.SetBursts(bursts);
ps.Play();
}
if (deformer)
{
float vibforce = collision.relativeVelocity.magnitude / 150.0f;
//GamePad.VibrateForSeconds(playerIndex, vibforce, vibforce, 0.1f);
float vel = collision.relativeVelocity.magnitude / collision.contacts.Length;
for (int i = 0; i < collision.contacts.Length; i++)
{
Vector3 point = collision.contacts[i].point;
deformer.AddDeformingForce(point, vel * force);
}
}
if (!collision.transform.GetComponent <Player>() && !IsUnderWater)
{
if (Physics.Raycast(transform.position + Vector3.up * 0.5f + raycastOffsetPlayer * transform.forward, Vector3.down, raycastDist) ||
Physics.Raycast(transform.position + Vector3.up * 0.5f - raycastOffsetPlayer * transform.forward, Vector3.down, raycastDist) ||
Physics.Raycast(transform.position + Vector3.up * 0.5f + raycastOffsetPlayer * transform.right, Vector3.down, raycastDist) ||
Physics.Raycast(transform.position + Vector3.up * 0.5f - raycastOffsetPlayer * transform.right, Vector3.down, raycastDist))
{
IsGrounded = true;
}
}
}
private void Awake()
{
cutingWind = GetComponentInChildren <ParticleSystem>();
_audioSource = GetComponent <AudioSource>();
//Ball = GetComponentInChildren<ParticleSystem>();
_pointLigth = GetComponentInChildren <Light>();
trBall = GetComponentInChildren <TrailRenderer>();
cutingWindMain = cutingWind.main;
BallMain = Ball.main;
shapeWInd = cutingWind.shape;
emissionWind = cutingWind.emission;
_burstWind = emissionWind.GetBurst(1);
cutingWindMain.startColor = grColor;
BallMain.startColor = grColor;
trBall.colorGradient = grColor;
_pointLigth.intensity = 0;
_audioSource.loop = true;
}
private void ProcessEffect(ContactPoint2D contact)
{
var minThresholdImpulse = 20f;
var maxImpulse = 100f;
if (contact.normalImpulse > minThresholdImpulse || health <= 0f)
{
var ruble = Instantiate(rubleParticlePrefab, contact.point, Quaternion.identity);
var rotation = Quaternion.LookRotation(ruble.transform.forward, contact.normal * -1);
ruble.transform.rotation = rotation;
var rubleParticle = ruble.GetComponent <ParticleSystem>();
var mainModule = rubleParticle.main;
var emissionModule = rubleParticle.emission;
var burst = new ParticleSystem.Burst(0, contact.normalImpulse / maxImpulse * mainModule.maxParticles);
emissionModule.SetBurst(0, burst);
Destroy(ruble, 1f);
cameraShake.Shake(contact.normalImpulse / maxImpulse * cameraShake.maxAmplitude);
}
}
// Start is called before the first frame update
void Start()
{
var BlockComponent = GetComponent <DataBlockComponent>();
if (LookIntoParent)
{
BlockComponent = transform.parent.gameObject.GetComponent <DataBlockComponent>();
}
if (BlockComponent == null)
{
return;
}
var particleObject = gameObject;
Target = particleObject.GetComponent <ParticleSystem>();
var tBurst = Target.emission.GetBurst(0);
if (BlockComponent.DataBlock == null)
{
return;
}
if (BlockComponent.DataBlock.GetParameterByName("ParticleMaterial", out var param))
{
var material = particleObject.GetComponent <ParticleSystemRenderer>().material;
if (!material.name.StartsWith(param.Value))
{
var nMaterial = (Material)Resources.Load("Particles/" + param.Value);
if (nMaterial != default)
{
particleObject.GetComponent <ParticleSystemRenderer>().material = nMaterial;
}
else
{
Debug.LogWarning($"The GameObject: {gameObject.name} is asking for ParticleMaterial: {param.Value} which does not exist. Using default material...");
}
}
}
if (BlockComponent.DataBlock.GetParameterByName <int>("Particle_BurstCount", out var tParam))
{
var nBurst = new ParticleSystem.Burst(tBurst.time, tParam.Value);
Target.emission.SetBurst(0, nBurst);
}
}
void InstantiateParticleSystem(int ndx)
{
if (particleSystems.Length <= ndx)
{
return;
}
GameObject particleGO = Instantiate <GameObject>(particleSystems[ndx], transform.position, Quaternion.identity);
ParticleSystem particleSys = particleGO.GetComponent <ParticleSystem>();
ParticleSystem.MainModule main = particleSys.main;
main.startLifetimeMultiplier = size * 0.5f;
ParticleSystem.EmissionModule emitter = particleSys.emission;
ParticleSystem.Burst burst = emitter.GetBurst(0);
ParticleSystem.MinMaxCurve burstCount = burst.count;
burstCount.constant = burstCount.constant * size;
burst.count = burstCount;
emitter.SetBurst(0, burst);
Destroy(particleGO, 4f);
}
