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)); }