public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
     }
     walker.PostWalk(this);
 }

    public void Initialize()
    {
        // Finding GameObjects
        m_object_player = GameObject.Find("Player");
        m_object_helpers = GameObject.Find ("Helpers");
        m_object_duckfield = GameObject.Find("Duckfield");
        m_object_audio = GameObject.Find("Audio");
        m_object_cameraman = GameObject.Find("Main Camera");

        // Finding Components
        m_collision_prober = m_object_player.GetComponent<CollisionProber>();
        m_scoring = m_object_player.GetComponent<Scoring>();
        m_health = m_object_player.GetComponent<Health>();
        m_walker = m_object_player.GetComponent<Walker>();
        m_jumper = m_object_player.GetComponent<Jumper>();

        m_time_helper = m_object_helpers.GetComponent<TimeHelper>();
        m_screen_helper = m_object_helpers.GetComponent<ScreenHelper>();

        m_duckfield = m_object_duckfield.GetComponent<DuckField>();

        m_duckization = m_object_audio.GetComponent<DuckizationController>();

        m_cameraman = m_object_cameraman.GetComponent<Cameraman>();
        m_ig_menu = m_object_cameraman.GetComponent<IgMenu>();
    }

        public void ImpossibleTrajectory()
        {
            this.walker = new Walker(new Board(5, 9));

            Coord from = new Coord(0, 7), to = new Coord(4, 1);
            this.AssertBestProbToArrive(from, to, 0);
        }

 internal static SemanticMap From(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
 {
     var map = new SemanticMap();
     var walker = new Walker(semanticModel, map, cancellationToken);
     walker.Visit(node);
     return map;
 }

        public void ReadGlow(GlowContainer glow, Client client)
        {
            var rootItem = new Item(null, _rootKey.Name, false, _rootKey);

             var walker = new Walker(this, client, rootItem);
             walker.Walk(glow);
        }

    /*
    ** 2008 August 16
    **
    ** The author disclaims copyright to this source code.  In place of
    ** a legal notice, here is a blessing:
    **
    **    May you do good and not evil.
    **    May you find forgiveness for yourself and forgive others.
    **    May you share freely, never taking more than you give.
    **
    *************************************************************************
    ** This file contains routines used for walking the parser tree for
    ** an SQL statement.
    *************************************************************************
    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
    **  C#-SQLite is an independent reimplementation of the SQLite software library
    **
    **  SQLITE_SOURCE_ID: 2010-08-23 18:52:01 42537b60566f288167f1b5864a5435986838e3a3
    **
    *************************************************************************
    */
    //#include "sqliteInt.h"
    //#include <stdlib.h>
    //#include <string.h>


    /*
    ** Walk an expression tree.  Invoke the callback once for each node
    ** of the expression, while decending.  (In other words, the callback
    ** is invoked before visiting children.)
    **
    ** The return value from the callback should be one of the WRC_*
    ** constants to specify how to proceed with the walk.
    **
    **    WRC_Continue      Continue descending down the tree.
    **
    **    WRC_Prune         Do not descend into child nodes.  But allow
    **                      the walk to continue with sibling nodes.
    **
    **    WRC_Abort         Do no more callbacks.  Unwind the stack and
    **                      return the top-level walk call.
    **
    ** The return value from this routine is WRC_Abort to abandon the tree walk
    ** and WRC_Continue to continue.
    */
    static int sqlite3WalkExpr( Walker pWalker, ref Expr pExpr )
    {
      int rc;
      if ( pExpr == null )
        return WRC_Continue;
      testcase( ExprHasProperty( pExpr, EP_TokenOnly ) );
      testcase( ExprHasProperty( pExpr, EP_Reduced ) );
      rc = pWalker.xExprCallback( pWalker, ref pExpr );
      if ( rc == WRC_Continue
      && !ExprHasAnyProperty( pExpr, EP_TokenOnly ) )
      {
        if ( sqlite3WalkExpr( pWalker, ref pExpr.pLeft ) != 0 )
          return WRC_Abort;
        if ( sqlite3WalkExpr( pWalker, ref pExpr.pRight ) != 0 )
          return WRC_Abort;
        if ( ExprHasProperty( pExpr, EP_xIsSelect ) )
        {
          if ( sqlite3WalkSelect( pWalker, pExpr.x.pSelect ) != 0 )
            return WRC_Abort;
        }
        else
        {
          if ( sqlite3WalkExprList( pWalker, pExpr.x.pList ) != 0 )
            return WRC_Abort;
        }
      }
      return rc & WRC_Abort;
    }

        public void TwoHopTrajectory()
        {
            this.walker = new Walker(new Board(5, 5));

            Coord from = new Coord(0, 3), to = new Coord(2, 1);
            this.AssertBestProbToArrive(from, to, 0.25f);
        }

 void WalkNodes(TreeNodeCollection nodes, Walker walker)
 {
     foreach (TreeNode n in nodes)
     {
         walker(n);
         WalkNodes(n.Nodes, walker);
     }
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         _function.Walk(walker);
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         foreach (var expr in _values)
             expr.Walk(walker);
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         _left.Walk(walker);
         _right.Walk(walker);
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         foreach (var v in _vars)
             v.Walk(walker);
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         if (_expression != null)
             _expression.Walk(walker);
     }
     walker.PostWalk(this);
 }

    void Awake()
    {
	    GameManager.instance.staff.Add(this);
	    remainingNames=new List<string>(nameArray);
	    walker = gameObject.AddComponent<Walker>();
	    staffRenderer=GetComponentInChildren<StaffRenderer>();
	    selectionArrow=GetComponentInChildren<Bounce>().gameObject;
	    selectionArrow.SetActive(false);
        assignmentProgress = -1;
    }

    void Awake()
    {
        GameManager.instance.jammers.Add(this);
	    walker = gameObject.AddComponent<Walker>();
	    walker.isJammer=true;
	    GenerateJammerName();

        trollStaff = gameObject.GetComponentInChildren<TrollStaff>();
        wifiProblem = gameObject.GetComponentInChildren<WiFiProblem>();
    }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         if (_target != null)
         {
             _target.Walk(walker);
         }
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         if (_expr != null)
         {
             _expr.Walk(walker);
         }
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         if (_defaultValue != null)
         {
             _defaultValue.Walk(walker);
         }
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         foreach (var val in _values)
         {
             val.Walk(walker);
         }
     }
     walker.PostWalk(this);
 }

 public override void Walk(Walker.TotemWalker walker)
 {
     if (walker.Walk(this))
     {
         _name.Walk(walker);
         if (_initializationValue != null)
         {
             _initializationValue.Walk(walker);
         }
     }
     walker.PostWalk(this);
 }