rj-action-library/Runtime/Godot/Nodes.cs

using Godot;

using System.Collections.Generic;
using System;

namespace Rokojori
{  
  public class Nodes
  {
    public static T Find<T>( Node root, NodePathLocatorType type = NodePathLocatorType.DirectChildren, int parentOffset = 0 ) where T:Node
    {
      var it = root;

      while ( parentOffset > 0 && it != null )
      {
        it = it.GetParent();
        parentOffset --;
      }

      if ( it == null )
      {
        return default(T);
      }

      switch ( type )
      {
        case NodePathLocatorType.DirectChildren:
        {
          return GetDirectChild<T>( it );
        }

        case NodePathLocatorType.Siblings:
        {
          return GetSibling<T>( it );
        }

        case NodePathLocatorType.DirectChildrenAndSiblings:
        {
          var child = GetDirectChild<T>( it );
          
          if ( child != null )
          {
            return child;
          }

          return GetSibling<T>( it );
        }

        case NodePathLocatorType.AnyChildren:
        {
          return GetAnyChild<T>( it );
        }

        case NodePathLocatorType.SiblingsAndAnyChildren:
        {
          var sibling = GetSibling<T>( it );

          if ( sibling != null )
          {
            return sibling;
          }

          return GetAnyChild<T>( it );;
        }

        
      }

      return default(T);
    }

    public static void ForEach<T>( Node root, Action<T> callback ) where T:class
    {
      var walker = nodesWalker;

      walker.Iterate( root,
       ( n )=>
       {
         var t = n as T;

         if ( t == null )
         {
            return;
         }

         callback( t );

       }
       ,false );
    }

    public static T GetSibling<T>( Node node ) where T:Node
    {
      if ( node == null )
      {
        return null;
      }

      var parent = node.GetParent();

      if ( parent == null )
      {
        return null;
      }

      return GetDirectChild<T>( parent );
    }

    public static T GetDirectChild<T>( Node parent ) where T:Node
    {
      if ( parent == null )
      {
        return null;
      }

      var numChildren = parent.GetChildCount();
      
      for ( int i = 0; i < numChildren; i++ )
      {
        var node = parent.GetChild( i );

        if ( node is T )
        {
          return (T) node;
        }
      }

      return null;
    }

    public static List<T> GetDirectChildren<T>( Node parent ) where T:Node
    {
      if ( parent == null )
      {
        return null;
      }

      var list = new List<T>();

      var numChildren = parent.GetChildCount();
      
      for ( int i = 0; i < numChildren; i++ )
      {
        var node = parent.GetChild( i );
        var script = node.GetScript();

        // RJLog.Log( "Node is", typeof(T), node.Name, node.GetType(), script.GetType(), ">>", ( node is T ) );

        
        if ( ! ( node is T ) )
        {
          continue;
        }

        list.Add( node as T );
        
      }

      return list;
    }

    public static void ForEachDirectChild<T>( Node parent, System.Action<T> action ) where T:Node
    {
      if ( parent == null || action == null )
      {
        return;
      }

      var numChildren = parent.GetChildCount();
      
      for ( int i = 0; i < numChildren; i++ )
      {
        var node = parent.GetChild( i );

        if ( ! ( node is T ) )
        {
          continue;
        }

        action( node as T );
      }
    } 

    static NodesWalker nodesWalker = new NodesWalker();

    public static T GetAnyChild<T>( Node parent ) where T:Node
    {
      var result = nodesWalker.Find( parent, 
      ( n )=> 
      {
        

        var castedNode = n as T;

        // RJLog.Log( "Testing", n.UniqueNameInOwner, castedNode != null, n.GetType() ); 
         
        return castedNode != null; 
      
      }, 
      
      
      true );

      return (T) result;
    } 

    /*

    public static void Enable( Node n, bool affectProcess = true, bool affectPhysicsProcess = true, bool affectInput = true )
    {
      SetState.SetStateOfNode( NodeStateType.Enabled, n, affectProcess, affectPhysicsProcess, affectInput );
    }

    public static void Disable( Node n, bool affectProcess = true, bool affectPhysicsProcess = true, bool affectInput = true )
    {
      SetState.SetStateOfNode( NodeStateType.Disabled, n, affectProcess, affectPhysicsProcess, affectInput );
    }

    */

    public static void Iterate( Node[] nodes, System.Action<Node> callback )
    {
      for ( int i = 0; i < nodes.Length; i++ )
      {
        nodesWalker.Iterate( nodes[ i ], callback );
      }
    }

   
  }

}