/// <summary> /// Main method. /// </summary> /// <param name="selector"></param> /// <param name="context"></param> /// <param name="provider"></param> /// <exception cref="System.ArgumentNullException">selector or context or provider</exception> protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { selector.ThrowIfNull(nameof(selector)); context.ThrowIfNull(nameof(context)); provider.ThrowIfNull(nameof(provider)); // Base method, clear the selector base.FillTreeWithData(selector, context, provider); // Scroll through the pages MultiPanel panel = (MultiPanel)context.Instance; foreach (MultiPanelPage page in panel.Controls) { SelectorNode node = new SelectorNode(page.Name, page); selector.Nodes.Add(node); if (page != panel.SelectedPage) continue; selector.SelectedNode = node; return; } }
/// <summary> /// /// </summary> protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); selector.Nodes.Add(new SelectorNode("<None>", null)); String[] layouts = Directory.GetFiles(this.GetLayoutsDir(), "*.fdl"); for (Int32 i = 0; i < layouts.Length; i++) { String label = Path.GetFileNameWithoutExtension(layouts[i]); SelectorNode item = new SelectorNode(label, layouts[i]); selector.Nodes.Add(item); } }
/// <summary> /// Main method. /// </summary> /// <param name="selection"></param> /// <param name="context"></param> /// <param name="provider"></param> protected override void FillTreeWithData(Selector selection, ITypeDescriptorContext context, IServiceProvider provider) { // Base method, clear the selection base.FillTreeWithData(selection, context, provider); // Scroll through the pages MultiPanel panel = (MultiPanel)context.Instance; foreach (MultiPanelPage page in panel.Controls) { SelectorNode node = new SelectorNode(page.Name, page); selection.Nodes.Add(node); if (page == panel.SelectedPage) { selection.SelectedNode = node; return; } } }
public void Sequence_Node_Succeds_When_One_Child_Succeeds(int childsCount, int successAt) { SelectorNode seq = new SelectorNode(); for (int i = 0; i < childsCount; i++) { var mock = Substitute.For <BTNode>(); mock.Update().Returns(i == successAt ? NodeState.Success : NodeState.Failure); seq.AddChild(mock); } for (int i = 0; i <= successAt; i++) { if (i == successAt) { Assert.IsTrue(seq.Update() == NodeState.Success); } else { Assert.IsTrue(seq.Update() == NodeState.Running); } } }
public void Selector_Node_Fails_If_All_Of_Its_Children_Fails(int childsCount) { SelectorNode seq = new SelectorNode(); for (int i = 0; i < childsCount; i++) { var mock = Substitute.For <BTNode>(); mock.Update().Returns(NodeState.Failure); seq.AddChild(mock); } for (int i = 0; i < childsCount; i++) { if (i == childsCount - 1) { Assert.IsTrue(seq.Update() == NodeState.Failure); } else { Assert.IsTrue(seq.Update() == NodeState.Running); } } }
public static BehaviorNode InitRootNode(BehaviorTree behaviorTree, AbstractActor unit, GameInstance game) { IsAttackAvailableForUnitNode attackAvailable0000 = new IsAttackAvailableForUnitNode("attackAvailable0000", behaviorTree, unit); FindPlayerTutorialTargetNode findPlayerTutorialTarget0000 = new FindPlayerTutorialTargetNode("findPlayerTutorialTarget0000", behaviorTree, unit); ShootTrainingWeaponsAtTargetNode shootTrainingWeaponsAtTarget0000 = new ShootTrainingWeaponsAtTargetNode("shootTrainingWeaponsAtTarget0000", behaviorTree, unit); SequenceNode attack_sequence = new SequenceNode("attack_sequence", behaviorTree, unit); attack_sequence.AddChild(attackAvailable0000); attack_sequence.AddChild(findPlayerTutorialTarget0000); attack_sequence.AddChild(shootTrainingWeaponsAtTarget0000); BraceNode brace0000 = new BraceNode("brace0000", behaviorTree, unit); SelectorNode selector0000 = new SelectorNode("selector0000", behaviorTree, unit); selector0000.AddChild(attack_sequence); selector0000.AddChild(brace0000); return(selector0000); }
public static BehaviorNode InitRootNode(BehaviorTree behaviorTree, AbstractActor unit, GameInstance game) { UnitHasRouteNode unitHasRoute0000 = new UnitHasRouteNode("unitHasRoute0000", behaviorTree, unit); LanceHasStartedRouteNode lanceHasStartedRoute0000 = new LanceHasStartedRouteNode("lanceHasStartedRoute0000", behaviorTree, unit); LanceStartRouteNode lanceStartRoute0000 = new LanceStartRouteNode("lanceStartRoute0000", behaviorTree, unit); SelectorNode selector0000 = new SelectorNode("selector0000", behaviorTree, unit); selector0000.AddChild(lanceHasStartedRoute0000); selector0000.AddChild(lanceStartRoute0000); LanceHasCompletedRouteNode lanceHasCompletedRoute0000 = new LanceHasCompletedRouteNode("lanceHasCompletedRoute0000", behaviorTree, unit); InverterNode inverter0000 = new InverterNode("inverter0000", behaviorTree, unit); inverter0000.AddChild(lanceHasCompletedRoute0000); MoveAlongRouteNode moveAlongRoute0000 = new MoveAlongRouteNode("moveAlongRoute0000", behaviorTree, unit); SequenceNode incrementally_patrol = new SequenceNode("incrementally_patrol", behaviorTree, unit); incrementally_patrol.AddChild(unitHasRoute0000); incrementally_patrol.AddChild(selector0000); incrementally_patrol.AddChild(inverter0000); incrementally_patrol.AddChild(moveAlongRoute0000); BraceNode brace0000 = new BraceNode("brace0000", behaviorTree, unit); SelectorNode route_AI_root = new SelectorNode("route_AI_root", behaviorTree, unit); route_AI_root.AddChild(incrementally_patrol); route_AI_root.AddChild(brace0000); return(route_AI_root); }
//start with enumerations (simple clear value cases) void Start() { //vul selector node //List<INode> nodes = new List<INode>(); //nodes.Add(new ConditionNode(IsHungry)); //nodes.Add(new ActionNode(Eat)); INode selectorNode = new SelectorNode( new SelectorNode( new ConditionNode(IsHungry), new ActionNode(Eat)), new SelectorNode( new SelectorNode( new ConditionNode(IsSleepy), new ActionNode(Sleep)))); //creeer een condition om de code van IsHungry in op te slaan //ConditionNode.Condition hungryCondition = IsHungry; //send the code from the method instead of the result of the method | don't use IsHungry(), but use IsHungry ConditionNode isHungryCondition = new ConditionNode(IsHungry); ConditionNode isSleepyCondition = new ConditionNode(IsSleepy); }
private void Awake() { move = new Vector3(0, 0, 0); var tag = GameObject.Find("Tag").GetComponent <Tag>(); var root = new SelectorNode("/"); root.Add("/", new DecoratorNode("/IsIt", () => tag.target == this.gameObject.transform)); root.Add("/IsIt", new ActionNode("/IsIt/RunAfter", () => { move = GameObject.Find("Player").transform.position - this.transform.position; return(true); })); root.Add("/", new ActionNode("/RunAway", () => { move = this.transform.position - tag.target.position; return(true); })); this.UpdateAsObservable() .Subscribe(_ => { root.Excute(); }); }
public void Add <TOut>(Expression <Func <T, TOut> > selector) { var node = new SelectorNode <T, TOut>(selector); Add(node); }
// Use this for initialization void Start() { //nodes rootNode = new SelectorNode(); //sequensers sequencer1 = new SequencerNode(); sequencer2 = new SequencerNode(); //selectors selector1 = new SelectorNode(); selector2 = new SelectorNode(); //repeaters repeatUntilFail1 = new RepeatUntilFailNode(); //behaviours leaf leafNodeIdle = new LeafNodeIdle(); leafNodeMove = new LeafNodeMove(); leafNodeMoveAway = new leafNodeMoveAway(); //behaviours nodes nodeChooseAttack = new NodeChooseAttack(); //repeater nodes repeatSetTimes1 = new RepeatSetTimesNode(); //check distance decorator checkdst = new DecoratorNodeCheckDist(); bb = new Blackboard(); bb.Boss = GameObject.FindGameObjectWithTag("Boss"); bb.agent = bb.Boss.GetComponent <NavMeshAgent>(); bb.closestEnemyCursor = GameObject.FindGameObjectWithTag("Player"); bb.movespeed = bossMoveSpeed; bb.aggroRange = bossAggroRange; bb.rotationSpeed = bossRotationSpeed; bb.maxValHealth = 100f; bb.maxValTwoHealth = 100f; bb.currentValHealth = 100f; bb.currentValTwoHealth = 100f; bb.fillAmountHealth = 1f; bb.fillAmountTwoHealth = 1f; //node inits rootNode.InitSelector(bb, "Root"); nodeChooseAttack.InitAttack(bb, "Attack"); leafNodeIdle.InitIdle(bb, "Idle"); leafNodeMove.InitMove(bb, "Move"); leafNodeMoveAway.Init(bossMoveSpeed, bossRotationSpeed); selector1.InitSelector(bb, "Selector"); sequencer1.InitSequenser(bb, "Sequence"); checkdst.initDistCheck(bb, "distanceCheck"); //sequence one children rootNode.GetController().AddChild(selector1); selector1.GetController().AddChild(leafNodeIdle); selector1.GetController().AddChild(sequencer1); sequencer1.GetController().AddChild(leafNodeMove); sequencer1.GetController().AddChild(checkdst); sequencer1.GetController().AddChild(nodeChooseAttack); //test for debug rootNode.SetCurrentTask(rootNode.GetController().GetChildList().First()); selector1.SetCurrentTask(selector1.GetController().GetChildList().First()); sequencer1.SetCurrentTask(sequencer1.GetController().GetChildList().First()); }
void Init(bool keepState = false) { testObject = new SelectorNode("some-selector", keepState); }
protected override void FillTreeWithData(Selector theSel, ITypeDescriptorContext theCtx, IServiceProvider theProvider) { base.FillTreeWithData(theSel, theCtx, theProvider); //clear the selection MultiPaneControl aCtl = (MultiPaneControl) theCtx.Instance; foreach (MultiPanePage aIt in aCtl.Controls) { SelectorNode aNd = new SelectorNode(aIt.Name, aIt); theSel.Nodes.Add(aNd); if (aIt == aCtl.SelectedPage) theSel.SelectedNode = aNd; } }
public void addChild(SelectorNode child) { child.parent = this; children.Add(child); }
void Init() { testObject = new SelectorNode("some-selector"); }
/// <summary> /// Parses the selector string into a sequence of selector nodes. /// Returns the leaf node. /// </summary> public static SelectorNode[] Parse(string fullSelector) { Regex selectorNodeStringValidator = new Regex(@"^\w+\.\w+|\w+|\.\w+$"); List<string> nodeStrings = fullSelector.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList(); List<SelectorNode> nodes = new List<SelectorNode>(nodeStrings.Count); SelectorNode node = null; for (int i = nodeStrings.Count - 1; i >= 0; --i) { string nodeString = nodeStrings[i]; if (nodeString == ">") { if (node == null) { // We don't have a leaf node yet. '>' is invalid to discover first. Debug.LogError("Bad syntax in selector \"" + fullSelector + "\"."); return null; } else { node.ParentRelationship = SelectorNodeRelationship.Direct; continue; } } else { if (!selectorNodeStringValidator.IsMatch(nodeString)) { Debug.LogError("Bad syntax in selector \"" + fullSelector + "\"."); return null; } SelectorNode newNode = new SelectorNode(); newNode.Parent = node; newNode.ParentRelationship = SelectorNodeRelationship.Indirect; // Indirect until we know otherwise. string[] nodeStringSplit = nodeString.Split('.'); if (nodeStringSplit.Length == 1) { if (nodeString.StartsWith(".")) { newNode.Class = nodeString; } else { newNode.Type = nodeString; } } else { newNode.Type = nodeStringSplit[0]; newNode.Class = nodeStringSplit[1]; } nodes.Add(newNode); node = newNode; } } if (nodes.Count == 0) { return null; } else { return nodes.AsEnumerable().Reverse().ToArray(); } }
public static BehaviorNode InitRootNode(BehaviorTree behaviorTree, AbstractActor unit, GameInstance game) { IsShutDownNode isShutdown0000 = new IsShutDownNode("isShutdown0000", behaviorTree, unit); MechStartUpNode mechStartUp0000 = new MechStartUpNode("mechStartUp0000", behaviorTree, unit); SequenceNode if_shutdown__restart = new SequenceNode("if_shutdown__restart", behaviorTree, unit); if_shutdown__restart.AddChild(isShutdown0000); if_shutdown__restart.AddChild(mechStartUp0000); IsMovementAvailableForUnitNode movementAvailable0000 = new IsMovementAvailableForUnitNode("movementAvailable0000", behaviorTree, unit); IsProneNode isProne0000 = new IsProneNode("isProne0000", behaviorTree, unit); StandNode stand0000 = new StandNode("stand0000", behaviorTree, unit); SequenceNode if_prone__stand_up = new SequenceNode("if_prone__stand_up", behaviorTree, unit); if_prone__stand_up.AddChild(movementAvailable0000); if_prone__stand_up.AddChild(isProne0000); if_prone__stand_up.AddChild(stand0000); IsMovementAvailableForUnitNode movementAvailable0001 = new IsMovementAvailableForUnitNode("movementAvailable0001", behaviorTree, unit); HasSensorLockAbilityNode hasSensorLockAbility0000 = new HasSensorLockAbilityNode("hasSensorLockAbility0000", behaviorTree, unit); HasSensorLockTargetNode hasSensorLockTarget0000 = new HasSensorLockTargetNode("hasSensorLockTarget0000", behaviorTree, unit); SortEnemiesBySensorLockQualityNode sortEnemiesBySensorLockQuality0000 = new SortEnemiesBySensorLockQualityNode("sortEnemiesBySensorLockQuality0000", behaviorTree, unit); RecordHighestPriorityEnemyAsSensorLockTargetNode recordHighestPriorityEnemyAsSensorLockTarget0000 = new RecordHighestPriorityEnemyAsSensorLockTargetNode("recordHighestPriorityEnemyAsSensorLockTarget0000", behaviorTree, unit); SequenceNode sensor_lock_success = new SequenceNode("sensor_lock_success", behaviorTree, unit); sensor_lock_success.AddChild(hasSensorLockAbility0000); sensor_lock_success.AddChild(hasSensorLockTarget0000); sensor_lock_success.AddChild(sortEnemiesBySensorLockQuality0000); sensor_lock_success.AddChild(recordHighestPriorityEnemyAsSensorLockTarget0000); ClearSensorLockNode clearSensorLock0000 = new ClearSensorLockNode("clearSensorLock0000", behaviorTree, unit); SelectorNode selector0000 = new SelectorNode("selector0000", behaviorTree, unit); selector0000.AddChild(sensor_lock_success); selector0000.AddChild(clearSensorLock0000); SequenceNode evalSensorLock = new SequenceNode("evalSensorLock", behaviorTree, unit); evalSensorLock.AddChild(selector0000); SuccessDecoratorNode maybe_sensor_lock = new SuccessDecoratorNode("maybe_sensor_lock", behaviorTree, unit); maybe_sensor_lock.AddChild(evalSensorLock); UnitHasRouteNode unitHasRoute0000 = new UnitHasRouteNode("unitHasRoute0000", behaviorTree, unit); LanceHasCompletedRouteNode lanceHasCompletedRoute0000 = new LanceHasCompletedRouteNode("lanceHasCompletedRoute0000", behaviorTree, unit); InverterNode inverter0000 = new InverterNode("inverter0000", behaviorTree, unit); inverter0000.AddChild(lanceHasCompletedRoute0000); LanceHasStartedRouteNode lanceHasStartedRoute0000 = new LanceHasStartedRouteNode("lanceHasStartedRoute0000", behaviorTree, unit); LanceStartRouteNode lanceStartRoute0000 = new LanceStartRouteNode("lanceStartRoute0000", behaviorTree, unit); SelectorNode selector0001 = new SelectorNode("selector0001", behaviorTree, unit); selector0001.AddChild(lanceHasStartedRoute0000); selector0001.AddChild(lanceStartRoute0000); BlockUntilPathfindingReadyNode blockUntilPathfindingReady0000 = new BlockUntilPathfindingReadyNode("blockUntilPathfindingReady0000", behaviorTree, unit); MoveAlongRouteNode moveAlongRoute0000 = new MoveAlongRouteNode("moveAlongRoute0000", behaviorTree, unit); SequenceNode move_along_route = new SequenceNode("move_along_route", behaviorTree, unit); move_along_route.AddChild(movementAvailable0001); move_along_route.AddChild(maybe_sensor_lock); move_along_route.AddChild(unitHasRoute0000); move_along_route.AddChild(inverter0000); move_along_route.AddChild(selector0001); move_along_route.AddChild(blockUntilPathfindingReady0000); move_along_route.AddChild(moveAlongRoute0000); HasSensorLockAbilityNode hasSensorLockAbility0001 = new HasSensorLockAbilityNode("hasSensorLockAbility0001", behaviorTree, unit); HasRecordedSensorLockTargetNode hasRecordedSensorLockTarget0000 = new HasRecordedSensorLockTargetNode("hasRecordedSensorLockTarget0000", behaviorTree, unit); SetMoodNode setMood0000 = new SetMoodNode("setMood0000", behaviorTree, unit, AIMood.Aggressive); SensorLockRecordedSensorLockTargetNode sensorLockRecordedSensorLockTarget0000 = new SensorLockRecordedSensorLockTargetNode("sensorLockRecordedSensorLockTarget0000", behaviorTree, unit); SequenceNode choseToSensorLock = new SequenceNode("choseToSensorLock", behaviorTree, unit); choseToSensorLock.AddChild(hasSensorLockAbility0001); choseToSensorLock.AddChild(hasRecordedSensorLockTarget0000); choseToSensorLock.AddChild(setMood0000); choseToSensorLock.AddChild(sensorLockRecordedSensorLockTarget0000); LanceDetectsEnemiesNode lanceDetectsEnemies0000 = new LanceDetectsEnemiesNode("lanceDetectsEnemies0000", behaviorTree, unit); FindDetectedEnemiesNode findDetectedEnemies0000 = new FindDetectedEnemiesNode("findDetectedEnemies0000", behaviorTree, unit); IsAttackAvailableForUnitNode attackAvailable0000 = new IsAttackAvailableForUnitNode("attackAvailable0000", behaviorTree, unit); SortEnemiesByThreatNode sortEnemiesByThreat0000 = new SortEnemiesByThreatNode("sortEnemiesByThreat0000", behaviorTree, unit); UseNormalToHitThreshold useNormalToHitThreshold0000 = new UseNormalToHitThreshold("useNormalToHitThreshold0000", behaviorTree, unit); WasTargetedRecentlyNode wasTargetedRecently0000 = new WasTargetedRecentlyNode("wasTargetedRecently0000", behaviorTree, unit); InverterNode inverter0001 = new InverterNode("inverter0001", behaviorTree, unit); inverter0001.AddChild(wasTargetedRecently0000); RandomPercentageLessThanBVNode randomPercentageLessThanBV0000 = new RandomPercentageLessThanBVNode("randomPercentageLessThanBV0000", behaviorTree, unit, BehaviorVariableName.Float_PriorityAttackPercentage); SortEnemiesByPriorityListNode sortEnemiesByPriorityList0000 = new SortEnemiesByPriorityListNode("sortEnemiesByPriorityList0000", behaviorTree, unit); SequenceNode sequence0000 = new SequenceNode("sequence0000", behaviorTree, unit); sequence0000.AddChild(inverter0001); sequence0000.AddChild(randomPercentageLessThanBV0000); sequence0000.AddChild(sortEnemiesByPriorityList0000); MaybeFilterOutPriorityTargetsNode maybeFilterOutPriorityTargets0000 = new MaybeFilterOutPriorityTargetsNode("maybeFilterOutPriorityTargets0000", behaviorTree, unit); FilterKeepingRecentAttackersNode filterKeepingRecentAttackers0000 = new FilterKeepingRecentAttackersNode("filterKeepingRecentAttackers0000", behaviorTree, unit); SucceedNode succeed0000 = new SucceedNode("succeed0000", behaviorTree, unit); SelectorNode priorityAttack = new SelectorNode("priorityAttack", behaviorTree, unit); priorityAttack.AddChild(sequence0000); priorityAttack.AddChild(maybeFilterOutPriorityTargets0000); priorityAttack.AddChild(filterKeepingRecentAttackers0000); priorityAttack.AddChild(succeed0000); ShootAtHighestPriorityEnemyNode shootAtHighestPriorityEnemy0000 = new ShootAtHighestPriorityEnemyNode("shootAtHighestPriorityEnemy0000", behaviorTree, unit); SequenceNode opportunity_fire = new SequenceNode("opportunity_fire", behaviorTree, unit); opportunity_fire.AddChild(lanceDetectsEnemies0000); opportunity_fire.AddChild(findDetectedEnemies0000); opportunity_fire.AddChild(attackAvailable0000); opportunity_fire.AddChild(sortEnemiesByThreat0000); opportunity_fire.AddChild(useNormalToHitThreshold0000); opportunity_fire.AddChild(priorityAttack); opportunity_fire.AddChild(shootAtHighestPriorityEnemy0000); BraceNode brace0000 = new BraceNode("brace0000", behaviorTree, unit); SelectorNode patrol_and_shoot_AI_root = new SelectorNode("patrol_and_shoot_AI_root", behaviorTree, unit); patrol_and_shoot_AI_root.AddChild(if_shutdown__restart); patrol_and_shoot_AI_root.AddChild(if_prone__stand_up); patrol_and_shoot_AI_root.AddChild(move_along_route); patrol_and_shoot_AI_root.AddChild(choseToSensorLock); patrol_and_shoot_AI_root.AddChild(opportunity_fire); patrol_and_shoot_AI_root.AddChild(brace0000); return(patrol_and_shoot_AI_root); }
protected override SelectorNode CreateBehaviour() { //create the dig nodes CanDigNode canDigNode = new CanDigNode(this); HealthLessThanNode healthCheckNode = new HealthLessThanNode(this, 0.6f); AnimatorNode digAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsDigging", ref m_DigAnimationLink); ToggleParticleSystemNode toggleParticleNode = new ToggleParticleSystemNode(this, DigParticleSystem); DelegateNode.Delegate toggleTriggerFunc = SetColliderTrigger; DelegateNode toggleTriggerNode = new DelegateNode(this, toggleTriggerFunc, true); DelegateNode.Delegate toggleColliderFunc = ToggleCollider; DelegateNode toggleColliderNode = new DelegateNode(this, toggleColliderFunc); ToggleNavMeshAgentNode toggleAgentNode = new ToggleNavMeshAgentNode(this); DelayNode delayNode = new DelayNode(this, 2.0f); //TODO: COMMENT THIS SECTION AND ADD STRING PlaySoundNode digSFX = new PlaySoundNode(this, "NergDig"); LerpNode lerpDownNode = new LerpNode(this, Vector3.down, 1.0f, 2.0f, 10.0f); DelegateNode.Delegate rotateFunc = RotateVertical; DelegateNode rotateNode = new DelegateNode(this, rotateFunc); TeleportToTargetOffsetNode teleportNode = new TeleportToTargetOffsetNode(this, new Vector3(0.0f, -5.0f, 0.0f)); LerpToTargetNode lerpToTargetNode = new LerpToTargetNode(this, 0.5f, 1.0f, 10.0f); AnimatorNode biteAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsBiting", ref m_BiteAnimationLink); RunUntillTargetNull targetNullNode = new RunUntillTargetNull(this); //create the dig sequence SequenceNode digSequence = new SequenceNode(this, "DigSequence", healthCheckNode, canDigNode, toggleParticleNode, toggleTriggerNode, toggleColliderNode, toggleAgentNode, delayNode, digSFX, lerpDownNode, toggleParticleNode, rotateNode, teleportNode, toggleColliderNode, toggleParticleNode, lerpToTargetNode, digSFX, delayNode, toggleParticleNode, targetNullNode ); //create the targeting nodes TargetingSightNode sightNode = new TargetingSightNode(this, 1); TargetingLowHealthNode lowHealth = new TargetingLowHealthNode(this, 3); CalculateTargetNode calcTarget = new CalculateTargetNode(this); //assign the targeting sequence SequenceNode targetingSequ = new SequenceNode(this, "TargetingSequence", sightNode, lowHealth, calcTarget); //create the spit nodes CooldownNode spitCooldownNode = new CooldownNode(this, 1.0f); //AnimatorNode spitAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsSpitting", ref m_SpitAnimationLink); ShootProjectileNode projectileNode = new ShootProjectileNode(this, 1, ProjectilePrefab, ProjectileSpawnLoc, "MasterNergProjectile", 10); //SFX for the sound of the nerg spitting PlaySoundNode spitSound = new PlaySoundNode(this, "NergSpit"); //create the movement nodes CooldownNode movementCooldownNode = new CooldownNode(this, 3.0f); //BackAwayNode backAwayNode = new BackAwayNode(this, false, 1.0f); SideStepNode sideStepNode = new SideStepNode(this, false, 2.0f); PredictiveAvoidanceNode predictMovementNode = new PredictiveAvoidanceNode(this, false, true, 2.0f, 5.0f); MovementOptionRandomNode movementNodes = new MovementOptionRandomNode(this, sideStepNode, predictMovementNode); //SFX for the sound of the nerg moving backward //TODO: COMMENT THIS SECTION AND ADD STRING //PlaySoundNode crawlingSFX = new PlaySoundNode(this,); //create the spit sequence SequenceNode spitSequence = new SequenceNode(this, "SpitSequence", spitCooldownNode, projectileNode, spitSound, movementCooldownNode, movementNodes /*, crawlingSFX*/); //assign the attack selector SelectorNode attackSelector = new SelectorNode(this, "AttackSelector", digSequence, spitSequence); //create the attack sequence SequenceNode attackSequence = new SequenceNode(this, "AttackTargetSequence", targetingSequ, attackSelector); //create utility selector SelectorNode utilitySelector = new SelectorNode(this, "UtilitySelector", attackSequence); return(utilitySelector); }
protected override SelectorNode CreateBehaviour() { //Create melee attack nodes //Create ground slam nodes CooldownNode groundSlamCooldownNode = new CooldownNode(this, GroundSlamCooldownTime); AnimatorNode groundSlamStartAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsGroundSlamStarting", ref m_GroundSlamStartLink); GroundSlamNode groundSlamNode = new GroundSlamNode(this, FallingRockPrefab, PunchHitBox.transform); //TODO: COMMENT THIS SECTION AND ADD STRING PlaySoundNode slamSFX = new PlaySoundNode(this, "GolemGroundSlamImpact"); AnimatorNode groundSlamRecoveryAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsGroundSlamRecovering", ref m_GroundSlamRecoveryLink); ToggleParticleSystemNode toggleGroundSlamPartclesNode = new ToggleParticleSystemNode(this, SlamParticleSystem); //Create ground slam sequence SequenceNode groundSlamSequence = new SequenceNode(this, "GroundSlamSequence", groundSlamCooldownNode, groundSlamStartAnimationNode, groundSlamNode, toggleGroundSlamPartclesNode, slamSFX, groundSlamRecoveryAnimationNode); //Create punch nodes CheckDistanceToTargetNode punchDistanceNode = new CheckDistanceToTargetNode(this, 5.0f); ToggleMeleeColliderNode togglePunchNode = new ToggleMeleeColliderNode(this, PunchHitBox, 15); LookAtTargetNode lookAtTargetNode = new LookAtTargetNode(this); AnimatorNode punchAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsPunching", ref m_PunchLink); //TODO: COMMENT THIS SECTION AND ADD STRING PlaySoundNode punchSFX = new PlaySoundNode(this, "GolemPunchImpact"); //Create punch sequence SequenceNode punchSequence = new SequenceNode(this, "PunchSequence", punchDistanceNode, togglePunchNode, lookAtTargetNode, punchSFX, punchAnimationNode, togglePunchNode); //Create melee attack selector in order: GroundSlam, Punch SelectorNode meleeAttackSelector = new SelectorNode(this, "MeleeAttackSelector"); meleeAttackSelector.AddChildren(groundSlamSequence, punchSequence); //Create ranged attack nodes //Create rock throw nodes CooldownNode rockThrowCooldownNode = new CooldownNode(this, 10.0f); AnimatorNode rockThrowStartAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsRockThrowStarting", ref m_RockThrowStartLink); //TODO: COMMENT THIS SECTION AND ADD STRING PlaySoundNode rockThrowSFX = new PlaySoundNode(this, "GolemRockThrow"); DelegateNode.Delegate setRockMeshFunc = SetRockMesh; DelegateNode setRockMeshTrueNode = new DelegateNode(this, setRockMeshFunc, true); AnimatorNode rockThrowingAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsRockThrowing", ref m_RockThrowingLink); DelegateNode setRockMeshFalseNode = new DelegateNode(this, setRockMeshFunc, false); RockThrowNode rockThrowNode = new RockThrowNode(this, RockThrowPrefab, FireLocation, RockThrowDamage); AnimatorNode rockThrowRecoveryAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsRockThrowRecovering", ref m_RockThrowRecoveryLink); //Create rock throw sequence SequenceNode rockThrowSequence = new SequenceNode(this, "RockThrowSequence", rockThrowCooldownNode, rockThrowStartAnimationNode, setRockMeshTrueNode, rockThrowingAnimationNode, setRockMeshFalseNode, rockThrowNode, rockThrowSFX, rockThrowRecoveryAnimationNode ); //Create ground spike nodes CooldownNode groundSpikesCooldownNode = new CooldownNode(this, 10.0f); AnimatorNode groundSpikesStartAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsGroundSpikeStarting", ref m_GroundSpikesStartLink); GroundSpikesNode groundSpikesNode = new GroundSpikesNode(this, SpikePrefab, SpikesMovementTime); AnimatorNode groundSpikesRecoveryAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsGroundSpikesRecovering", ref m_GroundSpikesRecoveryLink); //Create ground spike sequence SequenceNode groundSpikesSequence = new SequenceNode(this, "GroundSpikesSequence", groundSpikesCooldownNode, groundSpikesStartAnimationNode, groundSpikesNode, groundSpikesRecoveryAnimationNode); //Create ranged attack selector in order: RockThrow, GroundSpikes SelectorNode rangedAttackSelector = new SelectorNode(this, "RangedAttackSelector"); rangedAttackSelector.AddChildren(rockThrowSequence, groundSpikesSequence); //Create targeting nodes TargetingAfflicted targetingAfflictedNode = new TargetingAfflicted(this, 8, Status.Stun); TargetingDistanceNode targetingDistanceNode = new TargetingDistanceNode(this, 1); TargetingHighHealthNode targetingHighHealthNode = new TargetingHighHealthNode(this, 1); TargetingHighestDamageNode targetingHighestDamageNode = new TargetingHighestDamageNode(this, 1); TargetingCharacterType targetingCharacterType = new TargetingCharacterType(this, 1, WeaponType.RANGED); CalculateTargetNode calculateTargetNode = new CalculateTargetNode(this); //Create the targeting sequence and attach nodes SequenceNode targetingSequence = new SequenceNode(this, "TargetingSequence"); targetingSequence.AddChildren(targetingAfflictedNode, targetingDistanceNode, targetingHighHealthNode, targetingHighestDamageNode, targetingCharacterType, calculateTargetNode); //Create approach node ApproachNode approachNode = new ApproachNode(this); //Create Abilities/Melee/Ranged/Approach Selector SelectorNode actionSelector = new SelectorNode(this, "ActionSelector"); actionSelector.AddChildren(meleeAttackSelector, rangedAttackSelector, approachNode); //Create Target->Action sequence SequenceNode getTargetAndUseAbilitySequence = new SequenceNode(this, "GetTargetAndUseAbilitySequence"); getTargetAndUseAbilitySequence.AddChildren(targetingSequence, actionSelector); //Create the utility selector with the previous sequence and approach node SelectorNode utilitySelector = new SelectorNode(this, "UtilitySelector"); utilitySelector.AddChildren(getTargetAndUseAbilitySequence); return(utilitySelector); }
protected void DefineNode() { // RunningFromEnemy n_GetClosestEnemy = new LeafNode(GetClosestEnemy_node); n_IsPlayerPowerHigerThanEnemy = new LeafNode(IsPlayerPowerHigerThanEnemy); n_MeetWithDestination = new LeafNode(MeetWithDestination); n_BackToTowerAction = new LeafNode(BackToTowerAction); n_IsPlayerPowerLowerThanEnemy = new InverterNode(n_IsPlayerPowerHigerThanEnemy); n_BackToTower = new SelectorNode(new List <Node> { n_MeetWithDestination, n_BackToTowerAction }); n_RunningFromEnemy = new SequenceNode(new List <Node> { n_GetClosestEnemy, n_IsPlayerPowerLowerThanEnemy, n_BackToTower }); //end running // goto nearest checkpoint n_IsAlreadyHaveDestination = new LeafNode(IsAlreadyHaveDestination); n_GetNearestCheckPoint = new LeafNode(GetNearestCheckPoint); n_MeetWithDestinationCheckPoint = new LeafNode(MeetWithDestination); n_GotoCheckPointAction = new LeafNode(GotoCheckPointAction); n_SetDestinationCheckpoint = new SelectorNode(new List <Node> { n_IsAlreadyHaveDestination, n_GetNearestCheckPoint }); n_GotoCheckPoint = new SelectorNode(new List <Node> { n_MeetWithDestinationCheckPoint, n_GotoCheckPointAction }); n_GotoNearestCheckpoint = new SequenceNode(new List <Node> { n_SetDestinationCheckpoint, n_GotoCheckPoint }); //end nearest //Back to tower if power is critical n_CheckIfPowerisCritical = new LeafNode(CheckIfPowerIsCritical); n_BackToTowerifPowerIsCritical = new SequenceNode(new List <Node>() { n_CheckIfPowerisCritical, n_BackToTower }); //end back n_root = new SelectorNode(new List <Node> { n_BackToTowerifPowerIsCritical, n_RunningFromEnemy, n_GotoNearestCheckpoint }); }
Node InitializeBehaviourTree() { #region IDLE BEHAVIOURS // Selector to decide if the guard should selector a new waypoint on continue on his current path SelectorNode movement = new SelectorNode("Movement Selector", new PickLocation(ref guardBlackboard, ref navAgent, gameObject), new Move(ref guardBlackboard, ref navAgent)); // Checks the guards state, if idle, set speed and perform movement selector SequenceNode idlePatrol = new SequenceNode("Idle Patrol", new CheckState(ref guardBlackboard, Guardblackboard.GuardState.idle, ref navAgent), new SetSpeed(IDLE_SPEED, ref navAgent), movement); // Checks the guards state, if investigating, set speed and patrol waypoints at increased speed SequenceNode alertedPatrol = new SequenceNode("Alerted Patrol", new CheckState(ref guardBlackboard, Guardblackboard.GuardState.investigate, ref navAgent), new SetSpeed(ALERTED_SPEED, ref navAgent), movement); // Checks state, if idle or conversing then condition is passed SelectorNode conversationStateCheck = new SelectorNode("Conversation State Check", new CheckState(ref guardBlackboard, Guardblackboard.GuardState.idle, ref navAgent), new CheckState(ref guardBlackboard, Guardblackboard.GuardState.converse, ref navAgent)); // If conversation check is passed try and perform conversation branch SequenceNode converse = new SequenceNode("Conversation Sequence", conversationStateCheck, new CanConverse(ref guardBlackboard), new IsFriendlyNear(ref guardBlackboard, ref globalBlackboard), //new CanFriendlyConverse(ref guardBlackboard), //new LookAt(ref guardBlackboard), new WaitForTime(ref guardBlackboard, 4f, ref navAgent)); SelectorNode patrol = new SelectorNode("Patrol Selector", alertedPatrol, idlePatrol); SelectorNode idle = new SelectorNode("Idle Selector", converse, patrol); #endregion #region COMBAT BEHAVIOURS // Movement is a sequence rather than selector like idle as player could be moving SequenceNode combatMovement = new SequenceNode("Combat Movement", new CombatPickLocation(ref guardBlackboard, ref navAgent, ref globalBlackboard), new Move(ref guardBlackboard, ref navAgent)); SequenceNode shootPlayer = new SequenceNode("Shoot Player", new CheckRange(ref guardBlackboard, 3f), new ShootPlayer(ref globalBlackboard)); SelectorNode shootOrMove = new SelectorNode("Shoot or Move", shootPlayer, combatMovement); // If the player has been sighted by another guard or by the CCTV move to the spoted location and perform a "wander" // type steering behaviour SequenceNode playerSighted = new SequenceNode("Player Sighted", new CheckState(ref guardBlackboard, Guardblackboard.GuardState.alerted, ref navAgent), new SetSpeed(ALERTED_SPEED, ref navAgent), new SetSearchZone(ref guardBlackboard, ref globalBlackboard, ref navAgent, 10)); // If the player is in sight of this guard, set speed and close them down SequenceNode playerInSight = new SequenceNode("Player In Sight", new CheckState(ref guardBlackboard, Guardblackboard.GuardState.combat, ref navAgent), new SetSpeed(COMBAT_SPEED, ref navAgent), shootOrMove); SelectorNode combat = new SelectorNode("Combat Selector", playerInSight, playerSighted); #endregion SelectorNode root = new SelectorNode("root", idle, combat); return(root); }
void Start() { _behaviorTreeController = new BehaviorTreeController(); // rootとなるSequencer SequencerNode rootNode = new SequencerNode(); rootNode.name = "rootノード"; // 出発 ActionNode departure = new ActionNode(); departure.name = "出発する"; departure.SetRunningFunc(() => { Debug.LogError("出発"); return(NodeStatus.SUCCESS); }); // HP確認のDecorator DecoratorNode confirmationHp = new DecoratorNode(); confirmationHp.name = "HP確認するのDecorator"; confirmationHp.SetConditionFunc(() => { return(_myHp >= 100 ? NodeStatus.SUCCESS : NodeStatus.FAILURE); }); // 敵に寄る ActionNode enemyApproach = new ActionNode(); enemyApproach.name = "敵に寄るアクションノード"; enemyApproach.SetRunningFunc(() => { Debug.LogError("敵に寄る"); return(NodeStatus.SUCCESS); }); // HP確認のDecoratorの子供登録 confirmationHp.AddChild(enemyApproach); // 友達2人を呼ぶParallelNode ParallelNode callFriendAB = new ParallelNode(); callFriendAB.name = "友達2人を呼ぶParallelNode"; // 友達A ActionNode friendA = new ActionNode(); friendA.name = "友達Aを呼ぶ"; friendA.SetRunningFunc(() => { Debug.LogError("友達A"); return(NodeStatus.SUCCESS); }); // 友達B ActionNode friendB = new ActionNode(); friendB.name = "友達Bを呼ぶ"; friendB.SetRunningFunc(() => { Debug.LogError("友達B"); return(NodeStatus.SUCCESS); }); // 友達2人を呼ぶParallelNodeの子供登録 callFriendAB.AddChild(friendA); callFriendAB.AddChild(friendB); // スキルを繰り返し行うRepeaterNode RepeaterNode skillRepeater = new RepeaterNode(); skillRepeater.name = "スキルを繰り返し行うRepeaterNode"; // スキルを選択するSelector SelectorNode selectSkill = new SelectorNode(); selectSkill.name = "スキルを選択するSelector"; // スキルAの発動を確認するDecorator DecoratorNode triggerSkillA = new DecoratorNode(); triggerSkillA.name = "スキルAの発動を確認するDecorator"; triggerSkillA.SetConditionFunc(() => { int probability = Mathf.Clamp(probabilitySkillA, 0, 100); int random = Random.Range(0, 100); return(probability > random ? NodeStatus.SUCCESS : NodeStatus.FAILURE); }); // スキルA ActionNode skillA = new ActionNode(); skillA.name = "skillA"; skillA.SetRunningFunc(() => { Debug.LogError("skillA"); _enemyHp -= 50; return(NodeStatus.SUCCESS); }); // スキルAの発動を確認するDecoratorの子供登録 triggerSkillA.AddChild(skillA); // スキルB ActionNode skillB = new ActionNode(); skillB.name = "skillB"; skillB.SetRunningFunc(() => { Debug.LogError("skillB"); _enemyHp -= 60; return(NodeStatus.SUCCESS); }); // スキルを選択するSelectorの子供登録 selectSkill.AddChild(triggerSkillA); selectSkill.AddChild(skillB); // スキルを繰り返し行うRepeaterNodeの子供登録 skillRepeater._repeatNum = 2; skillRepeater.AddChild(selectSkill); // 敵の生存を確認するSelector SelectorNode enemySurvial = new SelectorNode(); enemySurvial.name = "敵の生存を確認するSelector"; // 敵が死んでいるか確認するDecorator DecoratorNode enemyDied = new DecoratorNode(); enemyDied.name = "敵が死んでいるか確認するDecorator"; enemyDied.SetConditionFunc(() => { return(_enemyHp <= 0 ? NodeStatus.SUCCESS : NodeStatus.FAILURE); }); // 敵が死んでいる ActionNode died = new ActionNode(); died.name = "敵が死んでいる"; died.SetRunningFunc(() => { Debug.LogError("End1"); Debug.LogError("EnemyHp : " + _enemyHp); return(NodeStatus.SUCCESS); }); // 敵が死んでいるか確認するDecoratorの子供登録 enemyDied.AddChild(died); // 敵が生きているか確認するDecorator DecoratorNode enemyAlive = new DecoratorNode(); enemyAlive.name = "敵が生きているか確認するDecorator"; enemyAlive.SetConditionFunc(() => { return(_enemyHp > 0 ? NodeStatus.SUCCESS : NodeStatus.FAILURE); }); // 敵が生きている ActionNode alive = new ActionNode(); alive.name = "敵が生きている"; alive.SetRunningFunc(() => { Debug.LogError("End2"); Debug.LogError("EnemyHp : " + _enemyHp); return(NodeStatus.SUCCESS); }); // 敵が生きているか確認するDecoratorの子供登録 enemyAlive.AddChild(alive); // 敵の生存を確認するSelectorの子供登録 enemySurvial.AddChild(enemyDied); enemySurvial.AddChild(enemyAlive); // rootノードの子供登録 rootNode.AddChild(departure); rootNode.AddChild(confirmationHp); rootNode.AddChild(callFriendAB); rootNode.AddChild(skillRepeater); rootNode.AddChild(enemySurvial); // ツリー実行 _behaviorTreeController.Initialize(rootNode); _behaviorTreeController.OnStart(); }
// Use this for initialization void Start() { // -- ROOT AND ITS CHILDREN -- // Root node selector m_AI = new SelectorNode(); //m_AI = gameObject.AddComponent<SelectorNode>(); // 1st node of Root Condition whistleCondition = new Condition(Conditions.hasWhistled); ConditionNode whistle = new ConditionNode(whistleCondition, this); //ConditionNode whistle = gameObject.AddComponent<ConditionNode>(); // 2nd node of Root Condition inSphereCondition = new Condition(Conditions.inSphere); ConditionNode inSphere = new ConditionNode(inSphereCondition, this); // 3rd node of Root StochasticNode runFaster = new StochasticNode(); // Adding children to Root m_AI.AddNode(whistle); m_AI.AddNode(inSphere); m_AI.AddNode(runFaster); // -- CHILDREN OF WHISTLE CONDITION (1ST CHILD OF ROOT) -- Action approachAction = new Action(Actions.ApproachPlayer); ActionNode approach = new ActionNode(approachAction, this); whistle.AddNode(approach); // -- CHILDREN OF IN-SPHERE CONDITION (2ND CHILD OF ROOT) -- Condition interactingCondition = new Condition(Conditions.interacting); ConditionNode interacting = new ConditionNode(interactingCondition, this); inSphere.AddNode(interacting); // -- CHILDREN OF RUN-FASTER CONDITION (3RD CHILD OF ROOT) -- SequenceNode runAhead = new SequenceNode(); SequenceNode runWith = new SequenceNode(); runFaster.AddNode(runAhead); runFaster.AddNode(runWith); // -- CHILDREN OF INTERACTING CONDITION NODE (CHILD OF IN-SPHERE CONDITION) -- SequenceNode sitThenHunt = new SequenceNode(); SequenceNode idle = new SequenceNode(); interacting.AddNode(sitThenHunt); interacting.AddNode(idle); // -- CHILDREN OF SIT-THEN-HUNT SEQUENCE (CHILD OF SIT-THEN-HUNT SEQUENCE) -- Action sitAction = new Action(Actions.Sit); ActionNode sit = new ActionNode(sitAction, this); SequenceNode huntSequence = new SequenceNode(); sitThenHunt.AddNode(sit); sitThenHunt.AddNode(huntSequence); // -- CHILDREN OF IDLE SEQUENCE (CHILD OF IDLE SEQUENCE) -- Action sniffAction = new Action(Actions.Sniff); ActionNode randomSpot = new ActionNode(sniffAction, this); Condition tenMinutesCondition = new Condition(Conditions.tenMinutes); ConditionNode tenMinutes = new ConditionNode(tenMinutesCondition, this); idle.AddNode(randomSpot); idle.AddNode(tenMinutes); // joint child // -- CHILDREN OF RUN-AHEAD SEQUENCE (CHILD OF RUN-FASTER CONDITION) -- Action runFastAction = new Action(Actions.RunFast); ActionNode runFast = new ActionNode(runFastAction, this); Action waitAction = new Action(Actions.Wait); ActionNode turnAndWait = new ActionNode(waitAction, this); runAhead.AddNode(runFast); runAhead.AddNode(tenMinutes); // joint child tenMinutes.AddNode(huntSequence); runAhead.AddNode(turnAndWait); // -- CHILDREN OF RUN-WITH SEQUENCE (CHILD OF RUN-FASTER CONDITION) -- Action runWithAction = new Action(Actions.RunWith); ActionNode runNear = new ActionNode(runWithAction, this); runWith.AddNode(runNear); // -- CHILDREN OF HUNT SEQUENCE (CHILD OF SIT-THEN-HUNT SEQUENCE AND TEN-MINUTES CONDITION) -- Action dissapearAction = new Action(Actions.Dissapear); ActionNode dissapear = new ActionNode(dissapearAction, this); Action huntedAction = new Action(Actions.Hunted); ActionNode hunted = new ActionNode(huntedAction, this); huntSequence.AddNode(dissapear); huntSequence.AddNode(hunted); // START m_AI.StartCoroutine(m_AI.Execute()); }
public override void Run() { blackBoard = new TestBlackboard(typeof(TestBlackboard.Vars)); tree = new TestTree(blackBoard, this); blackBoard.setData(TestBlackboard.Vars.FirePower, 5d); blackBoard.setData(TestBlackboard.Vars.LastScan, -10d); blackBoard.setData(TestBlackboard.Vars.ScanDelay, 5d); blackBoard.setData(TestBlackboard.Vars.MaxDist, 300d); //Build Tree { DecoratorNode repeater = new RepeatUntilWinNode(); tree.SetMaster(repeater); CompositeNode sequencer = new SequenceNode(); repeater.setChild(sequencer); //Scanning { DecoratorNode scanInverter1 = new InverterNode(); sequencer.addChild(scanInverter1); CompositeNode scanSequencer = new SequenceNode(); scanInverter1.setChild(scanSequencer); DecoratorNode scanInverter2 = new InverterNode(); scanSequencer.addChild(new ChangeColorNode(Color.Blue)); scanSequencer.addChild(scanInverter2); scanInverter2.setChild(new RecentlyScannedNode()); scanSequencer.addChild(new ScanNode()); } CompositeNode selector = new SelectorNode(); sequencer.addChild(selector); //Move to range { CompositeNode MoveToRangeSequencer = new SequenceNode(); selector.addChild(MoveToRangeSequencer); MoveToRangeSequencer.addChild(new ChangeColorNode(Color.Green)); MoveToRangeSequencer.addChild(new RecentlyScannedNode()); DecoratorNode MoveToRangeInverter = new InverterNode(); MoveToRangeSequencer.addChild(MoveToRangeInverter); MoveToRangeInverter.setChild(new InRangeNode()); MoveToRangeSequencer.addChild(new TurnTowardsNode()); MoveToRangeSequencer.addChild(new DriveNode()); } // Shooting { CompositeNode shootingSequencer = new SequenceNode(); selector.addChild(shootingSequencer); shootingSequencer.addChild(new ChangeColorNode(Color.Red)); shootingSequencer.addChild(new CheckGunHeatNode()); shootingSequencer.addChild(new ScanNode()); shootingSequencer.addChild(new ShootNode()); } selector.addChild(new DoNothingNode()); } Out.WriteLine("Created Behaviour tree"); //Run Tree { BTNode.Status s; do { s = tree.process(); }while(s == BTNode.Status.Running); } }
public void Update() { //Parse input from the user. float horiz = Input.GetAxis("Horizontal"); float vert = Input.GetAxis("Vertical"); float jump = Input.GetAxis("Jump"); float fire = Input.GetAxis("Close"); float horiz_mag = Mathf.Abs(horiz); float vert_mag = Mathf.Abs(vert); if (horiz_mag < Mathf.Abs(oldHoriz)) { horiz_hasFallen = true; } if (vert_mag < Mathf.Abs(oldVert)) { vert_hasFallen = true; } Direction dir = Direction.None; if (horiz_mag > .5 && vert_mag < .5 && horiz_hasFallen) { if (horiz > 0 && horiz > oldHoriz) { dir = Direction.Right; horiz_hasFallen = false; } else if (horiz < 0 && horiz < oldHoriz) { dir = Direction.Left; horiz_hasFallen = false; } } else if (horiz_mag < .5 && vert_mag > .5 && vert_hasFallen) { if (vert > 0 && vert > oldVert) { dir = Direction.Up; vert_hasFallen = false; } else if (vert < 0 && vert < oldVert) { dir = Direction.Down; vert_hasFallen = false; } } if (dir != Direction.None) { currentMenu.GetComponent <MoveSelector_Child>().input(dir); //Process change in description if it's needed. updateDescription(); } if (jump < oldJump) { jump_hasFallen = true; } if (jump > oldJump && oldJump == 0 && takeControl) { jump_hasFallen = false; int sel = currentMenu.GetComponent <MoveSelector_Child>().currentSelection; SelectorNode selected; try { selected = current.children[sel]; } catch (ArgumentOutOfRangeException e) { selected = current.children[0]; } if (selected.hasChildren()) { if (selected.children.Count > 0) { current = selected; updateDisplay(); } } else { if (selected.name == "run") { GameController.player.addSelectedMove("Run"); return; } object selectedObj = selections[selected.name]; if (types[selected.name] == "item") { Item selectedItem = (Item)selections[selected.name]; selectedItem.affectPlayer(GameController.player); GameController.player.removeItemByName(selectedItem.getName()); items.removeChildByName(selectedItem.getName()); GameController.player.addSelectedMove("Item Use"); current = root; } else if (types[selected.name] == "move") { Debug.Log(selected.name); GameController.player.addSelectedMove(selected.name); current = root; } updateDisplay(); } } if (fire < oldFire) { fire_hasFallen = true; } if (fire > oldFire && fire_hasFallen) { fire_hasFallen = false; if (current != root) { current = current.parent; } updateDisplay(); } oldHoriz = horiz; oldVert = vert; oldJump = jump; oldFire = fire; if (currentMenu.GetComponent <MoveSelector_Child>().type != currentType) { updateDisplay(); } }
protected override SelectorNode CreateBehaviour() { //Create the reposition nodes SafetyCheckNode safetyCheckNode = new SafetyCheckNode(this); DelegateNode.Delegate invincibleFunc = SetInvincible; DelegateNode setInvincibleTrueNode = new DelegateNode(this, invincibleFunc, true); AnimatorNode jumpAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsInannaJumping", ref m_JumpLink); LerpNode lerpUpwardsNode = new LerpNode(this, Vector3.up, JumpToMaxTime, JumpHeight, JumpSpeed); //Grab all tower points in the map GameObject[] towerPointGameObjects = GameObject.FindGameObjectsWithTag("TowerPoint"); Transform[] towerPointTransforms = new Transform[towerPointGameObjects.Length]; for (int i = 0; i < towerPointTransforms.Length; i++) { towerPointTransforms[i] = towerPointGameObjects[i].transform; } InannaMoveTowerNode moveTowerNode = new InannaMoveTowerNode(this, towerPointTransforms); LerpNode lerpDownwardsNode = new LerpNode(this, Vector3.down, JumpToMaxTime, JumpHeight, JumpSpeed); AnimatorNode landAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsInannaLanding", ref m_LandingLink); PlaySoundNode InnanaJumpSoundNode = new PlaySoundNode(this, "WingFlap"); DelegateNode setInvincibleFalseNode = new DelegateNode(this, invincibleFunc, false); //Create reposition sequence SequenceNode repositionSequence = new SequenceNode(this, "RepositionSequence", safetyCheckNode, setInvincibleTrueNode, jumpAnimationNode, InnanaJumpSoundNode, lerpUpwardsNode, moveTowerNode, lerpDownwardsNode, InnanaJumpSoundNode, landAnimationNode, setInvincibleFalseNode); //Create arrow rain nodes PlaySoundNode ArrowRainSound = new PlaySoundNode(this, "ArrowRain", 8.0f); RainOfArrowsCooldownNode arrowRainCooldownNode = new RainOfArrowsCooldownNode(this, RainOfArrowsCooldown, RainOfArrowsDiameter); RainOfArrowsTargetingNode arrowRainTargetNode = new RainOfArrowsTargetingNode(this, RainOfArrowsDiameter); AnimatorNode arrowRainAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsFiringRainOfArrows", ref m_ArrowRainShotLink); RainOfArrowsAttackNode arrowRainAttackNode = new RainOfArrowsAttackNode(this, m_CircularAOEPrefab.GetComponent <CircularAOE>(), RainOfArrowsWaitTime); //Create arrow rain sequence SequenceNode arrowRainSequence = new SequenceNode(this, "RainOfArrowsSequence", arrowRainCooldownNode, arrowRainTargetNode, arrowRainAnimationNode, arrowRainAttackNode, ArrowRainSound); //Create snipe shot nodes PlaySoundNode HeavyShotSound = new PlaySoundNode(this, "HeavyShot"); SnipeDelayNode snipeDelayNode = new SnipeDelayNode(this, m_Ereshkigal.transform, m_LineRenderer, m_Ereshkigal.EreshkigalSafeSpace, HitScanBuildUp); AnimatorNode snipeAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsSniping", ref m_SnipeShotLink); HitScanShotNode hitScanShotNode = new HitScanShotNode(this, ShootLocation.transform, m_HitScanShot, HitscanShotDamage, HitScanShotDelay); //Create snipe sequence SequenceNode snipeSequence = new SequenceNode(this, "SnipeSequence", snipeDelayNode, snipeAnimationNode, hitScanShotNode, HeavyShotSound); //Create arrow shot targeting nodes TargetingDistanceFromLocationGreaterThenNode targetingDistanceNode = new TargetingDistanceFromLocationGreaterThenNode(this, m_Ereshkigal.transform, m_Ereshkigal.EreshkigalSafeSpace * 0.5f, 2); TargetingLowHealthNode targetingLowestHPNode = new TargetingLowHealthNode(this, 2); TargetingHighestDamageNode targetingHighestDamageNode = new TargetingHighestDamageNode(this, 1); TargetingSightNode targetingSightNode = new TargetingSightNode(this, 1, true); CalculateTargetNode calculateTargetNode = new CalculateTargetNode(this); //Create arrow shot targeting sequence SequenceNode targetingSequence = new SequenceNode(this, "ArrowTargetingSequence", targetingDistanceNode, targetingLowestHPNode, targetingHighestDamageNode, targetingSightNode, calculateTargetNode); //Create other arrow shot nodes PlaySoundNode ArrowShotSoundNode = new PlaySoundNode(this, "ArrowFire"); CooldownNode arrowShotCooldownNode = new CooldownNode(this, ArrowShotRate); AnimatorNode arrowShotAnimationNode = new AnimatorNode(this, m_AnimatorRef, "IsFiringArrowShot", ref m_RegularShotLink); ShootProjectileNode arrowShotProjectileNode = new ShootProjectileNode(this, ArrowShotDamage, ArrowProjectilePrefab, ShootLocation, "InannaArrowPool", 5); //Create arrow shot sequence SequenceNode arrowShotSequence = new SequenceNode(this, "ArrowShotSequence", targetingSequence, arrowShotCooldownNode, arrowShotAnimationNode, ArrowShotSoundNode, arrowShotProjectileNode); //Create utility selector SelectorNode utilitySelector = new SelectorNode(this, "InannaUtilitySelector", repositionSequence, arrowRainSequence, snipeSequence, arrowShotSequence); return(utilitySelector); }
public void Start() { /*if (GameController.player == null) { * GameController.player = new PlayerCharacter(); * Debug.LogWarning("Can't find PlayerCharacter script in the scene. This may cause issues."); * }*/ takeControl = true; Debug.Log("Player in Move Selector: " + GameController.player.strength); /*if(GameController.player == null) { * Debug.LogWarning("There is no fighter class attached to the move selector. I'm creating a fake player for testing purposes."); * GameController.player = new PlayerCharacter(); * GameController.player.testInventory(); * }*/ if (GameController.player.name == "[Test_inv]") { GameController.player.testInventory(); } MoveUtils.InitMoves(); selections = new Dictionary <string, object>(); types = new Dictionary <string, string>(); selectorMap = new Dictionary <SelectorType, GameObject>(); selectorMap[SelectorType.Loop] = loopObject; selectorMap[SelectorType.Grid] = gridObject; selectorMap[SelectorType.In_Place] = inPlaceObject; root = new SelectorNode("root", "ROOT", new List <SelectorNode>(), SelectorType.Grid); SelectorNode moves = new SelectorNode("moves", "Moves", new List <SelectorNode>(), SelectorType.Loop); root.addChild(moves); foreach (Move m in GameController.player.getMoves()) { selections.Add(m.name, MoveUtils.GetMove(m.name)); types.Add(m.name, "move"); moves.addChild(new SelectorNode(m.name, m.name)); } items = new SelectorNode("items", "Items", new List <SelectorNode>(), SelectorType.Loop); root.addChild(items); if (GameController.player.inventory.Count > 0) { foreach (Item item in GameController.player.inventory) { Debug.Log(item.getName()); if (item.getName() != "Rock" && item.getName() != "Ladder") { selections.Add(item.getName(), item); types.Add(item.getName(), "item"); items.addChild(new SelectorNode(item.getName(), item.getDisplayName())); } } } SelectorNode options = new SelectorNode("run", "Run"); root.addChild(options); SelectorNode special = new SelectorNode("special", "Special", new List <SelectorNode>(), SelectorType.Loop); root.addChild(special); current = root; updateDisplay(); }
private static BaseNode __addNode(NodeType node_type, Vector2 mousePosition) { BaseNode node = null; switch (node_type) { case NodeType.BehaviourNode: node = new BehaviourNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.ExcelNode: node = new ExcelNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <ExcelNodeData>(node); nodes_list.Add(node); break; case NodeType.ActionNode: node = new ActionNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.ConditionNode: node = new ConditionNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.WaitNode: node = new WaitNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.SequenceNode: node = new SequenceNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.SelectorNode: node = new SelectorNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; case NodeType.LoopNode: node = new LoopNode(); node.Init(mousePosition, OnClickNode); NodeDataManager.CreateNodeData <BaseNodeData>(node); nodes_list.Add(node); break; } if (node != null && nodes_list.Count == 1) { rootNode = node; } return(node); }
public static BehaviorNode InitRootNode(BehaviorTree behaviorTree, AbstractActor unit, GameInstance game) { LanceHasLOSNode lanceHasLOS0000 = new LanceHasLOSNode("lanceHasLOS0000", behaviorTree, unit); FindVisibleEnemiesNode findVisibleEnemies0000 = new FindVisibleEnemiesNode("findVisibleEnemies0000", behaviorTree, unit); IsMovementAvailableForUnitNode movementAvailable0000 = new IsMovementAvailableForUnitNode("movementAvailable0000", behaviorTree, unit); SortEnemiesByThreatNode sortEnemiesByThreat0000 = new SortEnemiesByThreatNode("sortEnemiesByThreat0000", behaviorTree, unit); MoveTowardsHighestPriorityEnemyNode moveTowardsHighestPriorityEnemy0000 = new MoveTowardsHighestPriorityEnemyNode("moveTowardsHighestPriorityEnemy0000", behaviorTree, unit); SequenceNode canMove = new SequenceNode("canMove", behaviorTree, unit); canMove.AddChild(movementAvailable0000); canMove.AddChild(sortEnemiesByThreat0000); canMove.AddChild(moveTowardsHighestPriorityEnemy0000); IsAttackAvailableForUnitNode attackAvailable0000 = new IsAttackAvailableForUnitNode("attackAvailable0000", behaviorTree, unit); SortEnemiesByEffectivenessNode sortEnemiesByEffectiveness0000 = new SortEnemiesByEffectivenessNode("sortEnemiesByEffectiveness0000", behaviorTree, unit); ShootAtHighestPriorityEnemyNode shootAtHighestPriorityEnemy0000 = new ShootAtHighestPriorityEnemyNode("shootAtHighestPriorityEnemy0000", behaviorTree, unit); SequenceNode canAttack = new SequenceNode("canAttack", behaviorTree, unit); canAttack.AddChild(attackAvailable0000); canAttack.AddChild(sortEnemiesByEffectiveness0000); canAttack.AddChild(shootAtHighestPriorityEnemy0000); SelectorNode selector0000 = new SelectorNode("selector0000", behaviorTree, unit); selector0000.AddChild(canMove); selector0000.AddChild(canAttack); SequenceNode free_engage = new SequenceNode("free_engage", behaviorTree, unit); free_engage.AddChild(lanceHasLOS0000); free_engage.AddChild(findVisibleEnemies0000); free_engage.AddChild(selector0000); IsMovementAvailableForUnitNode movementAvailable0001 = new IsMovementAvailableForUnitNode("movementAvailable0001", behaviorTree, unit); FindPreviouslySeenEnemiesNode findPreviouslySeenEnemies0000 = new FindPreviouslySeenEnemiesNode("findPreviouslySeenEnemies0000", behaviorTree, unit); SortEnemiesByProximityNode sortEnemiesByProximity0000 = new SortEnemiesByProximityNode("sortEnemiesByProximity0000", behaviorTree, unit); MoveTowardsHighestPriorityEnemyNode moveTowardsHighestPriorityEnemy0001 = new MoveTowardsHighestPriorityEnemyNode("moveTowardsHighestPriorityEnemy0001", behaviorTree, unit); SequenceNode hunt_previously_seen = new SequenceNode("hunt_previously_seen", behaviorTree, unit); hunt_previously_seen.AddChild(movementAvailable0001); hunt_previously_seen.AddChild(findPreviouslySeenEnemies0000); hunt_previously_seen.AddChild(sortEnemiesByProximity0000); hunt_previously_seen.AddChild(moveTowardsHighestPriorityEnemy0001); SelectorNode selector0001 = new SelectorNode("selector0001", behaviorTree, unit); selector0001.AddChild(hunt_previously_seen); FailNode fail0000 = new FailNode("fail0000", behaviorTree, unit); SelectorNode patrol = new SelectorNode("patrol", behaviorTree, unit); patrol.AddChild(fail0000); BraceNode brace0000 = new BraceNode("brace0000", behaviorTree, unit); SelectorNode dumb_AI_root = new SelectorNode("dumb_AI_root", behaviorTree, unit); dumb_AI_root.AddChild(free_engage); dumb_AI_root.AddChild(selector0001); dumb_AI_root.AddChild(patrol); dumb_AI_root.AddChild(brace0000); return(dumb_AI_root); }
/// <summary> /// clone /// </summary> /// <returns></returns> public IBehaviourNode Clone() { var behaviourNode = new SelectorNode(); base.CopyToCompositeNode(behaviourNode); return behaviourNode; }
protected override void FillTreeWithData(ObjectSelectorEditor.Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); CardPanel Panel = (CardPanel)context.Instance; foreach (CardPanelPage Page in Panel.Controls) { SelectorNode Node = new SelectorNode(Page.Name, Page); selector.Nodes.Add(Node); if (Page == Panel.SelectedItem) { selector.SelectedNode = Node; } } }
// Methods public SelectorNode AddNode(string label, object value, SelectorNode parent) {}
public SelectorNode AddNode (string label, object value, SelectorNode parent) { throw new NotImplementedException (); }
public ApproachMachine() { DataStorage[PlayerPosition] = new Point(10, 10); DataStorage[GoalPosition] = new Point(0, 0); DataStorage[Switch] = false; var switchOffState = new State(); this[SwitchOff] = switchOffState; switchOffState.OnExecuteEvent = (machine, state) => { Debug.WriteLine($"SwitchOff"); if ((bool)machine.DataStorage[Switch]) { machine.NextStateName = SwitchOn; } }; var switchOnState = new State(); this[SwitchOn] = switchOnState; var behaviourMachine = new BehaviourMachine(); behaviourMachine.DataStorage.ReferTo(DataStorage, PlayerPosition); behaviourMachine.DataStorage.ReferTo(DataStorage, GoalPosition); switchOnState.OnExecuteEvent = (machine, state) => { Debug.WriteLine($"SwitchOn"); behaviourMachine.Execute(); }; var moveOrTeleportSelector = new SelectorNode(); behaviourMachine.RegisterRootNode(moveOrTeleportSelector); var moveDecorator = new DecoratorNode(); moveOrTeleportSelector.ChildNodes.Add(moveDecorator); moveDecorator.ConditionCallback = (machine, node) => { Debug.WriteLine($"move condition check"); var playerPosition = (Point)machine.DataStorage[PlayerPosition]; var goalPosition = (Point)machine.DataStorage[GoalPosition]; Debug.WriteLine($"P:{playerPosition} G:{goalPosition}"); return(!playerPosition.Equals(goalPosition)); }; var moveAction = new ActionNode(); moveDecorator.ChildNode = moveAction; moveAction.ActionCallback = (machine, node) => { Debug.WriteLine($"Move"); var playerPosition = (Point)machine.DataStorage[PlayerPosition]; var goalPosition = (Point)machine.DataStorage[GoalPosition]; var diffX = Math.Abs(playerPosition.X - goalPosition.X); var diffY = Math.Abs(playerPosition.Y - goalPosition.Y); if (diffX >= diffY) { playerPosition.X += playerPosition.X > goalPosition.X ? -1 : 1; } else { playerPosition.Y += playerPosition.Y > goalPosition.Y ? -1 : 1; } machine.DataStorage[PlayerPosition] = playerPosition; return(true); }; var teleportAction = new ActionNode(); teleportAction.DataStorage[TeleportCounter] = 10; moveOrTeleportSelector.ChildNodes.Add(teleportAction); teleportAction.ActionCallback = (machine, node) => { Debug.WriteLine($"teleport"); var teleportCounter = (int)node.DataStorage[TeleportCounter]; teleportCounter--; node.DataStorage[TeleportCounter] = teleportCounter; Debug.WriteLine($"teleport counter: {teleportCounter}"); if (teleportCounter > 0) { return(false); } var playerPosition = (Point)machine.DataStorage[PlayerPosition]; playerPosition.X = new Random().Next(-10, 10); playerPosition.Y = new Random().Next(-10, 10); machine.DataStorage[PlayerPosition] = playerPosition; node.DataStorage[TeleportCounter] = 10; Debug.WriteLine($"teleport to {playerPosition}"); return(true); }; }
protected override SelectorNode CreateBehaviour() { #region Spectral Chain Sequence //being section that deals with the attack #region Create the sequence for attacking //when ere begins to move to the center of the map she does it through this node AgentMoveToLocationNode moveToLocation = new AgentMoveToLocationNode(this, m_RoomCenter.position); //When ere's animation of her raising the chain happens AnimatorNode chainRaiseNode = new AnimatorNode(this, m_AnimatorRef, "IsChainRaising", ref m_SpearRaiseLink); //the chain move to player node which will move the chain to the player ChainMoveToPlayersNode chainMoveToPlayer = new ChainMoveToPlayersNode(this, SpearTipLocation, m_LineRenderer, ChainTravelTime); //this node determines if the chain attack is done HasChainReturnedNode hasChainReturned = new HasChainReturnedNode(this); AnimatorNode chainLowerNode = new AnimatorNode(this, m_AnimatorRef, "IsChainLowering", ref m_SpearLowerLink); PlaySoundNode ChainSoundNode = new PlaySoundNode(this, "ChainSound"); //tieing all the nodes into the sequence SequenceNode chainAttackSection = new SequenceNode(this, "Spectral Chain Attack", moveToLocation, chainRaiseNode, chainMoveToPlayer, hasChainReturned, chainLowerNode); #endregion #region Target Selection region //determines if to much time has passed away from center of the map TimeAwayFromCenterNode timeAwayFromCenter = new TimeAwayFromCenterNode(this, m_RoomCenter.position, CenterMapSafeSpace, MaxWaitTimeAwayFromCenter); //determines the player's distance from Inanna PlayerToCloseTargetNode playerToCloseToTargetNode = new PlayerToCloseTargetNode(this, m_Inanna.transform, MinimumDistanceToTarget); SelectorNode spectralChainAttackSelector = new SelectorNode(this, "Choose Attack Selector Spectral Chain", timeAwayFromCenter, playerToCloseToTargetNode); #endregion //cooldown node for spectral chain CooldownNode spectralChainCooldown = new CooldownNode(this, SpectralChainCooldown); //determines if Ere can still use chain attack CanUseChainsNode canUseChain = new CanUseChainsNode(this, MaxChainCyclesPerCycle); SequenceNode specrtalChainSequence = new SequenceNode(this, "Spectral Chain Sequence", spectralChainCooldown, canUseChain, spectralChainAttackSelector, ChainSoundNode, chainAttackSection); #endregion #region Ereshkigal Attack Sequence #region Target Selector #region Protecting Inanna Sequence //puts points into anyone to far away from Ere TargetingDistanceFromLocationGreaterThenNode distanceFromEre = new TargetingDistanceFromLocationGreaterThenNode(this, transform, EreshkigalSafeSpace, 1); //puts points into anyone to close to Anna TargetingDistanceFromLocationNode distanceFromAnna = new TargetingDistanceFromLocationNode(this, m_Inanna.transform, MinimumDistanceToTarget, 2); CalculateTargetNode calcTarget = new CalculateTargetNode(this); SequenceNode protectingInannaSequence = new SequenceNode(this, "Protecting Inanna Sequence", distanceFromEre, distanceFromAnna, calcTarget); #endregion TargetFollowUp followup = new TargetFollowUp(this); TargetSwitchNode switchTargetNode = new TargetSwitchNode(this); SelectorNode targetingSelector = new SelectorNode(this, "Taregting Selector", protectingInannaSequence, followup, switchTargetNode); #endregion #region Lunge Attack CooldownNode lungeCooldown = new CooldownNode(this, LungeCooldown); ToggleNavMeshAgentNode toggleAgentOff = new ToggleNavMeshAgentNode(this); //the crouch before the big jump animator node AnimatorNode preJump = new AnimatorNode(this, m_AnimatorRef, "IsPreJumping", ref m_PreJumpLink); //lerp and animation which will run in tandum LerpNode jumpLerp = new LerpNode(this, Vector3.up, 1.0f, JumpHeight, JumpSpeed); AnimatorNode fulljump = new AnimatorNode(this, m_AnimatorRef, "IsFullJumping", ref m_JumpLink); RunUntilSuceed runJumpAndAnimation = new RunUntilSuceed(this, "Run Animation and Jump", fulljump, jumpLerp); PlaySoundNode LungeSoundNode = new PlaySoundNode(this, "HeavyAttack2"); PlaySoundNode JumpSoundNode = new PlaySoundNode(this, "WingFlap"); PlaySoundNode ScreamSoundNode = new PlaySoundNode(this, "EreshkigalScream"); AnimatorNode jumpIdle = new AnimatorNode(this, m_AnimatorRef, "IsJumpIdle", ref m_JumpIdleLink); LookAtTargetNode lookAtTarget = new LookAtTargetNode(this); ToggleMeleeColliderNode toggleLungeOn = new ToggleMeleeColliderNode(this, SpearCollider, LungeDamage); AnimatorNode diveAnimation = new AnimatorNode(this, m_AnimatorRef, "IsDiving", ref m_DiveLink); LerpToTargetNode diveLerp = new LerpToTargetNode(this, DiveTime, JumpHeight, DiveSpeed); RunUntilSuceed diveAtPlayer = new RunUntilSuceed(this, "Run Dive and Animation", diveAnimation, diveLerp); ToggleMeleeColliderNode toggleLungeOff = new ToggleMeleeColliderNode(this, SpearCollider, 0); ToggleNavMeshAgentNode toggleAgentOn = new ToggleNavMeshAgentNode(this); AnimatorNode diveRecoveryNode = new AnimatorNode(this, m_AnimatorRef, "IsInDiveRecovery", ref m_DiveRecoverLink); SequenceNode lungeAttackSequence = new SequenceNode(this, "Lunge Attack Sequence", lungeCooldown, toggleAgentOff, preJump, runJumpAndAnimation, JumpSoundNode, jumpIdle, toggleLungeOn, lookAtTarget, ScreamSoundNode, diveAtPlayer, JumpSoundNode, toggleLungeOff, toggleAgentOn, diveRecoveryNode); #endregion #region Spear Toss Attack CooldownNode spearTossCooldown = new CooldownNode(this, SpearThrowCooldown); AnimatorNode spearThrowAnimator = new AnimatorNode(this, m_AnimatorRef, "IsSpearBeingThrow", ref m_SpearThrowLink); ShootProjectileNode spearProjectileShoot = new ShootProjectileNode(this, SpearThrowDamage, SpearProjectilePrefab, SpearThrowLocation.gameObject, "SpearProjectile", 2); AnimatorNode spearThrowRecoveryAnimator = new AnimatorNode(this, m_AnimatorRef, "IsInSpearRecovery", ref m_SpearThrowRecoveryLink); SequenceNode spearTossSequence = new SequenceNode(this, "Spear Toss Sequence", spearTossCooldown, spearThrowAnimator, spearProjectileShoot, LungeSoundNode, spearThrowRecoveryAnimator); #endregion #region Basic Attack Selector #region 360 Attack CheckDistanceToTargetNode attack360DistanceCheck = new CheckDistanceToTargetNode(this, Agent.stoppingDistance); AnimatorNode buildUp360 = new AnimatorNode(this, m_AnimatorRef, "IsIn360BuildUp", ref m_360BuildUpLink); ToggleMeleeColliderNode toggleOn360Collider = new ToggleMeleeColliderNode(this, SpearCollider, SpearAttack360Damage); AnimatorNode swing360 = new AnimatorNode(this, m_AnimatorRef, "IsIn360Swing", ref m_360SwingLink); ToggleMeleeColliderNode toggleOff360Collider = new ToggleMeleeColliderNode(this, SpearCollider, 0); AnimatorNode recovery360 = new AnimatorNode(this, m_AnimatorRef, "IsIn360Recovery", ref m_360RecoveryLink); SequenceNode sequence360Attack = new SequenceNode(this, "360 Attack Sequence", attack360DistanceCheck, buildUp360, toggleOn360Collider, swing360, LungeSoundNode, toggleOff360Collider, recovery360); #endregion #region Upper Stab PlaySoundNode MedThrustSound = new PlaySoundNode(this, "MedAttack3"); CheckDistanceToTargetNode attackUpperStab = new CheckDistanceToTargetNode(this, Agent.stoppingDistance); AnimatorNode buildUpUpperStab = new AnimatorNode(this, m_AnimatorRef, "IsInUpperStabBuildUp", ref m_UpperStabBuildUpLink); ToggleMeleeColliderNode toggleOnUpperStabCollider = new ToggleMeleeColliderNode(this, SpearCollider, SpearAttackUpperStabDamage); AnimatorNode swingUpperStab = new AnimatorNode(this, m_AnimatorRef, "IsInUpperStabSwing", ref m_UpperStabSwingLink); ToggleMeleeColliderNode toggleOffUpperStabCollider = new ToggleMeleeColliderNode(this, SpearCollider, 0); AnimatorNode recoveryUpperStab = new AnimatorNode(this, m_AnimatorRef, "IsInUpperStabRecovery", ref m_UpperStabRecoveryLink); SequenceNode sequenceUpperStabAttack = new SequenceNode(this, "Upper Stab Sequence", attackUpperStab, buildUpUpperStab, toggleOnUpperStabCollider, swingUpperStab, MedThrustSound, toggleOffUpperStabCollider, recoveryUpperStab); #endregion #region Jab PlaySoundNode PlayLightThrustSound = new PlaySoundNode(this, "LightAttack2"); CheckDistanceToTargetNode attackJabDistanceCheck = new CheckDistanceToTargetNode(this, Agent.stoppingDistance); AnimatorNode buildUpJab = new AnimatorNode(this, m_AnimatorRef, "IsInJabBuildUp", ref m_JabBuildUpLink); ToggleMeleeColliderNode toggleOnJabCollider = new ToggleMeleeColliderNode(this, SpearCollider, SpearAttackJabDamage); AnimatorNode swingJab = new AnimatorNode(this, m_AnimatorRef, "IsInJabSwing", ref m_JabSwingLink); ToggleMeleeColliderNode toggleOffJabCollider = new ToggleMeleeColliderNode(this, SpearCollider, 0); AnimatorNode recoveryJab = new AnimatorNode(this, m_AnimatorRef, "IsInJabRecovery", ref m_JabRecoveryLink); SequenceNode sequenceJabAttack = new SequenceNode(this, "Jab Attack Sequence", attackJabDistanceCheck, buildUpJab, toggleOnJabCollider, swingJab, PlayLightThrustSound, toggleOffJabCollider, recoveryJab); #endregion ChooseRandomChildNode randomBasicAttackSelector = new ChooseRandomChildNode(this, "Basic Attack Selector, Random", sequence360Attack, sequenceJabAttack, sequenceUpperStabAttack); #endregion ApproachNode approachTargetPlayer = new ApproachNode(this); SelectorNode chooseAttackSelector = new SelectorNode(this, "Attack Choosing Selector", lungeAttackSequence, spearTossSequence, randomBasicAttackSelector, approachTargetPlayer); SequenceNode ereshkigalAttackSequence = new SequenceNode(this, "Ereshkigal Basic Attack Sequence", targetingSelector, chooseAttackSelector); #endregion SelectorNode utilitySelector = new SelectorNode(this, "UtilitySelector", specrtalChainSequence, ereshkigalAttackSequence); return(utilitySelector); }
public override string Visit(SelectorNode node, CssVisitorParams p) { return(node.Selector.Value); }
public SelectorNode AddNode(string label, object value, SelectorNode parent) { throw null; }
/// <summary>The <see cref="Ast.Selectors.SelectorNode"/> visit implementation</summary> /// <param name="selectorNode">The selector AST node</param> /// <returns>The modified AST node if modified otherwise the original node</returns> public virtual AstNode VisitSelectorNode(SelectorNode selectorNode) { return(selectorNode); }
public virtual R Visit(SelectorNode node, P p) { return(default(R)); }
/// <summary> /// CSS-inspired, simplified selector matching. /// </summary> protected bool DoesSelectorMatchDescriptorChain(SelectorNode[] selectorChain, VisualizationDescriptor[] descriptorChain) { // // Algorithm: Starting at the leaf selector node and leaf descriptor node, // we move up both chains, acknowledging compatible node pairs on the way up. // The ParentRelationship value is important in permitting descriptor nodes // to be skipped or not. The algorithm terminates with a match if we have fully traversed // up the selector chain without finding any incompatibility between the chains, // and terminates without a match if otherwise. // VisualizationDescriptor descriptorNode = descriptorChain.LastOrDefault(); bool isLeafMatched = false; for (int i = selectorChain.Length - 1; i >= 0; --i) { if (descriptorNode == null) { // Ran out of descriptor nodes, thus the selector was not fully matched. return false; } SelectorNode selectorNode = selectorChain[i]; if ((selectorNode.Class != null && selectorNode.Class != descriptorNode.Class) || (selectorNode.Type != null && selectorNode.Type != descriptorNode.TargetType.Name)) { if (isLeafMatched) { // Not a matching node. if (selectorNode.ParentRelationship == SelectorNode.SelectorNodeRelationship.Direct) { // We needed to have directly matched the parent here or bust. return false; } else { // Let's keep our selector position, but move up the descriptor chain. i++; descriptorNode = descriptorNode.ParentDescriptor; continue; } } else { // We needed to at least match the leaf node. return false; } } else { // Found a match. if (!isLeafMatched) { isLeafMatched = true; } descriptorNode = descriptorNode.ParentDescriptor; } } // Completed traversal of the selector chain without returning early. // Complete match. return true; }