private static int Match(ETextures[] tileType, ETextures center, ETextures tileLeft, ETextures tileRight, ETextures tileLower, ETextures tileUpper)
{
if (tileLeft == ETextures.Whatever)
{
tileLeft = center;
}
if (tileRight == ETextures.Whatever)
{
tileRight = center;
}
if (tileUpper == ETextures.Whatever)
{
tileUpper = center;
}
if (tileLower == ETextures.Whatever)
{
tileLower = center;
}
if (tileType[0] == center && (tileType[1] == tileLeft || tileType[1] == ETextures.Whatever) && (tileType[2] == tileRight || tileType[2] == ETextures.Whatever) && (tileType[3] == tileUpper || tileType[3] == ETextures.Whatever) && (tileType[4] == tileLower || tileType[4] == ETextures.Whatever))
{
return((int)tileType[5]);
}
else
{
return(-1);
}
}
public static string getFileName(ETextures texture)
{
if (textureMap == null)
{
InitialTextureMap();
}
return(textureMap[texture]);
}
public PropertyForm(Game1 game, Tile tile)
{
InitializeComponent();
this.game = game;
this.tile = tile;
nrX.Value = tile.getRecHit().X;
nrY.Value = tile.getRecHit().Y;
nrWidth.Value = tile.getRecHit().Width;
nrHeight.Value = tile.getRecHit().Height;
cbType.Text = tile.getTextureType().ToString();
defaultTexture = tile.getTextureType();
}
private static void loadTile(String s)
{
string[] data = s.Split(':');
float x = float.Parse(data[1]) * MULTI;
float width = float.Parse(data[3]) * MULTI;
float height = float.Parse(data[4]) * MULTI;
float y = (float.Parse(data[2]) * MULTI * -1) - (float)height;
ETextures texture = ETextures.GRAY;
switch (data[5])
{
case "GRAY": texture = ETextures.GRAY; break;
case "RED": texture = ETextures.RED; break;
case "GREEN": texture = ETextures.GREEN; break;
case "HOUSE": texture = ETextures.HOUSE; break;
case "HOUSE_BROKEN": texture = ETextures.HOUSE_BROKEN; break;
}
Tile tile = new Tile(new Vector2(x, y));
tile.setRectangle((int)x, (int)y, (int)width, (int)height);
tile.setTexture(texture);
if (data[0].Equals("L"))
{
Game1.lower.Add(tile);
}
else if (data[0].Equals("M"))
{
Game1.middle.Add(tile);
}
else if (data[0].Equals("T"))
{
Game1.top.Add(tile);
}
}
public virtual void setTexture(ETextures type)
{
textureType = type;
switch (type)
{
case ETextures.GRAY: texture = ResManager.GRAY;
break;
case ETextures.RED: texture = ResManager.RED;
break;
case ETextures.GREEN: texture = ResManager.GREEN;
break;
case ETextures.FAN: texture = ResManager.pixel;
break;
case ETextures.HOUSE: texture = ResManager.HOUSE;
break;
case ETextures.HOUSE_BROKEN: texture = ResManager.HOUSE_BROKEN;
break;
}
}
/// <summary>
/// Function to control the Particle Systems based on user input
/// </summary>
public void ProcessInputForParticleSystem(float fElapsedTimeInSeconds)
{
// If the Current Particle System should be changed to the next Particle System
if (KeyWasJustPressed(Keys.H) || ButtonWasJustPressed(Buttons.RightTrigger))
{
meCurrentPS++;
if (meCurrentPS > EPSEffects.LastInList)
{
meCurrentPS = 0;
}
// Initialize the new Particle System
InitializeCurrentParticleSystem();
}
// Else if the Current Particle System should be changed back to the previous Particle System
else if (KeyWasJustPressed(Keys.G) || ButtonWasJustPressed(Buttons.LeftTrigger))
{
meCurrentPS--;
if (meCurrentPS < 0)
{
meCurrentPS = EPSEffects.LastInList;
}
// Initialize the new Particle System
InitializeCurrentParticleSystem();
}
// If the Current Particle System is not Initialized
if (mcCurrentParticleSystem == null || !mcCurrentParticleSystem.IsInitialized)
{
return;
}
// Define how fast the user can move and rotate the Emitter
float fEmitterMoveDelta = 75 * fElapsedTimeInSeconds;
float fEmitterRotateDelta = MathHelper.Pi * fElapsedTimeInSeconds;
// If the Shift key is down, move faster
if (KeyIsDown(Keys.LeftShift) || KeyIsDown(Keys.RightShift))
{
fEmitterMoveDelta *= 2;
}
// Check if the Emitter should be moved
if (KeyIsDown(Keys.W) ||
(ButtonIsDown(Buttons.DPadUp) && !ButtonIsDown(Buttons.RightStick)))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Up * fEmitterMoveDelta;
}
if (KeyIsDown(Keys.S) ||
(ButtonIsDown(Buttons.DPadDown) && !ButtonIsDown(Buttons.RightStick)))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Down * fEmitterMoveDelta;
}
if (KeyIsDown(Keys.A) || ButtonIsDown(Buttons.DPadLeft))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Left * fEmitterMoveDelta;
}
if (KeyIsDown(Keys.D) || ButtonIsDown(Buttons.DPadRight))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Right * fEmitterMoveDelta;
}
if (KeyIsDown(Keys.E) ||
(ButtonIsDown(Buttons.DPadUp) && ButtonIsDown(Buttons.RightStick)))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Forward * fEmitterMoveDelta;
}
if (KeyIsDown(Keys.Q) ||
(ButtonIsDown(Buttons.DPadDown) && ButtonIsDown(Buttons.RightStick)))
{
mcCurrentParticleSystem.Emitter.PositionData.Position += Vector3.Backward * fEmitterMoveDelta;
}
// Check if the Emitter should be rotated
if ((meCurrentPS != EPSEffects.Star && meCurrentPS != EPSEffects.Ball) ||
(!KeyIsDown(Keys.V) && !KeyIsDown(Keys.B) && !KeyIsDown(Keys.P)))
{
if (KeyIsDown(Keys.J) ||
(ButtonIsDown(Buttons.RightThumbstickLeft) && !ButtonIsDown(Buttons.RightStick)))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(-fEmitterRotateDelta, 0.0f, 0.0f));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(-fEmitterRotateDelta, 0.0f, 0.0f));
}
}
if (KeyIsDown(Keys.L) ||
(ButtonIsDown(Buttons.RightThumbstickRight) && !ButtonIsDown(Buttons.RightStick)))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(fEmitterRotateDelta, 0.0f, 0.0f));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(fEmitterRotateDelta, 0.0f, 0.0f));
}
}
if (KeyIsDown(Keys.I) || ButtonIsDown(Buttons.RightThumbstickUp))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(0.0f, -fEmitterRotateDelta, 0.0f));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(0.0f, -fEmitterRotateDelta, 0.0f));
}
}
if (KeyIsDown(Keys.K) || ButtonIsDown(Buttons.RightThumbstickDown))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(0.0f, fEmitterRotateDelta, 0.0f));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(0.0f, fEmitterRotateDelta, 0.0f));
}
}
if (KeyIsDown(Keys.U) ||
(ButtonIsDown(Buttons.RightThumbstickLeft) && ButtonIsDown(Buttons.RightStick)))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(0.0f, 0.0f, fEmitterRotateDelta));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(0.0f, 0.0f, fEmitterRotateDelta));
}
}
if (KeyIsDown(Keys.O) ||
(ButtonIsDown(Buttons.RightThumbstickRight) && ButtonIsDown(Buttons.RightStick)))
{
// If we should Rotate the Emitter around the Pivot Point
if (KeyIsDown(Keys.Y))
{
mcCurrentParticleSystem.Emitter.PivotPointData.RotatePositionAndOrientation(Matrix.CreateFromYawPitchRoll(0.0f, 0.0f, -fEmitterRotateDelta));
}
// Else we should just Rotate the Emitter about its center
else
{
mcCurrentParticleSystem.Emitter.OrientationData.Rotate(Matrix.CreateFromYawPitchRoll(0.0f, 0.0f, -fEmitterRotateDelta));
}
}
}
// Check if the Emitter should be reset
if (KeyWasJustPressed(Keys.Z))
{
mcCurrentParticleSystem.Emitter.PositionData.Position = Vector3.Zero;
mcCurrentParticleSystem.Emitter.OrientationData.Orientation = Quaternion.Identity;
}
// If the Texture should be changed
if (KeyWasJustPressed(Keys.T) || ButtonWasJustPressed(Buttons.Y))
{
if (mcCurrentParticleSystem.Texture != null)
{
// Get which Texture is currently being used for sure
for (int i = 0; i < (int)ETextures.LastInList + 1; i++)
{
ETextures eTexture = (ETextures)i;
string sName = eTexture.ToString();
if (mcCurrentParticleSystem.Texture.Name.Equals(sName))
{
meCurrentTexture = (ETextures)i;
}
}
// If we should go to the previous Texture
if (KeyIsDown(Keys.LeftShift) || KeyIsDown(Keys.RightShift))
{
meCurrentTexture--;
if (meCurrentTexture < 0)
{
meCurrentTexture = ETextures.LastInList;
}
}
// Else we should go to the next Texture
else
{
meCurrentTexture++;
if (meCurrentTexture > ETextures.LastInList)
{
meCurrentTexture = 0;
}
}
// Change the Texture being used to draw the Particles
mcCurrentParticleSystem.SetTexture("Textures/" + meCurrentTexture.ToString());
}
}
if (KeyWasJustPressed(Keys.Insert))
{
// Add a single Particle
mcCurrentParticleSystem.AddParticle();
}
if (KeyIsDown(Keys.Home))
{
// Add Particles while the button is pressed
mcCurrentParticleSystem.AddParticle();
}
if (KeyIsDown(Keys.PageUp))
{
// Add the max number of Particles
while (mcCurrentParticleSystem.AddParticle()) { }
}
if (KeyWasJustPressed(Keys.Delete) || ButtonWasJustPressed(Buttons.X))
{
// Toggle emitting particles on/off
mcCurrentParticleSystem.Emitter.EmitParticlesAutomatically = !mcCurrentParticleSystem.Emitter.EmitParticlesAutomatically;
}
if (KeyIsDown(Keys.Add, 0.02f) || KeyIsDown(Keys.OemPlus, 0.02f) || ButtonIsDown(Buttons.RightShoulder, 0.02f))
{
// Increase the number of Particles being emitted
mcCurrentParticleSystem.Emitter.ParticlesPerSecond++;
}
if (KeyIsDown(Keys.Subtract, 0.02f) || KeyIsDown(Keys.OemMinus, 0.02f) || ButtonIsDown(Buttons.LeftShoulder, 0.02f))
{
if (mcCurrentParticleSystem.Emitter.ParticlesPerSecond > 1)
{
// Decrease the number of Particles being emitted
mcCurrentParticleSystem.Emitter.ParticlesPerSecond--;
}
}
if (KeyWasJustPressed(Keys.Multiply) ||
((KeyIsDown(Keys.LeftShift) || KeyIsDown(Keys.RightShift)) && KeyWasJustPressed(Keys.D8)) ||
ButtonWasJustPressed(Buttons.B))
{
// Increase the Speed of the Particle System simulation
mcParticleSystemManager.SimulationSpeed += 0.1f;
if (mcParticleSystemManager.SimulationSpeed > 5.0f)
{
mcParticleSystemManager.SimulationSpeed = 5.0f;
}
// If DPSF is not inheriting from DrawableGameComponent then we need
// to set the individual particle system's Simulation Speeds
if (DPSFHelper.DPSFInheritsDrawableGameComponent)
{
mcParticleSystemManager.SetSimulationSpeedForAllParticleSystems(mcParticleSystemManager.SimulationSpeed);
}
}
if (KeyWasJustPressed(Keys.Divide) ||
(KeyIsUp(Keys.LeftShift) && KeyIsUp(Keys.RightShift) && KeyWasJustPressed(Keys.OemQuestion)) ||
ButtonWasJustPressed(Buttons.A))
{
// Decrease the Speed of the Particle System simulation
mcParticleSystemManager.SimulationSpeed -= 0.1f;
if (mcParticleSystemManager.SimulationSpeed < 0.1f)
{
mcParticleSystemManager.SimulationSpeed = 0.1f;
}
// If DPSF is not inheriting from DrawableGameComponent then we need
// to set the individual particle system's Simulation Speeds
if (DPSFHelper.DPSFInheritsDrawableGameComponent)
{
mcParticleSystemManager.SetSimulationSpeedForAllParticleSystems(mcParticleSystemManager.SimulationSpeed);
}
}
// Check which Particle System is being used
switch (meCurrentPS)
{
default: break;
case EPSEffects.Random:
if (KeyWasJustPressed(Keys.X))
{
mcRandomParticleSystem.LoadRandomEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcRandomParticleSystem.LoadRandomSpiralEvents();
}
if (KeyWasJustPressed(Keys.V))
{
mcRandomParticleSystem.InitialProperties.StartSizeMin += 2.0f;
if (mcRandomParticleSystem.InitialProperties.StartSizeMin > 100.0f)
{
mcRandomParticleSystem.InitialProperties.StartSizeMin = 100.0f;
}
mcRandomParticleSystem.InitialProperties.StartSizeMax =
mcRandomParticleSystem.InitialProperties.EndSizeMin =
mcRandomParticleSystem.InitialProperties.EndSizeMax =
mcRandomParticleSystem.InitialProperties.StartSizeMin;
}
if (KeyWasJustPressed(Keys.B))
{
mcRandomParticleSystem.InitialProperties.StartSizeMin -= 2.0f;
if (mcRandomParticleSystem.InitialProperties.StartSizeMin < 2.0f)
{
mcRandomParticleSystem.InitialProperties.StartSizeMin = 2.0f;
}
mcRandomParticleSystem.InitialProperties.StartSizeMax =
mcRandomParticleSystem.InitialProperties.EndSizeMin =
mcRandomParticleSystem.InitialProperties.EndSizeMax =
mcRandomParticleSystem.InitialProperties.StartSizeMin;
}
if (KeyWasJustPressed(Keys.N))
{
mcRandomParticleSystem.InitialProperties.StartColorMin =
mcRandomParticleSystem.InitialProperties.StartColorMax =
DPSFHelper.LerpColor(Color.Black, Color.White, (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble());
}
if (KeyWasJustPressed(Keys.M))
{
mcRandomParticleSystem.InitialProperties.EndColorMin =
mcRandomParticleSystem.InitialProperties.EndColorMax =
DPSFHelper.LerpColor(Color.Black, Color.White, (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble(), (float)mcRandom.NextDouble());
}
if (KeyWasJustPressed(Keys.P))
{
mcRandomParticleSystem.LoadTubeEvents();
}
break;
case EPSEffects.Fire:
if (KeyWasJustPressed(Keys.X))
{
mcFireParticleSystem.ParticleInitializationFunction = mcFireParticleSystem.InitializeParticleFireOnVerticalRing;
}
if (KeyWasJustPressed(Keys.C))
{
mcFireParticleSystem.ParticleInitializationFunction = mcFireParticleSystem.InitializeParticleFireOnHorizontalRing;
}
if (KeyWasJustPressed(Keys.V))
{
float fAmount = mcFireParticleSystem.GetAmountOfSmokeBeingReleased();
if (fAmount > 0.0f)
{
mcFireParticleSystem.SetAmountOfSmokeToRelease(fAmount - 0.05f);
}
}
if (KeyWasJustPressed(Keys.B))
{
float fAmount = mcFireParticleSystem.GetAmountOfSmokeBeingReleased();
if (fAmount < 1.0f)
{
mcFireParticleSystem.SetAmountOfSmokeToRelease(fAmount + 0.05f);
}
}
if (KeyWasJustPressed(Keys.N))
{
mcFireParticleSystem.ToggleAdditiveBlending();
}
if (KeyWasJustPressed(Keys.M))
{
if (mcFireParticleSystem.Emitter.PositionData.Velocity == Vector3.Zero)
{
mcFireParticleSystem.Emitter.PositionData.Velocity = new Vector3(30, 0, 0);
}
else
{
mcFireParticleSystem.Emitter.PositionData.Velocity = Vector3.Zero;
}
}
break;
case EPSEffects.FireSprite:
if (KeyWasJustPressed(Keys.X))
{
mcFireSpriteParticleSystem.ParticleInitializationFunction = mcFireSpriteParticleSystem.InitializeParticleFireOnVerticalRing;
}
if (KeyWasJustPressed(Keys.C))
{
mcFireSpriteParticleSystem.ParticleInitializationFunction = mcFireSpriteParticleSystem.InitializeParticleFireOnHorizontalRing;
}
if (KeyWasJustPressed(Keys.V))
{
float fAmount = mcFireSpriteParticleSystem.GetAmountOfSmokeBeingReleased();
if (fAmount > 0.0f)
{
mcFireSpriteParticleSystem.SetAmountOfSmokeToRelease(fAmount - 0.05f);
}
}
if (KeyWasJustPressed(Keys.B))
{
float fAmount = mcFireSpriteParticleSystem.GetAmountOfSmokeBeingReleased();
if (fAmount < 1.0f)
{
mcFireSpriteParticleSystem.SetAmountOfSmokeToRelease(fAmount + 0.05f);
}
}
if (KeyWasJustPressed(Keys.N))
{
mcFireSpriteParticleSystem.ToggleAdditiveBlending();
}
if (KeyWasJustPressed(Keys.M))
{
if (mcFireSpriteParticleSystem.Emitter.PositionData.Velocity == Vector3.Zero)
{
mcFireSpriteParticleSystem.Emitter.PositionData.Velocity = new Vector3(30, 0, 0);
}
else
{
mcFireSpriteParticleSystem.Emitter.PositionData.Velocity = Vector3.Zero;
}
}
break;
case EPSEffects.Smoke:
if (KeyWasJustPressed(Keys.X))
{
mcSmokeParticleSystem.LoadSmokeEvents();
mcSmokeParticleSystem.ParticleInitializationFunction = mcSmokeParticleSystem.InitializeParticleRisingSmoke;
}
if (KeyWasJustPressed(Keys.C))
{
mcSmokeParticleSystem.LoadSmokeEvents();
mcSmokeParticleSystem.ParticleInitializationFunction = mcSmokeParticleSystem.InitializeParticleFoggySmoke;
}
if (KeyWasJustPressed(Keys.V))
{
mcSphere.bVisible = true;
mcSphere.sPosition = mcSmokeParticleSystem.mcExternalObjectPosition = new Vector3(-125, 50, 0);
mcSphere.sVelocity = new Vector3(50, 0, 0);
mcSphere.cTimeAliveInSeconds = TimeSpan.Zero;
mcSmokeParticleSystem.mfAttractRepelRange = mcSphere.fSize * 2;
mcSmokeParticleSystem.mfAttractRepelForce = 3.0f;
mcSmokeParticleSystem.MakeParticlesAttractToExternalObject();
}
if (KeyWasJustPressed(Keys.B))
{
mcSphere.bVisible = true;
mcSphere.sPosition = mcSmokeParticleSystem.mcExternalObjectPosition = new Vector3(-125, 50, 0);
mcSphere.sVelocity = new Vector3(50, 0, 0);
mcSphere.cTimeAliveInSeconds = TimeSpan.Zero;
mcSmokeParticleSystem.mfAttractRepelRange = mcSphere.fSize * 2f;
mcSmokeParticleSystem.mfAttractRepelForce = 0.5f;
mcSmokeParticleSystem.MakeParticlesRepelFromExternalObject();
}
if (KeyWasJustPressed(Keys.N))
{
mcSmokeParticleSystem.ChangeColor();
}
break;
case EPSEffects.Snow:
if (KeyWasJustPressed(Keys.X))
{
mcSnowParticleSystem.AddWindForce();
}
if (KeyWasJustReleased(Keys.C))
{
mcSnowParticleSystem.RemoveWindForce();
}
break;
case EPSEffects.SquarePattern:
if (KeyWasJustPressed(Keys.X))
{
mcSquarePatternParticleSystem.LoadSquarePatternEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcSquarePatternParticleSystem.LoadChangeColorEvents();
}
if (KeyWasJustPressed(Keys.V))
{
mcSquarePatternParticleSystem.ChangeParticlesToRandomColors();
}
break;
case EPSEffects.Fountain:
if (KeyWasJustPressed(Keys.X))
{
mcFountainParticleSystem.MakeParticlesBounceOffFloor();
}
if (KeyWasJustPressed(Keys.C))
{
mcFountainParticleSystem.MakeParticlesNotBounceOffFloor();
}
if (KeyWasJustPressed(Keys.V))
{
mcFountainParticleSystem.mfBounciness -= 0.05f;
if (mcFountainParticleSystem.mfBounciness < 0.0f)
{
mcFountainParticleSystem.mfBounciness = 0.0f;
}
}
if (KeyWasJustPressed(Keys.B))
{
mcFountainParticleSystem.mfBounciness += 0.05f;
if (mcFountainParticleSystem.mfBounciness > 2.0f)
{
mcFountainParticleSystem.mfBounciness = 2.0f;
}
}
if (KeyWasJustPressed(Keys.N))
{
mcFountainParticleSystem.MakeParticlesShrink();
}
if (KeyWasJustPressed(Keys.M))
{
mcFountainParticleSystem.MakeParticlesNotShrink();
}
if (KeyWasJustPressed(Keys.P))
{
mcFountainParticleSystem.ToggleAdditiveBlending();
}
break;
case EPSEffects.Random2D:
if (KeyWasJustPressed(Keys.X))
{
mcRandom2DParticleSystem.LoadEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcRandom2DParticleSystem.LoadExtraEvents();
}
break;
case EPSEffects.GasFall:
if (KeyWasJustPressed(Keys.X))
{
mcGasFallParticleSystem.LoadEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcGasFallParticleSystem.LoadExtraEvents();
}
break;
case EPSEffects.Dot: break;
case EPSEffects.Fireworks:
if (KeyWasJustPressed(Keys.X))
{
mcFireworksParticleSystem.InitialProperties.PositionMin = new Vector3();
mcFireworksParticleSystem.InitialProperties.PositionMax = new Vector3();
}
if (KeyWasJustPressed(Keys.C))
{
mcFireworksParticleSystem.InitialProperties.PositionMin = new Vector3(-100, 0, 0);
mcFireworksParticleSystem.InitialProperties.PositionMax = new Vector3(100, 0, 0);
}
if (KeyWasJustPressed(Keys.V))
{
mcFireworksParticleSystem.TurnExplosionsOn();
}
if (KeyWasJustPressed(Keys.B))
{
mcFireworksParticleSystem.TurnExplosionsOff();
}
break;
case EPSEffects.Figure8: break;
case EPSEffects.Star:
if (KeyWasJustPressed(Keys.X))
{
mcStarParticleSystem.ParticleInitializationFunction = mcStarParticleSystem.InitializeParticleStar2D;
}
if (KeyWasJustPressed(Keys.C))
{
mcStarParticleSystem.ParticleInitializationFunction = mcStarParticleSystem.InitializeParticleStar3D;
}
float fRotationScale = MathHelper.Pi / 18.0f;
if (KeyIsDown(Keys.V))
{
// Check if the Emitter is being rotated
if (KeyWasJustPressed(Keys.J))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Down * fRotationScale;
}
if (KeyWasJustPressed(Keys.L))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Up * fRotationScale;
}
if (KeyWasJustPressed(Keys.I))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Left * fRotationScale;
}
if (KeyWasJustPressed(Keys.K))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Right * fRotationScale;
}
if (KeyWasJustPressed(Keys.U))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Backward * fRotationScale;
}
if (KeyWasJustPressed(Keys.O))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Forward * fRotationScale;
}
}
if (KeyIsDown(Keys.B))
{
// Check if the Emitter is being rotated
if (KeyWasJustPressed(Keys.J))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Down * fRotationScale;
}
if (KeyWasJustPressed(Keys.L))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Up * fRotationScale;
}
if (KeyWasJustPressed(Keys.I))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Left * fRotationScale;
}
if (KeyWasJustPressed(Keys.K))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Right * fRotationScale;
}
if (KeyWasJustPressed(Keys.U))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Backward * fRotationScale;
}
if (KeyWasJustPressed(Keys.O))
{
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Forward * fRotationScale;
}
}
if (KeyWasJustPressed(Keys.N))
{
mcStarParticleSystem.Emitter.PositionData.Velocity = Vector3.Zero;
mcStarParticleSystem.Emitter.PositionData.Acceleration = Vector3.Zero;
mcStarParticleSystem.Emitter.OrientationData.RotationalVelocity = Vector3.Zero;
mcStarParticleSystem.Emitter.OrientationData.RotationalAcceleration = Vector3.Zero;
mcStarParticleSystem.ParticleSystemEvents.RemoveAllEvents();
}
if (KeyWasJustPressed(Keys.M))
{
mcStarParticleSystem.mbHighlightAxis = !mcStarParticleSystem.mbHighlightAxis;
}
if (KeyIsDown(Keys.P))
{
// Check if the Emitter is being rotated
if (KeyWasJustPressed(Keys.J))
{
mcStarParticleSystem.LoadSlowRotationalWiggle();
}
if (KeyWasJustPressed(Keys.L))
{
mcStarParticleSystem.LoadFastRotationalWiggle();
}
if (KeyWasJustPressed(Keys.I))
{
mcStarParticleSystem.LoadMediumWiggle();
}
if (KeyWasJustPressed(Keys.K))
{
mcStarParticleSystem.LoadMediumRotationalWiggle();
}
if (KeyWasJustPressed(Keys.U))
{
mcStarParticleSystem.LoadSlowWiggle();
}
if (KeyWasJustPressed(Keys.O))
{
mcStarParticleSystem.LoadFastWiggle();
}
}
if (KeyWasJustPressed(Keys.OemOpenBrackets))
{
mcStarParticleSystem.ToggleEmitterIntermittance();
}
break;
case EPSEffects.Ball:
if (KeyIsDown(Keys.X, 0.02f))
{
mcBallParticleSystem.IncreaseRadius();
}
if (KeyIsDown(Keys.C, 0.02f))
{
mcBallParticleSystem.DecreaseRadius();
}
float fBallRotationScale = MathHelper.Pi / 18.0f;
if (KeyIsDown(Keys.V))
{
// Check if the Emitter is being rotated
if (KeyWasJustPressed(Keys.J))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Down * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.L))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Up * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.I))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Left * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.K))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Right * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.U))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Backward * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.O))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity += Vector3.Forward * fBallRotationScale;
}
}
if (KeyIsDown(Keys.B))
{
// Check if the Emitter is being rotated
if (KeyWasJustPressed(Keys.J))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Down * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.L))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Up * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.I))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Left * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.K))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Right * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.U))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Backward * fBallRotationScale;
}
if (KeyWasJustPressed(Keys.O))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration += Vector3.Forward * fBallRotationScale;
}
}
if (KeyWasJustPressed(Keys.N))
{
mcBallParticleSystem.Emitter.OrientationData.RotationalVelocity = Vector3.Zero;
mcBallParticleSystem.Emitter.OrientationData.RotationalAcceleration = Vector3.Zero;
}
if (KeyIsDown(Keys.OemOpenBrackets, 0.04f))
{
mcBallParticleSystem.MoreParticles();
}
if (KeyIsDown(Keys.P, 0.04f))
{
mcBallParticleSystem.LessParticles();
}
if (KeyWasJustPressed(Keys.M))
{
mcBallParticleSystem.RemoveAllParticles();
}
break;
case EPSEffects.RotatingQuad:
if (KeyWasJustPressed(Keys.X))
{
mcRotatingQuadParticleSystem.MakeParticlesFaceWhateverDirection();
}
if (KeyWasJustPressed(Keys.C))
{
mcRotatingQuadParticleSystem.MakeParticlesFaceTheCamera();
}
if (KeyWasJustPressed(Keys.V))
{
mcRotatingQuadParticleSystem.MakeParticlesFaceTheCenter();
}
if (KeyWasJustPressed(Keys.B))
{
mcRotatingQuadParticleSystem.RemoveAllParticles();
int iNumberOfParticles = mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed;
switch (iNumberOfParticles)
{
default:
case 1:
mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed = 10;
break;
case 10:
mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed = 100;
break;
case 100:
mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed = 500;
break;
case 500:
mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed = 1000;
break;
case 1000:
mcRotatingQuadParticleSystem.MaxNumberOfParticlesAllowed = 1;
break;
}
}
break;
case EPSEffects.Box:
if (KeyWasJustPressed(Keys.X))
{
mcBoxParticleSystem.LoadPartiallyTranparentBox();
}
if (KeyWasJustPressed(Keys.C))
{
mcBoxParticleSystem.LoadOpaqueBoxBars();
}
if (KeyWasJustPressed(Keys.V))
{
mcBoxParticleSystem.ToggleColorChanges();
}
break;
case EPSEffects.Image:
if (KeyWasJustPressed(Keys.X))
{
mcImageParticleSystem.LoadImage();
}
if (KeyWasJustPressed(Keys.C))
{
mcImageParticleSystem.LoadSpiralIntoFinalImage();
}
if (KeyWasJustPressed(Keys.V))
{
mcImageParticleSystem.LoadVortexIntoFinalImage();
}
if (KeyWasJustPressed(Keys.B))
{
string sSpinMode = mcImageParticleSystem.msSpinMode;
switch (sSpinMode)
{
case "Pitch":
sSpinMode = "Yaw";
break;
case "Yaw":
sSpinMode = "Roll";
break;
case "Roll":
sSpinMode = "All";
break;
case "All":
sSpinMode = "None";
break;
default:
case "None":
sSpinMode = "Pitch";
break;
}
mcImageParticleSystem.ToggleSpin(sSpinMode);
}
if (KeyWasJustPressed(Keys.N))
{
mcImageParticleSystem.ToggleUniformSpin();
}
if (KeyWasJustPressed(Keys.M))
{
mcImageParticleSystem.Scatter();
}
if (KeyWasJustPressed(Keys.P))
{
int iRows = mcImageParticleSystem.miNumberOfRows;
int iColumns = mcImageParticleSystem.miNumberOfColumns;
switch (iRows)
{
default:
case 2:
iRows = 4;
break;
case 4:
iRows = 8;
break;
case 8:
iRows = 16;
break;
case 16:
iRows = 32;
break;
case 32:
iRows = 64;
break;
case 64:
iRows = 2;
break;
}
mcImageParticleSystem.SetNumberOfRowsAndColumns(iRows, iColumns);
}
if (KeyWasJustPressed(Keys.OemOpenBrackets))
{
int iRows = mcImageParticleSystem.miNumberOfRows;
int iColumns = mcImageParticleSystem.miNumberOfColumns;
switch (iColumns)
{
default:
case 2:
iColumns = 4;
break;
case 4:
iColumns = 8;
break;
case 8:
iColumns = 16;
break;
case 16:
iColumns = 32;
break;
case 32:
iColumns = 64;
break;
case 64:
iColumns = 2;
break;
}
mcImageParticleSystem.SetNumberOfRowsAndColumns(iRows, iColumns);
}
break;
case EPSEffects.AnimatedTexturedQuad: break;
case EPSEffects.Sprite:
// If the mouse was moved
if (mcCurrentMouseState.X != mcPreviousMouseState.X ||
mcCurrentMouseState.Y != mcPreviousMouseState.Y)
{
mcSpriteParticleSystem.AttractorPosition = new Vector3(mcCurrentMouseState.X, mcCurrentMouseState.Y, 0);
}
// If the left mouse button was just pressed
if (mcCurrentMouseState.LeftButton == ButtonState.Pressed &&
mcPreviousMouseState.LeftButton == ButtonState.Released)
{
mcSpriteParticleSystem.ToggleAttractorMode();
}
// If the right mouse button was just pressed
if (mcCurrentMouseState.RightButton == ButtonState.Pressed &&
mcPreviousMouseState.RightButton == ButtonState.Released)
{
mcSpriteParticleSystem.ToggleAttractorStrength();
}
if (KeyWasJustPressed(Keys.X))
{
mcSpriteParticleSystem.LoadAttractionEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcSpriteParticleSystem.LoadCloudEvents();
}
if (KeyWasJustPressed(Keys.V))
{
mcSpriteParticleSystem.LoadGridEvents();
}
if (KeyWasJustPressed(Keys.B))
{
mcSpriteParticleSystem.LoadRotatorsEvents();
}
break;
case EPSEffects.AnimatedSprite:
// If the mouse was moved
if (mcCurrentMouseState.X != mcPreviousMouseState.X ||
mcCurrentMouseState.Y != mcPreviousMouseState.Y)
{
mcAnimatedSpriteParticleSystem.MousePosition = new Vector3(mcCurrentMouseState.X, mcCurrentMouseState.Y, 0);
}
// If the left mouse button was just pressed
if (mcCurrentMouseState.LeftButton == ButtonState.Pressed &&
mcPreviousMouseState.LeftButton == ButtonState.Released)
{
mcAnimatedSpriteParticleSystem.ToggleColorAmount();
}
// If the right mouse button was just pressed
if (mcCurrentMouseState.RightButton == ButtonState.Pressed &&
mcPreviousMouseState.RightButton == ButtonState.Released)
{
mcAnimatedSpriteParticleSystem.AddParticle();
}
if (KeyWasJustPressed(Keys.X))
{
mcAnimatedSpriteParticleSystem.LoadExplosionEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcAnimatedSpriteParticleSystem.LoadButterflyEvents();
}
break;
case EPSEffects.QuadSpray:
if (KeyWasJustPressed(Keys.X))
{
mcQuadSprayParticleSystem.LoadSprayEvents();
}
if (KeyWasJustPressed(Keys.C))
{
mcQuadSprayParticleSystem.LoadWallEvents();
}
if (KeyWasJustPressed(Keys.V))
{
mcQuadSprayParticleSystem.ToggleGravity();
}
break;
case EPSEffects.Magnets:
if (KeyWasJustPressed(Keys.X))
{
mcMagnetParticleSystem.LoadEmitterMagnetParticleSystem();
}
if (KeyWasJustPressed(Keys.C))
{
mcMagnetParticleSystem.LoadSeparateEmitterMagnetsParticleSystem();
}
if (KeyWasJustPressed(Keys.V))
{
mcMagnetParticleSystem.ToggleMagnetsAffectingPositionVsVelocity();
}
break;
case EPSEffects.Sparkler:
if (KeyWasJustPressed(Keys.X))
{
mcSparklerParticleSystem.LoadSimpleParticleSystem();
}
if (KeyWasJustPressed(Keys.C))
{
mcSparklerParticleSystem.LoadComplexParticleSystem();
}
break;
case EPSEffects.Sphere:
if (KeyIsDown(Keys.X, 0.02f))
{
mcSphereParticleSystem.ChangeSphereRadius(-5);
}
if (KeyIsDown(Keys.C, 0.02f))
{
mcSphereParticleSystem.ChangeSphereRadius(5);
}
if (KeyWasJustPressed(Keys.V))
{
mcSphereParticleSystem.MakeParticlesTravelInTheSameDirection();
}
if (KeyWasJustPressed(Keys.B))
{
mcSphereParticleSystem.MakeParticlesTravelInRandomDirections();
}
if (KeyWasJustPressed(Keys.N))
{
mcSphereParticleSystem.ChangeNumberOfParticles(-50);
}
if (KeyWasJustPressed(Keys.M))
{
mcSphereParticleSystem.ChangeNumberOfParticles(50);
}
break;
case EPSEffects.MultipleParticleImages: break;
case EPSEffects.MultipleParticleImagesSprite: break;
case EPSEffects.ExplosionFireSmoke:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionFireSmokeParticleSystem.ExplosionIntensity -= 5;
mcExplosionFireSmokeParticleSystem.ExplosionIntensity = (mcExplosionFireSmokeParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionFireSmokeParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionFireSmokeParticleSystem.ExplosionIntensity += 5;
mcExplosionFireSmokeParticleSystem.ExplosionIntensity = (mcExplosionFireSmokeParticleSystem.ExplosionIntensity > 200 ? 200 : mcExplosionFireSmokeParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionFireSmokeParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionFireSmokeParticleSystem.ExplosionParticleSize -= 5;
mcExplosionFireSmokeParticleSystem.ExplosionParticleSize = (mcExplosionFireSmokeParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionFireSmokeParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionFireSmokeParticleSystem.ExplosionParticleSize += 5;
mcExplosionFireSmokeParticleSystem.ExplosionParticleSize = (mcExplosionFireSmokeParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionFireSmokeParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionFlash:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionFlashParticleSystem.ExplosionIntensity -= 5;
mcExplosionFlashParticleSystem.ExplosionIntensity = (mcExplosionFlashParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionFlashParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionFlashParticleSystem.ExplosionIntensity += 5;
mcExplosionFlashParticleSystem.ExplosionIntensity = (mcExplosionFlashParticleSystem.ExplosionIntensity > 100 ? 100 : mcExplosionFlashParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionFlashParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionFlashParticleSystem.ExplosionParticleSize -= 5;
mcExplosionFlashParticleSystem.ExplosionParticleSize = (mcExplosionFlashParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionFlashParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionFlashParticleSystem.ExplosionParticleSize += 5;
mcExplosionFlashParticleSystem.ExplosionParticleSize = (mcExplosionFlashParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionFlashParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionFlyingSparks:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionFlyingSparksParticleSystem.ExplosionIntensity -= 5;
mcExplosionFlyingSparksParticleSystem.ExplosionIntensity = (mcExplosionFlyingSparksParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionFlyingSparksParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionFlyingSparksParticleSystem.ExplosionIntensity += 5;
mcExplosionFlyingSparksParticleSystem.ExplosionIntensity = (mcExplosionFlyingSparksParticleSystem.ExplosionIntensity > 200 ? 200 : mcExplosionFlyingSparksParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionFlyingSparksParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize -= 5;
mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize = (mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize += 5;
mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize = (mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionFlyingSparksParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionSmokeTrails:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity -= 5;
mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity = (mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity += 5;
mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity = (mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity > 200 ? 200 : mcExplosionSmokeTrailsParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionSmokeTrailsParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize -= 5;
mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize = (mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize += 5;
mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize = (mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionSmokeTrailsParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionRoundSparks:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionRoundSparksParticleSystem.ExplosionIntensity -= 5;
mcExplosionRoundSparksParticleSystem.ExplosionIntensity = (mcExplosionRoundSparksParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionRoundSparksParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionRoundSparksParticleSystem.ExplosionIntensity += 5;
mcExplosionRoundSparksParticleSystem.ExplosionIntensity = (mcExplosionRoundSparksParticleSystem.ExplosionIntensity > 100 ? 100 : mcExplosionRoundSparksParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionRoundSparksParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionRoundSparksParticleSystem.ExplosionParticleSize -= 5;
mcExplosionRoundSparksParticleSystem.ExplosionParticleSize = (mcExplosionRoundSparksParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionRoundSparksParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionRoundSparksParticleSystem.ExplosionParticleSize += 5;
mcExplosionRoundSparksParticleSystem.ExplosionParticleSize = (mcExplosionRoundSparksParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionRoundSparksParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionDebris:
if (KeyWasJustPressed(Keys.X))
{
mcExplosionDebrisParticleSystem.ExplosionIntensity -= 5;
mcExplosionDebrisParticleSystem.ExplosionIntensity = (mcExplosionDebrisParticleSystem.ExplosionIntensity < 1 ? 1 : mcExplosionDebrisParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.C))
{
mcExplosionDebrisParticleSystem.ExplosionIntensity += 5;
mcExplosionDebrisParticleSystem.ExplosionIntensity = (mcExplosionDebrisParticleSystem.ExplosionIntensity > 200 ? 200 : mcExplosionDebrisParticleSystem.ExplosionIntensity);
}
if (KeyWasJustPressed(Keys.V))
{
mcExplosionDebrisParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionDebrisParticleSystem.ExplosionParticleSize -= 5;
mcExplosionDebrisParticleSystem.ExplosionParticleSize = (mcExplosionDebrisParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionDebrisParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionDebrisParticleSystem.ExplosionParticleSize += 5;
mcExplosionDebrisParticleSystem.ExplosionParticleSize = (mcExplosionDebrisParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionDebrisParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.ExplosionShockwave:
if (KeyWasJustPressed(Keys.V))
{
mcExplosionShockwaveParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionShockwaveParticleSystem.ShockwaveSize -= 5;
mcExplosionShockwaveParticleSystem.ShockwaveSize = (mcExplosionShockwaveParticleSystem.ShockwaveSize < 100 ? 100 : mcExplosionShockwaveParticleSystem.ShockwaveSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionShockwaveParticleSystem.ShockwaveSize += 5;
mcExplosionShockwaveParticleSystem.ShockwaveSize = (mcExplosionShockwaveParticleSystem.ShockwaveSize > 400 ? 400 : mcExplosionShockwaveParticleSystem.ShockwaveSize);
}
break;
case EPSEffects.Explosion:
if (KeyWasJustPressed(Keys.V))
{
mcExplosionParticleSystem.ChangeExplosionColor();
}
if (KeyWasJustPressed(Keys.B))
{
mcExplosionParticleSystem.ExplosionParticleSize -= 5;
mcExplosionParticleSystem.ExplosionParticleSize = (mcExplosionParticleSystem.ExplosionParticleSize < 1 ? 1 : mcExplosionParticleSystem.ExplosionParticleSize);
}
if (KeyWasJustPressed(Keys.N))
{
mcExplosionParticleSystem.ExplosionParticleSize += 5;
mcExplosionParticleSystem.ExplosionParticleSize = (mcExplosionParticleSystem.ExplosionParticleSize > 100 ? 100 : mcExplosionParticleSystem.ExplosionParticleSize);
}
break;
case EPSEffects.SpriteParticleSystemTemplate: break;
case EPSEffects.Sprite3DBillboardParticleSystemTemplate: break;
case EPSEffects.QuadParticleSystemTemplate: break;
case EPSEffects.TexturedQuadParticleSystemTemplate: break;
case EPSEffects.DefaultSpriteParticleSystemTemplate: break;
case EPSEffects.DefaultSprite3DBillboardParticleSystemTemplate: break;
case EPSEffects.DefaultQuadParticleSystemTemplate: break;
case EPSEffects.DefaultTexturedQuadParticleSystemTemplate: break;
}
}
