package ch04.common;

public class Rectangle {

    public int x;
    public int y;
    public int width;
    public int height;

    public Rectangle() {
        this(0, 0, 0, 0);
    }

/**
     * Constructs a new <code>Rectangle</code> whose top-left corner is
     * specified as (<code>x</code>,&nbsp;<code>y</code>) and whose width
     * and height are specified by the arguments of the same name.
     *
     * @param x
     *            the specified x coordinate
     * @param y
     *            the specified y coordinate
     * @param width
     *            the width of the <code>Rectangle</code>
     * @param height
     *            the height of the <code>Rectangle</code>
     */
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }

    public boolean contains(int X, int Y, int W, int H) {
        int w = this.width;
        int h = this.height;

        if ((w | h | W | H) < 0) {
            // At least one of the dimensions is negative...
            return false;
        }
        // Note: if any dimension is zero, tests below must return false...
        int x = this.x;
        int y = this.y;
        if (X < x || Y < y) {
            return false;
        }
        w += x;
        W += X;
        if (W <= X) {
            // X+W overflowed or W was zero, return false if...
            // either original w or W was zero or
            // x+w did not overflow or
            // the overflowed x+w is smaller than the overflowed X+W
            if (w >= x || W > w) {
                return false;
            }
        } else {
            // X+W did not overflow and W was not zero, return false if...
            // original w was zero or

// x+w did not overflow and x+w is smaller than X+W
            if (w >= x && W > w) {
                return false;
            }
        }
        h += y;
        H += Y;
        if (H <= Y) {
            if (h >= y || H > h) {
                return false;
            }
        } else {
            if (h >= y && H > h) {
                return false;
            }
        }
        return true;
    }

    public boolean contains(int x, int y) {
        return inside(x, y);
    }

    public boolean inside(int X, int Y) {
        int w = this.width;
        int h = this.height;
        if ((w | h) < 0) {
            // At least one of the dimensions is negative...
            return false;
        }
        // Note: if either dimension is zero, tests below must return false...
        int x = this.x;
        int y = this.y;
        if (X < x || Y < y) {
            return false;
        }
        w += x;
        h += y;
        // overflow || intersect
        return ((w < x || w > X) && (h < y || h > Y));
    }
}

package ch04.common;

public class Polygon {

    public int npoints;
    public int[] ypoints;
    public int[] xpoints;

    protected Rectangle bounds;

    public Polygon() {
        xpoints = new int[4];
        ypoints = new int[4];
    }

    public Polygon(int xpoints[], int ypoints[], int npoints) {
        // Fix 4489009: should throw IndexOutofBoundsException instead
        // of OutofMemoryException if npoints is huge
        // and > {x,y}points.length
        if (npoints > xpoints.length || npoints > ypoints.length) {
            throw new IndexOutOfBoundsException(
                    "npoints > xpoints.length || npoints > ypoints.length");
        }

this.npoints = npoints;
        this.xpoints = new int[npoints];
        this.ypoints = new int[npoints];
        System.arraycopy(xpoints, 0, this.xpoints, 0, npoints);
        System.arraycopy(ypoints, 0, this.ypoints, 0, npoints);
    }

    void calculateBounds(int xpoints[], int ypoints[], int npoints) {
        int boundsMinX = Integer.MAX_VALUE;
        int boundsMinY = Integer.MAX_VALUE;
        int boundsMaxX = Integer.MIN_VALUE;
        int boundsMaxY = Integer.MIN_VALUE;

        for (int i = 0; i < npoints; i++) {
            int x = xpoints[i];
            boundsMinX = Math.min(boundsMinX, x);
            boundsMaxX = Math.max(boundsMaxX, x);
            int y = ypoints[i];
            boundsMinY = Math.min(boundsMinY, y);
            boundsMaxY = Math.max(boundsMaxY, y);
        }

        bounds = new Rectangle(boundsMinX, boundsMinY, boundsMaxX
                - boundsMinX, boundsMaxY - boundsMinY);
    }

    public void reset() {
        npoints = 0;
        bounds = null;
    }

    /**
     * Appends the specified coordinates to this <code>Polygon</code>.
     *
     * @param x
     * @param y
     */
    public void addPoint(int x, int y) {
        if (npoints == xpoints.length) {
            int tmp[];

            tmp = new int[npoints * 2];
            System.arraycopy(xpoints, 0, tmp, 0, npoints);
            xpoints = tmp;

            tmp = new int[npoints * 2];
            System.arraycopy(ypoints, 0, tmp, 0, npoints);
            ypoints = tmp;
        }
        xpoints[npoints] = x;
        ypoints[npoints] = y;

npoints++;
        if (bounds != null) {
            updateBounds(x, y);
        }
    }

    void updateBounds(int x, int y) {
        if (x < bounds.x) {
            bounds.width = bounds.width + (bounds.x - x);
            bounds.x = x;
        } else {
            bounds.width = Math.max(bounds.width, x - bounds.x);
        }

        if (y < bounds.y) {
            bounds.height = bounds.height + (bounds.y - y);
            bounds.y = y;
        } else {
            bounds.height = Math.max(bounds.height, y - bounds.y);
        }
    }

    public Rectangle getBoundingBox() {
        if (npoints == 0) {
            return new Rectangle();
        }
        if (bounds == null) {
            calculateBounds(xpoints, ypoints, npoints);
        }
        return bounds;
    }

    /**
     * Determines if the specified coordinates are inside this
     * <code>Polygon</code>.
     *
     * @param x
     * @param y
     * @return
     */
    public boolean contains(int x, int y) {
        if (npoints <= 2 || !getBoundingBox().contains(x, y)) {
            return false;
        }
        int hits = 0;

        int lastx = xpoints[npoints − 1];
        int lasty = ypoints[npoints − 1];
        int curx, cury;

// Walk the edges of the polygon
        for (int i = 0; i < npoints; lastx = curx, lasty = cury, i++) {
            curx = xpoints[i];
            cury = ypoints[i];

            if (cury == lasty) {
                continue;
            }

            int leftx;
            if (curx < lastx) {
                if (x >= lastx) {
                    continue;
                }
                leftx = curx;
            } else {
                if (x >= curx) {
                    continue;
                }
                leftx = lastx;
            }

            double test1, test2;
            if (cury < lasty) {
                if (y < cury || y >= lasty) {
                    continue;
                }
                if (x < leftx) {
                    hits++;
                    continue;
                }
                test1 = x - curx;
                test2 = y - cury;
            } else {
                if (y < lasty || y >= cury) {
                    continue;
                }
                if (x < leftx) {
                    hits++;
                    continue;
                }
                test1 = x - lastx;
                test2 = y - lasty;
            }

            if (test1 < (test2 / (lasty - cury) * (lastx - curx))) {
                hits++;
            }
        }

return ((hits & 1) != 0);
    }

    @Override
    public String toString() {
        if (npoints == 0)
            return null;
        String s = ""; //

        for (int i = 0; i < xpoints.length; i++) {
            s += "(" + xpoints[i] + "," + ypoints[i] + ") ";
        }
        return s;
    }

    /**
     * Get polygon points (x0y0, x1y1,.....) for rendering Each point pair will
     * render 1 line so the total # of points must be num sides * 4
     *
     * @return
     */
    public float[] getPoints() {
        int size = npoints * 4;
        float[] points = new float[size];
        int j = 1;

        if (size == 0 || xpoints == null || ypoints == null)
            return null;

        points[0] = xpoints[0];
        points[1] = ypoints[0];

        for (int i = 2; i < points.length − 2; i += 4) {

            points[i] = xpoints[j];
            points[i + 1] = ypoints[j];
            points[i + 2] = xpoints[j];
            points[i + 3] = ypoints[j];
            j++;
        }
        points[size − 2] = xpoints[0];
        points[size − 1] = ypoints[0];

        return points;
    }
}

package ch04.game;

import ch04.common.Polygon;
import android.graphics.Canvas;
import android.graphics.Paint;

/************************************************************
 * The PolygonSprite class defines a game object, including it's shape,
 * position, movement and rotation. It also can determine if two objects
 * collide.
 ************************************************************/

public class PolygonSprite
{

    // Base sprite shape, centered at the origin (0,0).
    public Polygon shape;

    // Final location and shape of sprite after
    // applying rotation and translation to get screen
    // position. Used for drawing on the screen and in
    // detecting collisions.
    public Polygon sprite;

    boolean active; // Active flag.
    double angle; // Current angle of rotation.
    double deltaAngle; // Amount to change the rotation angle.
    double deltaX, deltaY; // Amount to change the screen position.

    // coords
    int x;
    int y;

    // Constructors:

public PolygonSprite() {

        this.shape = new Polygon();
        this.active = false;
        this.angle = 0.0;
        this.deltaAngle = 0.0;
        this.x = 0;
        this.y = 0;
        this.deltaX = 0.0;
        this.deltaY = 0.0;
        this.sprite = new Polygon();
    }

    public void render(int width, int height) {

        int i;

        // Render the sprite's shape and location by rotating it's
        // base shape and moving it to its proper screen position.

        this.sprite = new Polygon();
        for (i = 0; i < this.shape.npoints; i++) {
            this.sprite.addPoint((int) Math.round(this.shape.xpoints[i]
                    * Math.cos(this.angle) + this.shape.ypoints[i]
                    * Math.sin(this.angle))
                    + (int) Math.round(this.x) + width / 2,
                    (int) Math.round(this.shape.ypoints[i]
                            * Math.cos(this.angle) - this.shape.xpoints[i]
                            * Math.sin(this.angle))
                            + (int) Math.round(this.y) + height / 2);
        }
    }

    public boolean isColliding(PolygonSprite s) {

        int i;

        // Determine if one sprite overlaps with another, i.e., if any vertice
        // of one sprite lands inside the other.

        for (i = 0; i < s.sprite.npoints; i++) {
            if (this.sprite.contains(s.sprite.xpoints[i],
                    s.sprite.ypoints[i])) {
                return true;
            }
        }
        for (i = 0; i < this.sprite.npoints; i++) {
            if (s.sprite.contains(this.sprite.xpoints[i],
                    this.sprite.ypoints[i])) {
                return true;
            }

}

        return false;
    }

    /**
     * Advance Sprite
     *
     * @param width screen width
     * @param height screen height
     * @return
     */
    public boolean advance(int width, int height) {

        boolean wrapped;

        // Update the rotation and position of the sprite based on the delta
        // values. If the sprite moves off the edge of the screen, it is wrapped
        // around to the other side and TRUE is returned.

        this.angle += this.deltaAngle;
        if (this.angle < 0)
            this.angle += 2 * Math.PI;
        if (this.angle > 2 * Math.PI)
            this.angle -= 2 * Math.PI;
        wrapped = false;
        this.x += this.deltaX;
        if (this.x < -width / 2) {
            this.x += width;
            wrapped = true;
        }
        if (this.x > width / 2) {
            this.x -= width;
            wrapped = true;
        }
        this.y -= this.deltaY;
        if (this.y < -height / 2) {
            this.y += height;
            wrapped = true;
        }
        if (this.y > height / 2) {
            this.y -= height;
            wrapped = true;
        }
        return wrapped;
    }

    @Override
    public String toString() {
        return "Sprite: " + sprite + " Shape:" + shape;
    }

/**
     * Draw Sprite using polygon points
     *
     * @param canvas
     * @param paint
     */
    void draw(Canvas canvas, Paint paint) {
        float[] points = sprite.getPoints();

        if (points != null) {
            canvas.drawLines(points, paint);
        }
    }
}