public async Task Generates_Valid_Script_With_Y_Axis_Size_Preservation()
{
var settings = new EmitterSettings
{
Trigger = new OneShotTrigger(),
Initializers = new[]
{
new RandomSizeInitializer
{
MinWidth = 10,
MaxWidth = 15,
MinHeight = 10,
MaxHeight = 15,
PreserveAspectRatio = true,
RandomizedAxis = RandomSizeInitializer.Axis.X
},
}
};
var code = EmitterLogicClassGenerator.Generate(settings, "ParmeTest", "ParmeClass", true);
var scriptOptions = ScriptOptions.Default.WithReferences(typeof(IEmitterLogic).Assembly);
var emitterLogic = await CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions);
emitterLogic.ShouldNotBeNull();
}
public static IEmitterLogic GetInstance(EmitterSettings settings)
{
var code = EmitterLogicClassGenerator.Generate(settings, "Parme.Editor", "Test", true);
var scriptOptions = ScriptOptions.Default
.WithReferences(typeof(IEmitterLogic).Assembly);
return(CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions).GetAwaiter().GetResult());
}
private static void GenerateCSharpCode(string inputFile, string outputFile, string className, string @namespace, IConsole console)
{
console.Out.WriteLine($"Generating C# code for emitter logic file '{inputFile}' into '{outputFile}'");
string json;
try
{
json = File.ReadAllText(inputFile);
}
catch (Exception exception)
{
console.Error.WriteLine($"Failed to read input file '{inputFile}': {exception.Message}");
return;
}
EmitterSettings emitterSettings;
try
{
emitterSettings = EmitterSettings.FromJson(json);
}
catch (MissingParmeTypeException exception)
{
var message = $"The emitter logic defined in '{inputFile}' could not be read, as it is expecting a " +
$"ParME type of '{exception.TypeName}', but this type is not known.";
console.Error.WriteLine(message);
return;
}
catch (Exception exception)
{
var message = $"Failed to parse emitter logic defined in `{inputFile}`: {exception.Message}" +
$"{Environment.NewLine}{Environment.NewLine}{exception}";
console.Error.WriteLine(message);
return;
}
@namespace ??= "Parme.Generated";
className ??= Path.GetFileNameWithoutExtension(inputFile);
var code = EmitterLogicClassGenerator.Generate(emitterSettings, @namespace, className, false);
try
{
File.WriteAllText(outputFile, code);
}
catch (Exception exception)
{
console.Error.WriteLine($"Failed to write generated code to '{outputFile}': {exception.Message}");
return;
}
console.Out.WriteLine("Parme emitter logic code successfully generated");
}
public async Task Logic_Class_Contains_Accessible_Texture_FileName()
{
var settings = new EmitterSettings
{
Trigger = new OneShotTrigger(),
TextureFileName = @"C:\test\some.png",
};
var code = EmitterLogicClassGenerator.Generate(settings, "ParmeTest", "ParmeClass", true);
var scriptOptions = ScriptOptions.Default.WithReferences(typeof(IEmitterLogic).Assembly);
var emitterLogic = await CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions);
emitterLogic.ShouldNotBeNull();
emitterLogic.TextureFilePath.ShouldBe(settings.TextureFileName);
}
public async Task Can_Generate_Valid_Script_Code_That_Returns_IEmitterLogic_Class_With_All_Particle_Modifiers_And_Initializers()
{
var allTriggers = typeof(IParticleTrigger).Assembly
.GetTypes()
.Where(x => !x.IsInterface)
.Where(x => !x.IsAbstract)
.Where(x => typeof(IParticleTrigger).IsAssignableFrom(x))
.Select(x => (IParticleTrigger)Activator.CreateInstance(x))
.ToList();
var allInitializers = typeof(IParticleInitializer).Assembly
.GetTypes()
.Where(x => !x.IsInterface)
.Where(x => !x.IsAbstract)
.Where(x => typeof(IParticleInitializer).IsAssignableFrom(x))
.Select(x => (IParticleInitializer)Activator.CreateInstance(x))
.ToList();
var allModifiers = typeof(IParticleModifier).Assembly
.GetTypes()
.Where(x => !x.IsInterface)
.Where(x => !x.IsAbstract)
.Where(x => typeof(IParticleModifier).IsAssignableFrom(x))
.Select(x => (IParticleModifier)Activator.CreateInstance(x))
.ToList();
var settings = new EmitterSettings
{
Trigger = allTriggers.First(),
Initializers = allInitializers,
Modifiers = allModifiers,
MaxParticleLifeTime = 1f,
PositionModifier = new AltitudeBouncePositionModifier(),
};
var code = EmitterLogicClassGenerator.Generate(settings, "ParmeTest", "ParmeClass", true);
var scriptOptions = ScriptOptions.Default
.WithReferences(typeof(IEmitterLogic).Assembly);
var emitterLogic = await CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions);
emitterLogic.ShouldNotBeNull();
}
private void UpdateEmitter(EmitterSettings settings)
{
Vector2?previousCameraOffset = null;
if (_emitter != null)
{
previousCameraOffset = _camera.Origin - _emitter.WorldCoordinates;
_emitterRenderGroup.RemoveEmitter(_emitter);
_emitter.Dispose();
_emitter = null;
}
if (settings != null)
{
var code = EmitterLogicClassGenerator.Generate(settings, "Parme.Editor", "Test", true);
var scriptOptions = ScriptOptions.Default
.WithReferences(typeof(IEmitterLogic).Assembly);
var logicClass = CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions).GetAwaiter().GetResult();
_emitter = new MonoGameEmitter(logicClass, _particlePool, GraphicsDevice, _textureFileLoader, _random);
_emitterRenderGroup.AddEmitter(_emitter);
_emitter.IsEmittingNewParticles = true;
// Don't reset the camera if we don't have a moving emitter. Without a moving emitter then this will
// just frustrate the user, as they've positioned the camera in that spot for a reason
if (_uiController.EmitterVelocity != Vector2.Zero)
{
ResetCamera(resetOriginTo: previousCameraOffset);
}
}
ResetRenderTarget();
ResetCameraBounds();
if (_applicationState.AutoSaveOnChange)
{
_appOperationQueue.Enqueue(new SaveEmitterRequested(_applicationState.ActiveFileName, settings));
}
}
public async Task Logic_Class_Contains_Accessible_Texture_Sections()
{
var settings = new EmitterSettings
{
Trigger = new OneShotTrigger(),
TextureFileName = @"C:\test\some.png",
TextureSections = new[]
{
new TextureSectionCoords(1, 2, 3, 4),
new TextureSectionCoords(5, 6, 7, 8),
}
};
var code = EmitterLogicClassGenerator.Generate(settings, "ParmeTest", "ParmeClass", true);
var scriptOptions = ScriptOptions.Default.WithReferences(typeof(IEmitterLogic).Assembly);
var emitterLogic = await CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions);
emitterLogic.ShouldNotBeNull();
emitterLogic.TextureSections.ShouldNotBeNull();
emitterLogic.TextureSections.Length.ShouldBe(2);
emitterLogic.TextureSections[0].ShouldBe(new TextureSectionCoords(1, 2, 3, 4));
emitterLogic.TextureSections[1].ShouldBe(new TextureSectionCoords(5, 6, 7, 8));
}
public async Task Class_Generation_Works_With_Comma_Separated_Decimal_Cultures()
{
var originalCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
try
{
var emitter = new EmitterSettings
{
MaxParticleLifeTime = 1.1f,
Trigger = new OneShotTrigger(),
Initializers = new IParticleInitializer[]
{
new RadialVelocityInitializer {
MinDegrees = 1, MaxDegrees = 360, Magnitude = 1.23f
},
new StaticColorInitializer {
Alpha = 0.76f, Blue = 200, Green = 199, Red = 198
},
new RandomRangeVelocityInitializer
{
MaxXVelocity = 123456.1f, MaxYVelocity = 1.2f, MinXVelocity = 1.3f, MinYVelocity = 1.4f
},
new StaticRotationalVelocityInitializer {
DegreesPerSecond = 256
},
new RandomRotationalVelocityInitializer
{
MinRotationSpeedInDegreesPerSecond = 111, MaxRotationSpeedInDegreesPerSecond = 123
},
},
Modifiers = new IParticleModifier[]
{
new DragModifier {
DragFactor = 1.2f
},
new ConstantAccelerationModifier {
XAcceleration = 1.1f, YAcceleration = 1.2f
},
new EndingColorModifier {
Alpha = 0.76f, Blue = 200, Green = 199, Red = 198
},
},
PositionModifier = new AltitudeBouncePositionModifier
{
Gravity = 5000,
MinBounceAcceleration = 1234,
MaxBounceAcceleration = 35353,
Elasticity = 0.9f,
},
};
var code = EmitterLogicClassGenerator.Generate(emitter, "ParmeTest", "ParmeClass", true);
var scriptOptions = ScriptOptions.Default
.WithReferences(typeof(IEmitterLogic).Assembly);
var emitterLogic = await CSharpScript.EvaluateAsync <IEmitterLogic>(code, scriptOptions);
emitterLogic.ShouldNotBeNull();
}
finally
{
Thread.CurrentThread.CurrentCulture = originalCulture;
}
}
