public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
var allLightsOrdered = layer.OrderBy(x => x.LightLocation.X).ThenBy(x => x.LightLocation.Y).ToList();
var leftToRight = allLightsOrdered.GroupBy(x => (int)(((x.LightLocation.X + 1) / 2) * 50)).Select(x => x.Select(s => s)).ToList();
var effectGroups = leftToRight.ChunkByGroupNumber(2).ToList();
while (!cancellationToken.IsCancellationRequested)
{
bool skip = false;
CancellationTokenSource tempCancel = new CancellationTokenSource();
var nextColor = RGBColor.Random();
foreach (var group in effectGroups)
{
if (!skip)
{
group.SelectMany(x => x).SetState(cancellationToken, nextColor, 1);
}
else
{
group.SelectMany(x => x).SetBrightness(cancellationToken, 0);
group.FlashQuick(tempCancel.Token, null, IteratorEffectMode.AllIndividual, IteratorEffectMode.Random);
}
skip = !skip;
}
await Task.Delay(waitTime());
tempCancel.Cancel();
effectGroups = effectGroups.Skip(1).Union(effectGroups.Take(1)).ToList();
}
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken, double x, double y)
{
Func <TimeSpan> customWaitTime = () => waitTime() / 10;
if (!color.HasValue)
{
color = RGBColor.Random();
}
HorizontalScanLineEffect hline = new HorizontalScanLineEffect(customWaitTime, color);
hline.X = x;
hline.AutoRepeat = false;
layer.PlaceEffect(hline);
VerticalScanLineEffect vline = new VerticalScanLineEffect(customWaitTime, color);
vline.Y = y;
vline.AutoRepeat = false;
layer.PlaceEffect(vline);
hline.Start();
vline.Start();
return(Task.Run(async() =>
{
await Task.Delay(customWaitTime() * 15);
hline.Stop();
vline.Stop();
await Task.Delay(TimeSpan.FromSeconds(1));
layer.Effects.Remove(hline);
layer.Effects.Remove(vline);
}));
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
var r = new Random();
var center = EffectSettings.LocationCenter;
var orderedLayer = layer.OrderByDescending(x => x.LightLocation.Angle(center.X, center.Y));
while (!cancellationToken.IsCancellationRequested)
{
color = RGBColor.Random();
foreach (var light in orderedLayer)
{
Task.Run(async() =>
{
var distance = 1 + light.LightLocation.Y;
var timeSpan = waitTime() / 2 * distance;
await Task.Delay(timeSpan);
//Debug.WriteLine($"{light.Id} Angle {angle} and timespan {timeSpan.TotalMilliseconds}");
light.SetState(cancellationToken, color, 1, TimeSpan.Zero);
if (DipToBlack)
{
await Task.Delay(waitTime() * DipToBlackWait);
light.SetBrightness(cancellationToken, 0, waitTime() * 0.1);
}
});
}
await Task.Delay(waitTime() * 1.1);
}
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
var r = new Random();
var center = EffectSettings.LocationCenter;
var orderedLayer = layer.OrderByDescending(x => x.LightLocation.Angle(center.X, center.Y));
while (!cancellationToken.IsCancellationRequested)
{
var randomColor = RGBColor.Random(r);
foreach (var light in orderedLayer)
{
Task.Run(async() =>
{
var angle = light.LightLocation.Angle(center.X, center.Y).Move360(90);
var timeSpan = waitTime() / 360 * angle;
await Task.Delay(timeSpan);
//Debug.WriteLine($"{light.Id} Angle {angle} and timespan {timeSpan.TotalMilliseconds}");
light.SetState(cancellationToken, randomColor, 1, waitTime() / 2);
});
}
await Task.Delay(waitTime() * 1.1);
}
}
private static void GenerateRandomEffectSettings(out RGBColor hexColor, out IteratorEffectMode iteratorMode, out IteratorEffectMode iteratorSecondaryMode)
{
Random r = new Random();
hexColor = RGBColor.Random(r);
while (hexColor.R < 0.15 && hexColor.G < 0.15 && hexColor.B < 0.15)
{
hexColor = RGBColor.Random(r);
}
Array values = Enum.GetValues(typeof(IteratorEffectMode));
iteratorMode = (IteratorEffectMode)values.GetValue(r.Next(values.Length));
iteratorSecondaryMode = (IteratorEffectMode)values.GetValue(r.Next(values.Length));
//Bounce and Single are no fun for random mode
if (iteratorMode == IteratorEffectMode.Bounce || iteratorMode == IteratorEffectMode.Single)
{
iteratorMode = IteratorEffectMode.Cycle;
}
else if (iteratorMode == IteratorEffectMode.RandomOrdered) //RandomOrdered only runs once
{
iteratorMode = IteratorEffectMode.Random;
}
}
public Task Start(IEnumerable <IEnumerable <EntertainmentLight> > layer, Func <TimeSpan> waitTime, RGBColor?color, IteratorEffectMode iteratorMode, IteratorEffectMode secondaryIteratorMode, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
if (iteratorMode != IteratorEffectMode.All)
{
if (secondaryIteratorMode == IteratorEffectMode.Bounce ||
secondaryIteratorMode == IteratorEffectMode.Cycle ||
secondaryIteratorMode == IteratorEffectMode.Random ||
secondaryIteratorMode == IteratorEffectMode.RandomOrdered ||
secondaryIteratorMode == IteratorEffectMode.Single)
{
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds *layer.Count()) / layer.SelectMany(x => x).Count());
return(layer.FlashQuick(cancellationToken, color, iteratorMode, secondaryIteratorMode,
waitTime: customWaitMS,
transitionTimeOn: () => TimeSpan.Zero,
transitionTimeOff: customWaitMS));
}
}
return(layer.FlashQuick(cancellationToken, color, iteratorMode, secondaryIteratorMode, waitTime: waitTime, transitionTimeOn: () => TimeSpan.Zero, transitionTimeOff: waitTime));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
return(layer.To2DGroup().FlashQuick(cancellationToken, color, IteratorEffectMode.All, waitTime: waitTime));
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
var r = new Random();
var center = EffectSettings.LocationCenter;
var orderedLeftLayer = layer.OrderByDescending(x => x.LightLocation.Angle(center.X, center.Y)).GetLeft();
var ordereRightLayer = layer.OrderByDescending(x => x.LightLocation.Angle(center.X, center.Y)).GetRight();
var toDark = r.NextDouble() >= 0.5;
while (!cancellationToken.IsCancellationRequested)
{
var randomLeftColor = RGBColor.Random(r);
var randomRightColor = RGBColor.Random(r);
foreach (var light in orderedLeftLayer)
{
Task.Run(async() =>
{
var angle = light.LightLocation.Angle(center.X, center.Y).Move360(91);
var timeSpan = waitTime() / 360 * angle;
await Task.Delay(timeSpan);
//Debug.WriteLine($"{light.Id} Angle {angle} and timespan {timeSpan.TotalMilliseconds}");
light.SetState(cancellationToken, randomLeftColor, 1, waitTime() / 2);
if (toDark)
{
await Task.Delay(waitTime() * 1.1);
await Task.Delay(timeSpan);
light.SetBrightness(cancellationToken, 0, waitTime() / 2);
}
});
}
await Task.Delay(waitTime() * 1.1);
foreach (var light in ordereRightLayer)
{
Task.Run(async() =>
{
var angle = Math.Abs(light.LightLocation.Angle(center.X, center.Y).Move360(271) - 180);
var timeSpan = waitTime() / 360 * angle;
await Task.Delay(timeSpan);
//Debug.WriteLine($"{light.Id} Angle {angle} and timespan {timeSpan.TotalMilliseconds}");
light.SetState(cancellationToken, randomRightColor, 1, waitTime() / 2);
if (toDark)
{
await Task.Delay(waitTime() * 1.1);
await Task.Delay(timeSpan);
light.SetBrightness(cancellationToken, 0, waitTime() / 2);
}
});
}
await Task.Delay(waitTime() * 1.1);
}
}
public override void Start()
{
base.Start();
CalculateMaxRadius();
var state = new Models.EntertainmentState();
state.SetBrightness(1);
state.SetRGBColor(RGBColor.Random());
this.State = state;
_cts = new CancellationTokenSource();
Task.Run(async() =>
{
double step = StepSize;
while (true && !_cts.IsCancellationRequested)
{
Radius += step;
await Task.Delay(_waitTime(), _cts.Token).ConfigureAwait(false);
if (Radius >= _maxRadius)
{
if (_fadeToZero)
{
step = -1 * Math.Abs(StepSize);
}
else
{
Radius = 0;
if (!AutoRepeat)
{
break;
}
state.SetRGBColor(RGBColor.Random());
}
}
if (Radius <= 0)
{
if (!AutoRepeat)
{
break;
}
step = Math.Abs(StepSize);
state.SetRGBColor(RGBColor.Random());
}
}
}, _cts.Token);
}
public VerticalScanLineEffect(Func <TimeSpan> waitTime = null, RGBColor?color = null)
{
_waitTime = waitTime;
if (_waitTime == null)
{
_waitTime = () => TimeSpan.FromMilliseconds(50);
}
_color = color ?? RGBColor.Random();
Radius = 1;
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
var fronToBack = layer.GroupBy(x => (int)(((x.LightLocation.Y + 1) / 2) * 50)).ToList();
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds * 2) / fronToBack.Count);
return(fronToBack.FlashQuick(cancellationToken, color, IteratorEffectMode.Bounce, IteratorEffectMode.All, waitTime: customWaitMS));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
var groupCount = layer.Count / 3;
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds * 2) / groupCount);
return(layer.OrderBy(x => Guid.NewGuid()).ChunkByGroupNumber(groupCount).FlashQuick(cancellationToken, color, IteratorEffectMode.Random, waitTime: customWaitMS));
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
layer.SetState(cancellationToken, color, 1, waitTime(), false);
//Wait for other events to finish and set state again
await Task.Delay(waitTime(), cancellationToken);
layer.SetState(cancellationToken, color, 1, waitTime(), false);
}
public static Task Flash(this IEnumerable <IEnumerable <EntertainmentLight> > group, CancellationToken cancellationToken, RGBColor?color, IteratorEffectMode mode = IteratorEffectMode.Cycle, IteratorEffectMode secondaryIteratorMode = IteratorEffectMode.All, Func <TimeSpan> waitTime = null, Func <TimeSpan> onTime = null, Func <TimeSpan> transitionTimeOn = null, Func <TimeSpan> transitionTimeOff = null, bool waitTillFinished = true, TimeSpan?duration = null)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
if (waitTime == null)
{
waitTime = () => TimeSpan.FromMilliseconds(50);
}
if (onTime == null)
{
onTime = waitTime;
}
if (transitionTimeOn == null)
{
transitionTimeOn = () => TimeSpan.FromMilliseconds(0);
}
if (transitionTimeOff == null)
{
transitionTimeOff = () => TimeSpan.FromMilliseconds(0);
}
Func <TimeSpan> actualWaitTime = () => waitTime() + onTime() + transitionTimeOn() + transitionTimeOff();
if (!waitTillFinished)
{
actualWaitTime = waitTime;
}
return(group.IteratorEffect(cancellationToken, async(current, ct, t) =>
{
if (!waitTillFinished)
{
actualWaitTime = waitTime;
}
else
{
actualWaitTime = () => waitTime() + onTime() + transitionTimeOn() + transitionTimeOff();
}
current.SetState(ct, color, 1, transitionTimeOn());
Task.Run(async() =>
{
await Task.Delay(onTime() + transitionTimeOn(), ct).ConfigureAwait(false);
current.SetBrightness(ct, 0, transitionTimeOff());
}, ct);
}, mode, secondaryIteratorMode, actualWaitTime, duration));
}
public HorizontalScanLineEffect(Func <TimeSpan>?waitTime = null, RGBColor?color = null)
{
if (waitTime != null)
{
_waitTime = waitTime;
}
else if (_waitTime == null)
{
_waitTime = () => TimeSpan.FromMilliseconds(50);
}
_color = color ?? RGBColor.Random();
Radius = 1;
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
//Non repeating effects should not run on baselayer
if (layer.IsBaseLayer)
{
return(Task.CompletedTask);
}
if (!color.HasValue)
{
color = RGBColor.Random();
}
return(layer.To2DGroup().FlashQuick(cancellationToken, color, IteratorEffectMode.All, IteratorEffectMode.All, waitTime: () => TimeSpan.FromMilliseconds(100), transitionTimeOn: () => TimeSpan.Zero, transitionTimeOff: waitTime, duration: waitTime()));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
var center = EffectSettings.LocationCenter;
var orderedByAngle = layer.OrderBy(x => x.LightLocation.Angle(center.X, center.Y));
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds * 2) / layer.Count);
Func <TimeSpan> customOnTime = () => customWaitMS() / 2;
Func <TimeSpan> customOffTime = () => customWaitMS() * 2;
return(orderedByAngle.To2DGroup().Flash(cancellationToken, color, IteratorEffectMode.Cycle, waitTime: customWaitMS, transitionTimeOn: customOnTime, transitionTimeOff: customOffTime, waitTillFinished: false));
}
public static Task SetRandomColor(this IEnumerable <IEnumerable <EntertainmentLight> > group, CancellationToken cancellationToken, IteratorEffectMode mode = IteratorEffectMode.Cycle, IteratorEffectMode secondaryIteratorMode = IteratorEffectMode.All, Func <TimeSpan> waitTime = null, Func <TimeSpan> transitionTime = null, TimeSpan?duration = null)
{
if (waitTime == null)
{
waitTime = () => TimeSpan.FromMilliseconds(50);
}
if (transitionTime == null)
{
transitionTime = () => TimeSpan.FromMilliseconds(0);
}
return(group.IteratorEffect(cancellationToken, async(current, ct, t) =>
{
var color = RGBColor.Random();
current.SetState(ct, color, 1, transitionTime());
}, mode, secondaryIteratorMode, waitTime, duration));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
//Non repeating effects should not run on baselayer
if (layer.IsBaseLayer)
{
return(Task.CompletedTask);
}
if (!color.HasValue)
{
color = RGBColor.Random();
}
var groupCount = layer.Count / 3;
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds) / groupCount);
return(layer.OrderBy(x => Guid.NewGuid()).ChunkByGroupNumber(groupCount).FlashQuick(cancellationToken, color, IteratorEffectMode.AllIndividual, IteratorEffectMode.RandomOrdered, waitTime: customWaitMS, duration: waitTime()));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
//Non repeating effects should not run on baselayer
if (layer.IsBaseLayer)
{
return(Task.CompletedTask);
}
if (!color.HasValue)
{
color = RGBColor.Random();
}
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds * 4) / layer.Count);
var fronToBack = layer.GroupBy(x => (int)(((x.LightLocation.Y + 1) / 2) * 50)).OrderBy(x => x.Key).Reverse();
return(fronToBack.FlashQuick(cancellationToken, color, IteratorEffectMode.Single, IteratorEffectMode.RandomOrdered, waitTime: customWaitMS));
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
Random r = new Random();
while (!cancellationToken.IsCancellationRequested)
{
var nextcolor = color ?? RGBColor.Random();
var hsb = nextcolor.GetHSB();
foreach (var light in layer)
{
var addHue = r.Next(-6000, 6000);
var addBri = r.Next(-100, 100);
var randomHsb = new HSB(hsb.Hue + addHue, hsb.Saturation, WrapValue(255, hsb.Brightness + addBri));
light.SetState(cancellationToken, randomHsb.GetRGB(), 1, UseTransition ? waitTime() / 2 : TimeSpan.Zero);
}
await Task.Delay(waitTime());
}
}
public Task Start(IEnumerable <IEnumerable <EntertainmentLight> > layer, Func <TimeSpan> waitTime, RGBColor?color, IteratorEffectMode iteratorMode, IteratorEffectMode secondaryIteratorMode, CancellationToken cancellationToken)
{
if (!color.HasValue)
{
color = RGBColor.Random();
}
if (iteratorMode == IteratorEffectMode.All)
{
iteratorMode = IteratorEffectMode.AllIndividual;
}
//This is no fun, no action, change it to cycle
if (iteratorMode == IteratorEffectMode.AllIndividual &&
(secondaryIteratorMode == IteratorEffectMode.All || secondaryIteratorMode == IteratorEffectMode.AllIndividual))
{
secondaryIteratorMode = IteratorEffectMode.Cycle;
}
if (iteratorMode != IteratorEffectMode.AllIndividual)
{
if (secondaryIteratorMode == IteratorEffectMode.Bounce ||
secondaryIteratorMode == IteratorEffectMode.Cycle ||
secondaryIteratorMode == IteratorEffectMode.Random ||
secondaryIteratorMode == IteratorEffectMode.RandomOrdered ||
secondaryIteratorMode == IteratorEffectMode.Single)
{
Func <TimeSpan> customWaitMS = () => TimeSpan.FromMilliseconds((waitTime().TotalMilliseconds *layer.Count()) / layer.SelectMany(x => x).Count());
Func <TimeSpan> customOnTime = () => customWaitMS() / 2;
Func <TimeSpan> customOffTime = () => customWaitMS() * 2;
return(layer.Flash(cancellationToken, color, iteratorMode, secondaryIteratorMode, waitTime: customWaitMS, transitionTimeOn: customOnTime, transitionTimeOff: customOffTime, waitTillFinished: false));
}
}
Func <TimeSpan> onTime = () => waitTime() / 2;
Func <TimeSpan> offTime = () => waitTime() * 2;
return(layer.Flash(cancellationToken, color, iteratorMode, secondaryIteratorMode, waitTime: waitTime, transitionTimeOn: onTime, transitionTimeOff: offTime, waitTillFinished: false));
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
var center = EffectSettings.LocationCenter;
var tentacles = layer.GroupBy(x => (int)((x.LightLocation.Angle(center.X, center.Y) / 3.6 / 3))).OrderBy(x => x.Key);
var grouped = tentacles.ChunkByGroupNumber(2).Select(x => x.SelectMany(l => l));
while (!cancellationToken.IsCancellationRequested)
{
CancellationTokenSource tempCancel = new CancellationTokenSource();
foreach (var group in grouped)
{
var nextColor = RGBColor.Random();
group.To2DGroup().FlashQuick(cancellationToken, null, IteratorEffectMode.All, IteratorEffectMode.All, waitTime, transitionTimeOff: waitTime, duration: waitTime());
await Task.Delay(waitTime(), cancellationToken);
}
tempCancel.Cancel();
}
}
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
//Non repeating effects should not run on baselayer
if (layer.IsBaseLayer)
{
return;
}
var center = EffectSettings.LocationCenter;
var orderedByDistance = layer.OrderBy(x => x.LightLocation.Distance(center.X, center.Y, center.Z));
if (!color.HasValue)
{
color = RGBColor.Random();
}
Func <TimeSpan> customWaitTime = () => waitTime() / layer.Count;
await orderedByDistance.To2DGroup().SetColor(cancellationToken, color.Value, IteratorEffectMode.Single, IteratorEffectMode.All, customWaitTime);
layer.SetBrightness(cancellationToken, 0, transitionTime: TimeSpan.FromMilliseconds(0));
}
public Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken)
{
Func <TimeSpan> customWaitTime = () => waitTime() / 10;
if (!color.HasValue)
{
color = RGBColor.Random();
}
var center = EffectSettings.LocationCenter;
var rotatingEffect = new RotatingLineEffect(cancellationToken, color.Value, customWaitTime);
rotatingEffect.X = center.X;
rotatingEffect.Y = center.Y; layer.PlaceEffect(rotatingEffect);
rotatingEffect.Start();
cancellationToken.Register(() => {
rotatingEffect.Stop();
layer.Effects.Remove(rotatingEffect);
});
return(Task.CompletedTask);
}
public static void Beat(double intensity)
{
var effectLayer = GetLayer(isBaseLayer: false);
//var effects = GetEffectTypes().Where(x => x.GetType() == typeof(RandomFlashEffect)).FirstOrDefault();
Func <TimeSpan> waitTime = () => TimeSpan.FromMilliseconds(100);
StartEffect(default(CancellationToken), typeof(FlashFadeEffect).GetTypeInfo(), effectLayer, waitTime, RGBColor.Random());
}
