Try to move in the direction specified. If it's blocked, try sliding. If that
doesn't work just don't bother

@param x The amount on the X axis to move
@param y The amount on the Y axis to move
@return True if we managed to move
328722
private boolean tryMove(float x, float y) {
		float newx = playerX + x;
		float newy = playerY + y;
		
		// first we try the real move, if that doesn't work
		// we try moving on just one of the axis (X and then Y) 
		// this allows us to slide against edges
		if (blocked(newx,newy)) {
			if (blocked(newx, playerY)) {
				if (blocked(playerX, newy)) {
					// can't move at all!
					return false;
				} else {
					playerY = newy;
					return true;
				}
			} else {
				playerX = newx;
				return true;
			}
		} else {
			playerX = newx;
			playerY = newy;
			return true;
		}
	}
1033358
function moveTo_(x, y, prevent) {
    var roundedIntervalX_, roundedIntervalY_;
    left_ = Math.round(x);
    top_ = Math.round(y);
    if (opt_drag_.intervalX>1) {
      roundedIntervalX_ = Math.round(left_%opt_drag_.intervalX);
      left_ = (roundedIntervalX_<halfIntervalX_)?(left_-roundedIntervalX_):(left_+(opt_drag_.intervalX-roundedIntervalX_));
    }
    if (opt_drag_.intervalY>1) {
      roundedIntervalY_ = Math.round(top_%opt_drag_.intervalY);
      top_ = (roundedIntervalY_<halfIntervalY_)?(top_-roundedIntervalY_):(top_+(opt_drag_.intervalY-roundedIntervalY_));
    }
    if (opt_drag_.container&&opt_drag_.container.offsetWidth) {
      left_ = Math.max(0,Math.min(left_,opt_drag_.container.offsetWidth-src.offsetWidth));
      top_ = Math.max(0,Math.min(top_,opt_drag_.container.offsetHeight-src.offsetHeight));
    }
    if (typeof currentX_ === "number") {
      if (((left_-currentX_)>opt_drag_.toleranceX||(currentX_-(left_+src.offsetWidth))>opt_drag_.toleranceX)||((top_-currentY_)>opt_drag_.toleranceY||(currentY_-(top_+src.offsetHeight))>opt_drag_.toleranceY)) {
        left_ = originalX_;
        top_ = originalY_;
      }
    }
    if(!opt_drag_.restrictX&&!prevent) {
      src.style.left = left_ + "px";
    }
    if(!opt_drag_.restrictY&&!prevent) {
      src.style.top = top_ + "px";
    }
  }
1152991
public void setPosition(float x, float y, boolean moveParticles) {
		if (moveParticles) {
			adjust = true;
			adjustx -= this.x - x;
			adjusty -= this.y - y;
		}
		this.x = x;
		this.y = y;		
	}
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();
            }
        }
    }
567484
def move(self, x, y):
        
        if not isinstance(x, baseinteger):
            raise TypeError("x can only be an instance of type baseinteger")
        if not isinstance(y, baseinteger):
            raise TypeError("y can only be an instance of type baseinteger")
        self._call("move",
                     in_p=[x, y])
972116
function(){
            var startDir = this.currentDirection,
                currentDir = this.currentDirection;

            var i = 0;
            while(i < 6){
                i++;
                var currentDirAdjustCoords = this.directionToAdjustCoord(currentDir),
                    targetX = this.x + currentDirAdjustCoords.x,
                    targetY = this.y + currentDirAdjustCoords.y;

                if(this.canMoveTo(targetX, targetY)){
                    this.currentDirection = currentDir;
                    this.moveTo(targetX, targetY);
                    return;
                }
                currentDir = this.getNextDirection(currentDir);
                // give up if all directions attempted
                if(currentDir === startDir){
                    return false;
                }
            }
        }
559642
def move(self, x, y):
        
        self._cursor = self._normalizePoint(x, y)
159490
def move_to(x, y):
    
    _make_cnc_request("coord/{0}/{1}".format(x, y))
    state['turtle'].goto(x, y)
118874
def move_mouse(x_delta, y_delta)
      send_request RequestMessage.new(mouse_event_message: MouseEvent.new(x_delta: x_delta, y_delta: y_delta))
    end
745702
public void moveCoordinate(Coordinate coordinate, int index) {
		if (index < coordinates.length) {
			coordinates[index] = (Coordinate) coordinate.clone();
		}
		setCoordinates(coordinates);
	}
173104
@Override
    public void move(final double dx, final double dy, final boolean midPointsOnly, final boolean moveLinePoints)
    {
        final IControlHandleList handles = m_connector.getPointHandles();

        int start = 0;

        int end = handles.size();

        if (midPointsOnly)
        {
            if (m_connector.getHeadConnection().getMagnet() != null)
            {
                start++;
            }
            if (m_connector.getTailConnection().getMagnet() != null)
            {
                end--;
            }
        }
        final Point2DArray points = m_connector.getLine().getPoint2DArray();

        for (int i = start, j = (start == 0) ? start : 2; i < end; i++, j += 2)
        {
            if (moveLinePoints)
            {
                final Point2D p = points.get(i);

                p.setX(m_startPoints.get(j) + dx);

                p.setY(m_startPoints.get(j + 1) + dy);
            }
            final IControlHandle h = handles.getHandle(i);

            final IPrimitive<?> prim = h.getControl();

            prim.setX(m_startPoints.get(j) + dx);

            prim.setY(m_startPoints.get(j + 1) + dy);
        }
        if (moveLinePoints)
        {
            m_connector.getLine().refresh();
        }
        m_wiresManager.getLayer().getLayer().batch();
    }
1303977
public void setDirection (float x, float y, float z)
    {
        if (_source != null) {
            _source.setDirection(x, y, z);
        }
        _dx = x;
        _dy = y;
        _dz = z;
    }
984405
public void setPosition(int x,int y) {
		int cx = (xoffset.getMin() + xoffset.getMax()) / 2;
		int cy = (yoffset.getMin() + yoffset.getMax()) / 2;
		
		int dx = x - cx;
		int dy = y - cy;
		
		xoffset.setMin(xoffset.getMin() + dx);
		xoffset.setMax(xoffset.getMax() + dx);
		yoffset.setMin(yoffset.getMin() + dy);
		yoffset.setMax(yoffset.getMax() + dy);
		
		xoffset.fireUpdated(null);
		yoffset.fireUpdated(null);
	}
133664
public SVGPath moveTo(double x, double y) {
    return append(PATH_MOVE).append(x).append(y);
  }
492433
function getDirection(x, y) {
  if (x === y) {
    return DIRECTION_NONE;
  }

  if (abs(x) >= abs(y)) {
    return x > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
  }
  return y > 0 ? DIRECTION_UP : DIRECTION_DOWN;
}
114825
public boolean mouseMove(Event e, int x, int y) {

        if (y <= iRowHeight) {
            int xb = x;

            x += iX - iGridWidth;

            int i = iColCount - 1;

            for (; i >= 0; i--) {
                if (x > -7 && x < 7) {
                    break;
                }

                x += iColWidth[i];
            }

            if (i >= 0) {
                if (!bDrag) {
                    setCursor(new Cursor(Cursor.E_RESIZE_CURSOR));

                    bDrag    = true;
                    iXDrag   = xb - iColWidth[i];
                    iColDrag = i;
                }

                return true;
            }
        }

        return mouseExit(e, x, y);
    }
873435
public void setDirection(final int DIRECTION) {
        switch (DIRECTION) {
            case SwingUtilities.SOUTH:
                direction = SwingUtilities.SOUTH;
                break;
            case SwingUtilities.EAST:
                direction = SwingUtilities.EAST;
                break;
            case SwingUtilities.WEST:
                direction = SwingUtilities.WEST;
                break;
            case SwingUtilities.NORTH:
            default:
                direction = SwingUtilities.NORTH;
                break;
        }
        repaint(getInnerBounds());
    }