public void ModifyAdd(IConnectionSink sink, T newAbilityInstance, int modificationOwner)
{
newAbilityInstance.root = root;
newAbilityInstance.carrier = carrier;
if (savedData != null && savedData.TryGetValue(modificationOwner, out var list))
{
var itemIndex = list.FindIndex(item => item.UId() == newAbilityInstance.UId());
if (itemIndex != -1)
{
// old save item from previous save
var item = list[itemIndex];
// is no longer needed and can be removed
list.RemoveAt(itemIndex);
if (list.Count == 0)
{
savedData.Remove(modificationOwner);
}
}
}
else
{
}
collection.Add(newAbilityInstance);
newAbilityInstance.Enlive();
sink.AddConnection(new AnonymousDisposable(() => collection.Remove(newAbilityInstance)));
}
public static IEventStream Interval(float timeInterval, IConnectionSink connectionSink)
{
var e = new TickUpdatable(timeInterval);
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(e));
return(e);
}
public static ICell <Vector3> GaussFilter(this ICell <Vector3> value,
IEventStream sampler, int samples, IConnectionSink connectionSink, bool prefill = false)
{
var filter = prefill ? new GaussFilteredVector(samples, value.value) : new GaussFilteredVector(samples);
connectionSink.AddConnection(sampler.Subscribe(() => { filter.PushValue(value.value); }));
return(filter);
}
//
public static ICell <float> Resample(this ICell <float> signal, IConnectionSink connectionSink)
{
var resampler = new Resampler {
source = signal
};
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(resampler));
return(resampler);
}
public static ICell <float> DecayingPush(this IEventStream <float> e, float ampPerPush, float asymptote,
IConnectionSink sink)
{
Cell <float> value = new Cell <float>();
sink.AddConnection(e.Subscribe(val =>
{
value.value = Mathf.Atan((value.value + ampPerPush * val) / asymptote) / (Mathf.PI / 4) * asymptote;
}));
sink.AddConnection(
UnityExecutor.Instance.AddUpdatable(new AnonymousUpdatable(dt => { value.value /= 1.1f; })));
return(value);
}
public static IEventStream <float> TimeAccumulator(this ICell <float> val, float interval,
IConnectionSink connectionSink)
{
var accum = 0f;
connectionSink.AddConnection(val.Bind(v => accum += v));
return(UnityExecutor.Instance.TickStream(interval).Map(() =>
{
var currAcc = accum;
accum = 0;
return currAcc;
}));
}
public static ICell <float> MovementSpeed(this ICell <Vector3> value, float sampleInterval,
IConnectionSink connectionSink)
{
Cell <float> derivative = new Cell <float>();
var lastValue = value.value;
connectionSink.AddConnection(UnityExecutor.Instance.TickStream(sampleInterval).Subscribe(() =>
{
var newVal = value.value;
derivative.value = Vector3.Distance(newVal, lastValue) / sampleInterval;
lastValue = newVal;
}));
return(derivative);
}
//TODO- Make valid in the first tick
public static ICell <float> Derivative(this ICell <float> value, float sampleInterval,
IConnectionSink connectionSink)
{
Cell <float> derivative = new Cell <float>();
float lastValue = value.value;
connectionSink.AddConnection(UnityExecutor.Instance.TickStream(sampleInterval).Subscribe(() =>
{
var newVal = value.value;
derivative.value = (newVal - lastValue) / sampleInterval;
lastValue = newVal;
}));
return(derivative);
}
public static CellOfSin SignalSin(this IEventStream reset, float scale, float speed, float resetVal,
IConnectionSink connectionSink)
{
CellOfSin cell = new CellOfSin {
scale = scale, speed = speed
};
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(cell));
if (reset != null)
{
connectionSink.AddConnection(reset.Subscribe(() => cell.Reset(resetVal)));
}
return(cell);
}
// On each event it makes /--\____/--\________....
public static ICell <float> SignalSpike(this IEventStream e, float attack, float plato, float decay,
IConnectionSink connectionSink)
{
SpikeCell cell = new SpikeCell
{
attackPoint = attack,
platoPoint = attack + plato,
decayPoint = attack + plato + decay
};
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(cell));
connectionSink.AddConnection(e.Subscribe(cell.Reset));
return(cell);
}
public LaggedCell(ICell <T> source, float lag = 1, Predicate <T> isValueLagged = null,
IConnectionSink connectionSink = null)
{
value = source.value;
if (connectionSink == null)
{
connectionSink = new Connections();
}
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(this));
connectionSink.AddConnection(source.ListenUpdates(val =>
{
if (isValueLagged == null || isValueLagged(val))
{
laggedValue = val;
lagRemaining = lag;
}
else
{
value = val;
lagRemaining = -1; // Kill currently lagged value, it will never be shown.
}
}));
}
public static void Subscribe(this IEventReader e, IConnectionSink connectionSink, Action action)
{
connectionSink.AddConnection(e.Subscribe(action));
}
public static void Bind <T>(this ICell <T> cell, IConnectionSink connectionSink, Action <T> action)
{
action(cell.value);
connectionSink.AddConnection(cell.ListenUpdates(action));
}
public void ModifyAdd(IConnectionSink sink, T elem)
{
collection.Add(elem);
sink.AddConnection(new AnonymousDisposable(() => collection.Remove(elem)));
}
public static ICell <T> Lag <T>(this ICell <T> e, float lag = 1, Predicate <T> isValueLagged = null,
IConnectionSink connectionSink = null)
=> new LaggedCell <T>(e, lag, isValueLagged, connectionSink);
public static void ExecuteEachFrame(Action action, IConnectionSink connectionSink)
{
connectionSink.AddConnection(UnityExecutor.Instance.eachFrame.Subscribe(action));
}
public static void AddConnection(this IConnectionSink sink, IConnectionSink dublicater, IDisposable connection)
{
sink.AddConnection(connection);
dublicater.AddConnection(connection);
}
// On each event it makes |\____|\_______|\_____....
public static ICell <float> SignalTrigger(this IEventStream e, float decayTime, IConnectionSink connectionSink)
{
TriggerCell cell = new TriggerCell {
decay = decayTime
};
connectionSink.AddConnection(UnityExecutor.Instance.AddUpdatable(cell));
connectionSink.AddConnection(e.Subscribe(cell.Reset));
return(cell);
}
public static void ListenUpdates <T>(this ICell <T> cell, IConnectionSink connectionSink, Action <T> action)
{
connectionSink.AddConnection(cell.ListenUpdates(action));
}
public static void Subscribe <T>(this IEventStream <T> stream, IConnectionSink connectionSink, Action <T> action)
{
connectionSink.AddConnection(stream.Subscribe(action));
}
