Crear un Neon Vector Shooter en XNA: Efecto de particulas

Spanish (Español) translation by Elías Nicolás (you can also view the original English article)

En esta serie de tutoriales, te mostraré cómo hacer un juego de disparos de neón, como Geometry Wars, en XNA. El objetivo de estos tutoriales no es dejarte con una réplica exacta de Geometry Wars, sino repasar los elementos necesarios que te permitirán crear tu propia variante de alta calidad.

Visión general

En la serie hasta el momento, hemos configurado el juego y agregado floración. A continuación, añadiremos efectos de partículas.

Los efectos de partículas se crean al hacer un gran número de partículas pequeñas. Son muy versátiles y se pueden usar para agregar estilo a casi cualquier juego. En Shape Blaster realizaremos explosiones utilizando efectos de partículas. También utilizaremos efectos de partículas para crear fuego de escape para la nave del jugador y para agregar un toque visual a los agujeros negros. Además, veremos cómo hacer que las partículas interactúen con la gravedad de los agujeros negros.

La clase `ParticleManager`

Comenzaremos creando una clase ParticleManager que almacenará, actualizará y dibujará todas las partículas. Haremos esta clase lo suficientemente general como para poder reutilizarla fácilmente en otros proyectos. Para mantener general a ParticleManager, no será responsable de cómo se ven o se mueven las partículas; manejaremos eso en otro lugar.

Las partículas tienden a ser creadas y destruidas rápidamente y en grandes cantidades. Usaremos un conjunto de objetos para evitar la creación de grandes cantidades de basura. Esto significa que asignaremos una gran cantidad de partículas por adelantado y luego seguiremos reutilizando estas mismas partículas. También haremos que ParticleManager tenga una capacidad fija. Esto lo simplificará y ayudará a garantizar que no excedamos nuestro rendimiento o limitaciones de memoria al crear demasiadas partículas. Cuando se exceda el número máximo de partículas, comenzaremos a reemplazar las partículas más antiguas por otras nuevas.

Haremos del ParticleManager una clase genérica. Esto nos permitirá almacenar información de estado personalizada para las partículas sin codificarla en el ParticleManager. También crearemos una clase Particle anidada.


public class ParticleManager<T>
{
  public class Particle
	{
		public Texture2D Texture;
		public Vector2 Position;
		public float Orientation;

		public Vector2 Scale = Vector2.One;

		public Color Color;
		public float Duration;
		public float PercentLife = 1f;
		public T State;
	}
}

La clase Particle tiene toda la información necesaria para mostrar una partícula y administrar su vida útil. El parámetro genérico, T State, está ahí para contener cualquier información adicional que podamos necesitar para nuestras partículas. Los datos necesarios variarán dependiendo de los efectos de partículas deseados; podría usarse para almacenar velocidad, aceleración, velocidad de rotación o cualquier otra cosa que pueda necesitar.

Para ayudar a administrar las partículas, necesitaremos una clase que funcione como una matriz circular, lo que significa que los índices que normalmente estarían fuera de los límites se ajustarán al principio de la matriz. Esto facilitará la sustitución de las partículas más antiguas primero si nos quedamos sin espacio para nuevas partículas en nuestra matriz. Agregamos lo siguiente como una clase anidada en ParticleManager.


private class CircularParticleArray
{
	private int start;
	public int Start
	{
		get { return start; }
		set { start = value % list.Length; }
	}

	public int Count { get; set; }
	public int Capacity { get { return list.Length; } }
	private Particle[] list;

	public CircularParticleArray(int capacity)
	{
		list = new Particle[capacity];
	}

	public Particle this[int i]
	{
		get { return list[(start + i) % list.Length]; }
		set { list[(start + i) % list.Length] = value; }
	}
}

Podemos configurar la propiedad Start para que ajuste el índice cero en nuestra CircularParticleArray en la matriz subyacente, y se usará Count para rastrear cuántas partículas activas hay en la lista. Nos aseguraremos de que la partícula en el índice cero sea siempre la partícula más antigua. Si reemplazamos la partícula más antigua por una nueva, simplemente incrementaremos el Start, que básicamente gira la matriz circular.

Ahora que tenemos nuestras clases de ayuda, podemos comenzar a completar la clase ParticleManager. Necesitaremos algunas variables miembro, y un constructor.


// This delegate will be called for each particle.
private Action<Particle> updateParticle;
private CircularParticleArray particleList;

public ParticleManager(int capacity, Action<Particle> updateParticle)
{
	this.updateParticle = updateParticle;
	particleList = new CircularParticleArray(capacity);

	// Populate the list with empty particle objects, for reuse.
	for (int i = 0; i < capacity; i++)
		particleList[i] = new Particle();
}

La primera variable declarada, updateParticle, será un método personalizado que actualiza las partículas apropiadamente para el efecto deseado. Un juego puede tener múltiples ParticleManagers que se actualizan de forma diferente si es necesario. También creamos una CircularParticleList y la llenamos con partículas vacías. El constructor es el único lugar donde ParticleManager asigna memoria.

A continuación, agregamos el método CreateParticle(), que crea una nueva partícula utilizando la siguiente partícula no utilizada en el conjunto, o la partícula más antigua si no hay partículas no utilizadas.


public void CreateParticle(Texture2D texture, Vector2 position, Color tint, float duration, Vector2 scale, T state, float theta = 0)
{
	Particle particle;
	if (particleList.Count == particleList.Capacity)
	{
		// if the list is full, overwrite the oldest particle, and rotate the circular list
		particle = particleList[0];
		particleList.Start++;
	}
	else
	{
		particle = particleList[particleList.Count];
		particleList.Count++;
	}

	// Create the particle
	particle.Texture = texture;
	particle.Position = position;
	particle.Tint = tint;

	particle.Duration = duration;
	particle.PercentLife = 1f;
	particle.Scale = scale;
	particle.Orientation = theta;
	particle.State = state;
}

Las partículas pueden ser destruidas en cualquier momento. Necesitamos eliminar estas partículas mientras aseguramos que las otras partículas permanezcan en el mismo orden. Podemos hacerlo iterando a través de la lista de partículas mientras hacemos un seguimiento de cuántas han sido destruidas. A medida que avanzamos, movemos cada partícula activa frente a todas las partículas destruidas intercambiándola con la primera partícula destruida. Una vez que todas las partículas destruidas están al final de la lista, las desactivamos configurando la variable Count de la lista al número de partículas activas. Las partículas destruidas permanecerán en la matriz subyacente, pero no se actualizarán ni dibujarán.

ParticleManager.Update() maneja la actualización de cada partícula y la eliminación de las partículas destruidas de la lista.


public void Update()
{
	int removalCount = 0;
	for (int i = 0; i < particleList.Count; i++)
	{
		var particle = particleList[i];
		updateParticle(particle);
		particle.PercentLife -= 1f / particle.Duration;

		// sift deleted particles to the end of the list
		Swap(particleList, i - removalCount, i);

		// if the particle has expired, delete this particle
		if (particle.PercentLife < 0)
			removalCount++;
	}
	particleList.Count -= removalCount;
}

private static void Swap(CircularParticleArray list, int index1, int index2)
{
	var temp = list[index1];
	list[index1] = list[index2];
	list[index2] = temp;
}

Lo último para implementar en ParticleManager es dibujar las partículas.


public void Draw(SpriteBatch spriteBatch)
{
	for (int i = 0; i < particleList.Count; i++)
	{
		var particle = particleList[i];

		Vector2 origin = new Vector2(particle.Texture.Width / 2, particle.Texture.Height / 2);
		spriteBatch.Draw(particle.Texture, particle.Position, null, particle.Color, particle.Orientation, origin, particle.Scale, 0, 0);
	}
}

La Struct `ParticleState`

Lo siguiente que debe hacer es crear una clase o estructura personalizada para personalizar el aspecto de las partículas en Shape Blaster. Habrá varios tipos diferentes de partículas en Shape Blaster que se comportarán de manera ligeramente diferente, así que comenzaremos creando una enum para el tipo de partícula. También necesitaremos variables para la velocidad y la longitud inicial de la partícula.


public enum ParticleType { None, Enemy, Bullet, IgnoreGravity }

public struct ParticleState
{
	public Vector2 Velocity;
	public ParticleType Type;
	public float LengthMultiplier;
}

Ahora estamos listos para escribir el método de actualización de la partícula. Es una buena idea hacer que este método sea rápido, ya que podría ser necesario para una gran cantidad de partículas.

Vamos a empezar simple. Agregue el siguiente método a ParticleState.


public static void UpdateParticle(ParticleManager.Particle particle)
{
	var vel = particle.State.Velocity;

	particle.Position += vel;
	particle.Orientation = vel.ToAngle();

	// denormalized floats cause significant performance issues
	if (Math.Abs(vel.X) + Math.Abs(vel.Y) < 0.00000000001f)
		vel = Vector2.Zero;

	vel *= 0.97f;		// particles gradually slow down
	x.State.Velocity = vel;
}

Explosiones enemigas

Volveremos y mejoraremos este método en un momento. Primero, vamos a crear algunos efectos de partículas para que podamos probar nuestros cambios. En GameRoot, declare un nuevo ParticleManager y llame a sus métodos Update() y Draw().


// in GameRoot
public static ParticleManager ParticleManager { get; private set; }

// in GameRoot.Initialize()
ParticleManager = new ParticleManager(1024 * 20, ParticleState.UpdateParticle);

// in GameRoot.Update()
ParticleManager.Update();

// in GameRoot.Draw()
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive);
ParticleManager.Draw();
spriteBatch.End();

Además, declare una nueva Texture2D llamada LineParticle para la textura de la partícula en la clase Art, y cargue la textura como hicimos para los otros sprites.

Ahora hagamos explotar a los enemigos. Modifique el método Enemy.WasShot() de la siguiente manera.


public void WasShot()
{
	IsExpired = true;

	for (int i = 0; i < 120; i++)
	{
		float speed = 18f * (1f - 1 / rand.NextFloat(1f, 10f));
		var state = new ParticleState()
		{
			Velocity = rand.NextVector2(speed, speed),
			Type = ParticleType.Enemy,
			LengthMultiplier = 1f
		};

		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, Position, Color.LightGreen, 190, 1.5f, state);
	}
}

Esto crea 120 partículas que dispararán hacia el exterior con diferentes velocidades en todas las direcciones. La velocidad aleatoria está ponderada de modo que las partículas tienen más probabilidades de viajar cerca de la velocidad máxima. Esto hará que haya más partículas en el borde de la explosión a medida que se expande. Las partículas duran 190 cuadros, o algo más de tres segundos.

Ahora puedes correr el juego y ver explotar a los enemigos. Sin embargo, todavía hay algunas mejoras por hacer para los efectos de partículas.

El primer problema es que las partículas desaparecen bruscamente una vez que se agota su duración. Sería mejor si pudieran desaparecer sin problemas. Pero vayamos un poco más lejos que esto y hagamos que las partículas se vuelvan más brillantes cuando se mueven rápido. Además, se ve bien si alargamos las partículas de movimiento rápido y acortamos las de movimiento lento.

Modifique el método ParticleState.UpdateParticle() de la siguiente manera (los cambios están resaltados).


public static void UpdateParticle(ParticleManager.Particle particle)
{
	var vel = particle.State.Velocity;

	particle.Position += vel;
	particle.Orientation = vel.ToAngle();

	float speed = vel.Length();
	float alpha = Math.Min(1, Math.Min(particle.PercentLife * 2, speed * 1f));
	alpha *= alpha;

	particle.Color.A = (byte)(255 * alpha);

	particle.Scale.X = particle.State.LengthMultiplier * Math.Min(Math.Min(1f, 0.2f * speed + 0.1f), alpha);

	if (Math.Abs(vel.X) + Math.Abs(vel.Y) < 0.00000000001f)	// denormalized floats cause significant performance issues
		vel = Vector2.Zero;

	vel *= 0.97f;		// particles gradually slow down
	x.State.Velocity = vel;
}

Las explosiones se ven mucho mejor ahora, pero todas son del mismo color. Podemos darles más variedad eligiendo colores al azar. Un método para producir colores aleatorios es elegir los componentes rojo, azul y verde al azar, pero esto producirá muchos colores apagados y nos gustaría que nuestras partículas tuvieran una apariencia de luz de neón. Podemos tener más control sobre nuestros colores al especificarlos en el espacio de color HSV. HSV significa tono, saturación y valor. Nos gustaría elegir colores con un tono aleatorio pero con una saturación y un valor fijos. Necesitamos una función auxiliar que pueda producir un color a partir de valores de HSV.


static class ColorUtil
{
	public static Color HSVToColor(float h, float s, float v)
	{
		if (h == 0 && s == 0)
			return new Color(v, v, v);

		float c = s * v;
		float x = c * (1 - Math.Abs(h % 2 - 1));
		float m = v - c;

		if (h < 1) return new Color(c + m, x + m, m);
		else if (h < 2) return new Color(x + m, c + m, m);
		else if (h < 3) return new Color(m, c + m, x + m);
		else if (h < 4) return new Color(m, x + m, c + m);
		else if (h < 5) return new Color(x + m, m, c + m);
		else return new Color(c + m, m, x + m);
	}
}

Ahora podemos modificar Enemy.WasShot() para usar colores aleatorios. Para hacer que el color de la explosión sea menos monótono, elegiremos dos colores clave cercanos para cada explosión e interpolaremos linealmente entre ellos con una cantidad aleatoria para cada partícula.


public void WasShot()
{
	IsExpired = true;

	float hue1 = rand.NextFloat(0, 6);
	float hue2 = (hue1 + rand.NextFloat(0, 2)) % 6f;
	Color color1 = ColorUtil.HSVToColor(hue1, 0.5f, 1);
	Color color2 = ColorUtil.HSVToColor(hue2, 0.5f, 1);

	for (int i = 0; i < 120; i++)
	{
		float speed = 18f * (1f - 1 / rand.NextFloat(1f, 10f));
		var state = new ParticleState()
		{
			Velocity = rand.NextVector2(speed, speed),
			Type = ParticleType.Enemy,
			LengthMultiplier = 1
		};

		Color color = Color.Lerp(color1, color2, rand.NextFloat(0, 1));
		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, Position, color, 190, 1.5f, state);
	}
}

Las explosiones deben verse como la animación de abajo.

Puedes jugar con la generación de colores que se adapte a tus preferencias. Una técnica alternativa que funciona bien es elegir a mano una serie de patrones de color para las explosiones y elegir aleatoriamente entre los esquemas de color preseleccionados.

Explosiones de bala

También podemos hacer explotar las balas cuando llegan al borde de la pantalla. Básicamente haremos lo mismo que hicimos para las explosiones enemigas.

Agregue un miembro Random estático a la clase Bullet.

1
2	private static Random rand = new Random();

Luego modifique Bullet.Update() de la siguiente manera.


// delete bullets that go off-screen
if (!GameRoot.Viewport.Bounds.Contains(Position.ToPoint()))
{
	IsExpired = true;

	for (int i = 0; i < 30; i++)
		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, Position, Color.LightBlue, 50, 1,
			new ParticleState() { Velocity = rand.NextVector2(0, 9), Type = ParticleType.Bullet, LengthMultiplier = 1 });

}

Puede notar que dar una dirección aleatoria a las partículas es un desperdicio, porque al menos la mitad de las partículas saldrán inmediatamente de la pantalla (más si la bala explota en una esquina). Podríamos hacer un trabajo extra para asegurar que las partículas solo tengan velocidades opuestas a la pared que están enfrentando. Sin embargo, en cambio, seguiremos el ejemplo de Geometry Wars y haremos que todas las partículas reboten en las paredes. Cualquier partícula que salga de la pantalla será devuelta.

Agregue las siguientes líneas a ParticleState.UpdateParticle() en cualquier lugar entre la primera y la última línea.


var pos = x.Position;
int width = (int)GameRoot.ScreenSize.X;
int height = (int)GameRoot.ScreenSize.Y;

// collide with the edges of the screen
if (pos.X < 0) 	vel.X = Math.Abs(vel.X); else if (pos.X > width)
	vel.X = -Math.Abs(vel.X);
if (pos.Y < 0) 	vel.Y = Math.Abs(vel.Y); else if (pos.Y > height)
	vel.Y = -Math.Abs(vel.Y);

Explosión del barco del jugador

Haremos una explosión realmente grande cuando el jugador muere. Modificar PlayerShip.Kill() de esta manera:


public void Kill()
{
	framesUntilRespawn = 60;

	Color yellow = new Color(0.8f, 0.8f, 0.4f);

	for (int i = 0; i < 1200; i++)
	{
		float speed = 18f * (1f - 1 / rand.NextFloat(1f, 10f));
		Color color = Color.Lerp(Color.White, yellow, rand.NextFloat(0, 1));
		var state = new ParticleState()
		{
			Velocity = rand.NextVector2(speed, speed),
			Type = ParticleType.None,
			LengthMultiplier = 1
		};

		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, Position, color, 190, 1.5f, state);
	}
}

Esto es similar a las explosiones enemigas, pero usamos más partículas y siempre usamos el mismo esquema de color. El tipo de partícula también se establece en ParticleType.None.

En la demostración, las partículas de las explosiones enemigas se ralentizan más rápido que las partículas de la nave del jugador que explotan. Esto hace que la explosión del jugador dure un poco más y se vea un poco más épica.

Agujeros negros revisados

Ahora que tenemos efectos de partículas, revisemos los agujeros negros y hagamos que interactúen con las partículas.

Efecto sobre las partículas

Los agujeros negros deberían afectar a las partículas además de otras entidades, por lo que necesitamos modificar ParticleState.UpdateParticle(). Añade las siguientes líneas.


if (x.State.Type != ParticleType.IgnoreGravity)
{
	foreach (var blackHole in EntityManager.BlackHoles)
	{
		var dPos = blackHole.Position - pos;
		float distance = dPos.Length();
		var n = dPos / distance;
		vel += 10000 * n / (distance * distance + 10000);

		// add tangential acceleration for nearby particles
		if (distance < 400)
			vel += 45 * new Vector2(n.Y, -n.X) / (distance + 100);
	}
}

Aquí, n es el vector unitario que apunta hacia el agujero negro. La fuerza atractiva es una versión modificada de la función del cuadrado inverso. La primera modificación es que el denominador es \(distancia ^2 + 10,000\). Esto hace que la fuerza de atracción se acerque a un valor máximo en lugar de tender hacia el infinito a medida que la distancia se vuelve muy pequeña. Cuando la distancia es mucho mayor que 100 píxeles, \(distancia^2\) se vuelve mucho mayor que 10,000. Por lo tanto, agregar 10,000 a \(distancia^2\) tiene un efecto muy pequeño, y la función se aproxima a una función cuadrada inversa normal. Sin embargo, cuando la distancia es mucho menor que 100 píxeles, la distancia tiene un pequeño efecto sobre el valor del denominador, y la ecuación se vuelve aproximadamente igual a:

1
2	vel += n;

La segunda modificación es agregar un componente lateral a la velocidad cuando las partículas se acercan lo suficiente al agujero negro. Esto tiene dos propósitos. Primero, hace que las partículas formen una espiral en el sentido de las agujas del reloj hacia el agujero negro. Segundo, cuando las partículas se acercan lo suficiente, alcanzarán el equilibrio y formarán un círculo brillante alrededor del agujero negro.

Consejo: para rotar un vector, V, 90 ° en el sentido de las agujas del reloj, tome (V.Y, -V.X). De manera similar, para rotar 90 ° en sentido antihorario, tome (-V.Y, V.X).

Partículas productoras

Los agujeros negros producirán dos tipos de partículas. Primero, rociarán periódicamente partículas que orbitarán alrededor de ellas. Segundo, cuando se dispara un agujero negro, rociará partículas especiales que no se ven afectadas por su gravedad.

Agregue el siguiente código al método BlackHole.WasShot()


float hue = (float)((3 * GameRoot.GameTime.TotalGameTime.TotalSeconds) % 6);
Color color = ColorUtil.HSVToColor(hue, 0.25f, 1);
const int numParticles = 150;
float startOffset = rand.NextFloat(0, MathHelper.TwoPi / numParticles);

for (int i = 0; i < numParticles; i++)
{
	Vector2 sprayVel = MathUtil.FromPolar(MathHelper.TwoPi * i / numParticles + startOffset, rand.NextFloat(8, 16));
	Vector2 pos = Position + 2f * sprayVel;
	var state = new ParticleState()
	{
		Velocity = sprayVel,
		LengthMultiplier = 1,
		Type = ParticleType.IgnoreGravity
	};

	GameRoot.ParticleManager.CreateParticle(Art.LineParticle, pos, color, 90, 1.5f, state);
}

Esto funciona principalmente de la misma manera que las otras explosiones de partículas. Una diferencia es que elegimos el tono del color en función del tiempo total transcurrido del juego. Si disparas al agujero negro varias veces en rápida sucesión, verás que el matiz de las explosiones gira gradualmente. Esto parece menos desordenado que el uso de colores aleatorios mientras se permite la variación.

Para el rociado de partículas en órbita, debemos agregar una variable a la clase BlackHole para rastrear la dirección en la que actualmente estamos rociando partículas.

1
2	private float sprayAngle = 0;

Ahora agregue lo siguiente al método BlackHole.Update().


// The black holes spray some orbiting particles. The spray toggles on and off every quarter second.
if ((GameRoot.GameTime.TotalGameTime.Milliseconds / 250) % 2 == 0)
{
	Vector2 sprayVel = MathUtil.FromPolar(sprayAngle, rand.NextFloat(12, 15));
	Color color = ColorUtil.HSVToColor(5, 0.5f, 0.8f); 	// light purple
	Vector2 pos = Position + 2f * new Vector2(sprayVel.Y, -sprayVel.X) + rand.NextVector2(4, 8);
	var state = new ParticleState()
	{
		Velocity = sprayVel,
		LengthMultiplier = 1,
		Type = ParticleType.Enemy
	};

	GameRoot.ParticleManager.CreateParticle(Art.LineParticle, pos, color, 190, 1.5f, state);
}

// rotate the spray direction
sprayAngle -= MathHelper.TwoPi / 50f;

Esto hará que los agujeros negros rocíen chorros de partículas púrpuras que formarán un anillo brillante que orbita alrededor del agujero negro, de esta manera:

Fuego de escape de la nave

Según lo dictado por las leyes de la física geométrica-neón, la nave del jugador se propulsa lanzando un chorro de partículas ardientes por su tubo de escape. Con nuestro motor de partículas en su lugar, este efecto es fácil de hacer y agrega un toque visual al movimiento de la nave.

A medida que la nave se mueve, creamos tres corrientes de partículas: una corriente central que se dispara directamente desde la parte posterior de la nave, y dos corrientes laterales cuyos ángulos giran de un lado a otro en relación con la nave. Las dos corrientes laterales giran en direcciones opuestas para hacer un patrón entrecruzado. Las corrientes laterales tienen un color más rojo, mientras que la transmisión central tiene un color amarillo-blanco más cálido. La siguiente animación muestra el efecto.

Para hacer que el fuego brille más intensamente de lo que lo haría solo con la floración, haremos que la nave emita partículas adicionales que se ven así:

Estas partículas se teñirán y se mezclarán con las partículas regulares. El código para el efecto completo se muestra a continuación.


private void MakeExhaustFire()
{
	if (Velocity.LengthSquared() > 0.1f)
	{
		// set up some variables
		Orientation = Velocity.ToAngle();
		Quaternion rot = Quaternion.CreateFromYawPitchRoll(0f, 0f, Orientation);

		double t = GameRoot.GameTime.TotalGameTime.TotalSeconds;
		// The primary velocity of the particles is 3 pixels/frame in the direction opposite to which the ship is travelling.
		Vector2 baseVel = Velocity.ScaleTo(-3);
		// Calculate the sideways velocity for the two side streams. The direction is perpendicular to the ship's velocity and the
		// magnitude varies sinusoidally.
		Vector2 perpVel = new Vector2(baseVel.Y, -baseVel.X) * (0.6f * (float)Math.Sin(t * 10));
		Color sideColor = new Color(200, 38, 9);	// deep red
		Color midColor = new Color(255, 187, 30);	// orange-yellow
		Vector2 pos = Position + Vector2.Transform(new Vector2(-25, 0), rot);	// position of the ship's exhaust pipe.
		const float alpha = 0.7f;

		// middle particle stream
		Vector2 velMid = baseVel + rand.NextVector2(0, 1);
		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, pos, Color.White * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(velMid, ParticleType.Enemy));
		GameRoot.ParticleManager.CreateParticle(Art.Glow, pos, midColor * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(velMid, ParticleType.Enemy));

		// side particle streams
		Vector2 vel1 = baseVel + perpVel + rand.NextVector2(0, 0.3f);
		Vector2 vel2 = baseVel - perpVel + rand.NextVector2(0, 0.3f);
		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, pos, Color.White * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(vel1, ParticleType.Enemy));
		GameRoot.ParticleManager.CreateParticle(Art.LineParticle, pos, Color.White * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(vel2, ParticleType.Enemy));

		GameRoot.ParticleManager.CreateParticle(Art.Glow, pos, sideColor * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(vel1, ParticleType.Enemy));
		GameRoot.ParticleManager.CreateParticle(Art.Glow, pos, sideColor * alpha, 60f, new Vector2(0.5f, 1),
			new ParticleState(vel2, ParticleType.Enemy));
	}
}

No hay nada furtivo en este código. Usamos una función sinusoidal para producir el efecto de giro en los flujos laterales variando su velocidad lateral a lo largo del tiempo. Para cada flujo, creamos dos partículas superpuestas por fotograma: una LineParticle blanca semitransparente y una partícula de color brillante detrás de ella. Llame a MakeExhaustFire() al final de PlayerShip.Update(), inmediatamente antes de establecer la velocidad del barco en cero.

Conclusión

Con todos estos efectos de partículas, Shape Blaster está empezando a verse muy bien. En la parte final de esta serie, agregaremos un efecto impresionante más: la cuadrícula de fondo combada.