private void Start() { target = GameObject.FindGameObjectWithTag("Player"); debug = WaypointGraph.Get("debug"); origin = transform.position; Path = debug.QueryPath(transform.position, target.transform.position); }
//// TODO: remove when done testing //void Start() //{ // isNPCLeader = false; // // targetTransform = null; // // SetUpTactialAreas(); // // SetUpAgentAndAnim(); // // GoToNearestCoverAround(); // //targetTransform = null; // SetUpTactialAreas(); // SetUpAgentAndAnim(); // //GoToNearestAmbushAround(); // //GoToNearestCoverAround(); // //GoToCapturePoint(CapturePoint.CapturePointId.H, TacticalWaypoint.WaypointType.AmbushPoint, true); //} // Use this for initialization void Awake() { isNPCLeader = false; isPlayerGrouped = false; waypointGraph = GameObject.FindGameObjectWithTag("WaypointGraph").GetComponent <WaypointGraph>(); capturePointMap = GameObject.FindGameObjectWithTag("CapturePointMap").GetComponent <CapturePointMap>(); // targetTransform = null; // SetUpTactialAreas(); // SetUpAgentAndAnim(); // GoToNearestCoverAround(); //targetTransform = null; SetUpTactialAreas(); SetUpAgentAndAnim(); //GoToNearestAmbushAround(); //GoToNearestCoverAround(); // GoToCapturePoint(CapturePoint.CapturePointId.A, TacticalWaypoint.WaypointType.AmbushPoint, true); // Start behavior tree bt = new BehaviorTree(Application.dataPath + "/GameScene/Scripts/npc_firing.xml", this); bt.Start(); }
/// <summary> /// Creates a pod with the given characteristics. /// </summary> /// <param name="id">The ID of the pod.</param> /// <param name="tier">The initial position (tier).</param> /// <param name="waypoint">The waypoint to place the pod at.</param> /// <param name="radius">The radius of the pod.</param> /// <param name="orientation">The initial orientation of the pod.</param> /// <param name="capacity">The capacity of the pod.</param> /// <returns>The newly created pod.</returns> public Pod CreatePod(int id, Tier tier, Waypoint waypoint, double radius, double orientation, double capacity) { // Consider override values if (SettingConfig.OverrideConfig != null && SettingConfig.OverrideConfig.OverridePodCapacity) { capacity = SettingConfig.OverrideConfig.OverridePodCapacityValue; } // Create the pod Pod pod = new Pod(this) { ID = id, Tier = tier, Radius = radius, X = waypoint.X, Y = waypoint.Y, Orientation = orientation, Capacity = capacity, Waypoint = waypoint }; Pods.Add(pod); tier.AddPod(pod); _idToPods[pod.ID] = pod; // Set volatile ID SetVolatileIDForPod(pod); // Emulate setdown operation WaypointGraph.PodSetdown(pod, waypoint); // Notify listeners NewPod(pod); // Return it return(pod); }
void Rule_Nav() { if (NavWaypointGraph(flyGraph = GetDsgVar <WaypointGraph>("Graph_3"), true)) { SetRule(""); } }
// Use this for initialization void Start() { //Find waypoint graph graphNodes = GameObject.FindGameObjectWithTag("waypoint graph").GetComponent <WaypointGraph>(); //Initial node index to move to currentPath.Add(currentNodeIndex); }
void Start() { gridchecker = waypointSet.GetComponent <GridCreator>(); //while (!gridchecker.finished) { } waypoints = new WaypointGraph(waypointSet); path = new List <int>(); pathfinder = createPathfinder(); pathfinder.navGraph = waypoints.navGraph; }
public void UpdateWaypointGraph() { graph = GetComponent <WaypointGraphGeneration>().GenerateGraph(); foreach (var edge in graph.Edges) { edge.Calculate(graph.Nodes); } }
void Start() { if(player == null) player = GameObject.FindGameObjectWithTag("Player").transform; if(graph == null) graph = GameObject.FindGameObjectWithTag("GameController").GetComponent<WaypointGraph>(); path = new List<Vector3>(); havePath = false; }
//Timer specific protected override void OnCreate() { base.OnCreate(); _waypointGraph = WaypointGraph.Instance; //Timer specific timerRecoder = new TimeRecorder("PathFinderSystem"); //Timer specific }
private void Awake() { if (Instance == null) { Instance = this; } else { Destroy(this); } }
//------------------------------------------------------------------------ // awake callbacks //------------------------------------------------------------------------ public void Awake() { gameManager = GameManager.Instance; walkerBody = GetComponent <Rigidbody>(); GameObject planet = GameObject.FindGameObjectWithTag(Tags.Planet); graph = planet.GetComponent <WaypointGraph>(); topo = planet.GetComponent <PlanetTopography>(); awake(); }
void Start() { sprite = transform.FindChild("EnemyPlaceholder").GetComponent <SpriteRenderer>(); minimapSprite = transform.FindChild("Minimap EnemyPlaceholder").GetComponent <SpriteRenderer>(); LoSCollider = transform.FindChild("LineOfSight"); player = GameObject.Find("Player").GetComponent <Player> (); playerTrail = player.GetComponent <PlayerTrail>(); waypointGraph = GameObject.Find("WaypointGraph").GetComponent <WaypointGraph>(); StartCoroutine("Patrol"); }
// Use this for initialization void Update() { if (done) { return; } graph = GetComponent <WaypointGraph> (); topography = GetComponent <PlanetTopography> (); nodePellet = new HashSet <int> (); int count = 0; print(graph.edges.Count); foreach (WaypointEdge edge in graph.edges) { if (edge.one.pacmanWalkable && edge.two.pacmanWalkable) { List <Vector3> positions = new List <Vector3> (); topography.getPelletPositions(edge.one, edge.two, out positions); for (int i = 1; i < positions.Count - 1; ++i) { Instantiate(pellet, positions[i], Quaternion.identity); count++; } if (!nodePellet.Contains(edge.one.GetInstanceID())) { nodePellet.Add(edge.one.GetInstanceID()); GameObject p = pellet; if (edge.one.powerPellet) { p = powerPellet; } Instantiate(p, positions[0], Quaternion.identity); count++; } if (!nodePellet.Contains(edge.two.GetInstanceID())) { nodePellet.Add(edge.two.GetInstanceID()); GameObject p = pellet; if (edge.two.powerPellet) { p = powerPellet; } Instantiate(p, positions[positions.Count - 1], Quaternion.identity); count++; } } } GameManager.Instance.levelData.pelletsTotal = count; done = true; }
void Start() { if (player == null) { player = GameObject.FindGameObjectWithTag("Player").transform; } if (graph == null) { graph = GameObject.FindGameObjectWithTag("GameController").GetComponent <WaypointGraph>(); } path = new List <Vector3>(); havePath = false; }
protected override void OnStart() { grabDist = GetDsgVar <float>("Float_6"); flyGraph = GetDsgVar <WaypointGraph>("Graph_3"); maxHitPoints = float.PositiveInfinity; HealFull(); anim.Set(Anim.Purple); if (flyGraph != null) { SetRule("Nav"); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { //Timer specific var startTimerJob = new StartTimerJob(); var handle = startTimerJob.Schedule(inputDeps); //Timer specific if (_waypointGraph == null) { _waypointGraph = WaypointGraph.Instance; } EntityQuery query = GetEntityQuery(ComponentType.ReadOnly(typeof(PathFindingRequest))); if (query.CalculateEntityCount() == 0) { //Timer specific var endTimerJob2 = new EndTimerJob(); timerRecoder.RegisterTimeInMS(time); //Timer specific return(endTimerJob2.Schedule(handle)); } ArchetypeChunkBufferType <PathPositions> pathPositionBufferChunk = GetArchetypeChunkBufferType <PathPositions>(); ArchetypeChunkComponentType <PathFindingRequest> pathFindingRequestChunk = GetArchetypeChunkComponentType <PathFindingRequest>(true); ArchetypeChunkComponentType <PathIndex> pathIndexChunk = GetArchetypeChunkComponentType <PathIndex>(); //Update quadrants data FindPathJob2 findPathJob = new FindPathJob2() { waypoints = _waypointGraph.Waypoints, Neighbors = _waypointGraph.Neighbors, pathFindingRequestType = pathFindingRequestChunk, pathPositionType = pathPositionBufferChunk, pathIndexType = pathIndexChunk }; var handle2 = findPathJob.Schedule(query, handle); //Timer specific var endTimerJob = new EndTimerJob(); timerRecoder.RegisterTimeInMS(time); //Timer specific return(endTimerJob.Schedule(handle2)); }
private void OnEnable() { graphProperty = serializedObject.FindProperty("graph"); movingObstacleTag = serializedObject.FindProperty("movingObstacleTag"); nodegraph = (WaypointGraph)target; gearsTex = Resources.Load <Texture>("gears"); plusTex = Resources.Load <Texture>("plus"); penTex = Resources.Load <Texture>("pen"); removeTex = Resources.Load <Texture>("remove"); clearTex = Resources.Load <Texture>("clear"); cancelTex = Resources.Load <Texture>("cancel"); bulkTex = Resources.Load <Texture>("bulk"); confirmTex = Resources.Load <Texture>("confirm"); }
/// <summary> /// Creates a new waypoint that serves as the handover point for an elevator. /// </summary> /// <param name="id">The ID of the waypoint.</param> /// <param name="tier">The position (tier).</param> /// <param name="x">The position (x-coordinate).</param> /// <param name="y">The position (y-coordinate).</param> /// <param name="elevator">The elevator.</param> /// <param name="isQueueWaypoint">Indicates whether this waypoint is also a queue waypoint.</param> /// <returns>The newly created waypoint.</returns> public Waypoint CreateWaypoint(int id, Tier tier, Elevator elevator, double x, double y, bool isQueueWaypoint) { Waypoint wp = new Waypoint(this) { ID = id, X = x, Y = y, Elevator = elevator, IsQueueWaypoint = isQueueWaypoint }; tier.AddWaypoint(wp); Waypoints.Add(wp); WaypointGraph.Add(wp); _idToWaypoint[wp.ID] = wp; // Set volatile ID SetVolatileIDForWaypoint(wp); // Return return(wp); }
/// <summary> /// Creates a typical waypoint. /// </summary> /// <param name="id">The ID of the waypoint.</param> /// <param name="tier">The position (tier).</param> /// <param name="x">The position (x-coordinate).</param> /// <param name="y">The position (y-coordinate).</param> /// <param name="podStorageLocation">Indicates whether the waypoint serves as a storage location.</param> /// <param name="isQueueWaypoint">Indicates whether the waypoint belongs to a queue.</param> /// <returns>The newly created waypoint.</returns> public Waypoint CreateWaypoint(int id, Tier tier, double x, double y, bool podStorageLocation, bool isQueueWaypoint) { Waypoint wp = new Waypoint(this) { ID = id, Tier = tier, X = x, Y = y, PodStorageLocation = podStorageLocation, IsQueueWaypoint = isQueueWaypoint }; tier.AddWaypoint(wp); Waypoints.Add(wp); WaypointGraph.Add(wp); _idToWaypoint[wp.ID] = wp; // Set volatile ID SetVolatileIDForWaypoint(wp); // Return return(wp); }
protected void Rule_Default() { if (level != "" && DistTo(rayman) < radius) { SetRule(""); if ((graph = GetDsgVar <WaypointGraph>("Graph_1")) != null) { rayman.ForceNav(graph, () => ChangeMap(level)); } else { ChangeMap(level); } } }
/// <summary> /// Creates a new waypoint that serves as a storage location. /// </summary> /// <param name="id">The ID of the waypoint.</param> /// <param name="tier">The position (tier).</param> /// <param name="pod">The pod currently stored at it.</param> /// <returns>The newly created waypoint.</returns> public Waypoint CreateWaypoint(int id, Tier tier, Pod pod) { Waypoint wp = new Waypoint(this) { ID = id, X = pod.X, Y = pod.Y, Radius = pod.Radius, PodStorageLocation = true, Pod = pod }; pod.Waypoint = wp; tier.AddWaypoint(wp); Waypoints.Add(wp); WaypointGraph.Add(wp); _idToWaypoint[wp.ID] = wp; // Set volatile ID SetVolatileIDForWaypoint(wp); // Return return(wp); }
/// <summary> /// Creates a new waypoint that serves as the handover point for an output station. /// </summary> /// <param name="id">The ID of the waypoint.</param> /// <param name="tier">The position (tier).</param> /// <param name="station">The station.</param> /// <param name="isQueueWaypoint">Indicates whether this waypoint is also a queue waypoint.</param> /// <returns>The newly created waypoint.</returns> public Waypoint CreateWaypoint(int id, Tier tier, OutputStation station, bool isQueueWaypoint) { Waypoint wp = new Waypoint(this) { ID = id, X = station.X, Y = station.Y, Radius = station.Radius, OutputStation = station, IsQueueWaypoint = isQueueWaypoint }; station.Waypoint = wp; tier.AddWaypoint(wp); Waypoints.Add(wp); WaypointGraph.Add(wp); _idToWaypoint[wp.ID] = wp; // Set volatile ID SetVolatileIDForWaypoint(wp); // Return return(wp); }
private void OnEnable() { graphProperty = serializedObject.FindProperty("MainGraph"); movingObstacleTag = serializedObject.FindProperty("movingObstacleTag"); autoRebuild = serializedObject.FindProperty("m_autoRebuild"); graphState = serializedObject.FindProperty("State"); graph = (WaypointGraph)target; plusTex = LoadContent("plus", "Place Waypoint Node"); penTex = LoadContent("pen", "Edit Waypoint Node"); removeTex = LoadContent("remove", "Remove Waypoint Node"); clearTex = LoadContent("clear", "Clear Waypoints"); //cancelTex = Resources.Load<Texture>("cancel"); //bulkTex = Resources.Load<Texture>("bulk"); //confirmTex = Resources.Load<Texture>("confirm"); btnUp = Resources.Load <Texture2D>("button-up"); btnDown = Resources.Load <Texture2D>("button-down"); }
/// <summary> /// Creates a new task allocation manager instance. /// </summary> /// <param name="instance">The instance the manager belongs to.</param> public BotManager(Instance instance) { // Init if not already done Instance = instance; waypointGraph = instance.WaypointGraph; foreach (var bot in instance.Bots) { _taskQueues[bot] = new DummyTask(instance, bot); } foreach (var bot in instance.Bots) { _lastTaskEnqueued[bot] = null; } // Subscribe to order assignment updates (in order to add more work on-the-fly) instance.OrderAllocated += OrderAllocated; instance.BundleAllocated += BundleAllocated; instance.PodPickup += PodPickup; }
void InitWaypoints() { Waypoints = GetComponentsInChildren <WaypointNode>(); m_Entrances = new List <WaypointNode>(); Debug.Log($"Found {Waypoints.Length} Waypoints"); // Clear any existing edges foreach (var wp in Waypoints) { wp.simulation = this; wp.Edges.Clear(); if (wp.waypointType == WaypointNode.WaypointType.Entrance) { m_Entrances.Add(wp); } } m_WaypointGraph = new WaypointGraph(Waypoints); var startTicks = DateTime.Now.Ticks; // TODO avoid duplication with the gizmos code by passing a delegate? foreach (var wp in Waypoints) { foreach (var otherWaypoint in Waypoints) { if (wp == otherWaypoint) { continue; } var validConnection = wp.ShouldConnect(OneWayAisles, otherWaypoint); if (validConnection) { wp.Edges.Add(otherWaypoint); } } } var endTicks = DateTime.Now.Ticks; Debug.Log($"Raycasting between Waypoints took {(endTicks - startTicks) * s_TicksToSeconds} seconds"); }
public void WaypointPathfinding() { var waypointData = new WaypointData(); var waypoint = new Waypoint[32]; for (int i = 0; i < waypoint.Length; ++i) { waypoint[i] = new Waypoint() { link = new List <int>(4), position = new Vector2(0, i), }; } waypoint[0].link.Add(1); waypoint[0].link.Add(2); waypoint[1].link.Add(6); waypoint[2].link.Add(6); waypoint[2].link.Add(3); waypoint[3].link.Add(4); waypoint[4].link.Add(5); waypoint[6].link.Add(7); waypoint[7].link.Add(8); waypoint[7].link.Add(9); waypointData.waypoint = waypoint; waypointData.MakeBidirectional(); var graph = new WaypointGraph(waypointData); var astar = new AStarPathfinding(); astar.FindPath(graph, 0, 9); CheckPath(astar.FormattedPath(), "path:9-7-6-2-0"); astar.FindPath(graph, 5, 8); CheckPath(astar.FormattedPath(), "path:8-7-6-2-3-4-5"); astar.FindPath(graph, 5, 31); CheckPath(astar.FormattedPath(), "path:31-x-9-7-6-2-3-4-5"); astar.FindPath(graph, 0, -1); CheckPath(astar.FormattedPath(9), "path:9-7-6-2-0"); CheckPath(astar.FormattedPath(6), "path:6-2-0"); CheckPath(astar.FormattedPath(4), "path:4-3-2-0"); CheckPath(astar.FormattedPath(11), "path:11-x-9-7-6-2-0"); }
public override void OnInspectorGUI() { DrawDefaultInspector(); waypointGraph = (WaypointGraph)target; if (waypointGraph == null || waypointGraph.waypoints == null || waypointGraph.edges == null) { waypointGraph.InitializeGraph(); } else if (waypointGraph.isEmpty()) { waypointGraph.PopulateGraph(); } waypointStr = EditorGUILayout.TextField("Waypoint: ", waypointStr); if (GUILayout.Button("Add Waypoint")) { waypointGraph.CreateWaypoint(waypointStr); waypointStr = ""; Repaint(); } fromStr = EditorGUILayout.TextField("From: ", fromStr); toStr = EditorGUILayout.TextField("To: ", toStr); if (GUILayout.Button("Add Edge")) { waypointGraph.CreateEdge(fromStr, toStr); fromStr = ""; toStr = ""; Repaint(); } SceneView.RepaintAll(); }
public void Start() { if (!doMagic) { return; } SphereCollider col = GetComponent <SphereCollider> (); WaypointGraph graph = GameObject.FindGameObjectWithTag("Planet").GetComponent <WaypointGraph>(); Ray ray; RaycastHit hit; WaypointNode other; WaypointEdge edge; string[] masks = { "Waypoint" }; LayerMask mask = LayerMask.GetMask(masks); if (right == null) { if (Physics.Raycast(transform.position, Vector3.right, out hit, 50.0f, mask.value)) { other = hit.collider.gameObject.GetComponent <WaypointNode> (); if (other != null) { right = other; other.left = this; edge = new WaypointEdge(); edge.one = this; edge.two = other; graph.edges.Add(edge); } } } if (left == null) { ray = new Ray(transform.position, Vector3.left); if (Physics.Raycast(transform.position, Vector3.left, out hit, 50.0f, mask.value)) { other = hit.collider.gameObject.GetComponent <WaypointNode> (); if (other != null) { left = other; other.right = this; edge = new WaypointEdge(); edge.one = this; edge.two = other; graph.edges.Add(edge); } } } if (front == null) { ray = new Ray(transform.position, Vector3.forward); if (Physics.Raycast(transform.position, Vector3.forward, out hit, 50.0f, mask.value)) { other = hit.collider.gameObject.GetComponent <WaypointNode> (); if (other != null) { front = other; other.back = this; edge = new WaypointEdge(); edge.one = this; edge.two = other; graph.edges.Add(edge); } } } if (back == null) { ray = new Ray(transform.position, Vector3.back); if (Physics.Raycast(transform.position, Vector3.back, out hit, 50.0f, mask.value)) { other = hit.collider.gameObject.GetComponent <WaypointNode> (); if (other != null) { back = other; other.front = this; edge = new WaypointEdge(); edge.one = this; edge.two = other; graph.edges.Add(edge); } } } }
public Waypoint(GameObject obj, WaypointGraph graph) { m_obj = obj; m_graph = graph; }
void GenerateMap() { map = new int[width, height]; //RandomFillMap (); // create the initial perlin noise map PerlinFillMap(); IdentifyPoints(); // Generate the main rooms List<Vector2> rooms = GenerateRoomCenters(roomsToGen, roomSize, 2); rooms = ForceDirectRooms (rooms, roomSize, 0.1f, 80, width, height, 20); for (int i = 0; i < rooms.Count; i++) { EmptyCircle((int) rooms[i].x, (int) rooms[i].y, 15); } for (int i = 0; i < 5; i++) { // use cellular automata to smooth out the map SmoothMap (); } // add in the spawn point if (useRandomSeed) { seed = Time.time.ToString (); } System.Random prng = new System.Random (seed.GetHashCode ()); int spawnIndex = prng.Next (0, rooms.Count); CreateSpawnPoint(rooms [spawnIndex]); rooms.RemoveAt (spawnIndex); if (pvp) { CreateSpawnPoint(rooms [spawnIndex]); } else { // spawn in a single enemy int enemyIndex = prng.Next (0, rooms.Count); StoreEnemySpawns (rooms); } // add a border around the map int borderSize = 5; int[,] borderedMap = new int[width + borderSize * 2, height + borderSize * 2]; for (int x = 0; x < borderedMap.GetLength(0); x++) { for (int y = 0; y < borderedMap.GetLength(1); y++) { if (x >= borderSize && x < width + borderSize && y >= borderSize && y < height + borderSize) { borderedMap[x,y] = map[x-borderSize,y-borderSize]; } else { borderedMap[x,y] = 1; } } } // generate the mesh GetComponent<MeshGenerator> ().GenerateMesh (borderedMap, 1); // see which nodes are connected // note that we need to call debug perlin first for this to work graph = new WaypointGraph (debugPoints, width, height); // test the waypoint graph a bit Waypoint startPoint = graph.waypoints[prng.Next(0, graph.waypoints.Count)]; Waypoint endPoint = graph.waypoints[prng.Next(0, graph.waypoints.Count)]; // attach the waypoint graph to the ai manager aiManager.setWaypointGraph(graph); }
public void setWaypointGraph(WaypointGraph graph) { this.graph = graph; }
// Use this for initialization void Start() { //Find waypoint graph graphNodes = GameObject.FindGameObjectWithTag("waypoint graph").GetComponent <WaypointGraph>(); }
public override void OnInspectorGUI() { DrawDefaultInspector(); WaypointGraph instance = (WaypointGraph)target; if (GUILayout.Button("Build waypoint graph distance")) { var tmpWaypoints = instance.GetComponentsInChildren <WaypointEditor>(); foreach (var waypointEditor in tmpWaypoints) { waypointEditor.maxDistance = new List <float>(); for (var index = 0; index < waypointEditor.neighbors.Count; index++) { var neighbor = waypointEditor.neighbors[index]; Vector3 startPos = waypointEditor.transform.position; Vector3 endPos = neighbor.transform.position; Vector3 dir = (endPos - startPos).normalized; Vector3 perp = new Vector3(dir.z, 0, -dir.x); Vector3 offset = Vector3.zero; for (int i = 0; i < 10; i++) { Physics.Raycast(startPos + dir * i, perp, out RaycastHit hit); } float maxDistance = float.MaxValue; while (Vector3.Distance(startPos + offset, startPos) < Vector3.Distance(startPos, endPos)) { offset += dir; if (Physics.Raycast(startPos + offset, perp, out RaycastHit hit)) { float distance = Vector3.Distance(startPos + offset, hit.point); if (distance < maxDistance) { maxDistance = distance; } } if (Physics.Raycast(startPos + offset, -perp, out RaycastHit hit2)) { float distance = Vector3.Distance(startPos + offset, hit2.point); if (distance < maxDistance) { maxDistance = distance; } } } waypointEditor.maxDistance.Add(maxDistance); } } } }