given a direction (one of the above two), move an 'advancer' to that location
171664
function (progress, adv) {
  if (progress) {
    var id = progress[0]
      , pos = progress[1]
      , insertM = this.findMatch(id);

    if (!insertM) {
      throw new Error('tournament corrupt: ' + id + ' not found!');
    }

    insertM.p[pos] = adv;
    if (insertM.p[(pos + 1) % 2] === WO) {
      insertM.m = (pos) ? [0, 1] : [1, 0]; // set WO map scores
      return insertM.id; // this id was won by adv on WO, inform
    }
  }
}
1081478
@Deprecated
  public Point2 move(Direction4 direction) {
    return new Point2(x + direction.dx, y + direction.dy);
  }
465458
private void moveVertical(int offset) {
        if (offset < 0) {
            moveUp(Math.abs(offset));
        } else if (offset > 0) {
            moveDown(offset);
        }
    }
1226768
def _move_datetime(dt, direction, delta):
    
    if direction == 'next':
        dt = dt + delta
    elif direction == 'last':
        dt = dt - delta
    else:
        pass
        # raise some delorean error here
    return dt
1106747
function ( direction ) {
			var current = F.current;

			if (current) {
				if (!isString(direction)) {
					direction = current.direction.prev;
				}

				F.jumpto(current.index - 1, direction, 'prev');
			}
		}
203939
def move_backward(self):
        """"""
        self.at(ardrone.at.pcmd, True, 0, self.speed, 0, 0)
397784
function rotateRelativeOffset([forward, right], direction) {
  verifyRelativeDirection(direction);

  if (direction === FORWARD) {
    return [forward, right];
  }

  if (direction === RIGHT) {
    return [-right, forward];
  }

  if (direction === BACKWARD) {
    return [-forward, -right];
  }

  return [right, -forward];
}
674522
def move_backward(self, seconds=None):
        """"""
        self._move(speed=-SPEED_MAX, steering=0, seconds=seconds)
754066
def _advance_frame(self):
        
        self.current_frame += 1
        if self.current_frame == self.frame_len:
            self.current_frame = 0
1288625
def move(self, x, y):
        
        self._x = int(round(x * 2, 0))
        self._y = int(round(y * 2, 0))
159279
public Location move(
            Angle bearing, 
            Velocity velocity, 
            RateOfTurn rateOfTurn, 
            TimeSpan timeSpan)
    {
        Location loc = copy();
        loc.moveIt(bearing, velocity, rateOfTurn, timeSpan);
        return loc;
    }
710045
private void moveTo(double extrp, int dx, int dy)
    {
        final Force force = getMovementForce(transformable.getX(), transformable.getY(), dx, dy);
        final double sx = force.getDirectionHorizontal();
        final double sy = force.getDirectionVertical();

        // Move object
        moveX = sx;
        moveY = sy;
        transformable.moveLocation(extrp, force);
        moving = true;

        // Object arrived, next step
        final boolean arrivedX = checkArrivedX(extrp, sx, dx);
        final boolean arrivedY = checkArrivedY(extrp, sy, dy);

        if (arrivedX && arrivedY)
        {
            // When object arrived on next step, we place it on step location, in order to avoid bug
            // (to be sure object location is correct)
            setLocation(path.getX(currentStep), path.getY(currentStep));

            // Go to next step
            final int next = currentStep + 1;
            if (currentStep < getMaxStep() - 1)
            {
                updateObjectId(currentStep, next);
            }
            if (!pathStoppedRequested && !skip)
            {
                currentStep = next;
            }
            // Check if a new path has been assigned (this allow the object to change its path before finishing it)
            if (currentStep > 0 && !skip)
            {
                checkPathfinderChanges();
            }
        }
    }
211602
def move(self, newX1) :
		""""""
		if self.x1 != None and self.x2 != None :
			offset = newX1-self.x1
			aux_moveTree(offset, self)
		elif len(self.children) > 0 :
			offset = newX1-self.children[0].x1
			aux_moveTree(offset, self)
803458
function ( index, direction, router ) {
			var current = F.current;

			if (!current) {
				return;
			}

			index = getScalar(index);

			F.direction = direction || current.direction[ (index >= current.index ? 'next' : 'prev') ];
			F.router    = router || 'jumpto';

			if (current.loop) {
				if (index < 0) {
					index = current.group.length + (index % current.group.length);
				}

				index = index % current.group.length;
			}

			if (current.group[ index ] !== undefined) {
				F.cancel();

				F._start(index);
			}
		}
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))
843790
def shift(self, direction):
        
        try:
            if direction == Direction.UP:
                return self.shift_up()
            elif direction == Direction.DOWN:
                return self.shift_down()
            elif direction == Direction.RIGHT:
                return self.shift_right()
            elif direction == Direction.LEFT:
                return self.shift_left()
            else:
                raise IndexError("Invalid direction {}".format(direction))
        except IndexError as e:
            raise IndexError(e)
469139
def move(self, pos):
        """"""

        try:
            payload = {"address":self.address, "user": self.user, "pwd": self.pswd, "pos": map_position(pos)}
            resp = requests.get(
                    "http://{address}/decoder_control.cgi?command={pos}&user={user}&pwd={pwd}".format(**payload)
            )
        except KeyError:
            raise CamException("Position must be within 1 to 16.")
        if resp.status_code != 200:
            raise CamException("Unauthorized. Wrong user or password.")
        return "ok"