public void Setup() { _customer = new Customer {Preferred = true}; _actionNode = new ActionNode<Customer>(x => Trace.WriteLine("Called for " + x.Element.Object.Preferred)); _constantNode = new ConstantNode<Customer>(); _agenda = new PriorityQueueAgenda(); _context = MockRepository.GenerateMock<RuleContext<Customer>>(); var element = MockRepository.GenerateMock<SessionElement<Customer>>(); element.Stub(x => x.Object).Return(_customer); _context.Stub(x => x.Element).Return(element); _context.Expect(x => x.EnqueueAgendaAction(0, null)) .IgnoreArguments() .Repeat.AtLeastOnce() .WhenCalled(invocation => { var priority = (int) invocation.Arguments[0]; var action = invocation.Arguments[1] as Action; _agenda.Add(priority, action); }); }
public NodeLinkedList() { last = new DoNothingNode(); first = new DoNothingNode(); first.Next = last; last.Prev = first; }
public virtual void WriteCode(TemplateContext ctx, ActionNode node) { var varStatement = ctx.CurrentDeclaration._private_(node.Meta.FullName, node.VarName); varStatement.InitExpression = new CodeObjectCreateExpression(node.Meta.FullName); foreach (var item in node.GraphItems.OfType<IActionIn>()) { var contextVariable = item.Item; if (contextVariable == null) continue; ctx._("{0}.{1} = {2}", varStatement.Name, item.Name, item.VariableName); } ctx._("{0}.System = System", varStatement.Name); foreach (var item in node.GraphItems.OfType<ActionBranch>()) { var branchOutput = item.OutputTo<SequenceItemNode>(); if (branchOutput == null) continue; if (DebugSystem.IsDebugMode) ctx._("{0}.{1} = ()=> {{ System.StartCoroutine({2}()); }}", varStatement.Name, item.Name, item.VariableName); else ctx._("{0}.{1} = {2}", varStatement.Name, item.Name, item.VariableName); } ctx._("{0}.Execute()", varStatement.Name); node.WriteActionOutputs(ctx); }
public JumpNode(ActionNode partner) { if(partner != null) { this.jumpNode = partner; } else { throw new Exception("JumpNode needs something to jump to."); } }
public void Add(ActionNode node) { ActionNode foreLast = last.Prev; last.Prev = node; node.Next = last; foreLast.Next = node; node.Prev = foreLast; }
public void dequeue() { if (head.previous != null) { head = head.previous; head.next = null; return; } head = tail = null; }
public void enqueue(string funcname, Transform target) { ActionNode temp = new ActionNode (funcname, target, tail); if (tail != null) tail.previous = temp; tail = temp; if (head == null) head = tail; }
public void Building_a_agenda_from_the_consequence_rocks() { var context = MockRepository.GenerateMock<RuleContext<Customer>>(); context.Expect(x => x.EnqueueAgendaAction(0, null)).IgnoreArguments(); Action<int> action = null; action = MockRepository.GenerateMock<Action<int>>(); var actionNode = new ActionNode(() => action(27)); actionNode.Activate(context); context.VerifyAllExpectations(); }
public void ActionTick() { var node = new ActionNode<NumberTestNode>( ()=> new NumberTestNode(3) , (ntn) => ntn.Tick , (ntn) => ntn.Start , (ntn) => ntn.End); ITicker ticker = node; var result1 = ticker.Tick(0); ticker.Tick(0); var result2 = ticker.Tick(0); var result3 = ticker.Tick(0); Assert.AreEqual(TICKRESULT.RUNNING , result1); Assert.AreEqual(TICKRESULT.SUCCESS, result2); Assert.AreEqual(TICKRESULT.FAILURE, result3); }
/// <summary> /// Selects an Item. /// <param name="item">The item to be selected.</param> /// </summary> void SelecteItem(Item item) { m_SelectedItem = item; m_SelectedScript = item as Script; if (m_SelectedScript != null) { m_NodeEditor = NodeEditor.CreateEditor(m_SelectedScript.type); m_SelectedNodeSample = ActionNode.CreateInstance(m_SelectedScript.type, null, null); } // It's a Category? else if (item is Category) { m_CurrentCategory = item as Category; m_SelectedScript = null; } GUIUtility.hotControl = 0; GUIUtility.keyboardControl = 0; }
public void can_run_action() { var time = new TimeData(0); var invokeCount = 0; var testObject = new ActionNode( "some-action", 0, t => { Assert.Equal(time, t); ++invokeCount; return(Status.Running); } ); Assert.Equal(Status.Running, testObject.Tick(time)); Assert.Equal(1, invokeCount); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="data">Dialog Step Data</param> /// <param name="npc">Npc to which the dialog belongs</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, KortistoNpc npc) { ActionNode actionNode = data.Action; if (actionNode == null) { return(null); } string actionContent = await BuildActionContent(actionNode, data, npc); ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleAction); ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); renderResult.StepCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ActionContent).Replace(template.Code, actionContent); renderResult.StepCode = ReplaceBaseStepPlaceholders(renderResult.StepCode, data, data.Children.FirstOrDefault() != null ? data.Children.FirstOrDefault().Child : null); return(renderResult); }
/// <summary> /// Returns the valid action renderer for a node /// </summary> /// <param name="actionNode">Action Node</param> /// <returns>Action renderer</returns> private IActionRenderer GetActionRenderForNode(ActionNode actionNode) { int parsedActionType = 0; if (!int.TryParse(actionNode.ActionType, out parsedActionType)) { _errorCollection.AddDialogUnknownActionTypeError(actionNode.ActionType); return(null); } ActionType actionType = (ActionType)parsedActionType; if (!_actionRenderes.ContainsKey(actionType)) { _errorCollection.AddDialogUnknownActionTypeError(actionNode.ActionType); return(null); } return(_actionRenderes[actionType]); }
public override void AddAction(int id, ActionNode an) { if (id == 0) { _cChunksAction = (CreateChunksAction)an; } if (id == 1) { _cBlockDataAction = (CreateBlockDataAction)an; } if (id == 2) { _terraformAction = (TerraformBlockDataAction)an; } if (id == 3) { _cMeshAction = (CreateMeshAction)an; } _allNodes.Add(an); }
private ActionNode SelectionStatement() { ActionNode itsAST; SourceCodePosition itsPos = _currentToken.SourcePosition; Accept(Token.TokenType.If); Accept(Token.TokenType.LeftParen); ExpressionNode itsExpr = Expression(); Accept(Token.TokenType.RightParen); Accept(Token.TokenType.LeftBrace); ActionSequenceNode itsActions = ActionStatements(); Accept(Token.TokenType.RightBrace); ActionSequenceNode itsElseifs = ElseIfStatements(); ActionNode itsElse = ElseStatement(); itsAST = new IfActionNode(itsExpr, itsActions, itsElseifs, itsElse, itsPos); return(itsAST); }
// Use this for initialization void Start() { healthCheckNode = new ActionNode(CriticalHealthCheck); attackCheckNode = new ActionNode(CheckPlayerHealth); buffCheckRandomNode = new RandomBinaryNode(); buffCheckNode = new ActionNode(BuffCheck); buffCheckSequence = new Sequence(new List <BTNode> { buffCheckRandomNode, buffCheckNode, }); rootNode = new Selector(new List <BTNode> { healthCheckNode, attackCheckNode, buffCheckSequence, }); }
void Start() { player = GameObject.Find("Player"); rb = GetComponent <Rigidbody2D>(); initialPosition = rb.position; FreezeWorldComponent.FreezeEvent += FreezeObject; FreezeWorldComponent.UnfreezeEvent += UnfreezeObject; worldState.Add("CanAttack", false); worldState.Add("ZeroHealthPoints", false); ActionNode attackNode = new ActionNode(); attackNode.actionMethod = Attack; ActionNode moveNode = new ActionNode(); moveNode.actionMethod = CheckAndUpdateMoveDirection; ActionNode dieNode = new ActionNode(); dieNode.actionMethod = Die; BinaryNode attackDecisionNode = new BinaryNode(); attackDecisionNode.yesNode = attackNode; attackDecisionNode.noNode = moveNode; attackDecisionNode.decision = "CanAttack"; BinaryNode healthDecisionNode = new BinaryNode(); healthDecisionNode.yesNode = dieNode; healthDecisionNode.noNode = attackDecisionNode; healthDecisionNode.decision = "ZeroHealthPoints"; decisionTree = healthDecisionNode; rb.velocity = new Vector2(speed, 0); }
override public double execute(double dt) { if (state == 0) { /* * ActionNode currentNode = MascaretUtils.getCurrentActionNode(agent); * MascaretHumanActions.changeConstraintValue(ui.DecisionAgent, "decisionValue", -1); * ui.decisionValue = -1; * choices = MascaretUtils.getOutgoingNodes(agent, currentNode); * MascaretHumanActions.setConstrainedEdges(MascaretUtils.getOutgoingEdges(agent, currentNode)); * PrintSingleton.Instance.log("==================================== DECISION ========================================== " + choices.Count); * ui.DisplayChoices(choices, agentC); */ ActionNode currentNode = MascaretUtils.getCurrentActionNode(agent); PrintSingleton.Instance.log("==================================== DECISION ========================================== " + currentNode.name); MascaretHumanActions.setConstrainedEdges(MascaretUtils.getOutgoingEdges(agent, currentNode)); ui.DisplayChoices(MascaretUtils.getOutgoingNodes(agent, currentNode), agentC); state++; MascaretHumanActions.changeConstraintValue(ui.DecisionAgent, "decisionValue", -1); return(Time.deltaTime); } else { if (ui.decisionValue != -1) { PrintSingleton.Instance.log("Decision : " + ui.decisionValue); return(0); } /*else * { * MascaretHumanActions.resetConstraints(); * return Time.deltaTime; * }*/ return(Time.deltaTime); } }
/// <summary> /// Used to set up the attacker type tree /// </summary> void SetupAttacker() { DecisionNode hasFlagNode = new DecisionNode(Decisions.Attacker_HasEnemyFlag, this); DecisionNode teamHasEnemyFlagNode = new DecisionNode(Decisions.Shared_TeamHasEnemyFlag, this); ActionNode runBackAndScore = new ActionNode(Actions.Attacker_GoBackToTeamFlag, this); hasFlagNode.AddFailureNode(teamHasEnemyFlagNode); hasFlagNode.AddSuccessNode(runBackAndScore); DecisionNode enemyInRadiusNode = new DecisionNode(Decisions.Shared_IsEnemyInAttackRadius, this); DecisionNode enemySpottedNotInRadius = new DecisionNode(Decisions.Shared_HasSeenEnemy, this); teamHasEnemyFlagNode.AddFailureNode(enemyInRadiusNode); teamHasEnemyFlagNode.AddSuccessNode(enemySpottedNotInRadius); ActionNode attackTarget = new ActionNode(Actions.Shared_AttackEnemyTarget, this); ActionNode followTeamMateWithFlag = new ActionNode(Actions.Shared_FollowTeamMateWithFlag, this); enemySpottedNotInRadius.AddSuccessNode(attackTarget); enemySpottedNotInRadius.AddFailureNode(followTeamMateWithFlag); DecisionNode isHealthLow = new DecisionNode(Decisions.Shared_IsHealthLow, this); ActionNode findPickup = new ActionNode(Actions.Shared_SearchForHealthpack, this); enemyInRadiusNode.AddFailureNode(isHealthLow); enemyInRadiusNode.AddSuccessNode(attackTarget); DecisionNode canTakeEnemyFlag = new DecisionNode(Decisions.Attacker_CanTakeEnemyFlag, this); isHealthLow.AddFailureNode(canTakeEnemyFlag); isHealthLow.AddSuccessNode(findPickup); ActionNode moveToEnemyFlag = new ActionNode(Actions.Attacker_MoveToEnemyFlag, this); ActionNode takeEnemyFlag = new ActionNode(Actions.Attacker_TakeEnemyFlag, this); canTakeEnemyFlag.AddSuccessNode(takeEnemyFlag); canTakeEnemyFlag.AddFailureNode(moveToEnemyFlag); decTree = new DecisionTree(hasFlagNode); }
void Update() { float dt = Time.deltaTime; //Process state switch (this.folkState) { default: case FolkState.Idle: idleState(dt); break; case FolkState.Wandering: wanderingState(dt); break; case FolkState.Travelling: travellingState(dt); break; } //Process actions Vector3 vect = new Vector3(); float d = dt; while (actionQueue.Count > 0 && d > 0f) { ActionNode an = actionQueue[0]; d = an.getVector(d, ref vect); transform.position += transform.TransformVector(vect); if (d > 0f) { actionQueue.Remove(an); } } }
public INode GetNode(ushort Id, byte level) { NodeInfo pInfo = getNodeInfo(Id, level); if (pInfo == null) { return(null); } INode pNode = null; switch (pInfo.Type) { case 0: //动画 pNode = new ActionNode(Id); break; case 1: // break; case 2: break; case 3: //人物 if (Id > 10000) { pNode = new Hero(1, 1); } else { pNode = new Soldier(1, 1); } break; case 4: //飞行物 break; case 5: break; } return(new INode()); }
/// <summary> /// Reset the supplied node properties. /// <param name="node">The node to be reseted.</param> /// </summary> public static void ResetNode(ActionNode node) { // Get the owner as an Uniyt object var ownerUnityObj = node != null ? node.owner as UnityEngine.Object : null; // Validate parameters if (ownerUnityObj != null) { // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(ownerUnityObj, "Reset Node"); #else Undo.RecordObject(ownerUnityObj, "Reset Node"); #endif node.name = node.GetType().Name; node.Reset(); node.OnValidate(); StateUtility.SetDirty(node.owner); } }
public void SUCCESS2() { myTestsFuncs.counter = 0; myTestsFuncs.target = 10; ActionNode T3 = new ActionNode(myTestsFuncs.CounterInc); ActionNode T2A = new ActionNode(myTestsFuncs.CounterInc); Inverter T2B = new Inverter(T3); ActionNode T2C = new ActionNode(myTestsFuncs.CounterInc); List <Node> rootChildren = new List <Node> { T2A, T2B, T2C }; Selector rootNode = new Selector(rootChildren); rootNode.Run(); Assert.AreEqual(NodeStates.SUCCESS, rootNode.NodeState); }
public static NodeLinkedList compile(LinkedListNode <Token> firstToken) { CompiledStatement cs = CompilerFactory.Instance.CreateCompiledStatement(firstToken); Compiled = cs.compile(ref firstToken); while (firstToken != null) { cs = CompilerFactory.Instance.CreateCompiledStatement(firstToken); NodeLinkedList nll = cs.compile(ref firstToken); Compiled.Add(nll); } ActionNode a = Compiled.First; while (a != null) { Console.WriteLine(a.GetType()); a = a.Next; } return(Compiled); }
public void Building_an_agenda_from_the_action_node_of_t() { var customer = new Customer(); var wme = MockRepository.GenerateMock<SessionElement<Customer>>(); wme.Stub(x => x.Object).Return(customer); var context = MockRepository.GenerateMock<RuleContext<Customer>>(); context.Stub(x => x.Element).Return(wme); context.Expect(x => x.EnqueueAgendaAction(0, null)).IgnoreArguments(); var action = MockRepository.GenerateMock<Action<RuleContext<Customer>>>(); var node = new ActionNode<Customer>(x => action(x)); node.Activate(context); context.VerifyAllExpectations(); }
public void AddTransition(ActionNode nodeFrom, ActionNode nodeTo, Func <bool> condition, Action transitionAction) { if (nodeFrom == null || nodeTo == null) { throw new ArgumentNullException("Must define a start and an end node."); } if (nodeFrom.Equals(nodeTo)) { throw new Exception("Start node cannot equal end node."); } // Does not prevent the user from creating circular dependencies. transitionPool.Add(new Transition(context) { NodeFrom = nodeFrom, NodeTo = nodeTo, CanTransition = condition, ActionForward = transitionAction }); }
private void SetDecisionTree() { CheckNode playerVisible = new CheckNode(PlayerVisible); CheckNode playerWithinRange = new CheckNode(PlayerWithinRange); CheckNode playerSeenRecently = new CheckNode(PlayerSeenRecently); ActionNode attack = new ActionNode(Attack); ActionNode moveToPlayer = new ActionNode(MoveToPlayer); ActionNode wander = new ActionNode(Wander); playerVisible.True = playerWithinRange; playerVisible.False = playerSeenRecently; playerWithinRange.True = attack; playerWithinRange.False = moveToPlayer; playerSeenRecently.True = moveToPlayer; playerSeenRecently.False = wander; decisionTree = new DecisionTree(playerVisible); }
public void FAILURE1() { myTestsFuncs.counter = 0; myTestsFuncs.target = 1; ActionNode T3 = new ActionNode(myTestsFuncs.CounterInc); ActionNode T2A = new ActionNode(myTestsFuncs.CounterInc); Inverter T2B = new Inverter(T3); ActionNode T2C = new ActionNode(myTestsFuncs.CounterInc); List <Node> rootChildren = new List <Node> { T2A, T2B, T2C }; Sequence rootNode = new Sequence(rootChildren); rootNode.Run(); Assert.AreEqual(NodeStates.FAILURE, rootNode.NodeState); }
public void Setup() { _primaryCalled = new Future <Customer>(); _secondaryCalled = new Future <Customer>(); _customer = new Customer { Preferred = true }; _actionNode = new ActionNode <Customer>(x => _primaryCalled.Complete(x.Element.Object)); _constantNode = new ConstantNode <Customer>(); var element = MockRepository.GenerateMock <SessionElement <Customer> >(); element.Stub(x => x.Object).Return(_customer); _session = new StatefulSessionImpl(MockRepository.GenerateMock <RulesEngine>()); _context = new SessionRuleContext <Customer>(_session, element); }
private void ConnectTargets(EventNode Event, ActionNode Action) { if (!(Action.DotaAction is TargetedAction)) { return; //An action without targets doesn't need it's nodes resolved } TargetedAction ta = Action.DotaAction as TargetedAction; if (ta.Target.Preset == null) { return; //Not a preset. TODO: Generated a Make Target node with the details of this target key } var outputItem = Event.GetTargetNodeFor(ta.Target.Preset); if (outputItem == null) { return; } graphControl1.Connect(outputItem, Action.TargetPin); }
public ActionType GetCurrentDialog(out DialogDetail dialog, out SelectionDetail selection) { dialog = null; selection = null; if (m_currentCollection != null && m_currentCollection.m_actions != null && m_currentCollectionDialogID < m_currentCollection.m_actions.Count) { ActionNode action = m_currentCollection.m_actions[m_currentCollectionDialogID]; switch (action.m_Type) { case "dialog": dialog = DialogDetail.ConversionFromXML(action.m_Detail); return(ActionType.Dialog); case "selection": selection = SelectionDetail.ConversionFromXML(action.m_Detail); return(ActionType.Selection); } } return(ActionType.None); }
private void loadActionNodes() { InternalScriptSettings settings = new InternalScriptSettings(); settings.DebugMode = DebugMode; settings.Cache = cache; actionNodes = new Dictionary <string, ScraperNode>(); foreach (XmlNode currAction in xml.DocumentElement.SelectNodes("child::action")) { ActionNode newNode = (ActionNode)ScraperNode.Load(currAction, settings); if (newNode != null && newNode.LoadSuccess) { actionNodes[newNode.Name] = newNode; } else { logger.Error("Error loading action node: " + currAction.OuterXml); loadSuccessful = false; } } }
public static int getChoiceScore(ActionNode choice) { if (choice.Action.Kind == "CallOperation") { foreach (ValuePin currentPin in choice.Action.ValuePins) { if (currentPin.name == "Feedback") { PrintSingleton.Instance.log("Pin : " + currentPin.name + " : " + currentPin.ValueSpec.getStringFromValue()); string feedback_text = stringUtils.CleanString(currentPin.ValueSpec.getStringFromValue()); string[] feedbackDiv = feedback_text.Split('_'); int feedbackValue = -1; if (Int32.TryParse(feedbackDiv[0], out feedbackValue)) { return(feedbackValue); } //return CleanString(currentPin.ValueSpec.getStringFromValue()); } } } return(-1); }
// Token: 0x0600001B RID: 27 RVA: 0x000033B0 File Offset: 0x000015B0 public static void SetupRufusInteraction() { GameObject gameObject = GameObject.Find("Dialogue_Rufus/NPC/DialogueTree_1_Initial"); bool flag = gameObject != null; if (flag) { DialogueTreeController component = gameObject.GetComponent <DialogueTreeController>(); bool flag2 = component != null; if (flag2) { Graph graph = component.graph; List <Node> allNodes = graph.allNodes; StatementNodeExt statementNodeExt = allNodes.FirstOrDefault((Node n) => n != null && n is StatementNodeExt && ((StatementNodeExt)n).statement.text.Contains("Elatt however... I’ve had the honor to speak with him. He is very real. Having a god that was once man is comforting.")) as StatementNodeExt; bool flag3 = statementNodeExt != null; if (flag3) { ActionNode actionNode = graph.AddNode <ActionNode>(); GiveReward giveReward = new GiveReward(); actionNode.action = giveReward; giveReward.RewardReceiver = GiveReward.Receiver.Instigator; NodeCanvas.Tasks.Actions.ItemQuantity itemQuantity = new NodeCanvas.Tasks.Actions.ItemQuantity(); itemQuantity.Item = new BBParameter <ItemReference>(new ItemReference { ItemID = Templar.Instance.prayerInstance.ItemID }); itemQuantity.Quantity = 1; giveReward.ItemReward = new List <NodeCanvas.Tasks.Actions.ItemQuantity> { itemQuantity }; statementNodeExt.outConnections[0] = Connection.Create(statementNodeExt, actionNode, -1, -1); FinishNode finishNode = graph.AddNode <FinishNode>(); allNodes.Add(finishNode); graph.ConnectNodes(actionNode, finishNode, -1, -1); } } } }
public BanditBossBehaviourTree(BanditBossBehaviour boss) { moveToPlayer = new MoveAction(boss.Move, boss.FindPlayer); moveToThrowingPosition = new MoveAction(boss.Move, boss.PositionForHealthEvent); moveToHidingPlace = new MoveAction(boss.Move, boss.HidingPlace); fireShotgun.OpenBranch(new ActionNode(boss.ShotgunAttack)); throwMolotov.OpenBranch(new ActionNode(boss.Attack)); ThisOrThat selectAttack = new ThisOrThat(throwMolotov, fireShotgun, boss.PlayerOnLowerLevel); healthEvent = new ActionNode(boss.HealthEvent); //TODO Define both weapon sequences and whistle sequence whistleAndRetreat.OpenBranch( whistle = new ActionNode(boss.WhistleToAllies), moveToHidingPlace, hide = new ActionNode(boss.Hide) ); healthEventSeq.OpenBranch( new ConditionalAction(boss.HealthEventDue), moveToThrowingPosition, healthEvent, whistleAndRetreat ); attack.OpenBranch( moveToPlayer, selectAttack ); findBestAction.OpenBranch( healthEventSeq, attack ); treeRoot = new Root(); treeRoot.OpenBranch(findBestAction); }
// Create the decision tree protected override void Start() { // Call base class Start() base.Start(); // Create the leaf actions IDecisionTreeNode seek = new ActionNode(SeekAction); IDecisionTreeNode nothing = new ActionNode(StandStillAction); IDecisionTreeNode patrol = new ActionNode(PatrolAction); // Create the random decision behaviour node RandomDecisionBehaviour rdb = new RandomDecisionBehaviour( () => Random.value, () => Time.frameCount, randomDecisionDurationInFrames, 0.55f); IDecisionTreeNode rndNode = new DecisionNode( rdb.RandomDecision, seek, nothing); // Create the root node root = new DecisionNode(PlayerInSight, rndNode, patrol); }
public override void OnEditorRefresh() { State.MinorStructures.Clear(); List <ActionNode> nodes = new List <ActionNode> (); List <ActionNodePlaceholder> acps = new List <ActionNodePlaceholder> (); ActionNode node = null; ActionNodePlaceholder acp = null; foreach (Transform child in transform) { if (child.gameObject.HasComponent <StructureBuilder> () || child.name.Contains("-STR")) { MinorStructure ms = new MinorStructure(); ms.TemplateName = StructureBuilder.GetTemplateName(child.name); ms.Position = child.transform.localPosition; ms.Rotation = child.transform.localRotation.eulerAngles; State.MinorStructures.Add(ms); } else if (child.gameObject.HasComponent <ActionNode> (out node)) { if (node.State.Users == ActionNodeUsers.AnyOccupant) { nodes.Add(node); } } else if (child.gameObject.HasComponent <ActionNodePlaceholder> (out acp)) { if (acp.SaveToStructure) { acps.Add(acp); } } } ActionNodePlaceholder.LinkNodes(acps, nodes, State.MovementNodes); }
/// <summary> /// Paste the supplied nodes in the supplied ActionState. /// <param name="actionState">The ActionState to paste the node.</param> /// <param name="nodes">The nodes to be pasted.</param> /// <returns>The pasted nodes.</returns> /// </summary> public static ActionNode[] PasteNodes(InternalActionState actionState, ActionNode[] nodes) { var newNodes = new List <ActionNode>(); // Validate parameters if (nodes != null && actionState != null) { // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(actionState, "Paste Node"); #else Undo.RecordObject(actionState, "Paste Node"); #endif // Copy nodes for (int i = 0; i < nodes.Length; i++) { if (nodes[i] != null && !(nodes[i] is BranchNode)) { ActionNode newNode = nodes[i].Copy(actionState); if (newNode != null) { newNodes.Add(newNode); } } } if (newNodes.Count > 0) { // Saves node and sets dirty flag StateUtility.SetDirty(actionState); // Reload actionState to update variables actionState.LoadNodes(); } } return(newNodes.ToArray()); }
//得到一个招式可连接的普通招式 public ActionNode GetNormalNode(MeteorUnit owner, ActionNode source) { //普通攻击映射输入的行号 int weapon = owner.GetWeaponType(); //"1,5,9,13,25,35,48,61,73,91,95,101,108,123," "85,22,32,46,59,107,122,105," J 攻击 59较特殊,估计所有重武器的空中A都是338动作 int[] GroundKeyMap = new int[] { 1, 5, 9, 13, 25, 35, 48, 61, 73, 91, 95, 101, 108, 123 }; int[] AirKeyMap = new int[] { 85, 22, 32, 46, 59, 107, 122, 105 }; if (owner.IsOnGround()) { for (int i = 0; i < source.target.Count; i++) { for (int j = 0; j < GroundKeyMap.Length; j++) { if (GroundKeyMap[j] == source.target[i].KeyMap && owner.meteorController.Input.CheckPos(source.target[i].KeyMap, source.target[i].ActionIdx)) { return(source.target[i]); } } } } else { for (int i = 0; i < source.target.Count; i++) { for (int j = 0; j < AirKeyMap.Length; j++) { if (AirKeyMap[j] == source.target[i].KeyMap && owner.meteorController.Input.CheckPos(source.target[i].KeyMap, source.target[i].ActionIdx)) { return(source.target[i]); } } } } return(null); }
private void tvwActions_AfterSelect(object sender, TreeViewEventArgs e) { try { splcActions.Panel2Collapsed = true; ActionNode nd = e.Node as ActionNode; if (nd?.Checked ?? false) { tbScript.Selection = new Range(tbScript, new Place(0, nd.StartLine), new Place(0, nd.EndLine)); } if (!nd?.IsValid ?? false) { splcActions.Panel2Collapsed = false; lblErrors.Text = string.Join("\r\n", nd.ValidationErrors); } } catch (Exception exc) { MessageBox.Show(exc.Message); } }
public static Node ToNode(this NodeType type) { Node toReturn = null; switch (type) { case NodeType.End: toReturn = new Node(); break; case NodeType.OneOptionMessage: toReturn = new OneOptionMessageNode(); break; case NodeType.TwoOptionMessage: toReturn = new TwoOptionMessageNode(); break; case NodeType.FourOptionMessage: toReturn = new FourOptionMessageNode(); break; case NodeType.TextboxMessage: toReturn = new Node(); break; case NodeType.Action: toReturn = new ActionNode(); break; case NodeType.StartSequence: toReturn = new StartSequenceNode(); break; case NodeType.TimeLeap: toReturn = new TimeLeapNode(); break; case NodeType.IngameDelay: toReturn = new IngameDelayNode(); break; } return toReturn; }
public ActionNode(string s, Transform t, ActionNode n) { funcname = s; target = t; next = n; }
public override void WriteCode(TemplateContext ctx, ActionNode node) { var codeMethodReferenceExpression = new CodeMethodReferenceExpression( new CodeSnippetExpression(SystemType.FullName), Method.Name); if (this.InstanceInfo != null) { var instanceVar = node.InputVars.FirstOrDefault(p => p.ActionFieldInfo == this.InstanceInfo); if (instanceVar != null) { codeMethodReferenceExpression = new CodeMethodReferenceExpression(new CodeSnippetExpression(instanceVar.VariableName),Method.Name); } } var _currentActionInvoker = new CodeMethodInvokeExpression( codeMethodReferenceExpression); foreach (var x in Method.GetParameters()) { var item = node.GraphItems.OfType<IActionItem>().FirstOrDefault(p => p.Name == x.Name); var input = item as IActionIn; if (input != null) { if (input.ActionFieldInfo == InstanceInfo) continue; if (input.ActionFieldInfo.IsGenericArgument) { } else { _currentActionInvoker.Parameters.Add( new CodeSnippetExpression((input.ActionFieldInfo.IsByRef ? "ref " : string.Empty) + string.Format("{0}", input.VariableName))); } } var @out = item as ActionOut; if (@out != null) { if (@out.ActionFieldInfo != null && @out.ActionFieldInfo.IsReturn) { continue; } _currentActionInvoker.Parameters.Add( new CodeSnippetExpression(string.Format("out {0}", @out.VariableName))); } var branch = item as ActionBranch; if (branch != null) { if (DebugSystem.IsDebugMode) { _currentActionInvoker.Parameters.Add( new CodeSnippetExpression(string.Format("()=> {{ System.StartCoroutine({0}()); }}", branch.VariableName))); } else { _currentActionInvoker.Parameters.Add( new CodeSnippetExpression(string.Format("{0}", branch.VariableName))); } } } var resultOut = node.GraphItems.OfType<IActionItem>().FirstOrDefault(p => p.ActionFieldInfo != null && p.ActionFieldInfo.IsReturn); if (resultOut == null) { ctx.CurrentStatements.Add(_currentActionInvoker); } else { var assignResult = new CodeAssignStatement( new CodeSnippetExpression(resultOut.VariableName), _currentActionInvoker); ctx.CurrentStatements.Add(assignResult); } }
public ActionAndWeight(float weight, ActionNode action) { _weight = weight; _action = action; }
private float DrawActionNode(ActionNode node, float x, float y) { float fieldwidth = NODEWIDTH - PADDING * 2; EditorGUI.LabelField(new Rect(x + PADDING, y, fieldwidth * LABELWIDTH, FIELDHEIGHT), "Action"); node.Action = EditorGUI.TextField(new Rect(x + PADDING + fieldwidth * LABELWIDTH, y, fieldwidth - fieldwidth * LABELWIDTH, FIELDHEIGHT), node.Action); y += FIELDHEIGHT + PADDING; if (GUI.Button(new Rect(x + PADDING , y, fieldwidth, FIELDHEIGHT), "Edit Data")) { ActionNodeEditor.ShowWindow(node); }; y += FIELDHEIGHT + PADDING; return y; }
private static void InitializeWithCommonValue(XElement element, Tree tree, ActionNode actionNode, string defaultIconName, string defaultLabelName = null, ActionLocation defaultActionLocation = null, List<PermissionType> defaultPermissionTypes = null) { XAttribute labelAttribute = element.Attribute("Label"); XAttribute toolTipAttribute = element.Attribute("ToolTip"); XAttribute iconAttribute = element.Attribute("Icon"); if ((defaultLabelName == null) && (labelAttribute == null)) tree.AddValidationError(element.GetXPath(), "TreeValidationError.Common.MissingAttribute", "Label"); actionNode.XPath = element.GetXPath(); actionNode.Id = tree.BuildProcessContext.ActionIdCounter++; actionNode.Label = labelAttribute.GetValueOrDefault(defaultLabelName); actionNode.ToolTip = toolTipAttribute.GetValueOrDefault(actionNode.Label); actionNode.Icon = FactoryHelper.GetIcon(iconAttribute.GetValueOrDefault(defaultIconName)); actionNode.Location = GetActionLocation(element, tree, defaultActionLocation); if (defaultPermissionTypes != null) { actionNode.PermissionTypes = defaultPermissionTypes; } else { actionNode.PermissionTypes = GetPermissionTypes(element, tree); } }
/// <summary> /// clone /// </summary> /// <returns></returns> public IBehaviourNode Clone() { var behaviourNode = new ActionNode(this.action); base.CopyTo(behaviourNode); return behaviourNode; }
public void Setup() { _primaryCalled = new Future<Customer>(); _secondaryCalled = new Future<Customer>(); _customer = new Customer {Preferred = true}; _actionNode = new ActionNode<Customer>(x => _primaryCalled.Complete(x.Element.Object)); _constantNode = new ConstantNode<Customer>(); var element = MockRepository.GenerateMock<SessionElement<Customer>>(); element.Stub(x => x.Object).Return(_customer); _session = new StatefulSessionImpl(MockRepository.GenerateMock<RulesEngine>()); _context = new SessionRuleContext<Customer>(_session, element); }
public ConditionalJumpNode(ActionNode trueNode, ActionNode falseNode) { nextOnFalse = falseNode; nextOnTrue = trueNode; }
public ActionNodeViewModel(ActionNode graphItemObject, Invert.Core.GraphDesigner.DiagramViewModel diagramViewModel) : base(graphItemObject, diagramViewModel) { }
public void nuke() { head = tail = null; }
public void Add(NodeLinkedList nll) { last.Next = nll.first; nll.first.Prev = last; last = nll.last; }
public void Only_those_that_are_matched_should_be_called() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNodeA = new AlphaNode<Customer>(); alphaNodeA.AddSuccessor(junction); var joinJunction = new JoinNode<Customer>(alphaNodeA); var alphaNodeB = new AlphaNode<Customer>(); alphaNodeB.AddSuccessor(joinJunction); var actionNode = new ActionNode<Customer>(x => _secondaryCalled.Complete(x.Element.Object)); var joinJunction2 = new JoinNode<Customer>(alphaNodeA); joinJunction2.AddSuccessor(actionNode); var alphaNodeC = new AlphaNode<Customer>(); alphaNodeC.AddSuccessor(joinJunction2); var tree = new TypeNode<Customer>(); var isPreferred = new ConditionNode<Customer>(x => x.Preferred); isPreferred.AddSuccessor(alphaNodeA); tree.AddSuccessor(isPreferred); tree.AddSuccessor(alphaNodeB); var isActive = new ConditionNode<Customer>(x => x.Active); isActive.AddSuccessor(alphaNodeC); tree.AddSuccessor(isActive); var visitor = new StringNodeVisitor(); tree.Visit(visitor); Trace.WriteLine(visitor.Result); tree.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); _secondaryCalled.IsCompleted.ShouldBeFalse(); }