public static void TriggerEventHandler <TArgs>(this GraphStack stack, Func <EventHook, bool> predicate, TArgs args, Func <IGraphParentElement, bool> recurse, bool force)
{
Ensure.That(nameof(stack)).IsNotNull(stack);
GraphReference reference = null;
foreach (var element in stack.graph.elements)
{
if (element is IGraphEventHandler <TArgs> handler)
{
if (reference == null)
{
reference = stack.ToReference();
}
if (predicate == null || predicate.Invoke(handler.GetHook(reference)))
{
if (force || handler.IsListening(reference))
{
handler.Trigger(reference, args);
}
}
}
if (element is IGraphParentElement parentElement && recurse(parentElement))
{
if (stack.TryEnterParentElementUnsafe(parentElement))
{
stack.TriggerEventHandler(predicate, args, recurse, force);
stack.ExitParentElement();
}
}
}
}
public override void StopListening(GraphStack stack)
{
if (AttemptUnregister())
{
base.StopListening(stack);
}
}
public override void StopListening(GraphStack stack)
{
base.StopListening(stack);
T currentVoidEvent = Flow.FetchValue <T>(_event, stack.ToReference());
currentVoidEvent?.Unregister(_eventRaisedHandler);
}
public void StopListening(GraphStack stack)
{
if (stack.TryEnterParentElement(this))
{
nest.graph.StopListening(stack);
stack.ExitParentElement();
}
}
public override void StartListening(GraphStack stack)
{
base.StartListening(stack);
var data = stack.GetElementData <Data>(this);
data._previousValue = null;
data.firstExecution = true;
}
public void StartListening(GraphStack stack)
{
stack.GetGraphData <FlowGraphData>().isListening = true;
foreach (var unit in units)
{
(unit as IGraphEventListener)?.StartListening(stack);
}
}
public override void StartListening(GraphStack stack)
{
base.StartListening(stack);
var data = stack.GetElementData <Data>(this);
data.triggered = false;
data.time = 0;
}
public void StopListening(GraphStack stack)
{
foreach (var unit in units)
{
(unit as IGraphEventListener)?.StopListening(stack);
}
stack.GetGraphData <FlowGraphData>().isListening = false;
}
public override void StopListening(GraphStack stack)
{
base.StopListening(stack);
var data = stack.GetElementData <Data>(this);
var reference = stack.ToReference();
Action <string, string> handler = (_storyOptionsName, eventName) => TriggerOption(reference, _storyOptionsName, eventName);
data.handler = handler;
dh = handler;
}
public override void StartListening(GraphStack stack)
{
//m_machine = stack.machine;
m_graphReference = stack.ToReference();
if (startOn && AttemptRegister(Flow.New(graphReference)))
{
base.StartListening(stack);
}
}
public void StartListening(GraphStack stack)
{
if (stack.TryEnterParentElement(this))
{
nest.graph.StartListening(stack);
stack.ExitParentElement();
}
stack.GetElementData <Data>(this).isListening = true;
}
public void StopListening(GraphStack stack)
{
stack.GetElementData <Data>(this).isListening = false;
if (stack.TryEnterParentElement(this))
{
nest.graph.StopListening(stack);
stack.ExitParentElement();
}
}
public void StopListening(GraphStack stack)
{
var data = stack.GetElementData<Data>(this);
if (data.UpdateAction == null) return;
var hook = new EventHook(EventHooks.Update, stack.machine);
EventBus.Unregister(hook, data.UpdateAction);
if (data.IsOpened) data.Close();
data.UpdateAction = null;
}
public void StartListening(GraphStack stack)
{
var data = stack.GetElementData<Data>(this);
if (data.UpdateAction != null) return;
var reference = stack.ToReference();
data.UpdateAction = args => OnUpdate(reference);
var hook = new EventHook(EventHooks.Update, stack.machine);
EventBus.Register(hook, data.UpdateAction);
}
public void StartListening(GraphStack stack)
{
Debug.Log("Start");
isListening = true;
var fm = selfReference.self.GetComponent <FlowMachine>();
if (fm)
{
currCoroutine = fm.StartCoroutine(DoCoroutine());
}
}
public void StopListening(GraphStack stack)
{
Debug.Log("Stop");
isListening = false;
if (currCoroutine != null)
{
var fm = selfReference.self.GetComponent <FlowMachine>();
if (fm)
{
fm.StopCoroutine(currCoroutine);
}
}
}
public void StopListening(GraphStack stack)
{
var activeStates = GetActiveStatesNoAlloc(stack);
foreach (var state in activeStates)
{
(state as IGraphEventListener)?.StopListening(stack);
}
activeStates.Free();
stack.GetGraphData <StateGraphData>().isListening = false;
}
public void StopListening(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
if (!data.isListening)
{
return;
}
var hook = new EventHook(EventHooks.Update, stack.machine);
EventBus.Unregister(hook, data.update);
data.update = null;
data.isListening = false;
}
public override void StartListening(GraphStack stack)
{
base.StartListening(stack);
var graphReference = stack.ToReference();
var pi = Flow.FetchValue <PlayerInput>(Target, graphReference);
var inputAction = Flow.FetchValue <InputAction>(InputAction, graphReference);
if (inputAction == null)
{
return;
}
m_Action = pi
? pi.actions.FindAction(inputAction.id)
: inputAction.actionMap != null ? inputAction : null;
}
public void StartListening(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
if (data.isListening)
{
return;
}
var reference = stack.ToReference();
var hook = new EventHook(EventHooks.Update, stack.machine);
Action <EmptyEventArgs> update = args => TriggerUpdate(reference);
EventBus.Register(hook, update);
data.update = update;
data.isListening = true;
}
public override void StartListening(GraphStack stack)
{
base.StartListening(stack);
Flow flow = Flow.New(stack.ToReference());
T currentEvent = flow.GetValue <T>(_event);
_eventRaisedHandler = (value) =>
{
flow.Invoke(trigger);
_currentValue = value;
};
if (currentEvent)
{
currentEvent.Unregister(_eventRaisedHandler);
currentEvent.Register(_eventRaisedHandler);
}
}
public virtual void StartListening(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
if (data.isListening)
{
return;
}
if (register)
{
var reference = stack.ToReference();
var hook = GetHook(reference);
Action <TArgs> handler = args => Trigger(reference, args);
EventBus.Register(hook, handler);
data.hook = hook;
data.handler = handler;
}
data.isListening = true;
}
private void UpdateTarget(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
var wasListening = data.isListening;
var newTarget = Flow.FetchValue <GameObject>(target, stack.ToReference());
if (newTarget != data.target)
{
if (wasListening)
{
StopListening(stack);
}
data.target = newTarget;
if (wasListening)
{
StartListening(stack, false);
}
}
}
protected void StartListening(GraphStack stack, bool updateTarget)
{
if (updateTarget)
{
UpdateTarget(stack);
}
var data = stack.GetElementData <Data>(this);
if (data.target == null)
{
return;
}
if (UnityThread.allowsAPI)
{
if (MessageListenerType != null) // can be null. CustomEvent doesn't need a message listener
{
MessageListener.AddTo(MessageListenerType, data.target);
}
}
base.StartListening(stack);
}
public virtual void StopListening(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
if (!data.isListening)
{
return;
}
// The coroutine's flow will dispose at the next frame, letting us
// keep the current flow for clean up operations if needed
foreach (var activeCoroutine in data.activeCoroutines)
{
activeCoroutine.StopCoroutine(false);
}
if (register)
{
EventBus.Unregister(data.hook, data.handler);
data.handler = null;
}
data.isListening = false;
}
public override void StartListening(GraphStack stack)
{
StartListening(stack, true);
}
public override void StopListening(GraphStack stack)
{
base.StopListening(stack);
m_Action = null;
}
public void RestoreStack(GraphStack stack)
{
this.stack.CopyFrom(stack);
}
public void DisposePreservedStack(GraphStack stack)
{
stack.Dispose();
preservedStacks.Remove(stack);
}
public override void StartListening(GraphStack stack)
{
base.StartListening(stack);
var data = stack.GetElementData <Data>(this);
}
