Пример #1
0
    // Delete the closest node to proximity of 1.0f on click
    void DeleteNode()
    {
        Event        current = Event.current;
        WaypointNode dNode   = null;

        if (!current.alt)
        {
            Ray        mRay = HandleUtility.GUIPointToWorldRay(current.mousePosition);
            RaycastHit rHit;

            if (Physics.Raycast(mRay, out rHit, Mathf.Infinity))
            {
                dNode = currentWaypoints.GetClosestNode(rHit.point, 1.0f);
            }

            if (dNode != null)
            {
                Handles.DrawWireDisc(dNode.Position, Vector3.up, 0.5f);
            }


            if (current.type == EventType.mouseDown && dNode != null)
            {
                foreach (WaypointLink p in dNode.NeighborNodes)
                {
                    WaypointNode node = (WaypointNode)currentWaypoints.GetClosestNode(p.from);
                    node.RemoveLink(p);
                    node = (WaypointNode)currentWaypoints.GetClosestNode(p.to);
                    node.RemoveLink(p);
                }
                currentWaypoints.WaypointList.Remove(dNode);
                dNode = null;
            }
        }
    }
Пример #2
0
    WaypointNode GetNextWaypoint(int currentIndex)
    {
        WaypointNode nextNode = null;

        try {
            var waypoints = _waypoint.GetComponentsInChildren <WaypointNode>();
            if (currentIndex < waypoints.Length)
            {
                nextNode = waypoints[currentIndex];
            }
        } catch (UnityException ue) {
            nextNode = null;
        }
        if (nextNode != null)
        {
            try {
                Transform temp = nextNode.transform.FindChild("Stoplight");
                if (temp != null)
                {
                    stoplight = temp.gameObject;
                }
                else
                {
                    stoplight = null;
                }
            } catch (UnityException ue) {
                stoplight = null;
            }
        }

        return(nextNode);
    }
Пример #3
0
    private void MakeRailTo(WaypointNode src, WaypointNode dst, int segmentID)
    {
        Vector3 a = src.transform.localPosition;
        Vector3 b = dst.transform.localPosition;

        Vector3 dir = (b - a).normalized;

        a += dir * src.radius;
        b -= dir * dst.radius;


        float distance = Vector3.Distance(a, b);

        waypoints.Add(a);
        waypoints.Add(b);

        TrackSection tsp = Instantiate(trackSectionPrefab);

        tsp.SetEnds(src, dst);
        tsp.Init();
        tsp.transform.SetParent(renderersHolder);
        tsp.generator = this;
        tsp.SetPositions(new List <Vector3> {
            a, b
        }.ToArray());
    }
Пример #4
0
    private void GenRail(WaypointNode curr)
    {
        grey.Add(curr);

        foreach (WaypointNode node in curr.Children)
        {
            if (!grey.Contains(node))
            {
                GenRail(node);
            }
            if (!black.Contains(node))
            {
                MakeRailTo(curr, node, grey.Count);
            }
        }

        foreach (KeyValuePair <WaypointNode, List <WaypointNode> > connections in curr.Connections)
        {
            foreach (WaypointNode node in connections.Value)
            {
                MakeCurveRail(curr, connections.Key, node, grey.Count);
            }
        }

        black.Add(curr);
    }
Пример #5
0
    private void MakeCurveRail(WaypointNode curr, WaypointNode prev, WaypointNode next, int segmentID)
    {
        Vector3 a = curr.transform.localPosition + GetDirection(curr.transform, prev.transform) * curr.radius;
        Vector3 b = curr.transform.localPosition;
        Vector3 c = curr.transform.localPosition + GetDirection(curr.transform, next.transform) * curr.radius;

        //float distance = Vector3.Distance(a, b);
        float distance  = (Mathf.PI / 2) * curr.radius;
        int   midpoints = (int)(distance / step);
        float angleStep = step / (curr.radius * (Mathf.PI / 2));

        List <Vector3> points = new List <Vector3>();

        TrackSection tsp = Instantiate(trackSectionPrefab);

        tsp.SetEnds(prev, next);
        tsp.Init();

        for (int i = 0; i < midpoints; i++)
        {
            Vector3 x = Vector3.Lerp(a, b, i * angleStep);
            Vector3 y = Vector3.Lerp(b, c, i * angleStep);
            points.Add(Vector3.Lerp(x, y, i * angleStep));
        }

        tsp.transform.SetParent(curr.transform);
        tsp.generator = this;
        tsp.SetPositions(points.ToArray());
    }
Пример #6
0
    public void init()
    {
        pos          = Map.grid.grid_to_world(Map.grid.world_to_grid(transform.position));
        current_node = Map.grid.get_node(Map.grid.world_to_grid(pos));

        controller = GetComponent <PlatformCollision>();
        controller.init();
        player_movement = GetComponent <PlayerMovement>();
        player_movement.init();

        Transform weapon_obj = transform.parent.FindChild("weapon");

        if (weapon_obj == null)
        {
            Debug.LogError("'weapon' object cannot be found in player parent's children");
        }
        weapon_inventory = weapon_obj.GetComponent <WeaponInventory>();
        weapon_inventory.init(this);
        weapon_control = weapon_obj.GetComponent <PlayerWeaponControl>();
        weapon_control.init();

        grappling_hook = GetComponent <GrapplingHook>();
        grappling_hook.init();
        health = GetComponent <GenericHealth>();
        health.init(this);
    }
Пример #7
0
 public void get_next_path_node()
 {
     if (path != null && path.Count != 0 && current_path_index < path.Count)
     {
         next_node = path[current_path_index];
     }
 }
Пример #8
0
        void OnArrived(Creature owner)
        {
            if (_path == null || _path.nodes.Empty())
            {
                return;
            }

            Cypher.Assert(_currentNode < _path.nodes.Count, $"WaypointMovementGenerator.OnArrived: tried to reference a node id ({_currentNode}) which is not included in path ({_path.id})");
            WaypointNode waypoint = _path.nodes.ElementAt((int)_currentNode);

            if (waypoint.delay != 0)
            {
                owner.ClearUnitState(UnitState.RoamingMove);
                _nextMoveTime.Reset((int)waypoint.delay);
            }

            if (waypoint.eventId != 0 && RandomHelper.URand(0, 99) < waypoint.eventChance)
            {
                Log.outDebug(LogFilter.MapsScript, $"Creature movement start script {waypoint.eventId} at point {_currentNode} for {owner.GetGUID()}.");
                owner.ClearUnitState(UnitState.RoamingMove);
                owner.GetMap().ScriptsStart(ScriptsType.Waypoint, waypoint.eventId, owner, null);
            }

            // inform AI
            CreatureAI ai = owner.GetAI();

            if (ai != null)
            {
                ai.MovementInform(MovementGeneratorType.Waypoint, (uint)_currentNode);
                ai.WaypointReached(waypoint.id, _path.id);
            }

            owner.UpdateCurrentWaypointInfo(waypoint.id, _path.id);
        }
Пример #9
0
 public WaypointRoute(MovingObject movingObject, WaypointNode waypoint)
 {
     _waypoints = new Queue <WaypointNode>();
     _waypoints.Enqueue(waypoint);
     Destination   = waypoint;
     _movingObject = movingObject;
 }
Пример #10
0
        void OnArrived(Creature creature)
        {
            if (path == null || path.nodes.Empty())
            {
                return;
            }

            WaypointNode waypoint = path.nodes.LookupByIndex((int)currentNode);

            if (waypoint.delay != 0)
            {
                creature.ClearUnitState(UnitState.RoamingMove);
                Stop((int)waypoint.delay);
            }

            if (waypoint.eventId != 0 && RandomHelper.URand(0, 99) < waypoint.eventChance)
            {
                Log.outDebug(LogFilter.Unit, "Creature movement start script {0} at point {1} for {2}.", waypoint.eventId, currentNode, creature.GetGUID());
                creature.ClearUnitState(UnitState.RoamingMove);
                creature.GetMap().ScriptsStart(ScriptsType.Waypoint, waypoint.eventId, creature, null);
            }

            // Inform script
            MovementInform(creature);
            creature.UpdateWaypointID(currentNode);

            creature.SetWalk(waypoint.moveType != WaypointMoveType.Run);
        }
    public override void getPelletPositions(WaypointNode one, WaypointNode two, out List <Vector3> positions)
    {
        positions = new List <Vector3> ();
        int     distance   = (int)calculateDistance(one.transform.position, two.transform.position);
        Vector3 direction1 = (one.transform.position - transform.position).normalized;
        Vector3 direction2 = (two.transform.position - transform.position).normalized;

        Collider col = GetComponent <Collider> ();

        for (int i = 0; i <= distance; i++)
        {
            float   ratio     = (float)i / (float)distance;
            Vector3 direction = Vector3.Slerp(direction1, direction2, ratio);
            Ray     ray       = new Ray(transform.position, direction);
            // reverse ray
            ray.origin    = ray.GetPoint(2 * planetRadius);
            ray.direction = -direction;
            RaycastHit hit;
            col.Raycast(ray, out hit, 2 * planetRadius);
            Vector3 position = hit.point;
            //print (position);
            position += direction * 0.25f;
            positions.Add(position);
        }
    }
Пример #12
0
    public void DrawEdge(WaypointNode neighbor)
    {
        var drawColor = Color.cyan;

        drawColor.a  = .5f;
        Gizmos.color = drawColor;
        // Offset slightly to one side, so that one-way edges are clearer
        Vector3 start = transform.position;
        Vector3 end   = neighbor.transform.position;
        Vector3 dir   = (end - start).normalized;
        Vector3 side  = Vector3.Cross(transform.up, dir);

        var drawMagnitude = .5f;

        start += drawMagnitude * side;
        end   += drawMagnitude * side;

        Gizmos.DrawLine(start, end);

        // Draw an arrow head part-way along the line too (slightly closer to the end)
        const float offsetFraction = .65f;
        var         arrowStart     = offsetFraction * end + (1.0f - offsetFraction) * start;
        var         arrowSide1     = arrowStart - drawMagnitude * dir + drawMagnitude * side;
        var         arrowSide2     = arrowStart - drawMagnitude * dir - drawMagnitude * side;

        Gizmos.DrawLine(arrowStart, arrowSide1);
        Gizmos.DrawLine(arrowStart, arrowSide2);
    }
Пример #13
0
    protected void linkNodes(WaypointNode one, float uCoordA, float vCoordA,
                             WaypointNode two, float uCoordB, float vCoordB)
    {
        float diffU = Mathf.Abs(uCoordA - uCoordB);
        float diffV = Mathf.Abs(vCoordA - vCoordB);

        if (diffU > diffV)
        {
            if (uCoordA > uCoordB)
            {
                one.setLeft(two); two.setRight(one);
            }
            else
            {
                one.setRight(two); two.setLeft(one);
            }
        }
        else
        {
            if (vCoordA > vCoordB)
            {
                one.setBack(two); two.setFront(one);
            }
            else
            {
                one.setFront(two); two.setBack(one);
            }
        }
    }
Пример #14
0
    public void recalc_path()
    {
        if (next_node != null)
        {
            current_node = next_node;
        }
        Vector2             dest      = Map.grid.world_to_grid(Entities.player.pos);
        List <WaypointNode> temp_path = Map.grid.find_path(Map.grid.find_neighbour_node(current_node),
                                                           Map.grid.find_neighbour_node(Map.grid.get_node(dest.x, dest.y)), path_find_timeout_ms);

        if (temp_path.Count >= 2)
        {
            path = temp_path;
        }
        else if (path != null)
        {
            path.Clear();
        }

        if (path != null && path.Count >= 2)
        {
            current_path_index = 1;
            get_next_path_node();
        }
    }
Пример #15
0
    //-----------------------------------------------------------------------------------
    // which directions are allowed now?
    //-----------------------------------------------------------------------------------

    protected List <Direction> allowedDirections()
    {
        // if two or more potential choices are an equal distance from the target,
        // the decision between them is made in the order of up > left > down (> right)
        List <Direction> directions = new List <Direction>();
        Direction        direction  = walker.direction();
        WaypointNode     node       = walker.getCurrentNode();

        if (node.getFront() != null && !direction.isOpposite(Direction.Front))
        {
            directions.Add(Direction.Front);
        }
        if (node.getLeft() != null && !direction.isOpposite(Direction.Left))
        {
            directions.Add(Direction.Left);
        }
        if (node.getBack() != null && !direction.isOpposite(Direction.Back))
        {
            directions.Add(Direction.Back);
        }
        if (node.getRight() != null && !direction.isOpposite(Direction.Right))
        {
            directions.Add(Direction.Right);
        }
        return(directions);
    }
Пример #16
0
    public List <WaypointNode> GetRouteTo(WaypointNode dest)
    {
        List <WaypointNode> route = new List <WaypointNode>();
        int          insertIndex  = 0;
        WaypointNode begin        = this;
        WaypointNode end          = dest;

        while (begin.RecalculateLevel() > end.RecalculateLevel())
        {
            begin = begin.PushTo(insertIndex, route);
            insertIndex++;
        }
        while (begin.RecalculateLevel() < end.RecalculateLevel())
        {
            end = end.PushTo(insertIndex, route);
        }
        while (begin.RecalculateLevel() >= 0 && begin != end)
        {
            begin = begin.PushTo(insertIndex, route);
            insertIndex++;
            end = end.PushTo(insertIndex, route);
        }
        if (begin == null)
        {
            return(null);
        }
        else
        {
            begin.PushTo(insertIndex, route);
            return(route);
        }
    }
Пример #17
0
        void FillPointMovementListForCreature()
        {
            var movePoints = Global.ScriptMgr.GetPointMoveList(me.GetEntry());

            if (movePoints.Empty())
            {
                return;
            }

            LastWP = movePoints.Last().uiPointId;

            foreach (var point in movePoints)
            {
                float x = point.fX;
                float y = point.fY;
                float z = point.fZ;

                GridDefines.NormalizeMapCoord(ref x);
                GridDefines.NormalizeMapCoord(ref y);

                WaypointNode wp = new WaypointNode();
                wp.id          = point.uiPointId;
                wp.x           = x;
                wp.y           = y;
                wp.z           = z;
                wp.orientation = 0.0f;
                wp.moveType    = m_bIsRunning ? WaypointMoveType.Run : WaypointMoveType.Walk;
                wp.delay       = point.uiWaitTime;
                wp.eventId     = 0;
                wp.eventChance = 100;

                _path.nodes.Add(wp);
            }
        }
Пример #18
0
    public virtual void DoSwitch(WaypointNode swtch)
    {
        WaypointNode node = _connections[swtch][0];

        _connections[swtch].RemoveAt(0);
        _connections[swtch].Add(node);
    }
Пример #19
0
    public WaypointNode find_neighbour_node(WaypointNode start_node)
    {
        if (start_node.walkable)
        {
            return(start_node);
        }
        for (int n = 0; n < neighbours.Length; n += 2)
        {
            int x = (int)start_node.grid_pos.x + neighbours[n];
            int y = (int)start_node.grid_pos.y + neighbours[n + 1];

            if (x < 0 || x >= grid_width)
            {
                continue;
            }
            if (y < 0 || y >= grid_height)
            {
                continue;
            }

            WaypointNode node = get_node(x, y);
            if (node.walkable)
            {
                return(node);
            }
        }
        return(start_node);
    }
Пример #20
0
    public override void OnInspectorGUI()
    {
        Handles.BeginGUI();
        GUI.enabled = !_isActive;
        if (GUILayout.Button("start"))
        {
            _isActive = true;
            _start    = _selected;
        }
        GUI.enabled = _isActive;
        if (GUILayout.Button("end"))
        {
            _isActive = false;
            _dest     = _selected;
            _route    = _start.GetRouteTo(_dest);
        }

        GUI.enabled = true;
        if (m_editMode)
        {
            if (GUILayout.Button("Disable Editing"))
            {
                EndEditMode();
            }
        }
        else if (GUILayout.Button("Enable Editing"))
        {
            StartEditMode();
        }


        Handles.EndGUI();
    }
Пример #21
0
        void FormationMove(Creature creature)
        {
            if (path == null || path.nodes.Empty())
            {
                return;
            }

            bool transportPath = creature.GetTransport() != null;

            WaypointNode waypoint = path.nodes.LookupByIndex((int)currentNode);

            Position formationDest = new Position(waypoint.x, waypoint.y, waypoint.z, 0.0f);

            //! If creature is on transport, we assume waypoints set in DB are already transport offsets
            if (transportPath)
            {
                ITransport trans = creature.GetDirectTransport();
                if (trans != null)
                {
                    trans.CalculatePassengerPosition(ref formationDest.posX, ref formationDest.posY, ref formationDest.posZ, ref formationDest.Orientation);
                }
            }

            // Call for creature group update
            if (creature.GetFormation() != null && creature.GetFormation().getLeader() == creature)
            {
                creature.GetFormation().LeaderMoveTo(formationDest.posX, formationDest.posY, formationDest.posZ);
            }
        }
Пример #22
0
    protected virtual Direction directionFrightened()
    {
        // ghosts use a pseudo-random number generator (PRNG)
        // to pick a way to turn at each intersection when frightened
        System.Random rnd       = new System.Random();
        Direction     direction = (Direction)rnd.Next(4);

        if (validDirection(direction))
        {
            return(direction);
        }

        // if a wall blocks the chosen direction,
        // the virus then attempts the remaining directions in this order:
        // up, left, down, and right, until a passable direction is found
        WaypointNode node = walker.getCurrentNode();

        if (node.getFront() != null)
        {
            return(Direction.Front);
        }
        if (node.getLeft() != null)
        {
            return(Direction.Left);
        }
        if (node.getBack() != null)
        {
            return(Direction.Back);
        }
        if (node.getRight() != null)
        {
            return(Direction.Right);
        }
        return(Direction.None);
    }
Пример #23
0
    public void init(WaypointNode cur, WaypointNode nex, Direction dir)
    {
        currentNode      = cur;
        nextNode         = nex;
        currentDirection = dir;

        _active = true;
    }
Пример #24
0
    /// <summary>
    /// Computes the shorted path between the start and end nodes.
    /// Uses the Euclidean distance for edge costs.
    /// Note that this implementation is very inefficient - it uses Dijkstra's algorithm instead of A*, and does
    /// not have a proper priority queue. For the sizes of graphs that we're dealing with, this should be OK though.
    /// </summary>
    /// <param name="startNode"></param>
    /// <param name="endNode"></param>
    /// <returns>List of nodes for the path, or null if a path can't be found.</returns>
    public static List <WaypointNode> FindPath(WaypointNode startNode, WaypointNode endNode)
    {
        // TODO implement a priority queue. For now we have to linear search to find the lowest-cost node.

        // Distance from the startNode to each open node.
        Dictionary <WaypointNode, float> pathCost = new Dictionary <WaypointNode, float>();

        // The parent of each node in the path, or null for the startNode
        Dictionary <WaypointNode, WaypointNode> parents = new Dictionary <WaypointNode, WaypointNode>();

        // Nodes that have already been explored.
        HashSet <WaypointNode> closed = new HashSet <WaypointNode>();

        parents[startNode]  = null;
        pathCost[startNode] = 0.0f;

        while (!closed.Contains(endNode))
        {
            if (pathCost.Count == 0)
            {
                // Unreachable
                return(null);
            }
            // "pop" the lowest cost node
            var currentNode = FindLowestValue(pathCost);
            var currentCost = pathCost[currentNode];
            foreach (var neighbor in currentNode.Edges)
            {
                if (closed.Contains(neighbor))
                {
                    continue;
                }

                var costToNeighbor = Vector3.Distance(currentNode.transform.position, neighbor.transform.position);
                if (!pathCost.ContainsKey(neighbor) || currentCost + costToNeighbor < pathCost[neighbor])
                {
                    // Update cost and parent for the neighbor
                    pathCost[neighbor] = currentCost + costToNeighbor;
                    parents[neighbor]  = currentNode;
                }
            }

            pathCost.Remove(currentNode);
            closed.Add(currentNode);
        }

        // Walk backwards from the goal
        List <WaypointNode> pathOut = new List <WaypointNode>();
        var current = endNode;

        while (current != null)
        {
            pathOut.Add(current);
            current = parents[current];
        }
        pathOut.Reverse();
        return(pathOut);
    }
Пример #25
0
    //------------------------------------------------------------------------
    // start callbacks
    //------------------------------------------------------------------------

    public virtual void startNavigation()
    {
        // set nodes
        currentNode = spawn;
        nextNode    = currentNode;

        // move to spawn
        transform.position = spawn.transform.position;
    }
Пример #26
0
    void Start()
    {
        ai_parent = GetComponent <AILogicFlyingEnemy>();

        ai_parent.pos   = Map.grid.grid_to_world(Map.grid.world_to_grid(transform.position));
        ai_parent.pos.z = -10;

        current_node = Map.grid.get_node(Map.grid.world_to_grid(ai_parent.pos));
    }
Пример #27
0
 public WaypointRoute(MovingObject movingObject, List <WaypointNode> waypoints)
 {
     //Debug.Log(waypoints[0].gameObject.name);
     //Debug.Log(waypoints.Count);
     _waypoints  = new Queue <WaypointNode>(waypoints);
     Destination = waypoints[waypoints.Count - 1];
     //Debug.Log(Destination.gameObject.name);
     _movingObject = movingObject;
 }
Пример #28
0
 public WaypointNode(int id, WaypointNode wpParent = null, List <WaypointNode> n = null, float f = 0, float g = 0, float h = 0)
 {
     position  = transform.position;
     ID        = id;
     parent    = wpParent;
     neighbors = n;
     F         = f;
     G         = g;
     H         = h;
 }
Пример #29
0
 public void DeactivateWorker(BasicWorker worker, WaypointNode target)
 {
     worker.gameObject.SetActive(false);
     if (targets.IndexOf(target) != -1)
     {
         workersOnTarget[targets.IndexOf(target)]--;
     }
     waiting.Add(worker);
     workers.Remove(worker);
 }
Пример #30
0
 public WaypointNode(Vector3 p, int id, WaypointNode wpParent = null, List <WaypointNode> n = null, float f = 0, float g = 0, float h = 0)
 {
     position  = p;
     ID        = id;
     parent    = wpParent;
     neighbors = n;
     F         = f;
     G         = g;
     H         = h;
 }
Пример #31
0
 public WaypointNode(Vector3 p, int id, WaypointNode wpParent = null, List<WaypointNode> n = null, float f = 0, float g = 0, float h = 0)
 {
     position = p;
     ID = id;
     parent = wpParent;
     neighbors = n;
     F = f;
     G = g;
     H = h;
 }
Пример #32
0
 public WaypointNode(int id, WaypointNode wpParent = null, List<WaypointNode> n = null, float f = 0, float g = 0, float h = 0)
 {
     position = transform.position;
     ID = id;
     parent = wpParent;
     neighbors = n;
     F = f;
     G = g;
     H = h;
 }
 private bool NodesAlreadyConnected(WaypointNode n, WaypointNode a)
 {
     foreach (WaypointNode wpn in a.neighbors)
     {
         if (wpn == n)
         {
             return true;
         }
     }
     return false;
 }
Пример #34
0
    public void check_arrived_next_node()
    {
        float dist = Mathf.Sqrt(Mathf.Pow(ai_parent.pos.x - next_node.world_pos.x, 2) + Mathf.Pow(ai_parent.pos.y - next_node.world_pos.y, 2));
        if (dist <= 1)
        {
            try_recalc_path();

            if (path != null && path.Count != 0 && current_path_index + 1 < path.Count)
            {
                ++current_path_index;
                next_node = path[current_path_index];
            }
        }
        if (dist >= 4.0f) try_recalc_path();
    }
Пример #35
0
    public void recalc_path()
    {
        if (next_node != null) current_node = next_node;
        Vector2 dest = Map.grid.world_to_grid(Entities.player.pos);
        List<WaypointNode> temp_path = Map.grid.find_path(Map.grid.find_neighbour_node(current_node),
                                                          Map.grid.find_neighbour_node(Map.grid.get_node(dest.x, dest.y)), path_find_timeout_ms);

        if (temp_path.Count >= 2) path = temp_path;
        else if (path != null) path.Clear();

        if (path != null && path.Count >= 2)
        {
            current_path_index = 1;
            get_next_path_node();
        }
    }
Пример #36
0
    public void init()
    {
        pos = Map.grid.grid_to_world(Map.grid.world_to_grid(transform.position));
        current_node = Map.grid.get_node(Map.grid.world_to_grid(pos));

        controller = GetComponent<Controller2D>();
        controller.init();
        player_movement = GetComponent<PlayerMovement>();
        player_movement.init();

        Transform weapon_obj = transform.parent.FindChild("weapon_base");
        if (weapon_obj == null) Debug.LogError("'weapon_base' object cannot be found in player parent's children");
        inventory = weapon_obj.GetComponent<WeaponInventory>();
        inventory.init(this);
        weapon_control = weapon_obj.GetComponent<PlayerWeaponControl>();
        weapon_control.init();

        grappling_hook = GetComponent<GrapplingHook>();
        grappling_hook.init();
        health = GetComponent<GenericHealth>();
        health.init(this);
    }
Пример #37
0
    public void SetWaypointNode(WaypointNode waypointNode)
    {
        if (waypointNode.destinationNodes.Length == 0) {
            nextNode = null;
            return;
        }
        if(currentNode!=null)currentNode.occupied = null;

        currentNode = waypointNode;
        distance = 0;
        int nodeIndex = Random.Range(0, waypointNode.destinationNodes.Length);
        for (int i=0; i<waypointNode.destinationNodes.Length; i++) {
            int index = (nodeIndex+i)%waypointNode.destinationNodes.Length;
            if (waypointNode.destinationNodes [index].occupied == null){
                nodeIndex = index;
                break;
            }
        }
        nextNode = waypointNode.destinationNodes [nodeIndex];
        if(nextNode!=null && nextNode.occupied == null)nextNode.occupied = gameObject;
        if(currentNode!=null)currentNode.occupied = gameObject;
        transform.position = currentNode.transform.position;
        virtualCamera.ApplyToTransform(transform);
    }
Пример #38
0
 public void get_next_path_node()
 {
     if (path != null && path.Count != 0 && current_path_index < path.Count) next_node = path[current_path_index];
 }
Пример #39
0
 // Use this for initialization
 void Start()
 {
     enemiesAlive = 0;
     node = GetComponent<WaypointNode>();
     //lastSpawnTime = Time.time;
 }
Пример #40
0
 public NodeRecord(WaypointNode node)
 {
     this.node = node;
     costSoFar = 0;
 }
    // Add node to the point in world.
    void AddNodes()
    {
        Event current = Event.current;

        if (!current.alt)
        {
            if (current.type == EventType.mouseDown && current.button == 0)
            {
                Ray mRay = HandleUtility.GUIPointToWorldRay(current.mousePosition);
                RaycastHit rHit;
                if (Physics.Raycast(mRay, out rHit, Mathf.Infinity))
                {
                    WaypointNode newNode = new WaypointNode();
                    newNode.Position = rHit.point;
                    currentWaypoints.WaypointList.Add(newNode);
                    Event.current.Use();
                }
            }
        }
        
    }
Пример #42
0
    void Update()
    {
        //an addition by lachlan to skip levels as we please
        if (Input.GetKeyDown(KeyCode.P))
        {
            int p = Application.loadedLevel;
            Application.LoadLevel(p + 1);
        }
        if (Input.GetKeyDown(KeyCode.O))
        {
            int o = Application.loadedLevel;
            Application.LoadLevel(o - 1);
        }

        grappling_hook.update();
        if (grappling_hook.grapple_state == GrapplingHook.GrappleState.NONE)
        {
            update_scale();
            player_movement.update();
        }
        health.update();
        weapon_control.update();

        pos = transform.position;

        float world_bounds = 4.0f;
        Vector3 top_left = Camera.main.ScreenToWorldPoint(Vector3.zero);
        Vector3 bot_right = Camera.main.ScreenToWorldPoint(new Vector2(Screen.width, Screen.height));
        if (pos.x < top_left.x - world_bounds || pos.x > bot_right.x + world_bounds ||
            pos.y < top_left.y - world_bounds || pos.y > bot_right.y + world_bounds)
        {
            //Lachlan changed this to restart current level not the first level
            //ie it used to restart the game on death (you should probably call void destroy here)
            Application.LoadLevel(Application.loadedLevel);
        }
        if (Input.GetKeyDown(KeyCode.Alpha1)) weapon_inventory.equip_weapon(weapon_inventory.weapons[0]);
        if (Input.GetKeyDown(KeyCode.Alpha2)) weapon_inventory.equip_weapon(weapon_inventory.weapons[1]);
        if (Input.GetKeyDown(KeyCode.Alpha3)) weapon_inventory.equip_weapon(weapon_inventory.weapons[2]);
        if (Input.GetKeyDown(KeyCode.Alpha4)) weapon_inventory.equip_weapon(weapon_inventory.weapons[3]);
        if (Input.GetKeyDown(KeyCode.Alpha5)) weapon_inventory.equip_weapon(weapon_inventory.weapons[4]);
        if (Input.GetKeyDown(KeyCode.Alpha6)) weapon_inventory.equip_weapon(weapon_inventory.weapons[5]);

        current_node = Map.grid.get_node(Map.grid.world_to_grid(pos));
    }
    void OnSceneGUI(SceneView view)
    {
        if (!Event.current.control && !Event.current.alt && Event.current.type == EventType.MouseUp && Event.current.button == 1)
        {
            Event e = Event.current;
            RaycastHit hit;
            Vector3 mousePos = new Vector3(e.mousePosition.x, -e.mousePosition.y + SceneView.lastActiveSceneView.camera.pixelHeight);
            Ray ray = SceneView.lastActiveSceneView.camera.ScreenPointToRay(mousePos);

            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (waypointPrefab != null && canPlaceNewWaypoint && hit.transform.name != "Waypoint")
                {
                    GameObject newWaypoint = (GameObject)PrefabUtility.InstantiatePrefab(waypointPrefab);
                    newWaypoint.transform.position = hit.point;

                    if (activeNode != null)
                    {
                        activeNode.isActive = false;
                    }

                    activeNode = newWaypoint.GetComponent<WaypointNode>();
                    activeNode.position = hit.point;
                    activeNode.isActive = true;
                    GameObject pFinder = GameObject.FindGameObjectWithTag("WPPathfinder");
                    newWaypoint.transform.parent = pFinder.transform;
                    canPlaceNewWaypoint = false;
                    EditorUtility.SetDirty(activeNode);
                }
                else if (hit.transform.name == "Waypoint")
                {
                    if (activeNode != null)
                    {
                        activeNode.isActive = false;
                        EditorUtility.SetDirty(activeNode);
                    }

                    activeNode = hit.transform.GetComponent<WaypointNode>();
                    activeNode.isActive = true;
                    EditorUtility.SetDirty(activeNode);
                }
            }
        }
        else if (Event.current.control && !Event.current.alt && Event.current.type == EventType.MouseUp && Event.current.button == 1)
        {
            Event e = Event.current;
            RaycastHit hit;
            Vector3 mousePos = new Vector3(e.mousePosition.x, -e.mousePosition.y + SceneView.lastActiveSceneView.camera.pixelHeight);
            Ray ray = SceneView.lastActiveSceneView.camera.ScreenPointToRay(mousePos);

            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (hit.transform.name == "Waypoint")
                {
                    WaypointNode node = hit.transform.GetComponent<WaypointNode>();

                    if (node != activeNode && !NodesAlreadyConnected(node, activeNode))
                    {
                        activeNode.neighbors.Add(node);
                        node.neighbors.Add(activeNode);
                        EditorUtility.SetDirty(activeNode);
                        EditorUtility.SetDirty(node);
                    }
                }
            }
        }
        else if (Event.current.alt && !Event.current.control &&Event.current.type == EventType.MouseUp && Event.current.button == 0)
        {
            Event e = Event.current;
            RaycastHit hit;
            Vector3 mousePos = new Vector3(e.mousePosition.x, -e.mousePosition.y + SceneView.lastActiveSceneView.camera.pixelHeight);
            Ray ray = SceneView.lastActiveSceneView.camera.ScreenPointToRay(mousePos);

            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (hit.transform.name == "Waypoint")
                {
                    WaypointNode node = hit.transform.GetComponent<WaypointNode>();

                    if (node != activeNode && NodesAlreadyConnected(node, activeNode))
                    {
                        activeNode.neighbors.Remove(node);
                        EditorUtility.SetDirty(activeNode);
                    }
                }
            }
        }
        else if (Event.current.control && Event.current.alt && Event.current.type == EventType.MouseUp && Event.current.button == 1)
        {
            Event e = Event.current;
            RaycastHit hit;
            Vector3 mousePos = new Vector3(e.mousePosition.x, -e.mousePosition.y + SceneView.lastActiveSceneView.camera.pixelHeight);
            Ray ray = SceneView.lastActiveSceneView.camera.ScreenPointToRay(mousePos);

            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (hit.transform.name == "Waypoint")
                {
                    WaypointNode node = hit.transform.GetComponent<WaypointNode>();
                    GameObject[] wpList = GameObject.FindGameObjectsWithTag("Waypoint");

                    foreach (GameObject g in wpList)
                    {
                        if (g.GetComponent<WaypointNode>().neighbors.Contains(node))
                        {
                            g.GetComponent<WaypointNode>().neighbors.Remove(node);
                        }
                    }
                    GameObject.DestroyImmediate(hit.transform.gameObject);
                }
            }
        }
        else if (Event.current.alt && Event.current.control && Event.current.type == EventType.MouseUp && Event.current.button == 0)
        {
            Event e = Event.current;
            RaycastHit hit;
            Vector3 mousePos = new Vector3(e.mousePosition.x, -e.mousePosition.y + SceneView.lastActiveSceneView.camera.pixelHeight);
            Ray ray = SceneView.lastActiveSceneView.camera.ScreenPointToRay(mousePos);

            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (hit.transform.name == "Waypoint")
                {
                    WaypointNode node = hit.transform.GetComponent<WaypointNode>();

                    if (node != activeNode && NodesAlreadyConnected(node, activeNode) && NodesAlreadyConnected(activeNode, node))
                    {
                        activeNode.neighbors.Remove(node);
                        node.neighbors.Remove(activeNode);
                        EditorUtility.SetDirty(activeNode);
                        EditorUtility.SetDirty(node);
                    }
                }
            }
        }

        canPlaceNewWaypoint = true;
    }
Пример #44
0
 public Connection(double cost, WaypointNode fromNode, WaypointNode toNode)
 {
     this.cost = cost;
     this.fromNode = fromNode;
     this.toNode = toNode;
 }
Пример #45
0
    void Start()
    {
        ai_parent = GetComponent<AILogicFlyingEnemy>();

        ai_parent.pos = Map.grid.grid_to_world(Map.grid.world_to_grid(transform.position));
        ai_parent.pos.z = -10;

        current_node = Map.grid.get_node(Map.grid.world_to_grid(ai_parent.pos));
    }
Пример #46
0
 public List<WaypointNode> find_path(WaypointNode start_node, WaypointNode end_node, float timeout_ms = 16)
 {
     return find_path((int)start_node.grid_pos.x, (int)start_node.grid_pos.y,
                      (int)end_node.grid_pos.x, (int)end_node.grid_pos.y, timeout_ms);
 }
Пример #47
0
    void Update()
    {
        recalc_path_timer += Time.deltaTime;

        current_node = Map.grid.get_node(Map.grid.world_to_grid(ai_parent.pos));
    }
Пример #48
0
    public WaypointNode find_neighbour_node(WaypointNode start_node)
    {
        if (start_node.walkable) return start_node;
        for (int n = 0; n < neighbours.Length; n += 2)
        {
            int x = (int)start_node.grid_pos.x + neighbours[n];
            int y = (int)start_node.grid_pos.y + neighbours[n + 1];

            if (x < 0 || x >= grid_width) continue;
            if (y < 0 || y >= grid_height) continue;

            WaypointNode node = get_node(x, y);
            if (node.walkable) return node;
        }
        return start_node;
    }
Пример #49
0
 public float DistanceTo(WaypointNode node)
 {
     return new Vector2(transform.position.x - node.transform.position.x, transform.position.z - node.transform.position.z).magnitude;
 }
Пример #50
0
    void Update()
    {
        //an addition by lachlan to skip levels as we please
        if (Input.GetKey(KeyCode.LeftShift))
        {
            if (Input.GetKeyDown(KeyCode.P))
            {
                Debug.Log("shift+p (prev level)");
                int p = Application.loadedLevel;
                Map.switch_level(p + 1);
            }
            if (Input.GetKeyDown(KeyCode.O))
            {
                Debug.Log("shift+o (next level)");
                int o = Application.loadedLevel;
                Map.switch_level(o - 1);
            }
            if (Input.GetKeyDown(KeyCode.R))
            {
                Debug.Log("shift+r (restart level)");
                Map.reset_level();
            }
        }
        if (Input.GetKeyDown(KeyCode.LeftShift))
        {
            player_movement.moveSpeed = 10;
        }
        if (Input.GetKeyUp(KeyCode.LeftShift))
        {
            player_movement.moveSpeed = 6;
        }

        grappling_hook.update();
        if (grappling_hook.grapple_state == GrapplingHook.GrappleState.NONE)
        {
            player_movement.update();
        }
        health.update();
        weapon_control.update();

        pos = transform.position;

        float world_bounds = 4.0f;
        Vector3 top_left = Camera.main.ScreenToWorldPoint(Vector3.zero);
        Vector3 bot_right = Camera.main.ScreenToWorldPoint(new Vector2(Screen.width, Screen.height));
        if (pos.x < top_left.x - world_bounds || pos.x > bot_right.x + world_bounds ||
            pos.y < top_left.y - world_bounds || pos.y > bot_right.y + world_bounds)
        {
            Map.reset_level();
        }
        int i;
        bool found = false;
        if (Input.GetKeyDown(KeyCode.Q))
        {
            i = inventory.equipped_id - 1;
            while (true)
            {
                if (i < 0) i = inventory.weapons.Count - 1;
                if (inventory.weapons[i].active) { inventory.equip_weapon(inventory.weapons[i]); break; }
                if (i == inventory.equipped_id) break;
                --i;
            }
        }
        if (Input.GetKeyDown(KeyCode.E))
        {
            i = inventory.equipped_id + 1;
            while (true)
            {
                if (i >= inventory.weapons.Count) i = 0;
                if (inventory.weapons[i].active) { inventory.equip_weapon(inventory.weapons[i]); break; }
                if (i == inventory.equipped_id) break;
                ++i;
            }
        }

        current_node = Map.grid.get_node(Map.grid.world_to_grid(pos));
    }