void AddParticles()
{
if (myRootObject == null)
{
return;
}
float farthestObjectSqDistance = 0.0f;
int childCount = myRootObject.transform.childCount;
for (int i = 0; i < childCount; i++)
{
Transform tr = myRootObject.transform.GetChild(i);
farthestObjectSqDistance = Mathf.Max(farthestObjectSqDistance, (myRootObject.transform.position - tr.position).sqrMagnitude);
}
SetMaterialAndProperties(myStarMaterial, myStarSize, 0, farthestObjectSqDistance);
Random.seed = 0;
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
emitParams.velocity = Vector3.zero;
emitParams.startLifetime = Mathf.Infinity;
myStarfieldPS.Clear();
for (int i = 0; i < childCount; i++)
{
Transform tr = myRootObject.transform.GetChild(i);
Color color = Color.white;
if (myColors.Length > 0)
{
color = myColors[Random.Range(0, myColors.Length)];
}
emitParams.startColor = color;
emitParams.position = tr.position;
emitParams.startSize = myStarSize;
myStarfieldPS.Emit(emitParams, 1);
}
}
public void SpawnInitalParticles()
{
#if UNITY_5_2
Debug.Log("Functionality nor supported in this unity version");
#else
for (int x = 0; x < _vecSpawnDevisionsPerAxis.x; x++)
{
for (int y = 0; y < _vecSpawnDevisionsPerAxis.y; y++)
{
for (int z = 0; z < _vecSpawnDevisionsPerAxis.z; z++)
{
Vector3 vecCordPercent = new Vector3(x / (_vecSpawnDevisionsPerAxis.x - 1), y / (_vecSpawnDevisionsPerAxis.y - 1), z / (_vecSpawnDevisionsPerAxis.z - 1));
vecCordPercent -= new Vector3(0.5f, 0.5f, 0.5f);
vecCordPercent = Vector3.Scale(vecCordPercent, _vecSpawnVolume);
Vector3 vecWorldCord = _trnSpawnBox.TransformPoint(vecCordPercent);
//transfer world to particle effect
// Vector3 vecParticelCord = _psyBoxParticelSystem.transform.worldToLocalMatrix * vecWorldCord;
//Debug.Log("ParticleLocal " + vecParticelCord.ToString() + " world " + vecWorldCord.ToString());
float fSize = _fParticleSize * Mathf.Min(new float[] { _trnSpawnBox.lossyScale.x, _trnSpawnBox.lossyScale.y, _trnSpawnBox.lossyScale.z });
ParticleSystem.EmitParams empEmitParamiters = new ParticleSystem.EmitParams();
empEmitParamiters.startColor = _colColour;
empEmitParamiters.velocity = Vector3.up;
empEmitParamiters.position = vecWorldCord;
empEmitParamiters.startSize = fSize;
empEmitParamiters.startLifetime = Random.Range(_vecLifetime.x, _vecLifetime.y);
empEmitParamiters.rotation = Random.Range(_vecStartRotation.x, _vecStartRotation.y);
//spawn particle
_psyBoxParticelSystem.Emit(empEmitParamiters, 1);
}
}
}
#endif
}
private void EmitExplosion(ref Vector3 pos)
{
int count = UnityEngine.Random.Range(2, 5);
while (count != 0)
{
float xVelocity = UnityEngine.Random.Range(-2.0f, 2.0f) * cameraMultiplier;
float yVelocity = UnityEngine.Random.Range(1.0f, 3.0f) * cameraMultiplier;
float lifetime = UnityEngine.Random.Range(0.1f, 0.2f);
float size = UnityEngine.Random.Range(0.05f, 0.1f) * cameraMultiplier;
ParticleSystem.EmitParams param = new ParticleSystem.EmitParams();
param.position = pos;
param.velocity = new Vector3(xVelocity, yVelocity, 0.0f);
param.startLifetime = lifetime;
param.startSize = size;
param.startColor = explosionColor;
RainExplosionParticleSystem.Emit(param, 1);
count--;
}
}
void PlayThrowImpulseParticles(Vector2 direction)
{
float angle = Mathf.Atan2(-direction.normalized.y, direction.normalized.x) * Mathf.Rad2Deg;
var throwEmitParams = new ParticleSystem.EmitParams();
//add 180 to compensate for the initial offset
if (direction != Vector2.zero)
{
angle -= 60;
}
else
{
angle = 0;
}
throwEmitParams.rotation3D = new Vector3(0, 0, angle);
VFXManager.instance.EmitAtPosition("Throw_Impulse", 1, target.position, false, target);
}
void EmitParticle(float x, float y, float z)
{
var emitParams = new ParticleSystem.EmitParams();
emitParams.startColor = Color.red;
emitParams.startSize = 0.2f;
emitParams.velocity = Vector3.zero;
emitParams.position = new Vector3(x, y, z);
emitParams.startLifetime = this.pointLifetime;
this.ps.Emit(emitParams, 1);
// alternatively, to create a first-class GameObject instead
GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = new Vector3(x, y, z);
cube.transform.localScale = Vector3.one * this.cubeScale;
cube.transform.parent = this.pointRoot.transform;
Debug.Log("PointCloudMaker :: Point created at " + x + ", " + y + ", " + z);
}
void UpdateParticles()
{
if (rotatedVerts == null)
{
InitializeTesseract();
InitializeParticles();
}
for (int i = 0; i < rotatedVerts.Count; i++)
{
//particles[i].position = rotatedVerts[i];
//particles[i].color = Color.white;
//particles[i].size = 1f;
ParticleSystem.EmitParams p = new ParticleSystem.EmitParams();
p.position = rotatedVerts[i];
p.startSize = 1f;
p.startLifetime = 0.5f;
particleSystem.Emit(p, 1);
}
//GetComponent<ParticleSystem>().SetParticles(particles, particles.Length);
}
public void Emit_SquareShot(ParticleSystem par, Transform tr, float speed, float size, float lifetime, int rows)
{
ParticleSystem.EmitParams em = emitParamsDefault;
em.startLifetime = lifetime;
em.startSize = size;
int r = rows / 2;
for (int i = -r; i <= r; i++)
{
for (int j = -r; j <= r; j++)
{
if (i == -r || i == r || j == -r || j == r)
{
em.position = tr.position;
em.velocity = tr.TransformDirection(i, 0, j) * speed / r;
par.Emit(em, 1);
}
}
}
}
private void EmitLayerCloudType(LayerCloudType layerCloudType, float deltaTime)
{
if ((layerCloudType.MaterialIds.Length != 0) && layerCloudType.IsEmit(deltaTime))
{
int[] materialIds = layerCloudType.MaterialIds;
Vector3 vector = new Vector3();
float num = 0f;
if (!layerCloudType.IsOdd())
{
num = -layerCloudType.InterleavedOffset * layerCloudType.GetRandomSize();
}
Color color = new Color(0f, 0f, 1f, 1f);
Vector3 vector2 = (Vector3)(Vector3.forward * this._particleSystem.startSpeed);
Vector3 vector3 = (Vector3)(this.EmitterSize / 2f);
while (num < 1f)
{
int index = UnityEngine.Random.Range(0, materialIds.Length);
color.r = ((float)materialIds[index]) / ((float)this._materialCount);
color.r += 0.5f / ((float)this._materialCount);
float randomSize = layerCloudType.GetRandomSize();
color.g = randomSize / 2f;
num += randomSize / 2f;
vector.x = num;
num += layerCloudType.GetRandomGap() * randomSize;
vector.y = layerCloudType.GetRandomPositionY();
vector = ((Vector3)(vector * 2f)) - Vector3.one;
vector.x *= vector3.x;
vector.x = -vector.x;
vector.y *= vector3.y;
vector.z = UnityEngine.Random.value * 10f;
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams {
position = vector,
velocity = vector2,
startSize = this.GetParticleId(),
startLifetime = this._particleSystem.startLifetime * UnityEngine.Random.Range((float)0.99f, (float)1.01f),
startColor = color
};
this._particleSystem.Emit(emitParams, 1);
}
}
}
private void UseBlink()
{
// This would cast rays only against colliders in layer 9 and 11
int aux9 = 1 << 9;
int aux11 = 1 << 11;
int layerMask = aux9 | aux11;
// But instead we want to collide against everything except layer 9 and 11
layerMask = ~layerMask;
RaycastHit hit;
Vector3 direction = new Vector3(moveInput.x, 0, moveInput.z);
player.audioSource.PlayOneShot(player.sounds[2]); //Player.sounds[2] is the blink sound
if (Physics.Raycast(transform.position, direction, out hit, player.blinkDistance, layerMask))
{
Debug.Log("Blink interference, layer: " + hit.collider.gameObject.layer);
Vector3 nextPosition = CalculateBlinkDirection(hit.distance);
transform.position = Vector3.Lerp(transform.position, nextPosition, player.movementSpeed);
}
else
{
Debug.Log("No blink interference");
Vector3 nextPosition = CalculateBlinkDirection();
transform.position = Vector3.Lerp(transform.position, nextPosition, player.movementSpeed);
}
currentSkillRate = player.blinkRate;
StartCoroutine(SetInvulnerability());
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
emitParams.position = transform.position;
emitParams.applyShapeToPosition = true;
particles.Emit(emitParams, 50);
uiManager.StartCd(player.blinkRate);
soundActive = false;
}
private void OnParticleCollisionManual(GameObject other, int aliveParticles = -1)
{
collisionEvents.Clear();
var aliveEvents = initiatorPS.GetCollisionEvents(other, collisionEvents);
for (int i = 0; i < aliveEvents; i++)
{
var angle = Vector3.Angle(collisionEvents[i].normal, Vector3.up);
if (angle > MaxGroundAngleDeviation)
{
continue;
}
if (InstantiateWhenZeroSpeed)
{
if (collisionEvents[i].velocity.sqrMagnitude > 0.1f)
{
continue;
}
var isNearDistance = false;
for (int j = 0; j < aliveParticles; j++)
{
var distance = Vector3.Distance(collisionEvents[i].intersection, particles[j].position);
if (distance < MinDistanceBetweenDecals)
{
isNearDistance = true;
}
}
if (isNearDistance)
{
continue;
}
}
var emiter = new ParticleSystem.EmitParams();
emiter.position = collisionEvents[i].intersection;
var rotation = Quaternion.LookRotation(-collisionEvents[i].normal).eulerAngles;
rotation.z = Random.Range(0, 360);
emiter.rotation3D = rotation;
DecalParticles.Emit(emiter, 1);
}
}
private void FixedUpdate()
{
if (target == null)
{
Destroy(gameObject);
return;
}
Rigidbody rBody = target.GetComponent <Rigidbody>();
AudioSource aSource = DriftAudio;
float speed = rBody.velocity.magnitude;
float rot = rBody.angularVelocity.magnitude / 2;
float angle = Vector3.Angle(rBody.velocity, Quaternion.Euler(0, -90, 0) * rBody.angularVelocity);
if (((angle > 50 && (rot > 10 || speed > 10)) || (rot > 30 && speed < 30)) && grounded)
{
var emitParams = new ParticleSystem.EmitParams
{
position = target.transform.position - new Vector3(0, +0.5f, 0) + Random.insideUnitSphere * 0.25f,
velocity = Vector3.zero,
startSize = Random.Range(3f, 5f),
startLifetime = 5,
startColor = Color.white
};
pSystem.Emit(emitParams, 1);
if (aSource && aSource.volume < 1)
{
aSource.volume = Mathf.Min(aSource.volume + 0.5f, 1);
}
//aSource.pitch = 0.8f+Mathf.Min(rot/400f,1.2f);
}
else
{
if (aSource && aSource.volume > 0)
{
aSource.volume = Mathf.Max(aSource.volume - 0.2f, 0);
}
}
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
Vector3 wp = Camera.main.ScreenToWorldPoint(Input.mousePosition);
wp.z = 0;
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
emitParams.position = wp;
emitParams.applyShapeToPosition = true;
m_Particles.Emit(emitParams, 100);
Collider2D[] allOverlaps = Physics2D.OverlapCircleAll(wp, 1.1f);
Debug.Log(string.Format("Hit {0} objects", allOverlaps.Length));
for (int i = 0; i < allOverlaps.Length; i++)
{
GameObject target = allOverlaps[i].gameObject;
//Do your thing here.
}
}
}
public void Hurt(GameObject source, int amount)
{
Value -= amount;
unhurtTime = 0;
if (blood != null)
{
ParticleSystem.EmitParams p = new ParticleSystem.EmitParams();
Vector3 sourcePosition = source != null ? source.transform.position : this.transform.position - new Vector3(0, 6f, 0);
p.position = this.transform.position;
for (int i = 0; i < 10 * amount; ++i)
{
p.velocity = (this.transform.position - sourcePosition).normalized * Random.Range(1f, 2f) * (source == null?2:1) + new Vector3(Random.RandomRange(-0.5f, 0.5f), Random.RandomRange(-0.5f, 0.5f), 0);
blood.Emit(p, (source == null ? 5: 1));
}
}
else
{
Debug.LogWarning(this.gameObject.name + " does not have a blood emitter");
}
}
public void Emit_TriangleSpread(ParticleSystem par, Transform tr, float speed, float speedRate, float size, float figureSize, float lifetime, int rows, int cols)
{
ParticleSystem.EmitParams em = emitParamsDefault;
em.startLifetime = lifetime;
em.startSize = size;
for (int i = -rows; i <= rows; i++)
{
Vector3 pos = tr.TransformDirection(i, 0, -Mathf.Abs(i) * 2);
float sp = speed;
float fsp = figureSize;
for (int a = 0; a < cols; a++)
{
sp += speed * speedRate;
fsp += figureSize * speedRate;
em.position = tr.position;
em.velocity = ((tr.forward * sp) + (tr.forward * rows + (pos / rows) * cols) * fsp);
par.Emit(em, 1);
}
}
}
private void AddFootprint(Vector3 position, Vector3 direction, State state)
{
Setting setting = state.setting;
ParticleSystem particleSystem = state.particleSystem;
float y = Mathf.Atan2(direction.x, direction.z) * 57.29578f;
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
Vector3 vector = position + setting.offset;
vector.y = 0f;
emitParams.position = vector;
emitParams.axisOfRotation = Vector3.up;
emitParams.rotation = y;
emitParams.startSize = setting.size;
emitParams.startLifetime = this.duration;
Vector3 vector2 = (Vector3)(Quaternion.Euler(0f, y, 0f) * -this._lightDir);
vector2 = (Vector3)((vector2 + Vector3.one) * 0.5f);
emitParams.startColor = new Color(vector2.x, vector2.y, vector2.z, 1f);
particleSystem.Emit(emitParams, 1);
}
public void Emit_SquareShot(ParticleSystem par, Vector3 position, Vector3 forward, Vector3 upVec, float speed, float size, float lifetime, int rows)
{
ParticleSystem.EmitParams em = emitParamsDefault;
em.startLifetime = lifetime;
em.startSize = size;
shotTransform.rotation = Quaternion.LookRotation(forward, upVec);
int r = rows / 2;
for (int i = -r; i <= r; i++)
{
for (int j = -r; j <= r; j++)
{
if (i == -r || i == r || j == -r || j == r)
{
em.position = position;
em.velocity = shotTransform.TransformDirection(i, 0, j) * speed / r;
par.Emit(em, 1);
}
}
}
}
public void Emit_CycleShot(ParticleSystem par, Transform tr, float speed, float speedRate, float size, float sizeRate, float lifetime, int rows, int cols)
{
ParticleSystem.EmitParams em = emitParamsDefault;
em.startLifetime = lifetime;
for (int i = 0; i < rows; i++)
{
float angle = i * Mathf.PI * 2 / rows;
Vector3 pos = tr.TransformDirection(Mathf.Cos(angle), 0, Mathf.Sin(angle));
float sp = speed;
em.startSize = size;
for (int a = 0; a < cols; a++)
{
sp += speed * speedRate;
em.position = tr.position;
em.velocity = pos * sp;
em.startSize += size * sizeRate;
par.Emit(em, 1);
}
}
}
public void Update()
{
if (beamRemainingTime > 0)
{
Debug.DrawLine(lineRenderer.GetPosition(0), lineRenderer.GetPosition(1));
lineRenderer.widthMultiplier = stats.beamWidth * beamRemainingTime / stats.beamDuration;
beamRemainingTime -= Time.deltaTime;
var emitParams = new ParticleSystem.EmitParams();
emitParams.position = lineRenderer.GetPosition(1);
//emitParams.startColor = Color.red;
//emitParams.startSize = 0.8f;
hitParticles.Emit(emitParams, 15);
}
else
{
lineRenderer.enabled = false;
isInCooldown = false;
}
}
private void Emit(ParticleSystem p, ref Vector3 pos)
{
int count = UnityEngine.Random.Range(2, 5);
while (count != 0)
{
float yVelocity = UnityEngine.Random.Range(1.0f, 3.0f);
float zVelocity = UnityEngine.Random.Range(-2.0f, 2.0f);
float xVelocity = UnityEngine.Random.Range(-2.0f, 2.0f);
const float lifetime = 0.75f;// UnityEngine.Random.Range(0.25f, 0.75f);
float size = UnityEngine.Random.Range(0.05f, 0.1f);
ParticleSystem.EmitParams param = new ParticleSystem.EmitParams();
param.position = pos;
param.velocity = new Vector3(xVelocity, yVelocity, zVelocity);
param.startLifetime = lifetime;
param.startSize = size;
param.startColor = color;
p.Emit(param, 1);
count--;
}
}
public void PlayJumpParticles()
{
var jumpEmitParams = new ParticleSystem.EmitParams();
jumpEmitParams.rotation3D = new Vector3(0, 0, Mathf.Abs(velocity.x * 2f) * faceDir);
if (jumpsCompleted > 0)
{
var circleEmitParams = new ParticleSystem.EmitParams();
circleEmitParams.rotation3D = new Vector3(0, 0, Mathf.Abs(velocity.x * 2f) * faceDir);
//circleEmitParams.velocity = new Vector3(0, -1, 0);
VFXManager.instance.EmitAtPosition("Double_Jump_Circle", circleEmitParams, 1, transform.position + Vector3.down * 0.5f, false);
//jumpEmitParams.velocity = new Vector3(0, 2, 0);
VFXManager.instance.EmitAtPosition("Double_Jump_Dust", jumpEmitParams, 1, new Vector3(transform.position.x, transform.position.y - 0.5f, 0), false);
}
else //transform.position + Vector3.up * 0.5f
{
VFXManager.instance.EmitAtPosition("Jump_Dust", jumpEmitParams, 5, new Vector3(transform.position.x, controller.raycastOrigins.bottomLeft.y - 0.1f, 0) + (Vector3.up), false);
}
}
void Generate()
{
myStarfieldPS.Clear();
SetMaterialAndProperties(myStarMaterial, myStarSize, myMinDistance, myMaxDistance);
ParticleSystem.MainModule mainModule = myStarfieldPS.main;
mainModule.maxParticles = myStarCount;
Random.State previousState = Random.state;
Random.InitState(myRandomSeed);
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
emitParams.velocity = Vector3.zero;
emitParams.startLifetime = Mathf.Infinity;
Vector3 starfieldCenter = myCenterAroundZero ? Vector3.zero : transform.position;
for (int i = 0; i < myStarCount; ++i)
{
Color color = Color.white;
if (myColors.Length > 0)
{
color = myColors[Random.Range(0, myColors.Length)];
}
color.a *= myColorAlphaMult;
Vector3 randomInsideUnit = Random.insideUnitSphere;
Vector3 pos = starfieldCenter + randomInsideUnit.normalized * myMinDistance + randomInsideUnit * (myMaxDistance - myMinDistance);
emitParams.startColor = color;
emitParams.position = pos;
emitParams.startSize = myStarSize;
myStarfieldPS.Emit(emitParams, 1);
}
Random.state = previousState;
}
public void PlayDeathEffect()
{
/*
* GameObject deathPaint = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Death_Paint"), transform.position, Quaternion.identity);
* GameObject deathPaintHat = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Death_Paint"), hat.transform.position, Quaternion.identity);
* deathPaintHat.transform.localScale = Vector3.one * 5f;
* deathPaint.transform.parent = transform.root;
* deathPaintHat.transform.parent = transform.root;
*/
//hat
Vector3 spawnPosition;
if (hat.isCurrentlyAttached || hat.isBeingAttached)
{
spawnPosition = transform.position - (Vector3.one * 0.7f);
}
else
{
spawnPosition = hat.transform.position;
}
var firstBlastEmitParams = new ParticleSystem.EmitParams();
VFXManager.instance.EmitAtPosition("Hat_Explosion", firstBlastEmitParams, 1, spawnPosition + Vector3.up * 1.5f, true);
/*
* var deathWind = new ParticleSystem.EmitParams();
* deathWind.startSize3D = new Vector3(Random.Range(80, 100), Random.Range(30, 50), 1);
* VFXManager.instance.EmitAtPosition("Death_Wind", deathWind, 1, spawnPosition, true);
*/
var deathSkullEmitParams = new ParticleSystem.EmitParams();
deathSkullEmitParams.velocity = new Vector3(0, 2, 0);
VFXManager.instance.EmitAtPosition("Death_Skull", deathSkullEmitParams, 1, hat.transform.position + Vector3.up * 2.5f, false);
//char
VFXManager.instance.EmitAtPosition("Death_Insignia_Explosion", 1, transform.position + Vector3.up, false);
}
// Token: 0x0600047D RID: 1149 RVA: 0x000243F4 File Offset: 0x000225F4
private void OnParticleCollision(GameObject other)
{
if (this.m_chance < 100f && UnityEngine.Random.Range(0f, 100f) > this.m_chance)
{
return;
}
int num = this.part.GetCollisionEvents(other, this.collisionEvents);
for (int i = 0; i < num; i++)
{
ParticleCollisionEvent particleCollisionEvent = this.collisionEvents[i];
Vector3 eulerAngles = Quaternion.LookRotation(particleCollisionEvent.normal).eulerAngles;
eulerAngles.x = -eulerAngles.x + 180f;
eulerAngles.y = -eulerAngles.y;
eulerAngles.z = (float)UnityEngine.Random.Range(0, 360);
ParticleSystem.EmitParams emitParams = default(ParticleSystem.EmitParams);
emitParams.position = particleCollisionEvent.intersection;
emitParams.rotation3D = eulerAngles;
emitParams.velocity = -particleCollisionEvent.normal * 0.001f;
this.m_decalSystem.Emit(emitParams, 1);
}
}
void Start()
{
OnValidate();
animatorOverrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
animator.runtimeAnimatorController = animatorOverrideController;
clipOverrides = new AnimationClipOverrides(animatorOverrideController.overridesCount);
animatorOverrideController.GetOverrides(clipOverrides);
emitParams = new ParticleSystem.EmitParams();
if (equipOnStart)
{
weapon.Equip(character.mainWeapon, true);
secondHand.Equip(character.SecondaryWeapon, true);
head.Equip(character.head, true);
shield.Equip(character.shield, true);
body.Equip(character.body, true);
backpack.Equip(character.backpack, true);
}
attacking = false;
AnimationParameterRefresh();
}
public override void Update()
{
// For each GameObject that fits the constraint...
constraint.ForEachGameObject((egoComponent, runParticleComponent, movement) =>
{
if (movement.onGround && Mathf.Abs(movement.velocity.x) > 0.1f)
{
var emitParams = new ParticleSystem.EmitParams();
var sh = runParticleComponent.ps.shape;
Vector3 rotation = sh.rotation;
Mathf.Sign(movement.velocity.x);
rotation.x = Mathf.Lerp(-16.5f, 198f, Mathf.Sign(movement.velocity.x));
sh.rotation = rotation;
runParticleComponent.ps.startSpeed = Mathf.Abs(movement.velocity.x) * runParticleComponent.intensity;
runParticleComponent.ps.Emit(emitParams, 1);
}
});
}
void Update()
{
direction.x = transform.position.x - lastPosition.x;
direction.y = transform.position.y - lastPosition.y;
//get the angle of the throw
float angle = Mathf.Atan2(-direction.normalized.y, direction.normalized.x) * Mathf.Rad2Deg;
//add 180 to compensate for the initial offset
angle += 180;
var fireEmitParams = new ParticleSystem.EmitParams();
fireEmitParams.rotation3D = new Vector3(0, 0, angle);
foreach (ParticleSystem ps in systems)
{
ps.Emit(fireEmitParams, 1);
}
lastPosition = transform.position;
}
void Update()
{
//_shapeIndex += EmissionShapeSwitchSpeed * Time.deltaTime;
//if( _shapeIndex > EmissionShapes.Length-1 ) _shapeIndex -= (EmissionShapes.Length-1);
if (!Playing)
{
return;
}
_timeToEmission -= Time.deltaTime;
if (_timeToEmission <= 0f)
{
_timeToEmission = EmissionPeriod - _timeToEmission;
int particlesCount = (int)(ParticlesPerGrid * FilledCells.Count);
if (particlesCount <= 0)
{
particlesCount = 1;
}
for (int c = 0; c < particlesCount; ++c)
{
// TODO rotations! convert points with rotations! use UV matrix?
Vector2 randCellPos = FilledCells[UnityEngine.Random.Range(0, FilledCells.Count)];
float x = (UnityEngine.Random.Range(randCellPos.x, randCellPos.x + GridSize / 100.0f) - _dXDy.x) * ParentObject.transform.localScale.x;
float y = (UnityEngine.Random.Range(randCellPos.y, randCellPos.y + GridSize / 100.0f) - _dXDy.y) * ParentObject.transform.localScale.y;
Vector3 pos = new Vector3(x, y, 0);
Vector3 veloc = new Vector3(UnityEngine.Random.Range(-1.0f, 1.0f) * _particleSystem.startSpeed, UnityEngine.Random.Range(-1.0f, 1.0f) * _particleSystem.startSpeed, 0);
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
emitParams.velocity = veloc;
emitParams.position = pos;
emitParams.startSize = _particleSystem.startSize;
emitParams.startLifetime = _particleSystem.startLifetime;
emitParams.startColor = _particleSystem.startColor;
_particleSystem.Emit(emitParams, ParticleEmissionCount);
}
}
}
public void EmitAtPosition(ParticleSystem system, int numberOfParticles, Vector3 position, bool retainShape = false, Transform relativeTo = null)
{
if (system == null)
{
return;
}
// Any parameters we assign in emitParams will override the current system's when we call Emit.
// Here we will override the position and velocity. All other parameters will use the behavior defined in the Inspector.
var emitParams = new ParticleSystem.EmitParams();
emitParams.position = position;
emitParams.applyShapeToPosition = retainShape;
system.Emit(emitParams, numberOfParticles);
if (relativeTo != null)
{
var main = system.main;
main.simulationSpace = ParticleSystemSimulationSpace.Custom;
main.customSimulationSpace = relativeTo;
}
}
public void drawStars(float scale)
{
scaling = scale;
pSys.Clear();
starObject = new Star[200000];
Star temp;
Stars starsInJson = JsonUtility.FromJson<Stars>(jsonFile.text);
hipToIdPairs = new int[200000];
Debug.Log(hipToIdPairs.Length);
foreach (Star star in starsInJson.stars)
{
if (star.hip != 0)
{
hipToIdPairs[star.hip] = star.id;
}
temp = new Star();
temp.id = star.id;
temp.hip = star.hip;
temp.proper = star.proper;
temp.mag = star.mag;
temp.x = star.x * scale;
temp.y = star.y * scale;
temp.z = star.z * scale;
starObject[star.id] = temp;
p = new ParticleSystem.EmitParams();
p.position = new Vector3(star.x * scale, star.y * scale, star.z * scale);
p.startLifetime = 100000;
p.velocity = Vector3.zero;
p.startSize = .01f * star.mag;
p.startColor = Color.white;
if (star.id == 0)
{
p.startColor = Color.yellow;
}
pSys.Emit(p, 1);
}
GameObject.Find("Constellation-Manager").GetComponent<ConstellationManager>().loadConstellation(constellationSelection);
GameObject.Find("NavBall").GetComponent<Navball>().setCourse(courseSelection);
}
private void OnCollisionEnter2D(Collision2D collision)
{
var sps = GetComponent <ParticleSystem>().subEmitters.GetSubEmitterSystem(0);
var emitparams = new ParticleSystem.EmitParams()
{
position = GetComponent <Transform>().position,
applyShapeToPosition = true,
};
sps.Emit(emitparams, 50);
var currentVelocity = body.velocity;
if (Mathf.Abs(currentVelocity.y) < 0.001f)
{
body.velocity = new Vector2(currentVelocity.x, currentVelocity.y - transform.position.y / 10);
}
if (Mathf.Abs(currentVelocity.x) < 0.001f)
{
body.velocity = new Vector2(currentVelocity.x - transform.position.x / 10, currentVelocity.y);
}
}
