public override IEnumerable<Particle> OperateOn(Particle p)
{
if ((p as ParticleAttractor) != null) this.currAttractors.Add(p as ParticleAttractor);
else this.currParticles.Add(p);
return base.OperateOn(p);
}
static Particle GenerateRandomParticle(ParticleEmitter emitterParam)
{
MatrixCoords particlePosition = emitterParam.Position;
int particleRowSpeed = emitterParam.RandGenerator.Next(emitterParam.MinSpeedCoord, emitterParam.MaxSpeedCoord + 1);
int particleColSpeed = emitterParam.RandGenerator.Next(emitterParam.MinSpeedCoord, emitterParam.MaxSpeedCoord + 1);
var particleSpeed = new MatrixCoords(particleRowSpeed, particleColSpeed);
Particle particleGenerated = null;
int particleTypeIndex = emitterParam.RandGenerator.Next(0, 2);
switch (particleTypeIndex)
{
case 0:
particleGenerated = new Particle(particlePosition, particleSpeed);
break;
case 1:
particleGenerated = new DyingParticle(particlePosition, particleSpeed, (uint) emitterParam.RandGenerator.Next(8));
break;
default:
throw new Exception("No such particle for this particle type index!");
}
return particleGenerated;
}
private static bool IsInRange(Particle particle, ParticleRepeller repeller)
{
return particle.Position.Row > repeller.Position.Row - repeller.RepulsionRadius
&& particle.Position.Row < repeller.Position.Row + repeller.RepulsionRadius
&& particle.Position.Col > repeller.Position.Col - repeller.RepulsionRadius
&& particle.Position.Col < repeller.Position.Col + repeller.RepulsionRadius;
}
static Particle GenerateRandomParticle(ParticleEmitter emitterParameter)
{
MatrixCoords particlePos = emitterParameter.Position;
int particleRowSpeed = emitterParameter.RandomGenerator.Next(emitterParameter.MinSpeedCoord, emitterParameter.MaxSpeedCoord + 1);
int particleColSpeed = emitterParameter.RandomGenerator.Next(emitterParameter.MinSpeedCoord, emitterParameter.MaxSpeedCoord + 1);
MatrixCoords particleSpeed = new MatrixCoords(particleRowSpeed, particleColSpeed);
Particle generated = null;
int particleTypeIndex = emitterParameter.RandomGenerator.Next(0, 3);
switch (particleTypeIndex)
{
case 0: generated = new Particle(particlePos, particleSpeed); break;
case 1:
uint lifespan = (uint)emitterParameter.RandomGenerator.Next(8);
generated = new DyingParticle(particlePos, particleSpeed, lifespan);
break;
case 2:
generated = new ChaoticParticle(particlePos, particleSpeed,RandomGenerator);
break;
case 3:
generated = new ChickenParticle(particlePos, particleSpeed, RandomGenerator);
break;
default:
throw new Exception("No such particle for this particleTypeIndex");
}
return generated;
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var potentialRepeller = p as RepellerParticle;
if (potentialRepeller != null)
{
currentTickRepellers.Add(potentialRepeller);
}
return base.OperateOn(p);
}
private static MatrixCoords GetAccelerationFromParticleAwayToReppeler(ParticleRepeller repeler, Particle particle)
{
var currParticleToReppelerVector = particle.Position - repeler.Position;
int ptoReppRow = currParticleToReppelerVector.Row;
ptoReppRow = DecreaseVectorCoordToPower(repeler, ptoReppRow);
int ptoReppCol = currParticleToReppelerVector.Col;
ptoReppCol = DecreaseVectorCoordToPower(repeler, ptoReppCol);
var currAcceleration = new MatrixCoords(ptoReppRow, ptoReppCol);
return currAcceleration;
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var particleAsReppeler = p as ParticleRepeller;
if (particleAsReppeler != null)
{
this.repellers.Add(particleAsReppeler);
}
else
{
this.allOtherParticles.Add(p);
}
return base.OperateOn(p);
}
private static MatrixCoords GetAccelerationFromParticleToAttractor(ParticleAttractor attractor, Particle particle)
{
var currParticleToAttractorVector = attractor.Position - particle.Position;
int pToAttrRow = currParticleToAttractorVector.Row;
pToAttrRow = DecreaseVectorCoordToPower(attractor, pToAttrRow);
int pToAttrCol = currParticleToAttractorVector.Col;
pToAttrCol = DecreaseVectorCoordToPower(attractor, pToAttrCol);
var currAcceleration = new MatrixCoords(pToAttrRow, pToAttrCol);
return currAcceleration;
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var reppelerCandidate = p as ParticleRepeller;
if (reppelerCandidate == null)
{
return base.OperateOn(p);
}
else
{
this.repellers.Add(reppelerCandidate);
}
return p.Update();
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var attractorCandidate = p as ParticleAttractor;
if (attractorCandidate == null)
{
this.particles.Add(p);
}
else
{
this.attractors.Add(attractorCandidate);
}
return base.OperateOn(p);
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var potentialAttractor = p as ParticleAttractor;
if (potentialAttractor != null)
{
currentTickAttractors.Add(potentialAttractor);
}
else
{
this.currentTickParticles.Add(p);
}
return base.OperateOn(p);
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var repeller = p as ParticleRepeller;
if (repeller == null)
{
this.particles.Add(p);
}
else
{
this.repellers.Add(repeller);
}
return base.OperateOn(p);
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var reppelerParticle = p as ParticleRepeller;
if (reppelerParticle != null)
{
this.currentTickRepellers.Add(reppelerParticle);
}
else
{
this.currentTickPartciles.Add(p);
}
return base.OperateOn(p);
}
public override IEnumerable<Particle> OperateOn(Particle p)
{
var pottentialRepeller = p as ParticleRepeller;
if (pottentialRepeller != null)
{
currentTickRepellers.Add(pottentialRepeller);
}
else
{
this.currentTickParticles.Add(p);
}
return base.OperateOn(p);
}
private List<Particle> particles = new List<Particle>(); // for current tick
public override IEnumerable<Particle> OperateOn(Particle p)
{
//find attractors
var repellerCandidate = p as ParticleRepeller;
if (repellerCandidate == null)
{
this.particles.Add(p);
}
else
{
this.repellers.Add(repellerCandidate);
}
return base.OperateOn(p);
}
private MatrixCoords GetAccelerationFromParticleToRepeller(ParticleRepeller repeller, Particle particle)
{
var currParticleToRepellerVector = repeller.Position - particle.Position;
var currAcceleration = new MatrixCoords();
int pToRepRow = currParticleToRepellerVector.Row;
pToRepRow = -DecreaseVectorCoordToPower(repeller, pToRepRow);
int pToRepCol = currParticleToRepellerVector.Col;
pToRepCol = -DecreaseVectorCoordToPower(repeller, pToRepCol);
currAcceleration = new MatrixCoords(pToRepRow, pToRepCol);
return currAcceleration;
}
private void Reppel(Particle particle, ParticleRepeller repeller)
{
var yDirection = repeller.RepulsionPower;
var xDirection = repeller.RepulsionPower;
if (particle.Position.Row - repeller.Position.Row < 0)
{
yDirection = -yDirection;
}
if (particle.Position.Col - repeller.Position.Col < 0)
{
xDirection = -xDirection;
}
particle.Accelerate(new MatrixCoords(yDirection, xDirection));
}
private static void GenerateParticle(Engine engine)
{
engine.AddParticle(new Particle(
new MatrixCoords(15, 0),
new MatrixCoords(0, 1)
));
engine.AddParticle(new DyingParticle(
new MatrixCoords(0, 15),
new MatrixCoords(1, 0),
8
));
var emitterPosition = new MatrixCoords(15, 15);
var emitterSpeed = new MatrixCoords(0, 0);
var emitter = new ParticleEmiter(emitterPosition, emitterSpeed, RandomGenerator, 5, 2, (emitterParameter) =>
{
MatrixCoords particlePos = emitterParameter.Position;
int particleRowSpeed = emitterParameter.Generator.Next(emitterParameter.MinSpeedCoord, emitterParameter.MaxSpeedCoord + 1);
int particleColSpeed = emitterParameter.Generator.Next(emitterParameter.MinSpeedCoord, emitterParameter.MaxSpeedCoord + 1);
MatrixCoords particleSpeed = new MatrixCoords(particleRowSpeed,particleColSpeed);
Particle generated = null;
int particleTypeIndex = emitterParameter.Generator.Next(0, 2);
switch (particleTypeIndex)
{
case 0: generated = new Particle(particlePos, particleSpeed); break;
case 1:
uint lifespan = (uint)emitterParameter.Generator.Next(8);
generated = new DyingParticle(particlePos,particleSpeed,lifespan);
break;
default:
throw new ArgumentException("Invalid Type");
}
return generated;
}
);
engine.AddParticle(emitter);
}
public override IEnumerable<Particle> Update()
{
if (this.Freezed)
{
this.framesFreezedCount++;
if (this.framesFreezedCount == this.FreezeTime)
{
this.Freezed = false;
this.framesFreezedCount = 0;
this.ProducedEggs = false;
}
List<Particle> produced = new List<Particle>();
int r = this.rand.Next(-1, 2);
if (!this.ProducedEggs)
{
for (int i = 0; i <= ChickenParticle.maxEggsToProducePerTick; i++)
{
int dir = this.rand.Next(-1, 2);
int dir2 = this.rand.Next(-1, 2);
Particle p = new Particle(this.Position, new MatrixCoords(dir, dir2));
produced.Add(p);
}
var baseProduced = base.Update();
produced.AddRange(baseProduced);
this.ProducedEggs = true;
return produced;
}
}
this.framesMovingCount++;
if (this.framesMovingCount == this.FreezeAfter)
{
this.Freezed = true;
this.framesMovingCount = 0;
}
return base.Update();
}
public virtual IEnumerable<Particle> OperateOn(Particle p)
{
return p.Update();
}
private double Range(Particle p1, Particle p2)
{
int cols = p1.Position.Col - p2.Position.Col;
int rows = p1.Position.Row - p2.Position.Row;
return Math.Sqrt(cols * cols + rows * rows);
}
public bool IsInRange(Particle p)
{
return Math.Sqrt(Math.Pow((this.Position.Row - p.Position.Row), 2) + Math.Pow((this.Position.Col - p.Position.Col), 2)) < this.Range;
}
public void InitParticle(ref Particle particle)
{
Random random = MathF.Rnd;
if (this.depthMult != 0.0f)
{
particle.Position = this.basePos + random.NextVector3(this.randomPos.MinValue, this.randomPos.MaxValue) * new Vector3(1.0f, 1.0f, this.depthMult);
particle.Velocity = this.baseVel + random.NextVector3(this.randomVel.MinValue, this.randomVel.MaxValue) * new Vector3(1.0f, 1.0f, this.depthMult);
}
else
{
particle.Position = this.basePos + new Vector3(random.NextVector2(this.randomPos.MinValue, this.randomPos.MaxValue));
particle.Velocity = this.baseVel + new Vector3(random.NextVector2(this.randomVel.MinValue, this.randomVel.MaxValue));
}
particle.Angle = random.NextFloat(this.randomAngle.MinValue, this.randomAngle.MaxValue);
particle.AngleVelocity = random.NextFloat(this.randomAngleVel.MinValue, this.randomAngleVel.MaxValue);
particle.TimeToLive = random.NextFloat(this.particleLifetime.MinValue, this.particleLifetime.MaxValue);
particle.SpriteIndex = random.Next((int)this.spriteIndex.MinValue, (int)this.spriteIndex.MaxValue);
particle.Color = random.NextColorHsva(this.minColor, this.maxColor).ToRgba();
particle.AgeFactor = 0.0f;
}
public IEnumerable<Particle> OperateOn(Particle p)
{
// TODO: OperateOn
return p.Update();
}
public void AddParticle(Particle p)
{
this.particles.Add(p);
}
private static int Distance(Particle p1, Particle p2)
{
return (int)Math.Sqrt((p1.Position.Row - p2.Position.Row) * (p1.Position.Row - p2.Position.Row) + (p1.Position.Col - p2.Position.Col) * (p1.Position.Col - p2.Position.Col));
}
