Making a Tetris clone

[Chris Stewart]

I want to make a Tetris clone for my final project in class. I have a general understanding of what steps need to happen during each loop of each piece, but I'm having a hard time getting started. Should I use a Grid layout manager, would that help me out when figuring out collisions? Any advice is greatly appreciated!

[Stan James]

I did a DOS Tetris years ago in Pascal using a grid of colored squares. That meant pieces could only drop in row sized increments, not smooth like a real graphical implementation.
I'd be sure to represent the game state in a model separate from my view. Maybe do all the collision detection and row-full detection in a 2 dimensional array and publish events to a view when the model changes.
I've never touched 2D graphics. I'm sure the recommendations from graphics experts will be different.

[Michael Morris]

You guys are still thinking like procedural programmers, shame on you. Why not create an AbstractTetrisShape (which would extend Panel or JPanel) and extend that class for all of your various blocks? Then have a TetrisSceneManager that would keep a Set of the AbstractTetrisShapes and determine collisions there. The code would be a lot cleaner and more manageable and extensible.
It would not be any more difficult than having one huge monolithic procedural class. As a matter of fact, I would guess it would be easier in the long run.

[Stan James]

Good point. I was indeed thinking back to a pre-OO Pascal solution. Follow up a bit on your design ideas ... the shape would know which points or cells it was covering, would have isOverlapping(anotherShape) method?

[Michael Morris]

Do you have to use Swing? This sort of thing seems to be easier to pull off with AWT. I have a small framework that demonstrates the basics for this sort of thing. Don't let the size of some of the classes scare you. Just take a look at the approach and see if you can see how to use it for a Tetris hack.
SpaceScene.java

import java.awt.*;
import java.awt.image.*;
public interface SpaceScene {
    public void addSpaceObject(SpaceObject obj);
    public void removeSpaceObject(SpaceObject obj);
    public void update();
    public SpaceObject[] getObjects();
    public void setSceneBounds(Rectangle bounds);
    public Rectangle getSceneBounds();
    public void paint(Graphics2D g2D, ImageObserver obs);
}

{B]SpaceSceneManager.java[/B]

import java.util.*;
import java.awt.*;
import java.awt.image.*;
public class SpaceSceneManager implements SpaceScene {
    private java.util.List spaceObjects;
    private java.util.List addObjects;
    private java.util.List removeObjects;
    SpaceObject[] objects;
    private Rectangle bounds;
    private boolean listChanged;
    public SpaceSceneManager() {
        spaceObjects  = new ArrayList();
        addObjects    = new ArrayList();
        removeObjects = new ArrayList();
        bounds = null;
        objects = new SpaceObject[0];
        listChanged = true;
    }
    public void addSpaceObject(SpaceObject obj) {
        addObjects.add(obj);
        listChanged = true;
    }
    public void removeSpaceObject(SpaceObject obj) {
        removeObjects.add(obj);
        listChanged = true;
    }
    public void update() {
        if (listChanged) {
            updateList();
        }
        SpaceObject[] objs = getObjects();
        for (int i = 0; i < objs.length; i++) {
           objs[i].lock();
           objs[i].update();
           objs[i].unlock();
        }
    }
    private void updateList() {
        spaceObjects.removeAll(removeObjects);
        spaceObjects.addAll(addObjects);
        removeObjects.clear();
        addObjects.clear();
        objects = (SpaceObject[]) spaceObjects.toArray(new SpaceObject[0]);
        listChanged = false;
    }
    public SpaceObject[] getObjects() {
        return objects;
    }
    public void setSceneBounds(Rectangle bounds) {
        this.bounds = bounds;
    }
    public void paint(Graphics2D g2D, ImageObserver obs) {
        SpaceObject[] objs = getObjects();
        for (int i = 0; i < objs.length; i++) {
           objs[i].paint(g2D, obs);
        }
    }

    public Rectangle getSceneBounds() {
        return bounds;
    }
}

SpaceObject.java

import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.*;
import java.io.*;
public abstract class SpaceObject implements KeyListener,
                                             MouseListener,
                                             MouseMotionListener {
    public  static final int    DO_NOTHING_ON_EXIT_SCENE =   0;
    public  static final int    BOUNCE_ON_EXIT_SCENE     =   1;
    public  static final int    WRAP_ON_EXIT_SCENE       =   2;
    private static final double MAX_VELOCITY             =  13.0;
    private static final double VELOCITY_INC             =   0.5;
    private static final double MAX_ORIENTATION          = 360.0;
    private static final double ORIENTATION_INC          =   2.0;
    private static final double VELOCITY_DECAY           =   0.025;
    private static final Color  BACKGROUND               = Color.BLACK;
    private static final Color  COLOR                    = Color.WHITE;
    private static final int    NONE                     =   0;
    private static final int    TOP                      =   1;
    private static final int    BOTTOM                   =   2;
    private static final int    LEFT                     =   3;
    private static final int    RIGHT                    =   4;
    private static final int    WRAP_THRESHOLD           =  10;
    private double velocity;
    private double maxVelocity;
    private double velocityDecay;
    private double velocityInc;
    private double x;
    private double y;
    private double xScale;
    private double yScale;
    private double direction;
    private double orientation;
    private double orientationIncrement;
    private Color background;
    private Color color;
    private SpaceScene scene;
    private int exitSceneStrategy;
    private int lastXsect;
    private AffineTransform transform;
    private boolean visible;
    private boolean locked;
    protected boolean debug = false;
    private final PrintStream out = System.out;
    public SpaceObject() {
        x = 0.0;
        y = 0.0;
        xScale = 1.0;
        yScale = 1.0;
        direction = 0.0;
        orientation = 0.0;
        orientationIncrement = ORIENTATION_INC;
        velocity = 0.0;
        maxVelocity = MAX_VELOCITY;
        velocityDecay = VELOCITY_DECAY;
        velocityInc = VELOCITY_INC;
        background = BACKGROUND;
        color = COLOR;
        exitSceneStrategy = DO_NOTHING_ON_EXIT_SCENE;
        lastXsect = NONE;
        transform = new AffineTransform();
        visible = true;
        locked = false;
    }
    public synchronized void lock() {
        while (locked) {
            try {
                wait();
            } catch (InterruptedException ignore) {}
        }
    }
    public synchronized void unlock() {
        notifyAll();
        locked = false;
    }
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
    public boolean isVisible() {
        return visible;
    }
    public int getExitSceneStrategy() {
        return exitSceneStrategy;
    }
    public void setExitSceneStrategy(int exitSceneStrategy) {
        if (exitSceneStrategy < DO_NOTHING_ON_EXIT_SCENE ||
            exitSceneStrategy > WRAP_ON_EXIT_SCENE) {
            return;
        }
        this.exitSceneStrategy = exitSceneStrategy;
    }
    public SpaceScene getScene() {
        return scene;
    }
    public void setScene(SpaceScene scene) {
        this.scene = scene;
    }
    public void die() {
        if (scene != null) {
            scene.removeSpaceObject(this);
        }
    }
    public double getVelocityInc() {
        return velocityInc;
    }
    public void setVelocityInc(double velocityInc) {
        if (velocityInc <= 0.0) {
            this.velocityInc = VELOCITY_INC;
        } else {
            this.velocityInc = velocityInc;
        }
    }
    public double getVelocityDecay() {
        return velocityDecay;
    }
    public void setVelocityDecay(double velocityDecay) {
        if (velocityDecay <= 0.0) {
            this.velocityDecay = VELOCITY_DECAY;
        } else {
            this.velocityDecay = velocityDecay;
        }
    }
    public double getMaxVelocity() {
        return maxVelocity;
    }
    public void setMaxVelocity(double maxVelocity) {
        if (maxVelocity <= 0.0) {
            this.maxVelocity = MAX_VELOCITY;
        } else {
            this.maxVelocity = maxVelocity;
        }
    }
    public double getVelocity() {
        return velocity;
    }
    public void setVelocity(double velocity) {
        this.velocity = velocity;
        if (this.velocity > getMaxVelocity()) {
            this.velocity = getMaxVelocity();
        } else if (this.velocity < 0.0) {
            this.velocity = 0.0;
        }
    }
    public void incrementVelocity() {
        if (velocity >= getMaxVelocity()) {
            return;
        }
        double vel = 0.0;
        double dir = getDirection();
        double ori = getOrientation();
        if (dir != ori) {
            Vector2D curr = Vector2D.getVector(getVelocity(),
                                               Math.toRadians(direction));
            Vector2D vNew = Vector2D.getVector(getVelocityInc(),
                                               Math.toRadians(orientation));
            Vector2D res  = curr.plus(vNew);
            vel = res.length();
            dir = Math.toDegrees(res.getDirection());
            setDirection(dir);
        } else {
            vel = velocity + getVelocityInc();
        }
        setVelocity(vel);
    }
    public void decayVelocity() {
        setVelocity(velocity - getVelocityDecay());
    }
    public double getDirection() {
        return direction;
    }
    protected void setDirection(double direction) {
        this.direction = normalizeAngle(direction);
    }
    private double normalizeAngle(double angle) {
        while (angle > MAX_ORIENTATION) {
            angle -= MAX_ORIENTATION;
        }
        while (angle < 0.0) {
            angle += MAX_ORIENTATION;
        }
        return angle;
    }
    public void setOrientation(double orientation) {
        this.orientation = normalizeAngle(orientation);
    }
    public void incrementOrientation() {
        setOrientation(orientation + orientationIncrement);
    }
    public void decrementOrientation() {
        setOrientation(orientation - orientationIncrement);
    }
    public double getOrientation() {
        return orientation;
    }
    public void setOrientationIncrement(double orientationIncrement) {
        this.orientationIncrement = orientationIncrement;
    }
    public double getOrientationIncrement() {
        return orientationIncrement;
    }
    public void synchronizeDirection() {
        direction = orientation;
    }
    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
    }

    public double getXScale() {
        return xScale;
    }
    public void setXScale(double xScale) {
        if (xScale <= 0.0) {
            return;
        }
        this.xScale = xScale;
    }
    public double getYScale() {
        return yScale;
    }
    public void setYScale(double yScale) {
        if (yScale <= 0.0) {
            return;
        }
        this.yScale = yScale;
    }
    public Color getColor() {
        return color;
    }
    public void setColor(Color color) {
        this.color = color;
    }
    public Color getBackground() {
        return background;
    }
    public void setBackground(Color background) {
        this.background = background;
    }
    private void debugDump(ArrayList list) {
        out.println("**********************************" );
        out.println("Thread: " + Thread.currentThread().getName());
        for (int i = 0; i < list.size(); i++) {
            out.println(list.get(i).toString());
        }
        out.println("**********************************" );
        out.println("" );
    }
    public void update() {
        double curX =
                x + getVelocity() * Math.cos(Math.toRadians(getDirection()));
        double curY =
                y + getVelocity() * Math.sin(Math.toRadians(getDirection()));
        setX(curX);
        setY(curY);
        decayVelocity();
        incrementCycles();
        Rectangle sceneBounds = getScene().getSceneBounds();
        if (sceneBounds != null &&
            getExitSceneStrategy() != DO_NOTHING_ON_EXIT_SCENE) {
            Rectangle bounds = getBounds();
            if (!sceneBounds.contains(bounds)) {
                double hgt   = sceneBounds.getHeight();
                double wdt   = sceneBounds.getWidth();
                double sXmin = sceneBounds.getX();
                double sXmax = sXmin + wdt;
                double sYmin = sceneBounds.getY();
                double sYmax = sYmin + hgt;
                double bXmin = bounds.getX();
                double bXmax = bXmin + bounds.getWidth();
                double bYmin = bounds.getY();
                double bYmax = bYmin + bounds.getHeight();
                double sCntX = (sXmin + sXmax) / 2.0;
                double sCntY = (sYmin + sYmax) / 2.0;
                double bCntX = bounds.getX() + bounds.getWidth()  / 2.0;
                double bCntY = bounds.getY() + bounds.getHeight() / 2.0;
                double dir   = getDirection();
                Line2D top   = new Line2D.Double(sXmin, sYmin, sXmax, sYmin);
                Line2D bot   = new Line2D.Double(sXmin, sYmax, sXmax, sYmax);
                Line2D lft   = new Line2D.Double(sXmin, sYmin, sXmin, sYmax);
                Line2D rgt   = new Line2D.Double(sXmax, sYmin, sXmax, sYmax);
                Line2D sC2bC = new Line2D.Double(sCntX, sCntY, bCntX, bCntY);
                if (getExitSceneStrategy() == BOUNCE_ON_EXIT_SCENE) {
                    if (top.intersects(bounds)) {
                        if (dir < 270.0) {
                            dir -= 2.0 * (dir - 180.0);
                        } else {
                            dir += 2.0 * (360.0 - dir);
                        }
                    } else if (bot.intersects(bounds)) {
                        if (dir < 90.0) {
                            dir -= 2.0 * dir;
                        } else {
                            dir += 2.0 * (180.0 - dir);
                        }
                    } else if (lft.intersects(bounds)) {
                        if (dir > 180.0) {
                            dir += 180.0 - 2.0 * (dir - 180.0);
                        } else {
                            dir -= 180.0 - 2.0 * (180.0 - dir);
                        }
                    } else if (rgt.intersects(bounds)) {
                        if (dir < 90.0) {
                            dir += 180.0 - 2.0 * dir;
                        } else {
                            dir -= 180.0 - 2.0 * (360.0 - dir);
                        }
                    } else {
                        if (sC2bC.intersectsLine(top)) {
                            if (dir < 270.0) {
                                dir -= 2.0 * (dir - 180.0);
                            } else {
                                dir += 2.0 * (360.0 - dir);
                            }
                        } else if (sC2bC.intersectsLine(bot)) {
                            if (dir < 90.0) {
                                dir -= 2.0 * dir;
                            } else {
                                dir += 2.0 * (180.0 - dir);
                            }
                        } else if (sC2bC.intersectsLine(lft)) {
                            if (dir > 180.0) {
                                dir += 180.0 - 2.0 * (dir - 180.0);
                            } else {
                                dir -= 180.0 - 2.0 * (180.0 - dir);
                            }
                        } else if (sC2bC.intersectsLine(rgt)) {
                            if (dir < 90.0) {
                                dir += 180.0 - 2.0 * dir;
                            } else {
                                dir -= 180.0 - 2.0 * (360.0 - dir);
                            }
                        } else {
                        }
                    }
                    if (bXmin < sXmin) {
                        setX(getX() + sXmin - bXmin);
                    }
                    if (bXmax > sXmax) {
                        setX(getX() - bXmax + sXmax);
                    }
                    if (bYmin < sYmin) {
                        setY(getY() + sYmin - bYmin);
                    }
                    if (bYmax > sYmax) {
                        setY(getY() - bYmax + sYmax);
                    }
                    setDirection(dir);
                    decayVelocity();
                } else if (getExitSceneStrategy() == WRAP_ON_EXIT_SCENE) {
                    if (bXmin > sXmax) {
                        setX(getX() - sXmax - (bXmax - bXmin) + WRAP_THRESHOLD);
                    }
                    if (bXmax < sXmin) {
                        setX(getX() + sXmax + (bXmax - bXmin) - WRAP_THRESHOLD);
                    }
                    if (bYmin > sYmax) {
                        setY(getY() - sYmax - (bYmax - bYmin) + WRAP_THRESHOLD);
                    }
                    if (bYmax < sYmin) {
                        setY(getY() + sYmax + (bYmax - bYmin) - WRAP_THRESHOLD);
                    }
                }
            }
        }
        transform.setToTranslation(getX(), getY());
        transform.rotate(Math.toRadians(getOrientation()));
        transform.scale(xScale, yScale);
    }
    public AffineTransform getTransform() {
        return transform;
    }
    public Rectangle getBounds() {
        double h   = getSize().getHeight();
        double w   = getSize().getWidth();
        double ori = getOrientation();
        double cos = Math.abs(Math.cos(Math.toRadians(ori)));
        double sin = Math.abs(Math.sin(Math.toRadians(ori)));
        double a   = h * cos;
        double b   = h * sin;
        double c   = w * cos;
        double d   = w * sin;
        double hgt = a + d;
        double wdt = b + c;
        double x   = getX();
        double y   = getY();
        if (ori <= 90.0) {
            x -= b;
        } else if (ori <= 180.0) {
            x -= wdt;
            y -= a;
        } else if (ori <= 270.0) {
            x -= c;
            y -= hgt;
        } else {
            y -= d;
        }
       return new Rectangle((int) x, (int) y, (int) wdt, (int) hgt);
    }
    public void setCyclesToLive(int cyclesToLive) {}
    public int getCyclesToLive() {
        return 1000;
    }
    public void incrementCycles() {}
    public boolean isAlive() {
        return true;
    }
    public int cyclesToLive() {
        return 1000;
    }
    public void keyPressed(KeyEvent e) {}
    public void keyReleased(KeyEvent e) {}
    public void keyTyped(KeyEvent e) {}
    public void mouseClicked(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mousePressed(MouseEvent e) {}
    public void mouseReleased(MouseEvent e) {}
    public void mouseDragged(MouseEvent e) {}
    public void mouseMoved(MouseEvent e) {}
    public abstract Dimension getSize();
    public abstract void paint(Graphics2D g2D, ImageObserver obs);
}

Ship.java

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
public class Ship extends SpaceObject {
    private static final int WIDTH  = 50;
    private static final int HEIGHT = 40;
    private static final int RETRO_THRESHOLD = 20;
    private Dimension size;
    private Rectangle bounds;
    private Image[] images;
    private boolean engineIsFiring;
    private boolean starboardRetroIsFiring;
    private boolean portRetroIsFiring;
    private boolean gunIsFiring;
    private double mouseDraggedX;
    private double mouseDraggedY;
    private double gunX;
    private double gunY;
    Bullet bullet;
    SpaceObject weaponsCursor;
    final Vector2D cursorSeat;
    final Vector2D cursorMaxRange;
//    final Vector2D cursorMaxStarboard;
//    final Vector2D cursorMaxPort;
    Vector2D cursorPositionReltive;
    Vector2D cursorPosition;
    double cursorRange;
    double cursorMaxAngle;
    public Ship() {
        super();
        engineIsFiring         = false;
        starboardRetroIsFiring = false;
        portRetroIsFiring      = false;
        gunIsFiring            = false;
        gunX = 50.0;
        gunY = 20.0;
        size = new Dimension(WIDTH, HEIGHT);
        images = createImages();
        bullet = null;
        weaponsCursor = new WeaponsCursor();
        weaponsCursor.setVisible(false);
        weaponsCursor.setXScale(getXScale());
        weaponsCursor.setYScale(getYScale());
        int cX = WIDTH + 2;
        int cY = (HEIGHT - (int) weaponsCursor.getSize().getHeight()) / 2;
        cursorSeat            = new Vector2D.Integer(cX, cY);
        cursorPositionReltive = new Vector2D.Integer(cX, cY);
        cursorPosition        = new Vector2D.Integer(cX, cY);
        cursorRange     = (double) (WIDTH * 4);
        cursorMaxAngle  = 45.0;
        cursorMaxRange = cursorSeat.plus(new Vector2D.Integer(cursorRange, 0));
//        cursorMaxStarboard;
//        cursorMaxPort;
    }
    private Image[] createImages() {
        int[] xpoints = {20, 50, 20};
        int[] ypoints = { 0, 20, 40};
        Polygon shell  = new Polygon(xpoints, ypoints, xpoints.length);
        xpoints[0] = 10;
        xpoints[1] = 20;
        xpoints[2] = 10;
        ypoints[0] = 15;
        ypoints[1] = 20;
        ypoints[2] = 25;
        Polygon engine = new Polygon(xpoints, ypoints, xpoints.length);
        Shape[] plume = new Shape[15];
        plume[ 0] = new Line2D.Double( 2.0, 18.0, 10.0, 20.0);
        plume[ 1] = new Line2D.Double( 1.0, 19.0, 10.0, 20.0);
        plume[ 2] = new Line2D.Double( 0.0, 20.0, 10.0, 20.0);
        plume[ 3] = new Line2D.Double( 1.0, 21.0, 10.0, 20.0);
        plume[ 4] = new Line2D.Double( 2.0, 22.0, 10.0, 20.0);
        plume[ 5] = new Line2D.Double( 5.0, 15.0, 10.0, 18.0);
        plume[ 6] = new Line2D.Double( 4.0, 16.0, 10.0, 18.0);
        plume[ 7] = new Line2D.Double( 3.0, 17.0, 10.0, 18.0);
        plume[ 8] = new Line2D.Double( 4.0, 18.0, 10.0, 18.0);
        plume[ 9] = new Line2D.Double( 5.0, 19.0, 10.0, 18.0);
        plume[10] = new Line2D.Double( 5.0, 25.0, 10.0, 22.0);
        plume[11] = new Line2D.Double( 4.0, 24.0, 10.0, 22.0);
        plume[12] = new Line2D.Double( 3.0, 23.0, 10.0, 22.0);
        plume[13] = new Line2D.Double( 4.0, 24.0, 10.0, 22.0);
        plume[14] = new Line2D.Double( 5.0, 25.0, 10.0, 22.0);
        Color[] plumeColor = new Color[15];
        plumeColor[ 0] = new Color(255, 214, 171);
        plumeColor[ 1] = new Color(255, 255, 214);
        plumeColor[ 2] = Color.WHITE;
        plumeColor[ 3] = plumeColor[1];
        plumeColor[ 4] = plumeColor[0];
        plumeColor[ 5] = new Color(171, 128,  44);
        plumeColor[ 6] = new Color(214, 171,  87);
        plumeColor[ 7] = new Color(214, 214, 128);
        plumeColor[ 8] = plumeColor[6];
        plumeColor[ 9] = plumeColor[5];
        plumeColor[10] = plumeColor[5];
        plumeColor[11] = plumeColor[6];
        plumeColor[12] = plumeColor[7];
        plumeColor[13] = plumeColor[6];
        plumeColor[14] = plumeColor[5];

        int wdt = (int) size.getWidth();
        int hgt = (int) size.getHeight();
        images    = new BufferedImage[6];
        for (int i = 0; i < images.length; i++) {
            images[i] = new BufferedImage(wdt, hgt,
                                          BufferedImage.TYPE_INT_RGB);
            Graphics2D g2d = ((BufferedImage) images[i]).createGraphics();
            g2d.setBackground(getBackground());
            g2d.clearRect(0, 0, wdt, hgt);
            g2d.setPaint(getPaint());
            Stroke oldStroke = g2d.getStroke();
            g2d.setStroke(new BasicStroke(2.0F));
            g2d.draw(shell);
            Point2D start = new Point2D.Double(35,  0);
            Point2D end   = new Point2D.Double(35, 40);
            Color sColor  = new Color(64, 64, 255);
            Color eColor  = new Color(255, 64, 64);
            g2d.setPaint(new GradientPaint(start, sColor, end, eColor));
            g2d.fill(shell);
            g2d.setPaint(getPaint());
            g2d.draw(engine);
            start  = new Point2D.Double(10, 20);
            end    = new Point2D.Double(20, 20);
            sColor = new Color(128, 128, 64);
            eColor = new Color(255, 255, 128);
            g2d.setPaint(new GradientPaint(start, sColor, end, eColor));
            g2d.fill(engine);
            g2d.setStroke(oldStroke);
            if (i > 2) {
                for (int j = 0; j < plume.length; j++) {
                    g2d.setPaint(plumeColor[j]);
                    g2d.draw(plume[j]);
                }
            }
            double retroHgt = 13;
            double retroWdt =  4;
            Point2D sRetroT = new Point2D.Double(38, 0);
            Point2D sRetroB = new Point2D.Double(sRetroT.getX() + retroWdt,
                                                 sRetroT.getY() + retroHgt);
            Point2D pRetroB = new Point2D.Double(38, 40);
            Point2D pRetroT = new Point2D.Double(pRetroB.getX() + retroWdt,
                                                 pRetroB.getY() - retroHgt);
            Color startRetro = Color.YELLOW;
            Color endRetro   = Color.RED;
            switch (i) {
            case 0  :
            case 3  :
            default :
                break;
            case 1  :
            case 4  :
                g2d.setPaint(new GradientPaint(sRetroT, startRetro,
                                               sRetroB, endRetro));
                g2d.fillOval((int) sRetroT.getX(), (int) sRetroT.getY(),
                             (int) retroWdt, (int) retroHgt);
                break;
            case 2  :
            case 5  :
                g2d.setPaint(new GradientPaint(pRetroB, startRetro,
                                               pRetroT, endRetro));
                g2d.fillOval((int) pRetroB.getX(), (int) pRetroT.getY(),
                             (int) retroWdt, (int) retroHgt);
                break;
            }
            g2d.dispose();
        }
        return images;
    }
    public void setBackground(Color background) {
        super.setBackground(background);
        images = createImages();
    }
    public void setColor(Color color) {
        super.setColor(color);
        images = createImages();
    }
    private Paint getPaint() {
        return getColor();
    }
    public void update() {
        super.update();
        if (engineIsFiring) {
            incrementVelocity();
        }
        if (starboardRetroIsFiring) {
            incrementOrientation();
        } else if (portRetroIsFiring) {
            decrementOrientation();
        }
        weaponsCursor.setX(getX() + cursorPosition.getX());
        weaponsCursor.setY(getY() + cursorPosition.getY());
    }
    public void die() {
        /* Add the nose section to the scene */
        SpaceObject nose = new ShipNoseSection();
        double nX = 30.0;
        double nY =  7.0;
        double x  = nX * Math.cos(Math.toRadians(getOrientation())) - nY *
                                  Math.sin(Math.toRadians(getOrientation()));
        double y  = nX * Math.sin(Math.toRadians(getOrientation())) + nY *
                                  Math.cos(Math.toRadians(getOrientation()));
        nose.setX(getX() + x);
        nose.setY(getY() + y);
        nose.setOrientation(getOrientation());
        nose.setDirection(getDirection() + Math.random() * 15.0);
        nose.setBackground(getBackground());
        nose.setScene(getScene());
        nose.setExitSceneStrategy(SpaceObject.DO_NOTHING_ON_EXIT_SCENE);
        getScene().addSpaceObject(nose);
        /* Add the port section to the scene */
        SpaceObject port = new ShipPortSection();
         nX = 20.0;
         nY = 27.0;
         x  = nX * Math.cos(Math.toRadians(getOrientation())) - nY *
                            Math.sin(Math.toRadians(getOrientation()));
         y  = nX * Math.sin(Math.toRadians(getOrientation())) + nY *
                            Math.cos(Math.toRadians(getOrientation()));
        port.setX(getX() + x);
        port.setY(getY() + y);
        port.setOrientation(getOrientation());
        port.setDirection(getDirection() + Math.random() * 90.0);
        port.setBackground(getBackground());
        port.setScene(getScene());
        port.setExitSceneStrategy(SpaceObject.DO_NOTHING_ON_EXIT_SCENE);
        getScene().addSpaceObject(port);
        /* Add the port section to the scene */
        SpaceObject starBoard = new ShipStarBoardSection();
         nX = 20.0;
         nY =  0.0;
         x  = nX * Math.cos(Math.toRadians(getOrientation())) - nY *
                            Math.sin(Math.toRadians(getOrientation()));
         y  = nX * Math.sin(Math.toRadians(getOrientation())) + nY *
                            Math.cos(Math.toRadians(getOrientation()));
        starBoard.setX(getX() + x);
        starBoard.setY(getY() + y);
        starBoard.setOrientation(getOrientation());
        starBoard.setDirection(getDirection() - Math.random() * 90.0);
        starBoard.setBackground(getBackground());
        starBoard.setScene(getScene());
        starBoard.setExitSceneStrategy(SpaceObject.DO_NOTHING_ON_EXIT_SCENE);
        getScene().addSpaceObject(starBoard);
        /* Add the port section to the scene */
        SpaceObject aft = new ShipAftSection();
         nX =  0.0;
         nY =  0.0;
         x  = nX * Math.cos(Math.toRadians(getOrientation())) - nY *
                            Math.sin(Math.toRadians(getOrientation()));
         y  = nX * Math.sin(Math.toRadians(getOrientation())) + nY *
                            Math.cos(Math.toRadians(getOrientation()));
        aft.setX(getX() + x);
        aft.setY(getY() + y);
        aft.setOrientation(getOrientation());
        aft.setDirection(getDirection() - Math.random() * 15.0);
        aft.setBackground(getBackground());
        aft.setScene(getScene());
        aft.setExitSceneStrategy(SpaceObject.DO_NOTHING_ON_EXIT_SCENE);
        getScene().addSpaceObject(aft);

        weaponsCursor.die();
        super.die();
    }
    public void setScene(SpaceScene scene) {
        super.setScene(scene);
        if (scene != null) {
            scene.addSpaceObject(weaponsCursor);
        }
    }
    public void setOrientation(double orientation) {
        super.setOrientation(orientation);
        cursorPosition = cursorPositionReltive.getRotatedInstance(
                                          Math.toRadians(getOrientation()));
        weaponsCursor.setOrientation(getOrientation());
    }
    public Dimension getSize() {
        return size;
    }
    public void mouseMoved(MouseEvent e) {
        double x = e.getPoint().getX();
        double y = e.getPoint().getY();
        double xDelta = x - mouseDraggedX;
        double yDelta = y - mouseDraggedY;
        if (Math.abs(xDelta) > Math.abs(yDelta) &&
            Math.abs(xDelta) > RETRO_THRESHOLD) {
            lock();
            if (xDelta < 0.0) {
                portRetroIsFiring      = true;
                starboardRetroIsFiring = false;
            } else {
                portRetroIsFiring      = false;
                starboardRetroIsFiring = true;
            }
            unlock();
        } else if (Math.abs(xDelta) < Math.abs(yDelta) &&
                   Math.abs(yDelta) > RETRO_THRESHOLD) {
            lock();
            portRetroIsFiring      = false;
            starboardRetroIsFiring = false;
            unlock();
        }
        mouseDraggedX = x;
        mouseDraggedY = y;
    }
    public void mouseDragged(MouseEvent e) {
        mouseMoved(e);
    }
    public void mousePressed(MouseEvent e) {
        switch (e.getButton()) {
        case MouseEvent.BUTTON1 :
            if (getScene() != null && !gunIsFiring) {
                if (bullet == null || !bullet.isAlive()) {
                    bullet = new PhotonTorpedo();
                    double x = gunX * Math.cos(
                                      Math.toRadians(getOrientation())) -
                               gunY * Math.sin(
                                      Math.toRadians(getOrientation()));
                    double y = gunX * Math.sin(
                                      Math.toRadians(getOrientation())) +
                               gunY * Math.cos(
                                      Math.toRadians(getOrientation()));
                    bullet.setX(getX() + x);
                    bullet.setY(getY() + y);
                    bullet.setOrientation(getOrientation());
                    bullet.synchronizeDirection();
                    bullet.setBackground(getBackground());
                    bullet.setScene(getScene());
                    bullet.setExitSceneStrategy(
                        SpaceObject.BOUNCE_ON_EXIT_SCENE);
                    gunIsFiring = true;
                    getScene().addSpaceObject(bullet);
                }
            }
            break;
        case MouseEvent.BUTTON3 :
            lock();
            engineIsFiring = true;
            unlock();
            mouseDraggedX = e.getPoint().getX();
            mouseDraggedY = e.getPoint().getY();
            break;
        }
    }
    public void mouseReleased(MouseEvent e) {
        lock();
        switch (e.getButton()) {
        case MouseEvent.BUTTON1 :
            gunIsFiring = false;
            break;
        case MouseEvent.BUTTON3 :
            engineIsFiring         = false;
            starboardRetroIsFiring = false;
            portRetroIsFiring      = false;
            break;
        }
        unlock();
    }
    public void keyPressed(KeyEvent e) {
        double cX = cursorPositionReltive.getX();
        double cY = cursorPositionReltive.getY();
        double dX = 0.0;
        double dY = 0.0;
        switch (e.getKeyCode()) {
        case KeyEvent.VK_LEFT :
            dY -= 2.0;
            break;
        case KeyEvent.VK_RIGHT :
            dY += 2.0;
            break;
        case KeyEvent.VK_UP :
            dX += 2.0;
            break;
        case KeyEvent.VK_DOWN :
            dX -= 2.0;
            break;
        case KeyEvent.VK_F1 :
            cursorPositionReltive = new Vector2D.Integer(cursorSeat.getX(),
                                                         cursorSeat.getY());
            // falls thru
        case KeyEvent.VK_F2 :
            weaponsCursor.setVisible(false);
            return;
        case KeyEvent.VK_F4 :
                cursorPositionReltive = new Vector2D.Integer(
                        cursorMaxRange.getX(), cursorMaxRange.getY());
                cursorPosition = cursorPositionReltive.getRotatedInstance(
                                          Math.toRadians(getOrientation()));
            // falls thru
        case KeyEvent.VK_F3 :
            if (!cursorPositionReltive.equals(cursorSeat)) {
                weaponsCursor.setVisible(true);
            }
            return;
        case KeyEvent.VK_D :
            debug = true;
            break;
        case KeyEvent.VK_F :
            debug = false;
            break;
        case KeyEvent.VK_F5:
            die();
            break;
        default :
            break;
        }
        Vector2D newV = new Vector2D.Integer(cX + dX, cY + dY);
        Vector2D diff = newV.minus(cursorSeat);
        double angle = Math.toDegrees(diff.getDirection());
        if (angle > 180.0) {
            angle = 360.0 - angle;
        }
        if (diff.length() < cursorRange && Math.abs(angle) <= cursorMaxAngle) {
            cursorPositionReltive = newV;
        }
        if (cursorPositionReltive.equals(cursorSeat)) {
            weaponsCursor.setVisible(false);
        } else {
            weaponsCursor.setVisible(true);
        }
        cursorPosition = cursorPositionReltive.getRotatedInstance(
                                          Math.toRadians(getOrientation()));
    }
    public void keyReleased(KeyEvent e) {}
    public void paint(Graphics2D g2d, ImageObserver obs) {
        if (!isVisible()) {
            return;
        }
        int index = 0;
        if (starboardRetroIsFiring) {
            index = 1;
        } else if (portRetroIsFiring) {
            index = 2;
        }
        if (engineIsFiring) {
            index += 3;
        }
        if (getImage(index) != null) {
            g2d.drawImage(getImage(index), getTransform(), obs);
        }
    }
    private Image getImage(int index) {
        return images[index];
    }
}

TestShip.java

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;
import java.util.*;
import java.applet.*;
public class TestShip extends Applet implements Runnable {
    private static final AffineTransform IDENTITY = new AffineTransform();
    private static final long FRAME_DELAY = 25L;
    private Color background;
    private Image buffer;
    private int width;
    private int height;
    private Thread animation;
    private SpaceScene sceneManager;
    public void start() {
        animation = new Thread(this);
        animation.start();
    }
    public void stop() {
        animation = null;
    }
    public void run() {
        while (animation == Thread.currentThread()) {
            sceneManager.update();
            repaint();
            try {
                Thread.sleep(FRAME_DELAY);
            } catch (InterruptedException ignore) {}
        }
    }
    public void init() {
        sceneManager = new SpaceSceneManager();
        width  = (int) getSize().getWidth();
        height = (int) getSize().getHeight();
        buffer = createImage(width, height);
        sceneManager.setSceneBounds(new Rectangle(0, 0, width, height));
        background = new Color(0, 0, 64);
        SpaceObject ship = new Ship();
        ship.setExitSceneStrategy(SpaceObject.BOUNCE_ON_EXIT_SCENE);
        ship.setX(width / 2);
        ship.setY(height / 2);
        ship.setOrientation(0.0);
        ship.synchronizeDirection();
        ship.setBackground(background);
        ship.setScene(sceneManager);
//        ship.setXScale(0.7);
//        ship.setYScale(0.4);
        sceneManager.addSpaceObject(ship);
        addMouseListener(ship);
        addMouseMotionListener(ship);
        addKeyListener(ship);
    }
    public void update(Graphics g) {
        paint(g);
    }
    public void paint(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;
        Graphics2D offscreen = (Graphics2D) buffer.getGraphics();
        offscreen.setBackground(background);
        offscreen.clearRect(0, 0, width, height);
        sceneManager.paint(offscreen, this);
        g2d.drawImage(buffer, IDENTITY, this);
        offscreen.dispose();
    }
}

Some of the other SpaceObject classes are not here, if you want I'll post everything later. See if you can follow my logic. Basically the SpaceScene is responsible for calling the update() method on all registered SpaceObjects. The Applet or application just starts an animation loop and on each cycle calls update() on the SpaceScene object. A Tetris hack will be much simpler than this since there are only four possible orientations. There is no collision detection in this but it would be simple to add to the SpaceScene implementation since it has knowledge of all the SpaceObjects in the scene.

[Chris Stewart]

All of this seems like a little much for the scope of this project. Seeing our current work load, I'll probably have about a week and a half to do this. Also, during our presentation he's going to be drilling us on the code, so I have to know it very very well.
Anybody have other suggestions for games or cool little apps?

[Jack Sheppard]

Checkers, Chess, Monopoly, Tank, Stratego, Risk, Minesweeper, Mini-golf, Pac-Man, Connect Four..

[Amy Phillips]

Chris,
As I have mentioned before the game doesn't have to be complex because there are plenty of features you can implement. In my first year at university I made a fruit machine, you entered a username, clicked a button and three random fruit images from an array where displayed. These were then compared to see if they were all the same or if maybe 2 matched and points allocated. The points were added up as you went along and displayed on the screen. Don't forget you only have a week and a half this isn't very long so don't go too mad. Its more important to make a good quality game that you understand.
Good luck