protected override void OnGUI(Rect position, GUIContent label) { var attribute = metadata.GetAttribute <HEU_UnitButtonAttribute>(true); if (attribute != null) { string functionName = attribute.functionName; string btnLabel = attribute.buttonLabel; int btnWidth = attribute.buttonWidth; var buttonPosition = new Rect( position.x, position.y, position.width + btnWidth, 16 ); if (GUI.Button(buttonPosition, btnLabel, new GUIStyle(UnityEditor.EditorStyles.miniButton))) { if (attribute != null) { object typeObject = metadata.parent.value; GraphReference reference = GraphWindow.activeReference; typeObject.GetType().GetMethod(functionName).Invoke(typeObject, new object[1] { reference }); } } } }
public static bool IsHierarchyListening(GraphReference reference) { using (var stack = reference.ToStackPooled()) { // Check if any parent of the graph is not listening while (stack.isChild) { var parent = stack.parent; // Exit the parent first, as the IsListening method expects to be at the level of the parent stack.ExitParentElement(); if (parent is IGraphEventListener listener && !listener.IsListening(stack)) { return(false); } } // Check if the root graph is not listening if (stack.graph is IGraphEventListener graphListener && !graphListener.IsListening(stack)) { return(false); } return(true); } }
public static bool CanPredict(IUnitValuePort port, GraphReference reference) { Ensure.That(nameof(port)).IsNotNull(port); var flow = New(reference); flow.isPrediction = true; bool canPredict; if (port is ValueInput) { canPredict = flow.CanPredict((ValueInput)port); } else if (port is ValueOutput) { canPredict = flow.CanPredict((ValueOutput)port); } else { throw new NotSupportedException(); } flow.Dispose(); return(canPredict); }
private void TriggerUpdate(GraphReference reference) { using (var flow = Flow.New(reference)) { Update(flow); } }
public override string GenerateValueOutput(ValueOutput output, int indent) { var outputString = string.Empty; if (output == liveUnit.result) { var a = liveUnit.a; var b = liveUnit.b; var entry = (unit.graph.units.ToListPooled().Where((x) => { return((x as EntryUnit) != null); }).ToListPooled()[0] as EntryUnit); var methodInput = entry as MethodInputUnit; GraphReference reference = null; if (methodInput != null) { reference = GraphReference.New(methodInput.macro, BoltX.UnitGuids(methodInput.graph as FlowGraph), false); } var aConnection = a.connection; var bConnection = b.connection; var aSource = aConnection.source; var bSource = bConnection.source; outputString += aConnection != null?aSource.unit.CodeGenerator().GenerateValueOutput(aSource, 0) : Patcher.ActualValue(a.type, Flow.FetchValue(a, a.type, reference)); outputString += CodeBuilder.Operator(BinaryOperator.Or); outputString += bConnection != null?bSource.unit.CodeGenerator().GenerateValueOutput(bSource, 0) : Patcher.ActualValue(b.type, Flow.FetchValue(b, b.type, reference)); } return(outputString); }
private void EditButton(Rect position) { if (GUI.Button(position, "Edit")) { GraphWindow.OpenActive(GraphReference.New((Method)macro.objectReferenceValue, true)); } }
protected override void OnGUI(Rect position, GUIContent label) { BeginBlock(metadata, position, GUIContent.none); var buttonPosition = new Rect( position.x, position.y, position.width + 8, 16 ); if (GUI.Button(buttonPosition, "Trigger", new GUIStyle(UnityEditor.EditorStyles.miniButton))) { var attribute = metadata.GetAttribute <UnitButtonAttribute>(true); if (attribute != null) { var method = attribute.action; object typeObject = metadata.parent.value; GraphReference reference = GraphWindow.activeReference; typeObject.GetType().GetMethod(method).Invoke(typeObject, new object[1] { reference }); } } if (EndBlock(metadata)) { metadata.RecordUndo(); } }
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(); } } } }
private bool CanProcess(out GraphReference reference) { reference = GraphWindow.activeReference; var active = GraphWindow.active; return(reference != null && active != null && active.hasFocus); }
public IEnumerator Enter(Flow flow) { currentFlow = flow; GameObject self = flow.GetValue <GameObject>(selfIn); float time = flow.GetValue <float>(timeIn); graphReference = flow.stack.AsReference(); enemy = self.GetComponent <Enemy>(); animator = self.GetComponent <Animator>(); if (!enemy.IsAlive) { currentFlow.StopCoroutine(true); } enemy.ReponseToAttack += TryCounter; //Attack start animator.SetBool("Attacking", true); enemy.enemyState = Enemy.EnemyState.Vulnerable; vulnerable = true; Player.Instance.Warn(new AttackWarning(self, AttackWarning.WarningType.StartAttack)); yield return(new WaitForSeconds(time)); animator.SetBool("Attacking", false); enemy.enemyState = Enemy.EnemyState.Normal; vulnerable = false; enemy.ReponseToAttack -= TryCounter; yield return(finished); }
public static object Predict(IUnitValuePort port, GraphReference reference) { Ensure.That(nameof(port)).IsNotNull(port); var flow = New(reference); flow.isPrediction = true; object value; if (port is ValueInput) { value = flow.GetValue((ValueInput)port); } else if (port is ValueOutput) { value = flow.GetValue((ValueOutput)port); } else { throw new NotSupportedException(); } flow.Dispose(); return(value); }
void OnEnable() { string val = DialogueLua.GetVariable("UserChoice").asString; var graphReference = GraphReference.New(_TargetFlowMachine, true); Variables.Graph(graphReference).Set(_TargetGraphVariableName, val); }
public IEnumerator Enter(Flow flow) { currentFlow = flow; GameObject self = flow.GetValue <GameObject>(selfIn); float time = flow.GetValue <float>(timeIn); breakThresholdValue = flow.GetValue <Attack>(breakThreshold); graphReference = flow.stack.AsReference(); enemy = self.GetComponent <Enemy>(); animator = self.GetComponent <Animator>(); if (!enemy.IsAlive) { currentFlow.StopCoroutine(true); } animator.SetBool("Blocking", true); enemy.Attacked += TryBreak; enemy.ReponseToAttack += TryAttack; enemy.enemyState = Enemy.EnemyState.Guard; yield return(new WaitForSeconds(time)); animator.SetBool("Blocking", false); enemy.enemyState = Enemy.EnemyState.Normal; enemy.Attacked -= TryBreak; enemy.ReponseToAttack -= TryAttack; yield return(finished); }
/// <summary> /// Draws a button to click and edit the graph of this method. /// </summary> /// <param name="previous"></param> private Rect EditGraph(Rect previous) { var padding = 4f; var doublePadding = padding * 2; var returnLabelSize = GUI.skin.label.CalcSize(new GUIContent("Returns")); var buttonRect = previous; buttonRect.y += 24; buttonRect.x += padding; buttonRect.width -= doublePadding; buttonRect.height = 18; if (GUI.Button(buttonRect, "Edit Graph")) { declaration.owner.activeGraph = declaration.graph; var reference = GraphReference.New(declaration, true); GraphWindow.OpenActive(reference); } y += 20; return(buttonRect); }
public static void StopListening(this IGraphEventListener listener, GraphReference reference) { using (var stack = reference.ToStackPooled()) { listener.StopListening(stack); } }
public void TriggerButton(GraphReference reference) { if (Application.isEditor && Application.isPlaying) { T vEvent = Flow.FetchValue <T>(_event, reference); vEvent?.Raise(vEvent.InspectorRaiseValue); } }
public override void Instantiate(GraphReference instance) { base.Instantiate(instance); if (_delegate != null) { _delegate.initialized = false; } }
public override void Instantiate(GraphReference instance) { base.Instantiate(instance); if (this is IGraphEventListener listener && instance.GetElementData <State.Data>(source).isActive) { listener.StartListening(instance); } }
public IEnumerable <string> GetDynamicVariableNames(VariableKind kind, GraphReference reference) { return(units.OfType <IUnifiedVariableUnit>() .Where(v => v.kind == kind && Flow.CanPredict(v.name, reference)) .Select(v => Flow.Predict <string>(v.name, reference)) .Where(name => !StringUtility.IsNullOrWhiteSpace(name)) .Distinct() .OrderBy(name => name)); }
public override void Instantiate(GraphReference instance) { base.Instantiate(instance); if (this is IGraphEventListener listener && XGraphEventListener.IsHierarchyListening(instance)) { listener.StartListening(instance); } }
public override void Uninstantiate(GraphReference instance) { if (this is IGraphEventListener listener) { listener.StopListening(instance); } base.Uninstantiate(instance); }
public override void StartListening(GraphStack stack) { //m_machine = stack.machine; m_graphReference = stack.ToReference(); if (startOn && AttemptRegister(Flow.New(graphReference))) { base.StartListening(stack); } }
public static Flow New(GraphReference reference) { Ensure.That(nameof(reference)).IsNotNull(reference); var flow = GenericPool <Flow> .New(() => new Flow());; flow.stack = reference.ToStackPooled(); return(flow); }
public static object FetchValue(ValueInput input, GraphReference reference) { var flow = New(reference); var result = flow.GetValue(input); flow.Dispose(); return(result); }
public override void Instantiate(GraphReference instance) { base.Instantiate(instance); var data = instance.GetElementData <Data>(this); if (this is IGraphEventListener listener && data.isActive) { listener.StartListening(instance); }
public override EventHook GetHook(GraphReference reference) { if (!reference.hasData) { return(hookName); } var data = reference.GetElementData <Data>(this); return(new EventHook(hookName, data.target)); }
void EditGraph() { if (graphReference.IsUnityNull()) { graphReference = GraphReference.New(flowMacro, ensureValid: true); } if (!graphReference.IsUnityNull() && graphReference.isValid) { GraphWindow.OpenActive(graphReference); } }
static GraphReference CreateGraphReferenceFromGrapohAndEntity(GraphBuilder b, GraphDefinition nestedDef, GraphBuilder.VariableHandle entityVariableDataIndex) { var graphReference = new GraphReference(); graphReference.Inputs.SetCount(nestedDef.InputTriggers.Count); graphReference.Outputs.SetCount(nestedDef.OutputTriggers.Count); graphReference.DataInputs.SetCount(nestedDef.InputDatas.Count); graphReference.DataOutputs.SetCount(nestedDef.OutputDatas.Count); graphReference = b.AddNode(graphReference); b.BindVariableToInput(entityVariableDataIndex, graphReference.Target); return(graphReference); }
protected Analyser(GraphReference reference, TTarget target) : base(target, new TAnalysis()) { Ensure.That(nameof(reference)).IsNotNull(reference); this.reference = reference; // HACK: It makes more sense to think of analysis as reference-bound, // however in practice they are context-bound and therefore it is safe // (and more importantly faster) to cache the context once for recursive // analyses. this.context = reference.Context(); }
/// <summary> /// Invokes a method of a Live Type. /// </summary> /// <param name="method"></param> /// <param name="liveType"></param> /// <param name="parameters"></param> public static void InvokeVoid(MethodInstance instance) { var reference = GraphReference.New(instance.method, true); var flow = Flow.New(reference, instance.isCoroutine); flow.AssignLocal <ILiveObject>("This", instance.target); SetParameters(instance, ((MethodInputUnit)instance.method.entry)); TriggerFlow(flow, instance.method.entry.trigger); RemoveInstance(instance); }