Esempio n. 1
0
    /// <summary>
    /// Sets snappedPos to the position of the nearest node. Returns false if there are no nodes close enough.
    /// </summary>
    /// <param name="position"></param>
    /// <param name="snappedNode"></param>
    /// <returns></returns>
    private static RuneNode FindNearestValidNode(Vector2 position, out bool nodeNearby)
    {
        RuneNode snappedNode = null;

        var closestNodeDist = Instance._maxPointerdistFromNode;

        for (int n = 0; n < Instance._nodes.childCount; n++)
        {
            var node     = Instance._nodes.GetChild(n);
            var nodeDist = Vector3.Distance(position, node.position);
            if (nodeDist < closestNodeDist)
            {
                // Update return node
                snappedNode     = node.GetComponent <RuneNode>();
                closestNodeDist = nodeDist;
            }
        }
        // If there wasn't a valid node
        if (closestNodeDist >= Instance._maxPointerdistFromNode)
        {
            // Notify root method that there was no valid node
            nodeNearby = false;
        }
        else
        {
            nodeNearby = true;
        }

        return(snappedNode);
    }
    /// <summary>
    /// Passes energy through the link to a connected node. Returns the amount of energy sent if successful,
    /// otherwise returns 0.
    /// </summary>
    /// <param name="amount"></param>
    /// <returns></returns>
    public float SendEnergy(float amount, RuneNode sender)
    {
        var reciever   = GetOther(sender);
        var sentEnergy = 0f;

        // Exit early if reciever inactive
        if (!reciever.Active)
        {
            return(sentEnergy);
        }

        Active = true;

        // Try to transmit energy
        if (sender == NodeA)
        {
            if (Flow >= 0)
            {
                reciever.IncreaseEnergy(amount);
                Flow       = 1;
                sentEnergy = amount;
            }
        }
        else
        {
            if (Flow <= 0)
            {
                reciever.IncreaseEnergy(amount);
                Flow       = -1;
                sentEnergy = amount;
            }
        }

        return(sentEnergy);
    }
    public void RotateTowards(RuneNode targetNode)
    {
        Debug.Log(targetNode.name + "is target");

        var angle = Vector3.Angle(Vector3.up, Position - targetNode.Position);

        transform.rotation = Quaternion.Euler(new Vector3(0, 0, targetNode.Position.x < Position.x ? -angle : angle));
    }
 public RuneNode GetOther(RuneNode thisNode)
 {
     if (thisNode == NodeA)
     {
         return(NodeB);
     }
     else if (thisNode == NodeB)
     {
         return(NodeA);
     }
     else
     {
         Debug.LogError("Node " + thisNode + " is not bound by link " + name);
         return(null);
     }
 }