sprite.java

这是j2me里MIDP2.0中game包的源代码

	    this.y = oldY -
		getTransformedPtY(dRefX, dRefY, this.t_currentTransformation);


	    // Calculate transformed sprites collision rectangle
	    // and transformed width and height

	    computeTransformedBounds(this.t_currentTransformation);

	} else {
	    // just reinitialize the animation frames.
	    initializeFrames(img, frameWidth, frameHeight, maintainCurFrame);
	}

    }

    /**
     * Defines the Sprite's bounding rectangle that is used for collision 
     * detection purposes.  This rectangle is specified relative to the 
     * un-transformed Sprite's upper-left corner and defines the area that is
     * checked for collision detection.  For pixel-level detection, only those
     * pixels within the collision rectangle are checked. 
     *
     * By default, a Sprite's collision rectangle is located at 0,0 as has the
     * same dimensions as the Sprite.  The collision rectangle may be 
     * specified to be larger or smaller than the default rectangle; if made 
     * larger, the pixels outside the bounds of the Sprite are considered to be
     * transparent for pixel-level collision detection.
     *
     * @param x the horizontal location of the collision rectangle relative to
     * the untransformed Sprite's left edge
     * @param y the vertical location of the collision rectangle relative to
     * the untransformed Sprite's top edge
     * @param width the width of the collision rectangle
     * @param height the height of the collision rectangle
     * @throws IllegalArgumentException if the specified
     * <code>width</code> or <code>height</code> is
     * less than <code>0</code>
     */
    public void defineCollisionRectangle(int x, int y, int width, int height) {

	if (width < 0 || height < 0) {
             throw new IllegalArgumentException();
	}

	collisionRectX = x;
	collisionRectY = y;
	collisionRectWidth = width;
	collisionRectHeight = height;

	// call set transform with current transformation to 
	// update transformed sprites collision rectangle
	setTransformImpl(t_currentTransformation);
    }

    /**
     * Sets the transform for this Sprite.  Transforms can be 
     * applied to a Sprite to change its rendered appearance.  Transforms 
     * are applied to the original Sprite image; they are not cumulative, 
     * nor can they be combined.  By default, a Sprite's transform is 
     * {@link #TRANS_NONE}.
     * <P>
     * Since some transforms involve rotations of 90 or 270 degrees, their
     * use may result in the overall width and height of the Sprite 
     * being swapped.  As a result, the values returned by 
     * {@link Layer#getWidth} and {@link Layer#getHeight} may change.
     * <p>
     * The collision rectangle is also modified by the transform so that
     * it remains static relative to the pixel data of the Sprite.  
     * Similarly, the defined reference pixel is unchanged by this method,
     * but its visual location within the Sprite may change as a result.
     * <P>
     * This method repositions the Sprite so that the location of 
     * the reference pixel in the painter's coordinate system does not change
     * as a result of changing the transform.  Thus, the reference pixel 
     * effectively becomes the centerpoint for the transform.  Consequently,
     * the values returned by {@link #getRefPixelX} and {@link #getRefPixelY} 
     * will be the same both before and after the transform is applied, but 
     * the values returned by {@link #getX getX()} and {@link #getY getY()}
     * may change.  
     * <p>
     * @param transform the desired transform for this <code>Sprite</code>
     * @throws IllegalArgumentException if the requested
     * <code>transform</code> is invalid
     * @see #TRANS_NONE
     * @see #TRANS_ROT90
     * @see #TRANS_ROT180
     * @see #TRANS_ROT270
     * @see #TRANS_MIRROR
     * @see #TRANS_MIRROR_ROT90
     * @see #TRANS_MIRROR_ROT180
     * @see #TRANS_MIRROR_ROT270
     *
     */
    public void setTransform(int transform) {
	setTransformImpl(transform);
    }

    /**
     * Checks for a collision between this Sprite and the specified Sprite.
     * <P>
     * If pixel-level detection is used, a collision is detected only if
     * opaque pixels collide.  That is, an opaque pixel in the first
     * Sprite would have to collide with an opaque  pixel in the second
     * Sprite for a collision to be detected.  Only those pixels within
     * the Sprites' respective collision rectangles are checked.
     * <P>
     * If pixel-level detection is not used, this method simply
     * checks if the Sprites' collision rectangles intersect.
     * <P>
     * Any transforms applied to the Sprites are automatically accounted for.
     * <P>
     * Both Sprites must be visible in order for a collision to be
     * detected.
     * <P>
     * @param s the <code>Sprite</code> to test for collision with
     * @param pixelLevel <code>true</code> to test for collision on a
     * pixel-by-pixel basis, <code>false</code> to test using simple
     * bounds checking.
     * @return <code>true</code> if the two Sprites have collided, otherwise
     * <code>false</code>
     * @throws NullPointerException if Sprite <code>s</code> is 
     * <code>null</code>
     */
    public final boolean collidesWith(Sprite s, boolean pixelLevel) 
    {
        
        // check if either of the Sprite's are not visible
        if (!(s.visible && this.visible)) {
            return false;
        }

	// these are package private 
	// and can be accessed directly
        int otherLeft    = s.x + s.t_collisionRectX;
        int otherTop     = s.y + s.t_collisionRectY;
        int otherRight   = otherLeft + s.t_collisionRectWidth;
        int otherBottom  = otherTop  + s.t_collisionRectHeight;

	int left   = this.x + this.t_collisionRectX;
	int top    = this.y + this.t_collisionRectY;
	int right  = left + this.t_collisionRectWidth;
	int bottom = top  + this.t_collisionRectHeight;

	// check if the collision rectangles of the two sprites intersect
	if (intersectRect(otherLeft, otherTop, otherRight, otherBottom,
			  left, top, right, bottom)) {

	    // collision rectangles intersect
	    if (pixelLevel) {

		// we need to check pixel level collision detection.
		// use only the coordinates within the Sprite frame if 
		// the collision rectangle is larger than the Sprite 
		// frame 
		if (this.t_collisionRectX < 0) {
		    left = this.x;
		}
		if (this.t_collisionRectY < 0) {
		    top = this.y;
		}
		if ((this.t_collisionRectX + this.t_collisionRectWidth)
		    > this.width) {
		    right = this.x + this.width;
		}
		if ((this.t_collisionRectY + this.t_collisionRectHeight)
		    > this.height) {
		    bottom = this.y + this.height;
		}

		// similarly for the other Sprite
		if (s.t_collisionRectX < 0) {
		    otherLeft = s.x;
		}
		if (s.t_collisionRectY < 0) {
		    otherTop = s.y;
		}
		if ((s.t_collisionRectX + s.t_collisionRectWidth)
		    > s.width) {
		    otherRight = s.x + s.width;
		}
		if ((s.t_collisionRectY + s.t_collisionRectHeight)
		    > s.height) {
		    otherBottom = s.y + s.height;
		}

		// recheck if the updated collision area rectangles intersect
		if (!intersectRect(otherLeft, otherTop, otherRight, otherBottom,
				  left, top, right, bottom)) {

		    // if they don't intersect, return false;
		    return false;
		}

		// the updated collision rectangles intersect,
		// go ahead with collision detection


		// find intersecting region, 
		// within the collision rectangles
		int intersectLeft = (left < otherLeft) ? otherLeft : left;
		int intersectTop  = (top < otherTop) ? otherTop : top;

		// used once, optimize.
		int intersectRight  = (right < otherRight) 
		                      ? right : otherRight;
		int intersectBottom = (bottom < otherBottom) 
		                      ? bottom : otherBottom;

		int intersectWidth  = Math.abs(intersectRight - intersectLeft);
		int intersectHeight = Math.abs(intersectBottom - intersectTop);

		// have the coordinates in painter space,
		// need coordinates of top left and width, height
		// in source image of Sprite.
		
		int thisImageXOffset = getImageTopLeftX(intersectLeft, 
							intersectTop,
							intersectRight,
							intersectBottom);
		
		int thisImageYOffset = getImageTopLeftY(intersectLeft, 
							intersectTop,
							intersectRight,
							intersectBottom);

		int otherImageXOffset = s.getImageTopLeftX(intersectLeft, 
							   intersectTop,
							   intersectRight,
							   intersectBottom);
		
		int otherImageYOffset = s.getImageTopLeftY(intersectLeft, 
							   intersectTop,
							   intersectRight,
							   intersectBottom);

		// check if opaque pixels intersect.

		return doPixelCollision(thisImageXOffset, thisImageYOffset,
					otherImageXOffset, otherImageYOffset,
					this.sourceImage,
					this.t_currentTransformation,
					s.sourceImage, 
					s.t_currentTransformation,
					intersectWidth, intersectHeight);

	    } else {
		// collides!
		return true;
	    }
	}
        return false;

    }

    /**
     * Checks for a collision between this Sprite and the specified
     * TiledLayer.  If pixel-level detection is used, a collision is
     * detected only if opaque pixels collide.  That is, an opaque pixel in
     * the Sprite would have to collide with an opaque pixel in TiledLayer
     * for a collision to be detected.  Only those pixels within the Sprite's
     * collision rectangle are checked.
     * <P>
     * If pixel-level detection is not used, this method simply checks if the
     * Sprite's collision rectangle intersects with a non-empty cell in the
     * TiledLayer.
     * <P>
     * Any transform applied to the Sprite is automatically accounted for.
     * <P>
     * The Sprite and the TiledLayer must both be visible in order for
     * a collision to be detected.
     * <P>
     * @param t the <code>TiledLayer</code> to test for collision with
     * @param pixelLevel <code>true</code> to test for collision on a
     * pixel-by-pixel basis, <code>false</code> to test using simple bounds
     * checking against non-empty cells.
     * @return <code>true</code> if this <code>Sprite</code> has
     * collided with the <code>TiledLayer</code>, otherwise
     * <code>false</code>
     * @throws NullPointerException if <code>t</code> is <code>null</code>
     */
    public final boolean collidesWith(TiledLayer t, boolean pixelLevel) {

	// check if either this Sprite or the TiledLayer is not visible
	if (!(t.visible && this.visible)) {
	    return false;
	}

        // dimensions of tiledLayer, cell, and
        // this Sprite's collision rectangle

        // these are package private 
        // and can be accessed directly
        int tLx1 = t.x;
        int tLy1 = t.y;
        int tLx2 = tLx1 + t.width;
        int tLy2 = tLy1 + t.height;

        int tW = t.getCellWidth();
        int tH = t.getCellHeight();

        int sx1 = this.x + this.t_collisionRectX;
        int sy1 = this.y + this.t_collisionRectY;
        int sx2 = sx1 + this.t_collisionRectWidth;
        int sy2 = sy1 + this.t_collisionRectHeight;

        // number of cells
        int tNumCols = t.getColumns();
        int tNumRows = t.getRows();

        // temporary loop variables.
        int startCol; // = 0;
        int endCol;   // = 0;
        int startRow; // = 0;
        int endRow;   // = 0;

        if (!intersectRect(tLx1, tLy1, tLx2, tLy2, sx1, sy1, sx2, sy2)) {
            // if the collision rectangle of the sprite
            // does not intersect with the dimensions of the entire 
            // tiled layer
            return false;
        }

        // so there is an intersection

            // note sx1 < sx2, tLx1 < tLx2, sx2 > tLx1  from intersectRect()
            // use <= for comparison as this saves us some
            // computation - the result will be 0
            startCol = (sx1 <= tLx1) ? 0 : (sx1 - tLx1)/tW;
            startRow = (sy1 <= tLy1) ? 0 : (sy1 - tLy1)/tH;
            // since tLx1 < sx2 < tLx2, the computation will yield
            // a result between 0 and tNumCols - 1
            // subtract by 1 because sx2,sy2 represent
            // the enclosing bounds of the sprite, not the 
            // locations in the coordinate system.
            endCol = (sx2 < tLx2) ? ((sx2 - 1 - tLx1)/tW) : tNumCols - 1;
            endRow = (sy2 < tLy2) ? ((sy2 - 1 - tLy1)/tH) : tNumRows - 1;

        if (!pixelLevel) {
            // check for intersection with a non-empty cell,
            for (int row = startRow; row <= endRow; row++) {
                for (int col = startCol; col <= endCol; col++) {
                    if (t.getCell(col, row) != 0) {
                        return true;
                    }
                }
            }
            // worst case! we scanned through entire 
            // overlapping region and
            // all the cells are empty!
            return false;
        } else {
            // do pixel level

            // we need to check pixel level collision detection.
            // use only the coordinates within the Sprite frame if 
            // the collision rectangle is larger than the Sprite 
            // frame 
            if (this.t_collisionRectX < 0) {
                sx1 = this.x;
            }
            if (this.t_collisionRectY < 0) {
                sy1 = this.y;
            }
            if ((this.t_collisionRectX + this.t_collisionRectWidth)
                > this.width) {
                sx2 = this.x + this.width;
            }
            if ((this.t_collisionRectY + this.t_collisionRectHeight)
                > this.height) {
                sy2 = this.y + this.height;
            }