spaceInvaders

package spaceinvaders;

import java.io.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import javax.swing.*;

public class SpaceInvaders extends JFrame implements Runnable {
    static final int WINDOW_WIDTH = 500;
    static final int WINDOW_HEIGHT = 700;
    final int XBORDER = 20;
    final int YBORDER = 20;
    final int YTITLE = 25;
    boolean animateFirstTime = true;
    int xsize = -1;
    int ysize = -1;
    Image image;
    Graphics2D g;

    int score;
    int numEnemies=10;
    int numProjectiles=30;
    int cannonXPos;
    int cannonYPos;
    int projectileXPos[]=new int[numProjectiles];
    int projectileYPos[]=new int[numProjectiles];
    int enemyXPos[]=new int[numEnemies];
    int enemyYPos[]=new int[numEnemies];
    boolean projectileActive[]=new boolean[numProjectiles];
    int currentProjectile;
    int currentEnemy;
    boolean enemyActive[]=new boolean[numEnemies];
    boolean youWin;
    boolean gameOver;
    int timeCount;
    int enemyXDir;

    static SpaceInvaders frame;
    public static void main(String[] args) {
        frame = new SpaceInvaders();
        frame.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    public SpaceInvaders() {
        addMouseListener(new MouseAdapter() {
            public void mousePressed(MouseEvent e) {
                if(youWin)
                    return;
                if (e.BUTTON1 == e.getButton()) {
                    //left button
                    projectileXPos[currentProjectile]=cannonXPos;
                    projectileYPos[currentProjectile]=cannonYPos;
                    projectileActive[currentProjectile]=true;
                    currentProjectile++;
                    if(currentProjectile==numProjectiles)
                    {
                        currentProjectile=0;
                    }
// location of the cursor.
                    int xpos = e.getX();
                    int ypos = e.getY();

                }
                if (e.BUTTON3 == e.getButton()) {
                    //right button
                    reset();
                }
                repaint();
            }
        });

    addMouseMotionListener(new MouseMotionAdapter() {
      public void mouseDragged(MouseEvent e) {

        repaint();
      }
    });

    addMouseMotionListener(new MouseMotionAdapter() {
      public void mouseMoved(MouseEvent e) {
        if(youWin)
            return;
          cannonXPos=e.getX()-getX(0);
        repaint();
      }
    });

        addKeyListener(new KeyAdapter() {

            public void keyPressed(KeyEvent e) {
                if (e.VK_UP == e.getKeyCode()) {
                } else if (e.VK_DOWN == e.getKeyCode()) {
                } else if (e.VK_LEFT == e.getKeyCode()) {
                } else if (e.VK_RIGHT == e.getKeyCode()) {
                }
                repaint();
            }
        });
        init();
        start();
    }
    Thread relaxer;
////////////////////////////////////////////////////////////////////////////
    public void init() {
        requestFocus();
    }
////////////////////////////////////////////////////////////////////////////
    public void destroy() {
    }



////////////////////////////////////////////////////////////////////////////
    public void paint(Graphics gOld) {
        if (image == null || xsize != getSize().width || ysize != getSize().height) {
            xsize = getSize().width;
            ysize = getSize().height;
            image = createImage(xsize, ysize);
            g = (Graphics2D) image.getGraphics();
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
        }
//fill background
        g.setColor(Color.cyan);
        g.fillRect(0, 0, xsize, ysize);

        int x[] = {getX(0), getX(getWidth2()), getX(getWidth2()), getX(0), getX(0)};
        int y[] = {getY(0), getY(0), getY(getHeight2()), getY(getHeight2()), getY(0)};
//fill border
        g.setColor(Color.white);
        g.fillPolygon(x, y, 4);
// draw border
        g.setColor(Color.red);
        g.drawPolyline(x, y, 5);

        if (animateFirstTime) {
            gOld.drawImage(image, 0, 0, null);
            return;
        }
        if(youWin)
            return;
        g.setColor(Color.BLACK);
        g.setFont(new Font("Arial",Font.PLAIN,15));
        g.drawString("Score:"+score,40,45);
        g.setColor(Color.RED);
        drawHouse(getX(cannonXPos),getYNormal(cannonYPos),0,1,1);
        //drawCircle(getX(),getYNormal(),0,1,1);
        //drawCircle(getX(),getYNormal(),0,1,1);

        g.setColor(Color.blue);
        for(int i=0;i<numEnemies;i++)
        {
            if(enemyActive[i])
            {
                drawHouse(getX(enemyXPos[i]),getYNormal(enemyYPos[i]),0,1,1);
            }
        }
        g.setColor(Color.BLACK);
        for(int i=0;i<numProjectiles;i++)
        {
            if(projectileActive[i])
            {
                drawCircle(getX(projectileXPos[i]),getYNormal(projectileYPos[i]),0,1,1);
            }
        }
        if(youWin)
        {
            g.setFont(new Font("Arial",Font.PLAIN,45));
            g.drawString("You Win",250,350);
        }

        gOld.drawImage(image, 0, 0, null);
    }
////////////////////////////////////////////////////////////////////////////
    public void drawHouse(int xpos,int ypos,double rot,double xscale,double yscale)
    {
        g.translate(xpos,ypos);
        g.rotate(rot  * Math.PI/180.0);
        g.scale( xscale , yscale );

        int xval[] = {0,10,10,-10,-10,0};
        int yval[] = {-15,-10,10,10,-10,-15};
        g.fillPolygon(xval,yval,xval.length);

        g.scale( 1.0/xscale,1.0/yscale );
        g.rotate(-rot  * Math.PI/180.0);
        g.translate(-xpos,-ypos);
    }

////////////////////////////////////////////////////////////////////////////
    public void drawCircle(int xpos,int ypos,double rot,double xscale,double yscale)
    {
        g.translate(xpos,ypos);
        g.rotate(rot  * Math.PI/180.0);
        g.scale( xscale , yscale );

        g.fillOval(-10,-10,20,20);

        g.scale( 1.0/xscale,1.0/yscale );
        g.rotate(-rot  * Math.PI/180.0);
        g.translate(-xpos,-ypos);
    }

////////////////////////////////////////////////////////////////////////////
// needed for     implement runnable
    public void run() {
        while (true) {
            animate();
            repaint();
            double seconds = .02;    //time that 1 frame takes.
            int miliseconds = (int) (1000.0 * seconds);
            try {
                Thread.sleep(miliseconds);
            } catch (InterruptedException e) {
            }
        }
    }
/////////////////////////////////////////////////////////////////////////
    public void reset() {
        score=0;
        youWin=false;
        gameOver=false;
        cannonXPos=getWidth2()/2;
        cannonYPos=10;
        for(int i=0;i<numProjectiles;i++)
        {
            projectileActive[i]=false;
        }
        for(int i=0;i<numEnemies;i++)
        {
            enemyXPos[i]=(int)(Math.random()*getWidth2()+0);
            enemyYPos[i]=(int)(Math.random()*getHeight2()/2+getHeight2()/2);
            enemyActive[i]=true;
        }
        currentProjectile=0;
        enemyXDir=3;
    }
/////////////////////////////////////////////////////////////////////////
    public void animate() {
        if (animateFirstTime) {
            animateFirstTime = false;
            if (xsize != getSize().width || ysize != getSize().height) {
                xsize = getSize().width;
                ysize = getSize().height;
            }

            reset();
        }
        if(youWin)
            return;
        if(gameOver)
            return;
        boolean enemySwitchDir=false;
        for(int i=0;i<numEnemies;i++)
        {
            if(enemyActive[i])
            {
                enemyXPos[i]+=enemyXDir;
                if(enemyXPos[i]>=460||enemyXPos[i]<=10)
                {
                    enemySwitchDir=true;
                }
            }
        }
        if(enemySwitchDir)
        {
            enemyXDir=-enemyXDir;
        }
        for(int i=0;i<numProjectiles;i++)
        {
            if(projectileActive[i])
            {
                if(projectileYPos[i]>=630)
                {
                    projectileActive[i]=false;
                }
                projectileYPos[i]+=10;
            }
        }
        for(int i=0;i<numEnemies;i++)
        {
            if(enemyActive[i])
            {
                if(enemyYPos[i]<=10)
                {
                 gameOver=true;
                }
            }
            enemyYPos[i]--;
        }
        for(int i=0;i<numEnemies;i++)
        {
            for(int j=0;j<numProjectiles;j++)
            {
                if(enemyXPos[i]-10<projectileXPos[j]&&enemyXPos[i]+10>projectileXPos[j]&&enemyYPos[i]-10<projectileYPos[j]&&enemyYPos[i]+10>projectileYPos[j])
                {
                    enemyActive[i]=false;
                    score++;
                }
            }
        }
        if(score>=numEnemies)
            youWin=true;
    }

////////////////////////////////////////////////////////////////////////////
    public void start() {
        if (relaxer == null) {
            relaxer = new Thread(this);
            relaxer.start();
        }
    }
////////////////////////////////////////////////////////////////////////////
    public void stop() {
        if (relaxer.isAlive()) {
            relaxer.stop();
        }
        relaxer = null;
    }
/////////////////////////////////////////////////////////////////////////
    public int getX(int x) {
        return (x + XBORDER);
    }

    public int getY(int y) {
        return (y + YBORDER + YTITLE);
    }

    public int getYNormal(int y) {
        return (-y + YBORDER + YTITLE + getHeight2());
    }


    public int getWidth2() {
        return (xsize - getX(0) - XBORDER);
    }

    public int getHeight2() {
        return (ysize - getY(0) - YBORDER);
    }
}