move : (normalmove | specialmove) time? comment*
333576
def parse_move
      s0 = @current_pos
      s1 = parse_normal_move
      s1 = parse_special_move if s1 == :failed
      if s1 != :failed
        s2 = parse_time
        s2 = nil if s2 == :failed
        s3 = parse_comments
        @reported_pos = s0
        s0 = -> (move, time, comments) do
          ret = {}
          ret["comments"] = comments if !comments.empty?
          ret["time"] = time if time
          if move["special"]
            ret["special"] = move["special"]
          else
            ret["move"] = move
          end
          ret
        end.call(s1, s2, s3)
      else
        @current_pos = s0
        s0 = :failed
      end
      s0
    end
907353
function gestureMove(ev) {
    if (!pointer || !typesMatch(ev, pointer)) return;

    updatePointerState(ev, pointer);
    runHandlers('move', ev);
  }
1174779
function getGameBeforeLastMove(game) {
    // $Fix I do NOT know if it is the best way to make game immutable.
    game = Object.assign({}, game);
    let lastMove = game.moves.pop();
    if (lastMove)
        game = getGameAfterMove(game, getBackMove(lastMove), true);
    if (Game.getPlayerTurn(game).isAi) {
        lastMove = game.moves.pop();
        if (lastMove) {
            game = getGameAfterMove(game, getBackMove(lastMove), true);
        }
    }
    return game;
}
1257474
function getGameAfterMove(game, move, backMove = false) {
    if (!backMove && canNotMove(game, move))
        return game;
    const board = getBoardAfterMove(game.board, move);
    return {
        players: game.players,
        board,
        score: Score.getScore(game.board),
        moves: backMove ? game.moves : game.moves.concat(getMoveXAndY(move))
    };
}
1223869
def goto_position(self, position, duration, control=None, wait=False):
        

        if control is None:
            control = self.goto_behavior

        if control == 'minjerk':
            goto_min_jerk = GotoMinJerk(self, position, duration)
            goto_min_jerk.start()
            if wait:
                goto_min_jerk.wait_to_stop()

        elif control == 'dummy':
            dp = abs(self.present_position - position)
            speed = (dp / float(duration)) if duration > 0 else numpy.inf

            self.moving_speed = speed
            self.goal_position = position

            if wait:
                time.sleep(duration)
293078
function getMoveFromArray(move) {
    return {
        from: Position.getPositionFromArray(move[0]),
        to: Position.getPositionFromArray(move[1])
    };
}
371991
def move_position(self, dx, dy, speed=None):
        ''' '''
        if speed:
            self._intf.write('MoveChuckPosition %1.1f %1.1f R Y %d' % (dx, dy, speed))
        else:
            self._intf.write('MoveChuckPosition %1.1f %1.1f R Y' % (dx, dy))
929837
def shift_up_left(self, times=1):
        
        try:
            return Location(self._rank + times, self._file - times)
        except IndexError as e:
            raise IndexError(e)
955266
public int moveIt(boolean bDisplayOption, int iMoveMode)
    {
        ((BaseField)m_fldDest.getField()).setEnabled(!this.getOwner().getState());
        if (iMoveMode != DBConstants.SCREEN_MOVE)
            return DBConstants.NORMAL_RETURN;
        if (this.getOwner().getState() == false)
        {
            if (bDisplayOption)
                ((BaseField)m_fldDest.getField()).displayField();   // Redisplay
            return DBConstants.NORMAL_RETURN;
        }
        else
            return super.moveIt(bDisplayOption, iMoveMode); // Move it!
    }
1088458
def move_left(self):
        """"""
        self.at(ardrone.at.pcmd, True, -self.speed, 0, 0, 0)
1203556
def parse_move
      s0 = @current_pos
      s1 = parse_line
      if s1 != :failed
        s2 = []
        s3 = parse_comment
        while s3 != :failed
          s2 << s3
          s3 = parse_comment
        end
        parse_pointer
        s4 = []
        s5 = parse_nl
        s5 = match_space if s5 == :failed
        while s5 != :failed
          s4 << s5
          s5 = parse_nl
          s5 = match_space if s5 == :failed
        end
        @reported_pos = s0
        s0 = -> (line, c) do
          ret = { "move" => line }
          ret["comments"] = c if !c.empty?
          ret
        end.call(s1, s2)
      else
        @current_pos = s0
        s0 = :failed
      end

      s0
    end
420748
def suggest_move(self, position):
        
        start = time.time()

        if self.timed_match:
            while time.time() - start < self.seconds_per_move:
                self.tree_search()
        else:
            current_readouts = self.root.N
            while self.root.N < current_readouts + self.num_readouts:
                self.tree_search()
            if self.verbosity > 0:
                dbg("%d: Searched %d times in %.2f seconds\n\n" % (
                    position.n, self.num_readouts, time.time() - start))

        # print some stats on moves considered.
        if self.verbosity > 2:
            dbg(self.root.describe())
            dbg('\n\n')
        if self.verbosity > 3:
            dbg(self.root.position)

        return self.pick_move()
119514
def move(self, dst):
        ""
        self.close()
        shutil.move(self.path, dst)
1011377
def move(self, dst):
        """"""
        shutil.move(self, dst)
        self = PathStr(dst).join(self.basename())
        return self
616638
function Motion (config) {
  this.v = config.v || 0
  this.a = config.a || 0

  if (typeof config.t !== 'undefined') {
    this.t = config.t
  }

  if (typeof config.s !== 'undefined') {
    this.s = config.s
  }

  // derive time from shifting
  if (typeof this.t === 'undefined') {
    if (typeof this.s === 'undefined') {
      this.t = -this.v / this.a
    }
    else {
      const t1 = (Math.sqrt(this.v * this.v + 2 * this.a * this.s) - this.v)
        / this.a
      const t2 = (-Math.sqrt(this.v * this.v + 2 * this.a * this.s) - this.v)
        / this.a
      this.t = Math.min(t1, t2)
    }
  }

  // derive shifting from time
  if (typeof this.s === 'undefined') {
    this.s = this.a * this.t * this.t / 2 + this.v * this.t
  }
}
48368
def pivot(self, speed, durationS=-1.0):
        
        if speed < 0:
            self.left_fwd(min(abs(speed), 255))
            self.right_rev(min(abs(speed), 255))
        else:
            self.left_rev(min(abs(speed), 255))
            self.right_fwd(min(abs(speed), 255))
        if durationS > 0:
            self.board.sleep(durationS)
            self.left_stop()
            self.right_stop()
654030
def bestmove(self):
        
        self.go()
        last_info = ""
        while True:
            text = self.stdout.readline().strip()
            split_text = text.split(' ')
            print(text)
            if split_text[0] == "info":
                last_info = Engine._bestmove_get_info(text)
            if split_text[0] == "bestmove":
                ponder = None if len(split_text[0]) < 3 else split_text[3]
                return {'move': split_text[1],
                        'ponder': ponder,
                        'info': last_info}