Added files

README.md

@@ -0,0 +1 @@
+A simple java spaceinvaders and bullithell 2d game

src/bullithell/images/Images.java

@@ -0,0 +1,19 @@
+package bullithell.images;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+public final class Images {
+	public static BufferedImage player, background, bomb, explode;
+	static{	
+		try{
+			player = ImageIO.read(new File("res/shipbullit.png"));
+			background = ImageIO.read(new File("res/stars.png"));
+			bomb = ImageIO.read(new File("res/bomb.png"));
+			explode = ImageIO.read(new File("res/explosion.png"));
+		}catch(IOException e){}
+	}
+}

src/bullithell/objects/Enemie.java

@@ -0,0 +1,6 @@
+package bullithell.objects;
+
+
+public class Enemie{
+
+}

src/bullithell/objects/Player.java

@@ -0,0 +1,178 @@
+package bullithell.objects;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RadialGradientPaint;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.geom.Ellipse2D;
+import java.util.ArrayList;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+
+import main.Joystick;
+import bullithell.images.Images;
+import bullithell.objects.missiles.Ball;
+import bullithell.objects.missiles.Missile;
+import bullithell.objects.missiles.PlayerMissile;
+import bullithell.particles.Fireball;
+
+public class Player extends Ship implements KeyListener{
+	private double movedirvert, movedirhor;
+	private int health, score, shieldpower;
+	private ArrayList<Fireball> particle;
+	private ArrayList<PlayerMissile> missiles;
+	private boolean launchmissiles;
+	private long lastFired;
+	Joystick joystick;
+	
+	public Player(int x, int y) {
+		super(Images.player,x,y);
+		new Thread(joystick = new Joystick());
+		reset();
+	}
+	
+	@Override public void keyTyped(KeyEvent e) {}
+	@Override
+	public void keyReleased(KeyEvent e) {
+		if(((e.getKeyChar() == 'd' ||  e.getKeyCode() == KeyEvent.VK_RIGHT) && movedirvert == 1) || ((e.getKeyChar() == 'a' || e.getKeyCode() == KeyEvent.VK_LEFT) && movedirvert == -1)){
+			movedirvert = 0;
+		}else if(((e.getKeyChar() == 'w' ||  e.getKeyCode() == KeyEvent.VK_UP) && movedirhor == -1) || ((e.getKeyChar() == 's' || e.getKeyCode() == KeyEvent.VK_DOWN) && movedirhor == 1)){
+			movedirhor = 0;
+		}else if(e.getKeyChar() == ' ' || e.getKeyCode() == KeyEvent.VK_ENTER){
+			launchmissiles = false;
+		}
+	}
+	@Override
+	public void keyPressed(KeyEvent e) {
+		if(e.getKeyChar() == 'd' || e.getKeyCode() == KeyEvent.VK_RIGHT){
+			movedirvert = 1;
+		}else if(e.getKeyChar() == 'a' || e.getKeyCode() == KeyEvent.VK_LEFT){
+			movedirvert = -1;
+		}else if(e.getKeyChar() == 'w' || e.getKeyCode() == KeyEvent.VK_UP){
+			movedirhor = -1;
+		}else if(e.getKeyChar() == 's' || e.getKeyCode() == KeyEvent.VK_DOWN){
+			movedirhor = 1;
+		}else if(e.getKeyChar() == ' ' || e.getKeyCode() == KeyEvent.VK_ENTER){
+			launchmissiles = true;
+		}
+	}
+	public void setLives(int health){
+		this.health = health;
+	}
+	public int getScore() {
+		return score;
+	}
+	public void setScore(int score) {
+		this.score = score;
+	}
+	public int getHealth() {
+		return health;
+	}	
+	public int getShieldpower() {
+		return shieldpower;
+	}
+	public void setShieldpower(int shieldpower) {
+		this.shieldpower = shieldpower;
+	}
+	public void setHealth(int health) {
+		this.health = health;
+	}
+	public void reset(){
+		particle = new ArrayList<Fireball>();
+		missiles = new ArrayList<PlayerMissile>();
+		health = 120;
+		shieldpower = 100;
+		score = 0;
+	}
+	public void draw(Graphics2D g2){
+		if(shieldpower > 0){
+			g2.setPaint(new RadialGradientPaint(new Point((int)(border.getX() + border.getWidth()/2),(int)(border.getY() + border.getHeight()/2)), (int)(border.getHeight()), new float[]{0.3f,0.9f,1f}, new Color[]{new Color(0,0,0,0),new Color(130,208,250,shieldpower*2),new Color(0,0,0,0) }));
+			g2.fillRect((int)(border.getX()-100), (int)(border.getY()-100), (int)(border.getWidth()+200),(int)(border.getHeight()+200));
+		}
+		super.draw(g2);
+		try{
+			Iterator<PlayerMissile> i = missiles.iterator();
+			while(i.hasNext()){
+				PlayerMissile m = i.next();
+				m.draw(g2);
+			}
+			Iterator<Fireball> j = particle.iterator();
+			while(j.hasNext()){
+				Fireball b = j.next();
+				b.draw(g2);
+			}
+		}catch(ConcurrentModificationException e){e.printStackTrace();}
+	}
+	
+	public void reCalculate(){
+		movedirvert = (joystick.getxAxisPercentage()-50)*0.15;
+		movedirhor = (joystick.getyAxisPercentage()-50)*-0.15;
+		
+		Iterator<PlayerMissile> i = missiles.iterator();
+		while(i.hasNext()){
+			PlayerMissile m = i.next();
+			if(m.outOfScreen(0, 0, 800, 800)){
+				i.remove();
+			}else{
+				m.recalculate();
+			}
+		}
+		Iterator<Fireball> j = particle.iterator();
+		while(j.hasNext()){
+			Fireball b = j.next();
+			if(b.color.getBlue() < 160){
+				j.remove();
+			}else{
+				b.update();
+			}
+		}
+		if(movedirvert != 0 || movedirhor != 0){
+			border.setLocation((int)(border.getX()+movedirvert*12), (int)(border.getY()+movedirhor*12));
+			for(int k = 0; k < 120; k++){
+				particle.add(new Fireball((int)(border.getX()+(border.getWidth()/2)+(Math.random()*10)-5), (int)(border.getMaxY()+(Math.random()*10)), (int)((border.getX() + border.getMaxX()) / 2)));
+			}
+		}
+		if(launchmissiles && System.currentTimeMillis() - lastFired > 200){
+			lastFired = System.currentTimeMillis();
+			missiles.add(new PlayerMissile(getX()+10, getY(), 20));
+			missiles.add(new PlayerMissile(getX()+45, getY(), 20));
+		}
+	}
+	
+	public boolean missileIntersect(Missile m){
+		Iterator<PlayerMissile> i = missiles.iterator();
+		while(i.hasNext()){
+			PlayerMissile pm = i.next();
+			if(pm.intersect(m)){
+				i.remove();
+				return true;
+			}
+		}
+		return false;
+	}
+	public boolean intersect(ArrayList<Missile> missiles){
+		boolean tempreturn = false;
+		for(Missile m:missiles){
+			Ellipse2D shield = new Ellipse2D.Double((int)(border.getX()+border.getWidth()/2-60), (int)(border.getY()+border.getHeight()/2)-50, (int)(border.getHeight())+50, (int)border.getWidth()+50);
+			if(shieldpower > 0 && shield.intersects(m.getBorder())){
+				if(m.type == Missile.Missiletype.BALL){
+					Ball ball = (Ball)m;
+					if(!ball.isReturned()){
+						m.setYspeed(m.getYspeed()*-1.5);
+						shieldpower -= 10;
+						ball.setReturned(true);
+					}
+
+				}
+			}else if(m.intersect(getBorder())){
+				health -= 10;
+				m.explode(true);
+				return true;
+			}
+
+		}
+		return tempreturn;
+	}
+}

src/bullithell/objects/Ship.java

@@ -0,0 +1,39 @@
+package bullithell.objects;
+
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+
+public class Ship{
+	private BufferedImage ship;
+	public Rectangle border;	
+	
+	public Ship(BufferedImage image, int x, int y){
+		ship = image;
+		border = new Rectangle(0, 0, image.getWidth(), image.getHeight());
+		setLocation(x, y);
+	}
+	
+	public void draw(Graphics2D g2){
+		g2.drawImage(ship, (int)border.getX(), (int)border.getY(), (int)border.getWidth(), (int)border.getHeight(), null);
+	}
+	
+	public void setLocation(int x, int y){
+		border.setLocation(x, y);
+	}
+	public int getX(){
+		return (int) border.getX();
+	}
+	public int getY(){
+		return (int) border.getY();
+	}
+	public int getWidth(){
+		return (int) border.getWidth();
+	}
+	public int getHeight(){
+		return (int) border.getHeight();
+	}
+	public Rectangle getBorder() {
+		return border;
+	}	
+}

src/bullithell/objects/missiles/Ball.java

@@ -0,0 +1,35 @@
+package bullithell.objects.missiles;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RadialGradientPaint;
+import java.awt.Rectangle;
+
+public class Ball extends Missile{
+	private Color color;
+	private boolean returned;
+	
+	public Ball(int x, int y, Color color, double xspeed, double yspeed){
+		setBorder(new Rectangle(x, y, 25,25));
+		this.color = color;
+		setXspeed(xspeed);
+		setYspeed(yspeed);
+		type = Missile.Missiletype.BALL;
+	}
+	public void draw(Graphics2D g2){
+		g2.setPaint(new RadialGradientPaint(new Point((int)(getBorder().getX() + getBorder().getWidth()/2),(int)(getBorder().getY() + getBorder().getHeight()/2)), (int)(getBorder().getHeight()), new float[]{0.0f,0.3f,0.5f,1f}, new Color[]{color,new Color(0,0,0,0),color,new Color(0,0,0,0) }));
+		g2.fillOval((int)getBorder().getX(), (int)getBorder().getY(), (int)getBorder().getWidth(), (int)getBorder().getHeight());
+		super.draw(g2);
+	}
+	public void recalculate(){
+		super.recalculate();
+	}
+	public boolean isReturned() {
+		return returned;
+	}
+	public void setReturned(boolean returned) {
+		this.returned = returned;
+	}
+	
+}

src/bullithell/objects/missiles/BombMissile.java

@@ -0,0 +1,31 @@
+package bullithell.objects.missiles;
+
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+
+import bullithell.images.Images;
+
+public class BombMissile extends Missile{
+	BufferedImage background;
+	
+	public BombMissile(int x, int y, String type){
+		setBorder(new Rectangle(x,y,Images.bomb.getWidth(), Images.bomb.getHeight()));
+		background = Images.bomb;
+		setExplodable(true);
+		this.type = Missile.Missiletype.BOMB;
+		switch(type){
+		case "slow":
+			setYspeed(1);
+			setXspeed(0);
+			break;
+		}
+	}
+	public void draw(Graphics2D g2) {
+		g2.drawImage(background, (int)getBorder().getX(), (int)getBorder().getY(), (int)getBorder().getWidth(), (int)getBorder().getHeight(),null);
+		super.draw(g2);
+	}
+	public void recalculate() {
+		super.recalculate();
+	}
+}

src/bullithell/objects/missiles/Missile.java

@@ -0,0 +1,84 @@
+package bullithell.objects.missiles;
+
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import bullithell.images.Images;
+
+public abstract class Missile {
+	private Rectangle border;
+	private double xspeed;
+	double yspeed;
+	private boolean explodable;
+	private int explodeState;
+	private BufferedImage explode;
+	public Missiletype type;
+	public enum Missiletype{BALL, BOMB, LASER};
+	
+	public double getXspeed() {
+		return xspeed;
+	}
+	public void setXspeed(double d) {
+		this.xspeed = d;
+	}
+	public double getYspeed() {
+		return yspeed;
+	}
+	public void setYspeed(double d) {
+		this.yspeed = d;
+	}
+	public Rectangle getBorder() {
+		return border;
+	}
+	public void setBorder(Rectangle border) {
+		this.border = border;
+	}	
+	public boolean isExplodable() {
+		return explodable;
+	}
+	public void setExplodable(boolean explodable) {
+		this.explodable = explodable;
+	}
+	public int getExplodeState() {
+		return explodeState;
+	}
+	public void draw(Graphics2D g2){
+		if(explodeState > 1){
+			g2.drawImage(explode, (int)((border.getX()+border.getWidth()/2)-64), (int)((border.getY()+border.getHeight()/2)-64), (int)128, (int)128, null);
+			g2.translate((Math.random()*10)-5, Math.random()*10-5);
+		}
+	};
+	public void recalculate(){
+		getBorder().setLocation((int)(getBorder().getX()+getXspeed()), (int)(getBorder().getY() + getYspeed()));
+	};
+	public void explode(boolean shipintersect){
+		if(explodable || shipintersect){
+			explodeState = 1;
+			explode = Images.explode.getSubimage(0, 0, 128, 128);
+			new Timer().schedule(new TimerTask() {
+				@Override
+				public void run() {
+					explode = Images.explode.getSubimage(explodeState*128, 0, 128, 128);
+					if(explodeState != 11){
+						explodeState++;
+					}
+				}
+			}, 0, 40);
+		}
+	}
+	public boolean outOfScreen(int x, int y, int w, int h){
+		return !getBorder().intersects(x, y, w, h);
+	}	
+	public boolean intersect(Missile m){
+		return intersect(m.getBorder());
+	}
+	public boolean intersect(Rectangle r){
+		if(explodeState == 0){
+			return getBorder().intersects(r);
+		}
+		return false;
+	}
+}

src/bullithell/objects/missiles/PlayerMissile.java

@@ -0,0 +1,32 @@
+package bullithell.objects.missiles;
+
+import java.awt.Color;
+import java.awt.GradientPaint;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RadialGradientPaint;
+import java.awt.Rectangle;
+
+public class PlayerMissile extends Missile {
+	private Rectangle background;
+	
+	public PlayerMissile(int x, int y, int speed){
+		this.setBorder(new Rectangle(x, y,3,20));
+		this.background = new Rectangle(x-20, y-20, 30, 40);
+		this.setYspeed(speed*-1);
+		this.setXspeed(0);
+		this.type = Missile.Missiletype.LASER;
+	}
+	public void draw(Graphics2D g2){
+		super.draw(g2);
+		g2.setPaint(new RadialGradientPaint(new Point((int)(getBorder().getX() + getBorder().getWidth()/2),(int)(getBorder().getY() + getBorder().getHeight()/2)), (int)(background.getHeight()/2), new float[]{0f,0.6f}, new Color[]{Color.WHITE,new Color(0,0,0,0)}));
+		g2.fill(background);
+		g2.setPaint(new GradientPaint(new Point((int)getBorder().getX(),(int)getBorder().getY()), Color.WHITE, new Point((int)getBorder().getMaxX(),(int)getBorder().getMaxY()), new Color(190,190,190,100)));
+		g2.fill(getBorder());
+	}
+	public void recalculate(){
+		super.recalculate();
+		background.setLocation((int)(getBorder().getX() - 15), (int)(getBorder().getY()-15));
+	}
+
+}

src/bullithell/panels/ContentPanel.java

@@ -0,0 +1,110 @@
+package bullithell.panels;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import javax.swing.JPanel;
+import javax.swing.Timer;
+
+import bullithell.images.Images;
+import bullithell.objects.Player;
+import bullithell.objects.missiles.Ball;
+import bullithell.objects.missiles.BombMissile;
+import bullithell.objects.missiles.Missile;
+
+@SuppressWarnings("serial")
+public class ContentPanel extends JPanel {
+	Timer framestimer, gameloop;
+	Player player;
+	ArrayList<Missile> missiles;
+	long oldtime;
+	
+	public ContentPanel(){
+		player = new Player(400,700);
+		missiles = new ArrayList<Missile>();
+		this.addKeyListener(player);
+		this.setFocusable(true);
+
+		gameloop = new Timer(1000/30, new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				player.reCalculate();
+				if(Math.random()*1000 > 900){
+					missiles.add(new BombMissile((int)(Math.random()*800), 10, "slow"));
+				}
+				Iterator<Missile> i = missiles.iterator();
+				while(i.hasNext()){
+					Missile m = i.next();					
+					if(m.outOfScreen(0, 0, 800, 800) || m.getExplodeState() == 11){
+						i.remove();
+					}else if(player.missileIntersect(m)){
+						m.explode(false);
+					}else if(player.intersect(missiles)){
+					}
+					
+					m.recalculate();
+				}
+				shootBalls();
+				
+				
+
+			}
+		});
+		//update 60fps
+		framestimer = new Timer(1000/60, new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				repaint();
+			}
+		});
+		framestimer.start();
+		gameloop.start();
+		
+
+	}
+	public void shootBalls(){
+		if(System.currentTimeMillis() - oldtime > 5000){
+		oldtime = System.currentTimeMillis();
+		for(int i1 = -9; i1 < 9; i1++){
+			missiles.add(new Ball(400, 10, Color.red, i1*0.8, Math.pow(i1, 2)*0.05+4));
+		}
+		}
+	}
+	public void paintComponent(Graphics g){
+		super.paintComponent(g);
+		Graphics2D g2 = (Graphics2D)g;
+		
+		//g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
+		
+		g2.drawImage(Images.background, 0,0,getWidth(), getHeight(),null);
+		for(Missile m: missiles){
+			m.draw(g2);
+		}
+		player.draw(g2);
+		
+		//player statics menu
+		g2.setFont(new Font("FreeSans", Font.BOLD, 20));
+		g2.setPaint(new GradientPaint(new Point((int)(150),(int)(getHeight()-35)), Color.red.darker(),new Point((int)(150),(int)(getHeight()-15)) , Color.red));
+		g2.drawString("Health", 40, getHeight()-20);
+		g2.fillRect(150, getHeight()-35, player.getHealth(), 20);
+		g2.setPaint(new GradientPaint(new Point((int)(150),(int)(getHeight()-35)), Color.blue.darker(),new Point((int)(150),(int)(getHeight()-15)) , Color.blue));
+		g2.drawString("Shield", 340, getHeight()-20);
+		g2.fillRect(450, getHeight()-35, player.getShieldpower(), 20);
+		g2.setColor(Color.WHITE);
+		g2.drawString("Level 1", 640, getHeight()-20);
+		g2.drawString("Score: 4000", 40, 40);
+		g2.drawString("Upgrade available", 550, 40);
+		
+		Toolkit.getDefaultToolkit().sync();
+	}
+}

src/bullithell/particles/Fireball.java

@@ -0,0 +1,56 @@
+package bullithell.particles;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+
+public class Fireball {
+	private double x,y, mp;
+	public Color color;
+
+	public Fireball(int startx, int starty, int middlepoint)
+	{
+		x = startx;
+		y = starty;
+		mp = middlepoint;
+		color = Color.white;
+	}
+	
+	public void update()
+	{
+		y += 1;
+		if(x < mp){
+			x -= 1 -Math.random()*-10;
+		}else{
+			x += 1 + Math.random()*10;
+		}
+		color = new Color(255,color.getGreen(),color.getBlue()-40);
+	}
+	
+	public void draw(Graphics g)
+	{
+		Graphics2D g2 = (Graphics2D)g;
+		g2.setColor(color);
+		Ellipse2D.Double ellipse = new Ellipse2D.Double(x,y,5,5);
+		g2.fill(ellipse);
+	}
+
+	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;
+	}
+	
+	
+}

src/frames/GameFrame.java

@@ -0,0 +1,17 @@
+package frames;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+@SuppressWarnings("serial")
+public class GameFrame extends JFrame {
+	public GameFrame(JPanel panel){
+		this.add(panel);
+		this.setLocationRelativeTo(null);
+		this.setSize(800, 800);
+		this.setVisible(true);
+		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+		this.setResizable(false);
+		
+	}
+}

src/frames/MainFrame.java

@@ -0,0 +1,18 @@
+package frames;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+@SuppressWarnings("serial")
+public class MainFrame extends JFrame {
+	public MainFrame(JPanel panel){
+		this.add(panel);
+		this.setLocationRelativeTo(null);
+		this.setLocation(2000, 80);
+		this.setSize(800, 800);
+		this.setVisible(true);
+		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
+		this.setResizable(false);
+		
+	}
+}

src/frames/MainMenu.java

@@ -0,0 +1,16 @@
+package frames;
+
+import javax.swing.JFrame;
+
+@SuppressWarnings("serial")
+public class MainMenu extends JFrame {
+	public MainMenu(){
+		this.add(new panels.MainMenu());
+		//this.setLocationRelativeTo(null);
+		this.setSize(1400, 875);
+		this.setVisible(true);
+		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
+		this.setResizable(false);
+		
+	}
+}

src/main/Joystick.java

@@ -0,0 +1,112 @@
+package main;
+
+import java.util.ArrayList;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import bullithell.images.Images;
+import net.java.games.input.Component;
+import net.java.games.input.Component.Identifier;
+import net.java.games.input.Controller;
+import net.java.games.input.ControllerEnvironment;
+
+/**
+ *
+ * Joystick Test with JInput
+ *
+ *
+ * @author TheUzo007 
+ *         http://theuzo007.wordpress.com
+ *
+ * Created 22 Oct 2013
+ *
+ */
+public class Joystick implements Runnable{
+    private int xAxisPercentage, yAxisPercentage;
+    private ArrayList<Controller> foundControllers;
+
+    public Joystick() {
+        foundControllers = new ArrayList<>();
+        searchForControllers();
+		if(!foundControllers.isEmpty())
+			new Timer().schedule(new TimerTask() {
+				@Override
+				public void run() {
+		            readData(foundControllers.get(0));
+				}
+			}, 0, 100);
+        	
+    }
+
+    private void searchForControllers() {
+        Controller[] controllers = ControllerEnvironment.getDefaultEnvironment().getControllers();
+        for(int i = 0; i < controllers.length; i++){
+            Controller controller = controllers[i];
+            if (
+                    controller.getType() == Controller.Type.STICK || 
+                    controller.getType() == Controller.Type.GAMEPAD || 
+                    controller.getType() == Controller.Type.WHEEL ||
+                    controller.getType() == Controller.Type.FINGERSTICK
+               )
+            {
+                // Add new controller to the list of all controllers.
+                foundControllers.add(controller);
+                
+            }
+        }
+    }
+    
+    private void readData(Controller controller){
+        // Pull controller for current data, and break while loop if controller is disconnected.
+        if( !controller.poll() ){
+            return;
+        }
+        
+        // Go trough all components of the controller.
+        Component[] components = controller.getComponents();
+        for(int i=0; i < components.length; i++)
+        {
+            Component component = components[i];
+            Identifier componentIdentifier = component.getIdentifier();
+            
+            
+            // Axes
+            if(component.isAnalog()){
+                float axisValue = component.getPollData();
+                int axisValueInPercentage = getAxisValueInPercentage(axisValue);
+                
+                // X axis
+                if(componentIdentifier == Component.Identifier.Axis.X){
+                    xAxisPercentage = axisValueInPercentage;
+                    continue; // Go to next component.
+                }
+                // Y axis
+                if(componentIdentifier == Component.Identifier.Axis.Y){
+                    yAxisPercentage = axisValueInPercentage;
+                    continue; // Go to next component.
+                }
+            }
+        }
+    }
+    private int getAxisValueInPercentage(float axisValue)
+    {
+        return (int)(((2 - (1 - axisValue)) * 100) / 2);
+    }
+
+	public int getxAxisPercentage() {
+		return xAxisPercentage;
+	}
+
+	public int getyAxisPercentage() {
+		return yAxisPercentage;
+	}
+
+	@Override
+	public void run() {
+		// TODO Auto-generated method stub
+		
+	}
+
+
+    
+}

src/main/Main.java

@@ -0,0 +1,9 @@
+package main;
+
+import frames.MainMenu;
+
+public class Main {
+	public static void main(String[] args){
+		new MainMenu();
+	}
+}

src/objects/Enemie.java

@@ -0,0 +1,18 @@
+package objects;
+
+import java.awt.image.BufferedImage;
+
+public class Enemie extends Ship{
+	int row, column;
+	public Enemie(BufferedImage image, int x, int y, int row, int column){
+		super(image,x,y);
+		this.row = row;
+		this.column = column;
+	}
+	public int getRow() {
+		return row;
+	}
+	public int getColumn() {
+		return column;
+	}
+}

src/objects/Missile.java

@@ -0,0 +1,27 @@
+package objects;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+
+public class Missile {
+	private Rectangle rect;
+	int dir;
+	public Missile(int x, int y, int dir){
+		rect = new Rectangle(x, y,6,20);
+		this.dir = dir;
+	}
+	public void draw(Graphics2D g2){
+		g2.setColor(Color.white);
+		g2.fill(rect);
+	}
+	public void recalculate(){
+		rect.setLocation((int)rect.getX(), (int)(rect.getY() + 10*dir));
+	}
+	public boolean playerCollision(Player player){
+		return rect.intersects(player.getBorder());
+	}
+	public boolean outOfScreen(int x, int y, int w, int h){
+		return !rect.intersects(x, y, w, h);
+	}
+}

src/objects/Player.java

@@ -0,0 +1,42 @@
+package objects;
+
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.image.BufferedImage;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class Player extends Ship implements KeyListener{
+	private Timer movetimer;
+	private int movedir;
+	
+	public Player(BufferedImage image, int x, int y) {
+		super(image,x,y);
+		movetimer = new Timer();
+		movetimer.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				border.setLocation((int)border.getX()+movedir*7, (int)border.getY());
+			}
+		}, 0, 10);
+	}
+	
+	@Override
+	public void keyPressed(KeyEvent e) {
+	}
+	@Override
+	public void keyReleased(KeyEvent e) {
+		if((e.getKeyChar() == 'd' && movedir == 1) || (e.getKeyChar() == 'a' && movedir == -1)){
+			movedir = 0;
+		}
+	}
+	@Override
+	public void keyTyped(KeyEvent e) {
+		if(e.getKeyChar() == 'd'){
+			movedir = 1;
+		}else if(e.getKeyChar() == 'a'){
+			movedir = -1;
+		}
+	}
+	
+}

src/objects/Ship.java

@@ -0,0 +1,49 @@
+package objects;
+
+import java.awt.BasicStroke;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.image.BufferedImage;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class Ship{
+	private BufferedImage ship;
+	public Rectangle border;	
+
+	
+	public Ship(BufferedImage image, int x, int y){
+		ship = image;
+		border = new Rectangle(0, 0, image.getWidth(), image.getHeight());
+		setLocation(x, y);
+	}
+	
+	public void draw(Graphics2D g2){
+		g2.drawImage(ship, (int)border.getX(), (int)border.getY(), (int)border.getWidth(), (int)border.getHeight(), null);
+		g2.setStroke(new BasicStroke(1));
+	}
+	
+	public void setLocation(int x, int y){
+		border.setLocation(x, y);
+	}
+	public int getX(){
+		return (int) border.getX();
+	}
+	public int getY(){
+		return (int) border.getY();
+	}
+	public int getWidth(){
+		return (int) border.getWidth();
+	}
+	public int getHeight(){
+		return (int) border.getHeight();
+	}
+
+	public Rectangle getBorder() {
+		return border;
+	}
+	
+	
+}

src/panels/MainMenu.java

@@ -0,0 +1,62 @@
+package panels;
+
+import java.awt.Cursor;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionAdapter;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+import javax.swing.JPanel;
+
+import frames.GameFrame;
+
+@SuppressWarnings("serial")
+public class MainMenu extends JPanel{
+	BufferedImage background;
+	Rectangle game1,game2;
+	public MainMenu(){
+		setFocusable(true);
+		this.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				if(game1.intersects(e.getX(), e.getY(), 1, 1)){
+					new GameFrame(new spaceinvaders.panels.ContentPanel());
+				}else if(game2.intersects(e.getX(), e.getY(), 1, 1)){
+					new GameFrame(new bullithell.panels.ContentPanel());
+				}
+			}
+		});
+		this.addMouseMotionListener(new MouseMotionAdapter() {
+			public void mouseMoved(MouseEvent e) {
+				if(game1.intersects(e.getX(), e.getY(), 1, 1)){
+					setCursor(new Cursor(Cursor.HAND_CURSOR));
+				}else if(game2.intersects(e.getX(), e.getY(), 1, 1)){
+					setCursor(new Cursor(Cursor.HAND_CURSOR));
+				}else{
+					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
+				}
+			}
+		});
+		try {
+			background = ImageIO.read(new File("res/mainmenu.png"));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		game1 = new Rectangle(91,411,469,378);
+		game2 = new Rectangle(842,406,469,378);
+	}
+	
+	public void paintComponent(Graphics g){
+		super.paintComponent(g);
+		Graphics2D g2 = (Graphics2D)g;
+		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
+		g2.drawImage(background, 0, 0, null);
+	}
+}

src/spaceinvaders/images/Images.java

@@ -0,0 +1,19 @@
+package spaceinvaders.images;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+public class Images {
+	public static BufferedImage player, enemie1, enemie2, enemie3;
+	static{	
+		try{
+			player = ImageIO.read(new File("res/ship.png"));
+			enemie1 = ImageIO.read(new File("res/enemie1.png"));
+			enemie2 = ImageIO.read(new File("res/enemie2.png"));
+			enemie3 = ImageIO.read(new File("res/enemie3.png"));
+		}catch(IOException e){}
+	}
+}

src/spaceinvaders/objects/Block.java

@@ -0,0 +1,43 @@
+package spaceinvaders.objects;
+
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class Block {
+	private ArrayList<Rectangle> blocks;
+	private Rectangle border;
+
+	public Block(int x, int y){
+		blocks = new ArrayList<Rectangle>();		
+		for(int i = 0; i < 13; i++){
+			for(int j = 0; j < 17; j++){
+				if(!(j > 3 + (((i-13)*-1)/2) && j < 13 - (((i-13)*-1)/2) && i > 6)){
+					if(!(i >=0 && i < 4 && (j >= 0 && j < 3-(i/2) || j > 13+(i/2) && j <= 16))){
+						blocks.add(new Rectangle(x+j*5,y+i*5,5,5));
+					}
+				}
+			}
+		}
+		border = new Rectangle(x,y,85,65);
+	}
+	public boolean missileCollision(Missile m){
+		if(border.intersects(m.getRect())){
+			Iterator<Rectangle> i = blocks.iterator();
+			while(i.hasNext()){
+				Rectangle r = i.next();
+				if(r.intersectsLine(m.getRect().getX(), m.getRect().getY(), 5, 5)){
+					i.remove();
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	public void draw(Graphics2D g2){
+		for(Rectangle r:blocks){
+			g2.fill(r);
+		}
+	}
+}

src/spaceinvaders/objects/Enemie.java

@@ -0,0 +1,31 @@
+package spaceinvaders.objects;
+
+import java.awt.image.BufferedImage;
+
+public class Enemie extends Ship{
+	private int row, column, destroyscore;
+	public Enemie(BufferedImage image, int x, int y, int row, int column){
+		super(image,x,y);
+		this.row = row;
+		this.column = column;
+		setDestroyScore();
+	}
+	private void setDestroyScore(){
+		if(row == 0){
+			destroyscore = 30;
+		}else if(row == 1 || row == 2){
+			destroyscore = 20;
+		}else if(row == 3 || row ==4){
+			destroyscore = 10;
+		}
+	}
+	public int getDestroyScore(){
+		return destroyscore;
+	}
+	public int getRow() {
+		return row;
+	}
+	public int getColumn() {
+		return column;
+	}
+}

src/spaceinvaders/objects/Missile.java

@@ -0,0 +1,46 @@
+package spaceinvaders.objects;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+
+public class Missile {
+	private Rectangle rect;
+	private int dir;
+	private char sender;
+	
+	public Missile(int x, int y, int dir, char sender){
+		rect = new Rectangle(x, y,2,17);
+		this.dir = dir;
+		this.sender = sender;
+	}
+	public void draw(Graphics2D g2){
+		g2.setColor(Color.white);
+		g2.fill(rect);
+	}
+	public void recalculate(){
+		rect.setLocation((int)rect.getX(), (int)(rect.getY() + 15*dir));
+	}
+	public boolean playerCollision(Player player){
+		return rect.intersects(player.getBorder());
+	}
+	public Enemie shipCollision(ArrayList<Enemie> enemies){
+		for(Enemie e:enemies){
+			if(rect.intersects(e.getBorder()))
+				return e;
+		}
+		return null;
+	}
+	public boolean outOfScreen(int x, int y, int w, int h){
+		return !rect.intersects(x, y, w, h);
+	}
+	public char getSender() {
+		return sender;
+	}
+	public Rectangle getRect() {
+		return rect;
+	}
+	
+	
+}

src/spaceinvaders/objects/Player.java

@@ -0,0 +1,65 @@
+package spaceinvaders.objects;
+
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import spaceinvaders.images.Images;
+
+public class Player extends Ship implements KeyListener{
+	private Timer movetimer;
+	private int movedir, lives, score;
+	
+	public Player(int x, int y) {
+		super(Images.player,x,y);
+		lives = 3;
+		movetimer = new Timer();
+		movetimer.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				border.setLocation((int)border.getX()+movedir*7, (int)border.getY());
+			}
+		}, 0, 40);
+	}
+	
+	@Override
+	public void keyTyped(KeyEvent e) {
+	}
+	@Override
+	public void keyReleased(KeyEvent e) {
+		if(((e.getKeyChar() == 'd' ||  e.getKeyCode() == KeyEvent.VK_RIGHT) && movedir == 1) || ((e.getKeyChar() == 'a' || e.getKeyCode() == KeyEvent.VK_LEFT) && movedir == -1)){
+			movedir = 0;
+		}
+	}
+	@Override
+	public void keyPressed(KeyEvent e) {
+		if(e.getKeyChar() == 'd' || e.getKeyCode() == KeyEvent.VK_RIGHT){
+			movedir = 1;
+		}else if(e.getKeyChar() == 'a' || e.getKeyCode() == KeyEvent.VK_LEFT){
+			movedir = -1;
+		}
+	}
+	public void setLives(int lives){
+		this.lives = lives;
+	}
+
+	public int getScore() {
+		return score;
+	}
+
+	public void setScore(int score) {
+		this.score = score;
+	}
+
+	public int getLives() {
+		return lives;
+	}
+	public void explode(){
+		lives--;
+	}
+	public void reset(){
+		lives = 3;
+		score = 0;
+	}
+}

src/spaceinvaders/objects/Ship.java

@@ -0,0 +1,47 @@
+package spaceinvaders.objects;
+
+import java.awt.BasicStroke;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+
+public abstract class Ship{
+	private BufferedImage ship, subimage;
+	public Rectangle border;	
+	private int offset;
+	
+	public Ship(BufferedImage image, int x, int y){
+		ship = image;
+		subimage = image.getSubimage(0, 0, 32, ship.getHeight());
+		border = new Rectangle(0, 0, 32, image.getHeight());
+		setLocation(x, y);
+	}
+	public void draw(Graphics2D g2){
+		g2.drawImage(subimage, (int)border.getX(), (int)border.getY(), (int)border.getWidth(), (int)border.getHeight(), null);
+		g2.setStroke(new BasicStroke(1));
+	}
+	public void setLocation(int x, int y){
+		border.setLocation(x, y);
+		subimage = ship.getSubimage(offset, 0, 32, ship.getHeight());
+		if(offset == 32){
+			offset = 0;
+		}else {
+			offset = 32;
+		}
+	}
+	public int getX(){
+		return (int) border.getX();
+	}
+	public int getY(){
+		return (int) border.getY();
+	}
+	public int getWidth(){
+		return (int) border.getWidth();
+	}
+	public int getHeight(){
+		return (int) border.getHeight();
+	}
+	public Rectangle getBorder() {
+		return border;
+	}	
+}

src/spaceinvaders/panels/ContentPanel.java

@@ -0,0 +1,238 @@
+package spaceinvaders.panels;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import javax.swing.JPanel;
+import javax.swing.Timer;
+
+import spaceinvaders.images.Images;
+import spaceinvaders.objects.Block;
+import spaceinvaders.objects.Enemie;
+import spaceinvaders.objects.Missile;
+import spaceinvaders.objects.Player;
+
+@SuppressWarnings("serial")
+public class ContentPanel extends JPanel {
+	Player player;
+	Timer framestimer, shipstimer, missiletimer;
+	BufferedImage[] images;
+	ArrayList<Enemie> enemies;
+	ArrayList<Missile> missiles;
+	ArrayList<Block> blocks;
+	int direction;
+	boolean gameover;
+	
+	public ContentPanel(){
+		setBackground(Color.black);
+		images = new BufferedImage[5];
+		images[0] = Images.enemie1;
+		images[1] = images[2] = Images.enemie2;
+		images[3] = images[4] = Images.enemie3;
+		blocks = new ArrayList<Block>();
+		player = new Player(200,700);
+		enemies = new ArrayList<Enemie>();
+		missiles = new ArrayList<Missile>();
+		
+		this.addKeyListener(player);
+		this.addKeyListener(new KeyAdapter() {
+			@Override
+			public void keyTyped(KeyEvent e) {
+				super.keyTyped(e);
+				if(e.getKeyChar() == ' '){
+					//only send new missile if there aren't any other in the game launched by the player
+					boolean launched = false;
+					for(Missile m:missiles){
+						if(m.getSender() == 'p'){
+							launched = true;
+							break;
+						}
+					}
+					if(!launched){
+						missiles.add(new Missile(player.getX()+player.getWidth()/2-3, player.getY(), -1, 'p'));
+					}
+				}else if(e.getKeyChar() == 'r'){
+					reset();
+				}
+			}
+		});
+		this.setFocusable(true);
+		
+		//update 60fps
+		framestimer = new Timer(1000/30, new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				repaint();
+			}
+		});
+
+		//ships moving
+		direction =  1;
+		shipstimer = new Timer(1000/1, new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				int tempdirection = direction;
+				for(Enemie enemie:enemies){
+					enemie.setLocation((int)(enemie.getX()+(8*direction)), enemie.getY());
+					if(enemie.getX()+(8*direction) <= 5 || enemie.getBorder().getMaxX()+(8*direction) >= 780){
+						tempdirection = direction * -1;
+					}
+				}
+				if(direction != tempdirection){
+					direction = tempdirection;
+					if(shipstimer.getDelay() -100 > 0) shipstimer.setDelay(shipstimer.getDelay()-100);
+					for(Enemie enemie:enemies){
+						enemie.setLocation((int)(enemie.getX()), enemie.getY()+15);
+						if(enemie.getBorder().getMaxY() > 450){
+							gameOver();
+						}
+					}
+				}
+				//random missile generate
+				double random = Math.random() *shipstimer.getDelay();
+				if(random >= 0 && random < 200){
+					int column = (int) (Math.random()*12);
+					Enemie lowestobject = null;
+					boolean first = true;
+					for(Enemie enemie:enemies){
+						if(enemie.getColumn() == column && (first || enemie.getRow() > lowestobject.getRow())){
+							lowestobject = enemie;
+							first = false;
+						}
+					}
+					if(lowestobject != null){
+						missiles.add(new Missile(lowestobject.getX()+lowestobject.getWidth()/2, lowestobject.getY()+lowestobject.getHeight(), 1, 'c'));
+					}
+				}
+			}
+		});
+		
+		//missile animator
+		missiletimer = new Timer(1000/30, new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				Iterator<Missile> i = missiles.iterator();
+				while(i.hasNext()){
+					Missile m = i.next();
+					m.recalculate();
+					Enemie ecollision = m.shipCollision(enemies);
+					if(m.outOfScreen(0,0,getWidth(),getHeight())){
+						i.remove();
+					}else if(m.getSender() != 'p' && m.playerCollision(player)){
+						player.explode();
+						i.remove();
+						if(player.getLives() == 0)	gameOver();
+					}else if(m.getSender() != 'c' &&  ecollision != null){
+						i.remove();
+						player.setScore(player.getScore() + ecollision.getDestroyScore());
+						enemies.remove(ecollision);
+						if(enemies.size() == 0){
+							createEnemies();
+							player.setLives(player.getLives()+1);
+						}
+					}
+					for(Block b: blocks){
+						if(b.missileCollision(m)){
+							i.remove();
+						}
+					}
+				}
+			}
+		});
+		missiletimer.start();
+		shipstimer.start();
+		framestimer.start();
+		
+		createBlocks();
+		createEnemies();
+	}
+	public void gameOver(){
+		repaint();
+		missiletimer.stop();
+		shipstimer.stop();
+		framestimer.stop();
+		gameover = true;
+	}
+	public void reset(){
+		missiles.clear();
+		player.reset();
+		createEnemies();
+		createBlocks();
+		gameover=false;
+		missiletimer.start();
+		shipstimer.start();
+		framestimer.start();
+	}
+	
+	public void createEnemies(){
+		direction = 1;
+		shipstimer.setDelay(1000);
+		enemies.clear();
+		for(int i = 0; i < 55; i++){
+			enemies.add(new Enemie(images[i/11], (50*i)%550 +10, 50*(int)(i/11)+100, i/11, i%11));		
+		}
+	}
+	public void createBlocks(){
+		blocks.clear();
+		blocks.add(new Block(50,500)); 
+		blocks.add(new Block(250,500));
+		blocks.add(new Block(450,500));
+		blocks.add(new Block(650,500));
+	}
+	
+	public void paintComponent(Graphics g){
+		super.paintComponent(g);
+		Graphics2D g2 = (Graphics2D)g;
+		g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+		
+		//Draw border
+		g2.setStroke(new BasicStroke(10));
+		g2.setColor(new Color(0,255,60));
+		g2.drawRect(0, 0, getWidth(), getHeight());
+		//score and lives
+		g.setFont(new Font("TimesRoman", Font.PLAIN, 28)); 
+		g2.drawString("Score: " + player.getScore() , 40,40);
+		int spacing = 0;
+		for(int i = 0; i < player.getLives(); i++){
+			g2.drawImage(Images.player, null, 750+spacing,20);
+			spacing -= 50;
+		}
+		
+		//Draw player
+		player.draw(g2);
+		//Draw enemies
+		for(Enemie e:enemies){
+			e.draw(g2);
+		}
+		//Draw blocks
+		for(Block b:blocks){
+			b.draw(g2);
+		}
+		//draw missiles
+		for(Missile m:missiles){
+			m.draw(g2);
+		}		
+		if(gameover){
+			g2.setColor(Color.green);
+			g.setFont(new Font("TimesRoman", Font.PLAIN, 130)); 
+			g2.drawString("Game Over", 30, 300);
+			g.setFont(new Font("TimesRoman", Font.PLAIN, 90));
+			g2.drawString("Score:" + player.getScore(), 30, 400);
+			g2.setPaint(new Color(255, 0, 0,100));
+			g2.fillRect(0, 0, getWidth(), getHeight());
+		}
+		Toolkit.getDefaultToolkit().sync();
+	}
+}