public override void TickEnded() { foreach (var repeller in this.currentTickRepellers) { foreach (var particle in this.currentTickParticles) { int radius = (int)Math.Sqrt((repeller.Position.Col - particle.Position.Col) * (repeller.Position.Col - particle.Position.Col) + (repeller.Position.Row - particle.Position.Row) * (repeller.Position.Row - particle.Position.Row)); if (radius < repeller.Radius) { var currentParticleToRepelVector = repeller.Position - particle.Position; int pToAttrRow = currentParticleToRepelVector.Row; pToAttrRow = DecreaseVectorCoordToPower(repeller, pToAttrRow); int pToAttrCol = currentParticleToRepelVector.Col; pToAttrCol = DecreaseVectorCoordToPower(repeller, pToAttrCol); //difference between repeller and attractor var currentAccelaration = new MatrixCoords(-pToAttrRow, -pToAttrCol); particle.Accelerate(currentAccelaration); } } } this.currentTickParticles.Clear(); this.currentTickRepellers.Clear(); base.TickEnded(); }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, int freezeAfter, int freezeTime) : base(position, speed) { this.FreezeTime = freezeTime; this.FreezeAfter = freezeAfter; this.Freezed = false; }
public override void TickEnded() { foreach (var repeller in this.repellers) { foreach (var particle in this.particles) { double distanceFromRepellerToParticle = CalculateEuclideanDistance(repeller.Position, particle.Position); if (repeller.RepellerRadius >= distanceFromRepellerToParticle) { var currParticleToRepellerVector = repeller.Position - particle.Position; int pToAttrRow = currParticleToRepellerVector.Row; pToAttrRow = DecreaseVectorCoordToPower(repeller, pToAttrRow); int pToAttrCol = currParticleToRepellerVector.Col; pToAttrCol = DecreaseVectorCoordToPower(repeller, pToAttrCol); var currAcceleration = new MatrixCoords(-pToAttrRow, -pToAttrCol); particle.Accelerate(currAcceleration); } } } this.repellers.Clear(); this.particles.Clear(); base.TickEnded(); }
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 void TickEnded() { foreach (var repeller in this.currentTickRepellers) { foreach (var particle in this.currentTickParticles) { var currParticleToRepellerVector = repeller.Position - particle.Position; // If particle is in the radius(range), repel it. // Using the same logic as "AdvancedParticleOperator". Using "Euclidean distance" formula to calculate the distance between the two particles if (IsInRange(currParticleToRepellerVector, repeller)) { int pToRepRow = currParticleToRepellerVector.Row; pToRepRow = DecreaseVectorCoordToPower(repeller, pToRepRow); int pToRepCol = currParticleToRepellerVector.Col; pToRepCol = DecreaseVectorCoordToPower(repeller, pToRepCol); var currAcceleration = new MatrixCoords(pToRepRow, pToRepCol); particle.Accelerate(currAcceleration); } } } this.currentTickParticles.Clear(); this.currentTickRepellers.Clear(); base.TickEnded(); }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator, uint maxAbsSpeedCoord) : base(position, speed) { this.RandomGenerator = randomGenerator; this.MinSpeedCoord = -(int)maxAbsSpeedCoord; this.MaxSpeedCoord = (int)maxAbsSpeedCoord; }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, Random randGenerator) : base(position, speed, randGenerator) { this.ChanceToStopInPercentsCount = InitialChanceToStopInPercents; this.CurrentTickOfDuration = 0; ticksToStopForDurationCount = (uint)this.RandGenerator.Next(1, 6); }
static void GenerateInitialData(Engine engine) { var emitterPosition = new MatrixCoords(29, 0); var emitterSpeed = new MatrixCoords(0, 0); var emitter = new ParticleEmitter(emitterPosition, emitterSpeed, randGenerator, 5, 2, GenerateRandomParticle); engine.AddParticle(emitter); //check attractor var attractorPosition = new MatrixCoords(10, 10); var attractor = new ParticleAttractor(attractorPosition, new MatrixCoords(0, 0), 1); engine.AddParticle(attractor); // 02.Test the ChaoticParticle through the ParticleSystemMain class // Create chaotic particle and add it to the engine var chaoticParticle = new ChaoticParticle(new MatrixCoords(15, 15), new MatrixCoords(1, 1), randGenerator); engine.AddParticle(chaoticParticle); // 04.Test the ChickenParticle class through the ParcticleSystemMain class. var chickenParticle = new ChickenParticle(new MatrixCoords(10, 10), new MatrixCoords(-1, 2), randGenerator, 20); engine.AddParticle(chickenParticle); // 06.Test the ParticleRepeller class through the ParticleSystemMain class // create repeller with large radius and power to see the result // because in one moment there are too many new chicken particles created var particleRepeller = new ParticleRepeller(new MatrixCoords(20, 20), new MatrixCoords(0, 0), 10, 20.0); engine.AddParticle(particleRepeller); }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator, int crazyness) : base(position, speed) { this.MaximalAcceleration = crazyness; this.MinimalAcceleration = -crazyness; this.RandomGenerator = randomGenerator; }
// Implement a ParticleRepeller class. A ParticleRepeller is a Particle, which pushes other particles away from it // (i.e. accelerates them in a direction, opposite of the direction in which the repeller is). // The repeller has an effect only on particles within a certain radius (see Euclidean distance). static void Main() { IRenderer renderer = new ConsoleRenderer(MaxRows, MaxCols); IParticleOperator particleOperator = new ParticleUpdater(); // Add particle repeller (appears as 'R' on the console) MatrixCoords repellerPosition = new MatrixCoords(MaxRows * 2 / 4, MaxCols * 2 / 4); MatrixCoords repellerSpeed = new MatrixCoords(0, 0); int repellerGravity = -4; // negative for antigravity ParticleRepeller repeller = new ParticleRepeller(repellerPosition, repellerSpeed, repellerGravity); // Use a field engine - derives from Engine, but can affect the speed of the particles, // the center of the field is the repeller int sleepTimeMs = 50; FieldEngine engine = new FieldEngine(renderer, particleOperator, sleepTimeMs, repeller); engine.AddParticle(repeller); // Add emmitter for free particles (appears as 'E' on the console) MatrixCoords emitterPosition = new MatrixCoords(MaxRows / 4, MaxCols / 4); MatrixCoords emitterSpeed = new MatrixCoords(4, 4); int particleLifeTicks = 30; ParticleEmitter emitter = new ParticleEmitter(emitterPosition, emitterSpeed, particleLifeTicks); engine.AddParticle(emitter); SetConsole(); engine.Run(); }
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; }
public override void TickEnded() { foreach (var repeller in this.currentTickRepellers) { foreach (var particle in this.currentTickParticles) { var currParticleToRepellerVector = particle.Position - repeller.Position; var distance = Math.Sqrt(Math.Pow(currParticleToRepellerVector.Row, 2) + Math.Pow(currParticleToRepellerVector.Col, 2)); if (distance <= repeller.RepellerRadius) { int pToAttrRow = currParticleToRepellerVector.Row; pToAttrRow = DefineAcceleration(repeller, pToAttrRow); int pToAttrCol = currParticleToRepellerVector.Col; pToAttrCol = DefineAcceleration(repeller, pToAttrCol); var currAcceleration = new MatrixCoords(pToAttrRow, pToAttrCol); particle.Accelerate(currAcceleration); } } } this.currentTickRepellers.Clear(); base.TickEnded(); }
public override IEnumerable<Particle> Update() { tickCounter++; var newParticles = new List<Particle>(); double totalSpeed = Math.Sqrt(this.Speed.Row * this.Speed.Row + this.Speed.Col * this.Speed.Col); if (tickCounter > 4 * ChickenParticle.totalChickenParticles && totalSpeed < maxSpeed) { waitCounter++; if (waitCounter > ticksToWait) { ChickenParticle.totalChickenParticles++; MatrixCoords initialSpeed = new MatrixCoords(0, 0); var newParticle = new ChickenParticle(this.Position, initialSpeed, ChickenParticle.totalChickenParticles); newParticles.Add(newParticle); tickCounter = 0; waitCounter = 0; } } else { this.Move(); } return newParticles; }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, int currentGeneration = 1) : base(position, speed) { tickCounter = 0; waitCounter = 0; this.currentGeneration = currentGeneration; }
public override void TickEnded() { foreach (var attractor in this.currentTickAttractors) { foreach (var particle in this.currentTickParticles) { 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); particle.Accelerate(currAcceleration); } } this.currentTickParticles.Clear(); this.currentTickAttractors.Clear(); base.TickEnded(); }
public override IEnumerable<Particle> Update() { if (!this.currentlyStopped && this.RandomGenerator.Next(0, 101) <= this.stopFrequencyPercent) { lastKnownSpeed = this.Speed; this.Accelerate(new MatrixCoords(this.Speed.Row * (-1), this.Speed.Col * (-1))); this.currentlyStopped = true; } if (currentlyStopped) { this.currentTick++; if (this.currentTick == this.stopDuarationTicks) { this.Accelerate(lastKnownSpeed); this.currentTick = 0; this.currentlyStopped = false; var baseProduced = base.Update(); List<Particle> newProduced = new List<Particle>() { new ChickenParticle(this.Position,lastKnownSpeed,this.RandomGenerator, (uint)base.DirectionChangeFrequencyRowPercent,(uint)this.DirectionChangeFrequencyColPercent, (uint)this.stopFrequencyPercent,(uint)this.stopDuarationTicks) }; newProduced.AddRange(baseProduced); return newProduced; } } return base.Update(); }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator, uint directionChangeFreqRowPercent, uint directionChangeFreqColPercent) : base(position, speed) { this.RandomGenerator = randomGenerator; this.directionChangeFrequencyRowPercent = (int)directionChangeFreqRowPercent; this.directionChangeFrequencyColPercent = (int)directionChangeFreqColPercent; }
// Methods protected override Particle GetNewParticle(MatrixCoords position, MatrixCoords speed) { if ((this.randGen.Next() % 2) == 0) { return new DyingParticle(position, speed, this.randGen.Next(MaxLifetime)); } return base.GetNewParticle(position, speed); }
protected MatrixCoords GetRandomCoords() { int randomSpeedRow = this.randomGenerator.Next(-MaxSpeedPerCoordinate, MaxSpeedPerCoordinate + 1); int randomSpeedCol = this.randomGenerator.Next(-MaxSpeedPerCoordinate, MaxSpeedPerCoordinate + 1); var createdSpeed = new MatrixCoords(randomSpeedRow, randomSpeedCol); return createdSpeed; }
/// <summary> /// Only constructor. Initialize all variables /// </summary> /// <param name="position">Particle position</param> /// <param name="speed">Particle speed</param> /// <param name="matrixSize">Size of the matrix(field)</param> /// <param name="randomGenerator">variable of type Random</param> public ChaoticParticle(MatrixCoords position, MatrixCoords speed, MatrixCoords matrixSize, Random randomGenerator) : base(position, speed) { // We need the matrix size, so we always print the chaotic particle inside the matrix this.MatrixSize = matrixSize; // Random is given in the constructor, so we can use one global Random variable, to avoid repetition of numbers this.randomGenerator = randomGenerator; }
protected override void Move() { base.Move(); int particleRowSpeed = this.RandomGenerator.Next(this.MinSpeedCoord, this.MaxSpeedCoord + 1); int particleColSpeed = this.RandomGenerator.Next(this.MinSpeedCoord, this.MaxSpeedCoord + 1); MatrixCoords particleSpeed = new MatrixCoords(particleRowSpeed, particleColSpeed); this.Accelerate(new MatrixCoords(-this.Speed.Row, -this.Speed.Col)); this.Accelerate(particleSpeed); }
private MatrixCoords GenerateRandomSpeed() { int randSpeedXCoord = this.RandGenerator.Next(-MaxSpeedChangeRange, MaxSpeedChangeRange + 1); int randSpeedYCoord = this.RandGenerator.Next(-MaxSpeedChangeRange, MaxSpeedChangeRange + 1); MatrixCoords randomSpeed = new MatrixCoords(randSpeedXCoord, randSpeedYCoord); return randomSpeed; }
/// <summary> /// Only constructor. Initialize all variables /// </summary> /// <param name="position">Particle position</param> /// <param name="speed">Particle speed</param> /// <param name="matrixSize">Size of the matrix(field)</param> /// <param name="randomGenerator">variable of type Random</param> /// <param name="ticksToLayParticle">ticks delay to lay particle(egg)</param> public ChickenParticle(MatrixCoords position, MatrixCoords speed, MatrixCoords matrixSize, Random randomGenerator, uint ticksToLayParticle) : base(position, speed, matrixSize, randomGenerator) { // Ticks to lay particle are put in the constructor, so the user can set different value this.ticksToLayParticle = ticksToLayParticle; this.currentTicksToLayParticle = ticksToLayParticle; // Random is given in the constructor, so we can use one global Random variable, to avoid repetition of numbers this.randomGenerator = randomGenerator; }
// Generate random position inside the matrix private MatrixCoords GenerateRandomPosition() { MatrixCoords randomPosition = new MatrixCoords(); randomPosition.Row = randomGenerator.Next(this.MatrixSize.Row); randomPosition.Col = randomGenerator.Next(this.MatrixSize.Col); return randomPosition; }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator) : base(position, speed, randomGenerator) { this.isSpawned = true; BreakThicksInitialization(); this.isMoving = true; }
private bool IsParticleInRangeOfRepeller(MatrixCoords positionRepeller, MatrixCoords positionParticle, int radius) { var result = Math.Sqrt ( (positionRepeller.Row - positionParticle.Row) * (positionRepeller.Row - positionParticle.Row) + (positionRepeller.Col - positionParticle.Col) * (positionRepeller.Col - positionParticle.Col) ); return radius >= result; }
public ParticleEmitter(MatrixCoords position, MatrixCoords speed, Random randGenerator, uint maxEmittedPerTickCount, uint maxAbsSpeedCoord, Func<ParticleEmitter, Particle> randomParticleGeneratorMethod) : base(position, speed) { this.RandGenerator = randGenerator; this.maxEmittedPerTickCount = maxEmittedPerTickCount; this.MinSpeedCoord = -(int) maxAbsSpeedCoord; this.MaxSpeedCoord = (int) maxAbsSpeedCoord; this.randomParticleGeneratorMethod = randomParticleGeneratorMethod; }
public DyingParticle(MatrixCoords position, MatrixCoords speed, int lifetime) : base(position, speed) { if (lifetime < 0) { throw new ArgumentException("lifetime must be greater than or equal to zero"); } this.lifetime = lifetime; }
protected override Particle GetNewParticle(MatrixCoords position, MatrixCoords speed) { bool createDying = this.randomGenerator.Next() % 2 == 0; if (createDying) { return new DyingParticle(position, speed, this.randomGenerator.Next(MaxParticleLifetime)); } return base.GetNewParticle(position, speed); }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, Random random, uint directionChangeFreqRowPercent, uint directionChangeFreqColPercent, uint stopFrequencyPercent, uint stopDuarationTicks) : base(position,speed,random,directionChangeFreqRowPercent,directionChangeFreqColPercent) { this.stopFrequencyPercent = (int)stopFrequencyPercent; this.stopDuarationTicks = (int)stopDuarationTicks; this.currentlyStopped = false; this.currentTick = 0; }
public override IEnumerable<Particle> Update() { // set speed to zero // use accelerate method because speed setter is private this.Accelerate(this.oppositeSpeedDirection); // generate new speed MatrixCoords speed = this.GenerateRandomSpeed(); // set the speed to the newly generated speed this.Accelerate(speed); return base.Update(); }
public ParticleEmitter(MatrixCoords position, MatrixCoords speed, Random randomGenerator, uint maxEmittedPerTickCount, uint maxAbsSpeedCoord, Func <ParticleEmitter, Particle> randomParticleGeneratorMethod) : base(position, speed) { this.RandomGenerator = randomGenerator; this.maxEmittedPerTickCount = maxEmittedPerTickCount; this.MinSpeedCoord = -(int)maxAbsSpeedCoord; this.MaxSpeedCoord = (int)maxAbsSpeedCoord; this.randomParticleGeneratorMethod = randomParticleGeneratorMethod; }
private bool RepellingParticlesInRange(MatrixCoords particlePosition, MatrixCoords repellerPosition, int radius) { int repellCol = Math.Abs(particlePosition.Col - repellerPosition.Col); int repellRow = Math.Abs(particlePosition.Row - repellerPosition.Row); int particleDistance = (repellCol * repellCol) + (repellRow * repellRow); if (particleDistance <= radius) { return(true); } else { return(false); } }
private static MatrixCoords GetAccelerationFromRepellerToParticle(ParticleRepeller repeller, Particle particle) { var currParticleToAttractorVector = repeller.Position - particle.Position; int pToAttrRow = currParticleToAttractorVector.Row; pToAttrRow = DecreaseVectorCoordToPower(repeller, pToAttrRow); int pToAttrCol = currParticleToAttractorVector.Col; pToAttrCol = DecreaseVectorCoordToPower(repeller, pToAttrCol); var currAcceleration = new MatrixCoords(-pToAttrRow, -pToAttrCol); return(currAcceleration); }
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> Update() { if (!HasStopped && this.RandGenerator.Next(0, 101) <= this.ChanceToStopInPercentsCount) { // save the previous chicken particle speed previousChickenParticleSpeed = this.Speed; // set the current speed to zero so that the chicken particle wont move this.Accelerate(this.oppositeSpeedDirection); this.HasStopped = true; } if (this.HasStopped) { this.CurrentTickOfDuration++; if (this.CurrentTickOfDuration == this.ticksToStopForDurationCount) { this.HasStopped = false; this.CurrentTickOfDuration = 0; // set the speed back to the speed, which was before the chicken particle stops this.Accelerate(this.previousChickenParticleSpeed); } // create new chicken particle var newProducedChickenParticle = new List <Particle>() { new ChickenParticle(this.Position, previousChickenParticleSpeed, this.RandGenerator) }; //get all previous produced particles var baseProducedParticles = base.Update(); // and add them to the newly produced particle newProducedChickenParticle.AddRange(baseProducedParticles); return(newProducedChickenParticle); } // if hasnt stop, we dont create new chicken particles so we simply call the base update method return(base.Update()); }
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); }
public override void TickEnded() { foreach (var attractor in this.currentTickAttractors) { foreach (var particle in this.currentTickParticles) { 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); particle.Accelerate(currAcceleration); } } foreach (var repulsor in this.currentTickRepulsors) { foreach (var particle in this.currentTickParticles) { if (GetDistanceBetweenPoints(repulsor, particle) <= repulsor.Range) { // Gets the vector between the particle position and the repulsors position // and accelerates the particle in that direction var currParticleToRepulsorVector = particle.Position - repulsor.Position; particle.Accelerate(currParticleToRepulsorVector); } } } this.currentTickParticles.Clear(); this.currentTickAttractors.Clear(); this.currentTickRepulsors.Clear(); base.TickEnded(); }
public override void TickEnded() { foreach (var attractor in this.attractors) { foreach (var particle in this.particles) { var currAcceleration = GetAccelerationFromParticleToAttractor(attractor, particle); ParticleRepeller pr = attractor as ParticleRepeller; if (pr != null && Distance(pr, particle) <= pr.RepellerRadius) { currAcceleration = new MatrixCoords(-currAcceleration.Row, -currAcceleration.Col); } particle.Accelerate(currAcceleration); } } this.attractors.Clear(); this.particles.Clear(); }
private static void GenerateInitialData(Engine engine) { engine.AddParticle( new Particle( new MatrixCoords(0, 8), new MatrixCoords(-1, 0)) ); engine.AddParticle( new DyingParticle( new MatrixCoords(20, 5), new MatrixCoords(-1, 1), 12) ); var emitterPosition = new MatrixCoords(29, 0); var emitterSpeed = new MatrixCoords(0, 0); var emitter = new ParticleEmitter(emitterPosition, emitterSpeed, RandomGenerator, 5, 2, GenerateRandomParticle ); //engine.AddParticle(emitter); var attractorPosition = new MatrixCoords(10, 3); var attractor = new ParticleAttractor( attractorPosition, new MatrixCoords(0, 0), 1); var attractorPosition2 = new MatrixCoords(10, 13); var attractor2 = new ParticleAttractor( attractorPosition2, new MatrixCoords(0, 0), 3); engine.AddParticle(attractor); engine.AddParticle(attractor2); }
public override void TickEnded() { foreach (var attractor in this.attractors) { foreach (var particle in this.particles) { var currAcceleration = GetAccelerationFromParticleToAttractor(attractor, particle); particle.Accelerate(currAcceleration); } } foreach (var repeller in repellers) { foreach (var particle in particles) { int deltaCol = repeller.Position.Col - particle.Position.Col; int deltaRow = repeller.Position.Row - particle.Position.Row; int distance = (int)Math.Sqrt((deltaCol * deltaCol + deltaRow * deltaRow)); if (distance < repeller.Radius) { var currAcceleration = GetAccelerationFromParticleToAttractor(repeller, particle); currAcceleration = new MatrixCoords(0, 0) - currAcceleration; particle.Accelerate(currAcceleration); } } } this.attractors.Clear(); this.repellers.Clear(); this.particles.Clear(); base.TickEnded(); }
public void EnqueueForRendering(IRenderable obj) { char[,] objImage = obj.GetImage(); int imageRows = objImage.GetLength(0); int imageCols = objImage.GetLength(1); MatrixCoords objTopLeft = obj.GetTopLeft(); int lastRow = Math.Min(objTopLeft.Row + imageRows, this.renderContextMatrixRows); int lastCol = Math.Min(objTopLeft.Col + imageCols, this.renderContextMatrixCols); for (int row = obj.GetTopLeft().Row; row < lastRow; row++) { for (int col = obj.GetTopLeft().Col; col < lastCol; col++) { if (row >= 0 && row < renderContextMatrixRows && col >= 0 && col < renderContextMatrixCols) { renderContextMatrix[row, col] = objImage[row - obj.GetTopLeft().Row, col - obj.GetTopLeft().Col]; } } } }
public override IEnumerable <Particle> Update() { List <Particle> baseParticles = new List <Particle>(base.Update()); if (this.movingInterval > 0) { this.movingInterval--; } else { HandleBreaks(); if (!isSpawned) { int rowSpeed = this.randomGenerator.Next(-1, 2); int colSpeed = this.randomGenerator.Next(-1, 2); var speed = new MatrixCoords(rowSpeed, colSpeed); var layProduct = new ChickenParticle(this.Position, speed, this.randomGenerator); baseParticles.Add(layProduct); isSpawned = !isSpawned; } } return(baseParticles); }
private static void GenerateInitialData(Engine engine) { engine.AddParticle( new Particle( new MatrixCoords(10, 10), new MatrixCoords(0, 0)) ); engine.AddParticle( new DyingParticle( new MatrixCoords(20, 30), new MatrixCoords(-1, 1), 8) ); var emitterPosition = new MatrixCoords(29, 0); var emitterSpeed = new MatrixCoords(0, 0); var emitter = new ParticleEmitter(emitterPosition, emitterSpeed, RandomGenerator, 5, 2, GenerateRandomParticle); //engine.AddParticle(emitter); var attractorPosition = new MatrixCoords(15, 15); var attractor = new ParticleAttractor(attractorPosition, new MatrixCoords(0, 0), 1); engine.AddParticle(attractor); var repellerPosition = new MatrixCoords(15, 25); var repeller = new ParticleRepeller(repellerPosition, new MatrixCoords(0, 0), 3, 10); engine.AddParticle(repeller); //engine.AddParticle( // new ChickenParticle( // new MatrixCoords(10, 10), // new MatrixCoords(0, 0), RandomGenerator, 2) // ); }
public override void TickEnded() { foreach (var repeller in currentTickRepellers) { foreach (var particle in currentTickParticles) { bool repelling = RepellingParticlesInRange(particle.Position, repeller.Position, repeller.RepellRadius); if (repelling == true) { int reverseRow = particle.Speed.Row * 2; int reverseCol = particle.Speed.Col * 2; var currAcceleration = new MatrixCoords(-reverseRow, -reverseCol); particle.Accelerate(currAcceleration); } } } this.currentTickParticles.Clear(); this.currentTickRepellers.Clear(); base.TickEnded(); }
public ParticleRepeller(MatrixCoords position, MatrixCoords speed, int repellerPower, double radius) : base(position, speed) { this.RepellerPower = repellerPower; this.RepellerRadius = radius; }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, int maxTolerance, Random randomGenerator) : base(position, speed) { this.MaxTolerance = maxTolerance; this.rand = randomGenerator; }
public ParticleAtractor(MatrixCoords position, MatrixCoords speed, int attraction) : base(position, speed) { this.Attraction = attraction; }
private static void GenerateInitialData(Engine engine) { /*engine.AddParticle( * new Particle( * new MatrixCoords(0, 8), * new MatrixCoords(-1, 0)) * ); * * engine.AddParticle( * new DyingParticle( * new MatrixCoords(20, 5), * new MatrixCoords(-1, 1), * 12) * );*/ // Test the ChaoticParticle. var chaoticParticle = new ChaoticParticle( new MatrixCoords(20, 25), new MatrixCoords(-1, 1), RandomGenerator); engine.AddParticle(chaoticParticle); // Test the ChickenParticle. var chickenParticle = new ChickenParticle( new MatrixCoords(25, 15), new MatrixCoords(0, 1), RandomGenerator); engine.AddParticle(chickenParticle); // Test the ParticleRepeller. var particleRepeller = new ParticleRepeller( new MatrixCoords(10, 13), new MatrixCoords(0, 0), 2, 10); engine.AddParticle(particleRepeller); var emitterPosition = new MatrixCoords(19, 15); var emitterSpeed = new MatrixCoords(0, 0); var emitter = new ParticleEmitter(emitterPosition, emitterSpeed, RandomGenerator, 5, 2, GenerateRandomParticle ); engine.AddParticle(emitter); var attractorPosition = new MatrixCoords(10, 3); var attractor = new ParticleAttractor( attractorPosition, new MatrixCoords(0, 0), 1); var attractorPosition2 = new MatrixCoords(10, 13); var attractor2 = new ParticleAttractor( attractorPosition2, new MatrixCoords(0, 0), 3); // engine.AddParticle(attractor); // engine.AddParticle(attractor2); }
public ParticleAttractor(MatrixCoords position, MatrixCoords speed, int attractionPower) : base(position, speed) { this.Power = attractionPower; }
public VariousLifeTimeParticleEmiter(MatrixCoords position, MatrixCoords speed, Random randomGenerator) : base(position, speed, randomGenerator) { }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator) : base(position, speed, randomGenerator) { }
public ChickenParticle(MatrixCoords position, MatrixCoords speed, Random randGenerator, uint chanceToStopInPercentsCount) : this(position, speed, randGenerator) { this.ChanceToStopInPercentsCount = chanceToStopInPercentsCount; }
protected virtual void Move() { this.Position += this.Speed; }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, Random rnd, uint maxSpeed) : base(position, speed) { this.Rnd = rnd; this.MaxSpeed = maxSpeed; }
public Particle(MatrixCoords position, MatrixCoords speed) { this.Position = position; this.Speed = speed; }
public void Accelerate(MatrixCoords acceleration) { this.Speed += acceleration; }
public ChaoticParticle(MatrixCoords position, MatrixCoords speed, Random randomGenerator) : base(position, speed) { this.randomSpeedGEnerator = randomGenerator; }
public DyingParticle(MatrixCoords position, MatrixCoords speed, uint lifespan = uint.MaxValue) : base(position, speed) { this.lifespan = lifespan; }