internal NodeBase(INode parentNode, IMove move, float uctk, IPlayer player)
 {
     this.parent = parentNode;
     this.move = move;
     this.uctk = uctk;
     this.playerJustMoved = player;
 }

        public GameState Execute()
        {
            _numPushed = 0;
            _oldPieceToMove = _state.PieceToMove;
            _oldLastMove = _state.LastMove;
            _start = _piece.Position;

            int ystep = _end.Y - _start.Y;

            _state.BoardPositions[_piece.Position.Y][_piece.Position.X] = null;
            Piece currentPiece = _piece;
            while (_state.BoardPositions[currentPiece.Position.Y + ystep][currentPiece.Position.X] != null)
            {
                Piece next = _state.BoardPositions[currentPiece.Position.Y + ystep][currentPiece.Position.X];
                _state.BoardPositions[currentPiece.Position.Y + ystep][currentPiece.Position.X] = currentPiece;
                currentPiece.Position = new Point(currentPiece.Position.X, currentPiece.Position.Y + ystep);
                currentPiece = next;
                _numPushed++;
            }

            _state.BoardPositions[currentPiece.Position.Y + ystep][currentPiece.Position.X] = currentPiece;
            currentPiece.Position = new Point(currentPiece.Position.X, currentPiece.Position.Y + ystep);

            _state.IsPlayerTwo = !_state.IsPlayerTwo;
            _state.PieceToMove = currentPiece;
            _state.LastMove = this;

            List<IMove> possible = new List<IMove>();
            possible.Add(new SumoDazedMove(_state, currentPiece));
            _state.PossibleMoves = possible;

            return _state;
        }

        public override bool IsValidMove(IPlayer player, IMove move)
        {
            var checkersBoard = (CheckersBoard)CurrentGameState;
            var checkersMove = (CheckersMove)move;
            var checkersPlayer = (CheckersPlayer)player;
            var startPiece = (CheckersPiece)checkersBoard.GetPieceAt(checkersMove.MovePath[0]);

            if (startPiece==null) return false;
            if (startPiece.Color != checkersPlayer.Color) return false;

            int maxEat=0;
            bool eatMove=false;

            foreach (var piece in checkersBoard.GetPiecesOfColor(startPiece.Color))
            {
                var possibleMoves = piece.PossibleMoves;
                if (possibleMoves.Count > 0)
                {
                    var otherMove = possibleMoves[0] as CheckersMove;
                    if (maxEat < otherMove.MovePath.Length)
                    {
                        maxEat = otherMove.MovePath.Length;
                    }
                    if (otherMove.EatMove)
                        eatMove = true;
                }
            }

            bool isPossible = startPiece.PossibleMoves.Cast<CheckersMove>().Contains(checkersMove);
            return
                eatMove==checkersMove.EatMove &&
                checkersMove.MovePath.Length==maxEat &&
                isPossible;
        }

 internal Pouring(IReadOnlyList<int> capacities, IReadOnlyList<int> state, Pouring previous, IMove move)
 {
     Capacities = capacities;
     State = state;
     Move = move;
     Previous = previous;
 }

 protected Enter(Actor self, Actor target, int maxTries = 1, bool targetCenter = false)
 {
     this.move = self.Trait<IMove>();
     this.target = Target.FromActor(target);
     this.maxTries = maxTries;
     this.targetCenter = targetCenter;
 }

 public DeliverGoods(Actor self)
 {
     trader = self.Trait<Trader>();
     traderInfo = self.Info.Traits.Get<TraderInfo>();
     move = self.Trait<IMove>();
     pathFinder = self.World.WorldActor.Trait<IPathFinder>();
 }

        public Follow(Actor self, Target target, WRange minRange, WRange maxRange)
        {
            this.target = target;
            this.minRange = minRange;
            this.maxRange = maxRange;

            move = self.Trait<IMove>();
        }

 public LayMines(Actor self)
 {
     minelayer = self.TraitOrDefault<Minelayer>();
     info = self.Info.TraitInfo<MinelayerInfo>();
     ammoPools = self.TraitsImplementing<AmmoPool>().ToArray();
     movement = self.Trait<IMove>();
     rearmBuildings = info.RearmBuildings;
 }

 public Contrail(Actor self, ContrailInfo info)
 {
     contrailTurret = new Turret(info.ContrailOffset);
     history = new ContrailHistory(info.TrailLength,
         info.UsePlayerColor ? ContrailHistory.ChooseColor(self) : info.Color);
     facing = self.Trait<IFacing>();
     move = self.Trait<IMove>();
 }

 public Refuel(Actor self, Actor host)
 {
     move = self.TraitOrDefault<IMove>();
     this.host = host;
     target = Target.FromActor(host);
     refuels = host.TraitOrDefault<RefuelsUnits>();
     fueltank = self.TraitOrDefault<Fueltank>();
 }

		public Drag(Actor self, WPos start, WPos end, int length)
		{
			positionable = self.Trait<IPositionable>();
			movement = self.TraitOrDefault<IMove>();
			moveDisablers = self.TraitsImplementing<IDisableMove>().ToArray();
			this.start = start;
			this.end = end;
			this.length = length;
		}

 public PutShipsUserControl(IMove lvl)
 {
     InitializeComponent();
     computer = Computer.getInstance(lvl);
     DisableComputerBoard();
     computerShipsAdded = computer.PutComputerShips();
     MessageBox.AppendText("Dodano wszystkie statki przeciwnika.");
     MessageBox.AppendText(Environment.NewLine + "Proszę dodać dwumasztowy statek.");
 }

        public static Computer getInstance(IMove lvl)
        {
            if (instance == null)
            {
                instance = new Computer(lvl);
            }
            return instance;

        }

 public Drag(Actor self, WPos start, WPos end, int length)
 {
     positionable = self.Trait<IPositionable>();
     movement = self.TraitOrDefault<IMove>();
     disableable = movement as IDisabledTrait;
     this.start = start;
     this.end = end;
     this.length = length;
 }

        public Board(int[,] data, IMove move)
        {
            if (data == null) { throw new ArgumentNullException(nameof(data)); }

            _data = (int[,])data.Clone();
            _data[move.Row, move.Column] = move.Value;

            // Validate(_data);
        }

    protected virtual void Start()
    {
        this.moveBehaviour = this.GetComponent<IMove> ();
        if (this.moveBehaviour == null) {
            this.moveBehaviour = this.gameObject.AddComponent<EmptyMove> ();
        }

        this.moveBehaviour.Init (this.sea);
    }

 public bool CanMovePiece(IPlayer player, IBoard board, IMove move)
 {
     var context = new DefaultGameRuleStrategyContext();
     var canMovePiece = false;
     for (var strategy = this; !context.IsDone && !canMovePiece && strategy != null; strategy = strategy.next)
     {
         canMovePiece = strategy.CanStrategyMovePiece(player, board, move, context);
     }
     return canMovePiece;
 }

 internal SingleThreadedNode(INode parent, IMove move, IGameState gameState, float uctk)
     : base(parent, move, uctk, gameState.PlayerJustMoved)
 {
     this.wins = 0L;
     this.visits = 0L;
     this.childs = new List<INode>();
     var moves = gameState.GetMoves();
     var shuffled = moves.Shuffle();
     this.untriedMoves = new Stack<IMove>(shuffled); //randomize Moves
 }

        protected override bool CanStrategyMovePiece(IPlayer player, IBoard board, IMove move, IGameRuleStrategyContext context)
        {
            if (board.Bar.Any(x => x.Player == player.Name))
            {
                context.IsDone = true;
                return this.IsMoveValid(board, move.Die.Value, player.Name);
            }

            return false;
        }

 public PickupUnit(Actor self, Actor cargo)
 {
     this.cargo = cargo;
     carryable = cargo.Trait<Carryable>();
     cargoFacing = cargo.Trait<IFacing>();
     movement = self.Trait<IMove>();
     carryall = self.Trait<Carryall>();
     helicopter = self.Trait<Helicopter>();
     selfFacing = self.Trait<IFacing>();
     state = State.Intercept;
 }