You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
637 lines
17 KiB
637 lines
17 KiB
/*
|
|
Set 3 programming project
|
|
5-18-16
|
|
*****************Tanks***************
|
|
https://github.com/jrtechs/Tanks/wiki
|
|
*/
|
|
|
|
package tanks;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Font;
|
|
import java.awt.Graphics;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ActionListener;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.KeyListener;
|
|
import java.util.ArrayList;
|
|
import javax.swing.JFrame;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.Timer;
|
|
|
|
public class Tanks
|
|
{
|
|
//fields
|
|
private JFrame frame;
|
|
private JPanel panel;
|
|
private int fheight=650;
|
|
private int fwidth=900;
|
|
|
|
private Timer move;
|
|
private KeyListener key;
|
|
|
|
//game elements
|
|
private ArrayList<Bullet> bullets;
|
|
private Player p;
|
|
private ArrayList<Enemy> enemy;
|
|
private Wave wave;
|
|
|
|
//constructor
|
|
public Tanks()
|
|
{
|
|
|
|
|
|
frame=new JFrame("Tanks project");
|
|
frame.setSize(fwidth,fheight + 150);
|
|
//frame.setResizable(false);
|
|
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
|
|
newGame();
|
|
|
|
key=new KeyListener()
|
|
{
|
|
@Override
|
|
public void keyTyped(KeyEvent e)
|
|
{
|
|
|
|
}
|
|
@Override
|
|
public void keyPressed(KeyEvent e)
|
|
{
|
|
if(e.getKeyCode() == KeyEvent.VK_ESCAPE)
|
|
{
|
|
if(wave.gameMode == 1)
|
|
{
|
|
wave.setGameMode(3);
|
|
}
|
|
else if (wave.gameMode == 3)
|
|
{
|
|
wave.setGameMode(1);
|
|
}
|
|
}
|
|
p.updateDir(e, true);
|
|
}
|
|
@Override
|
|
public void keyReleased(KeyEvent e)
|
|
{
|
|
p.updateDir(e, false);
|
|
}
|
|
};
|
|
frame.addKeyListener(key);
|
|
|
|
panel = new JPanel()
|
|
{
|
|
protected void paintComponent(Graphics g)
|
|
{
|
|
//Paint Wave
|
|
wave.draw(g);
|
|
for(Bullet b: bullets)
|
|
{
|
|
b.draw(g);
|
|
}
|
|
|
|
for(Enemy en: enemy)
|
|
{
|
|
en.draw(g);
|
|
}
|
|
g.setColor(Color.BLACK);
|
|
g.fillRect(0, fheight, fwidth, 150);
|
|
p.draw(g);
|
|
|
|
//Game Info Section
|
|
//Wave
|
|
g.setColor(Color.WHITE);
|
|
g.setFont(new Font("Arial" , 1, 25));
|
|
g.drawString("Wave: " + wave.waveNum, 50, fheight + 50);
|
|
|
|
//Kills
|
|
g.setColor(Color.WHITE);
|
|
g.setFont(new Font("Arial" , 1, 25));
|
|
g.drawString("Kills: " + wave.kills, 300, fheight + 50);
|
|
|
|
//Health
|
|
g.setColor(Color.WHITE);
|
|
g.setFont(new Font("Arial" , 1, 25));
|
|
g.drawString("Health: " + p.health, 500, fheight + 50);
|
|
|
|
//Time
|
|
g.setColor(Color.WHITE);
|
|
g.setFont(new Font("Arial" , 1, 25));
|
|
g.drawString("Time: " + wave.timeCount , 700, fheight + 50);
|
|
|
|
//Pausing the game
|
|
if(wave.gameMode == 3)
|
|
{
|
|
g.setColor(Color.WHITE);
|
|
g.setFont(new Font("Arial" , 1, 40));
|
|
g.drawString("PAUSED - PRESS ESC TO CONTINUE" , 75, fheight/2);
|
|
}
|
|
|
|
if(wave.gameMode == 2)
|
|
{
|
|
g.setColor(Color.RED);
|
|
g.setFont(new Font("Arial" , 1, 40));
|
|
g.drawString("You Died" , fwidth/2 - 100, fheight/2);
|
|
}
|
|
|
|
}
|
|
};
|
|
frame.add(panel);
|
|
frame.setVisible(true);
|
|
|
|
//Timer
|
|
ActionListener tic = new ActionListener()
|
|
{
|
|
//Override
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
if(wave.gameMode == 1)
|
|
{
|
|
p.move();
|
|
for(int i = 0; i < bullets.size(); i ++)
|
|
{
|
|
try
|
|
{
|
|
bullets.get(i).move();
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(int i = 0; i < enemy.size(); i++)
|
|
{
|
|
try
|
|
{
|
|
enemy.get(i).move();
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
panel.repaint();
|
|
}
|
|
};
|
|
|
|
move = new Timer(30, tic); //Timer that moves things... Moves the player and enemies?
|
|
move.start();
|
|
}
|
|
|
|
void newGame()
|
|
{
|
|
bullets = new ArrayList<Bullet>();
|
|
enemy = new ArrayList<Enemy>();
|
|
p = new Player();
|
|
wave = new Wave();
|
|
}
|
|
|
|
public static void main(String[] arguments)
|
|
{
|
|
Tanks game = new Tanks();
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
Sub-classes that require the fields in tanks
|
|
*/
|
|
|
|
|
|
/*
|
|
the player class which extends the living class
|
|
a player has a turret and an int kills
|
|
a player has a specialized move method
|
|
a player has a update direction method which takes in a keyevent
|
|
*/
|
|
private class Player extends Living
|
|
{
|
|
private Turret t;
|
|
private boolean up,down,left,right, rleft, rRight;
|
|
|
|
public Player()
|
|
{
|
|
t=new Turret(this);
|
|
speed = 5;
|
|
x = frame.getWidth()/2;
|
|
y = frame.getHeight()/2;
|
|
health = 100;
|
|
this.imageLocation = "player.png";
|
|
super.loadImage();
|
|
width = 50;
|
|
height = 50;
|
|
}
|
|
|
|
void move()
|
|
{
|
|
if(rleft)
|
|
{
|
|
t.rotate(-1);
|
|
}
|
|
if(rRight)
|
|
{
|
|
t.rotate(1);
|
|
}
|
|
if(up==true)
|
|
{
|
|
|
|
super.move(-1);
|
|
t.move(-1);
|
|
}
|
|
if(down==true)
|
|
{
|
|
t.move(1);
|
|
super.move(1);
|
|
}
|
|
if(left==true)
|
|
{
|
|
super.direction -=5;
|
|
t.rotate(-1);
|
|
}
|
|
if(right==true)
|
|
{
|
|
super.direction+=5;
|
|
t.rotate(1);
|
|
}
|
|
if(y<=0)
|
|
{
|
|
y+=speed;
|
|
}
|
|
else if(x<=0)
|
|
{
|
|
x+=speed;
|
|
}
|
|
else if(x>=fwidth-width)
|
|
{
|
|
x-=speed;
|
|
}
|
|
else if(y>=fheight-height)
|
|
{
|
|
y-=speed;
|
|
}
|
|
t.x = x;
|
|
t.y = y;
|
|
|
|
}
|
|
void updateDir(KeyEvent e, boolean pressed)
|
|
{
|
|
int id=e.getKeyCode();
|
|
if(id== KeyEvent.VK_UP)
|
|
{
|
|
up=pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_DOWN)
|
|
{
|
|
down=pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_LEFT)
|
|
{
|
|
left=pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_RIGHT)
|
|
{
|
|
right=pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_A)
|
|
{
|
|
rleft = pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_D)
|
|
{
|
|
rRight = pressed;
|
|
}
|
|
else if(id==KeyEvent.VK_SPACE)
|
|
{
|
|
if(pressed)
|
|
{
|
|
shoot();
|
|
}
|
|
}
|
|
|
|
}
|
|
void shoot()
|
|
{
|
|
bullets.add(new Bullet (t));
|
|
}
|
|
public void draw (Graphics g)
|
|
{
|
|
super.draw(g);
|
|
t.draw(g);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
A zombie extends Enemy
|
|
a zombie has a specialized move method which
|
|
moves it twards the player
|
|
|
|
the move method checks to see if it collides with the player
|
|
if so it removes itself from the arraylist in tanks and deducts damage
|
|
*/
|
|
private class Zombie extends Enemy
|
|
{
|
|
//constructor instanciated fields
|
|
public Zombie()
|
|
{
|
|
super();
|
|
this.spawn(frame);
|
|
width = 30;
|
|
height = 30;
|
|
health = 10;
|
|
isAlive=true;
|
|
speed = 3;
|
|
imageLocation = "zombie.png";
|
|
super.loadImage();
|
|
}
|
|
//uses super to move player if collision then removes zombie and player
|
|
//takes damage
|
|
public void move()
|
|
{
|
|
direction = angleToPlayer(p);
|
|
super.move(-1);
|
|
if(this.checkCollision(p))
|
|
{
|
|
enemy.remove(this);
|
|
p.takeDamage();
|
|
if(!p.isAlive)
|
|
{
|
|
wave.setGameMode(2);
|
|
wave.kills++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
a bullet moves at a specified angle
|
|
if the bullet collides with a enemy it gives damage
|
|
if the bullet goes off the screen it removes itself from the arraylist
|
|
*/
|
|
private class Bullet extends RotationalElement
|
|
{
|
|
|
|
public boolean enemyBullet; // whether it is an enemy or player bullet
|
|
|
|
public Bullet(RotationalElement e)
|
|
{
|
|
width = 25;
|
|
height = 25;
|
|
x = e.x + 12;
|
|
y = e.y + 12;
|
|
direction = e.direction;
|
|
speed = 10;
|
|
imageLocation = "bullet.png";
|
|
super.loadImage();
|
|
}
|
|
|
|
//Moving the bullet
|
|
public void move()
|
|
{
|
|
super.move(-1);
|
|
|
|
//Checks if the bullet goes off screen, if so... it get removed
|
|
if(x < 0 || x > frame.getWidth())
|
|
{
|
|
bullets.remove(this);
|
|
}
|
|
if (y < 0 || y > frame.getHeight())
|
|
{
|
|
bullets.remove(this);
|
|
}
|
|
|
|
//Checks for collision with enemies, enemy takes damage and byllet is removed
|
|
for(int i = 0; i < enemy.size(); i++)
|
|
{
|
|
if(enemyBullet == false)
|
|
{
|
|
boolean collided = this.checkCollision(enemy.get(i));
|
|
if(collided)
|
|
{
|
|
enemy.get(i).takeDamage();
|
|
bullets.remove(this);
|
|
if(!enemy.get(i).isAlive)
|
|
{
|
|
enemy.remove(enemy.get(i));
|
|
wave.kills++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Checking enemy bullet collision with the player, player takes damage and bullet is removed
|
|
if(enemyBullet)
|
|
{
|
|
boolean collided = this.checkCollision(p);
|
|
if(collided)
|
|
{
|
|
p.takeDamage();
|
|
bullets.remove(this);
|
|
if(!p.isAlive)
|
|
{
|
|
wave.setGameMode(2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
a turret is drawn ontop of the tank
|
|
a turret can rotate and shoot bullets,
|
|
if rotate is called, put in -1 or 1, if -1, it will
|
|
turn left, 1 will cause
|
|
it to turn right
|
|
*/
|
|
private class Turret extends RotationalElement
|
|
{
|
|
public Turret(RotationalElement e)
|
|
{
|
|
width = 50;
|
|
height = 50;
|
|
x = e.x;
|
|
y = e.y;
|
|
direction = e.direction;
|
|
speed = 10;
|
|
imageLocation = "turret.png";
|
|
super.loadImage();
|
|
}
|
|
public void shoot()
|
|
{
|
|
//bullets.add(new Bullet (this));
|
|
}
|
|
|
|
public void rotate(int e)
|
|
{
|
|
super.direction = super.direction + 5*e;
|
|
}
|
|
}
|
|
/*
|
|
|
|
*/
|
|
private class Tank extends Enemy
|
|
{
|
|
|
|
Bullet b;
|
|
Turret t;
|
|
Timer tim;
|
|
ActionListener al;
|
|
public Tank()
|
|
{
|
|
super();
|
|
enemy.add(this);
|
|
this.spawn(frame);
|
|
width = 50;
|
|
height = 50;
|
|
health = 20;
|
|
isAlive=true;
|
|
speed = 2;
|
|
imageLocation = "enemyTank.png";
|
|
super.loadImage();
|
|
t = new Turret(this);
|
|
t.imageLocation = "enemyTurret.png";
|
|
t.loadImage();
|
|
|
|
al = new ActionListener()
|
|
{
|
|
@Override
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
if(getAlive())
|
|
{
|
|
b = new Bullet(t);
|
|
b.enemyBullet=true;
|
|
bullets.add(b);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
tim = new Timer(3500,al);
|
|
tim.start();
|
|
|
|
|
|
}
|
|
public void draw (Graphics g)
|
|
{
|
|
super.draw(g);
|
|
t.draw(g);
|
|
|
|
}
|
|
public void move()
|
|
{
|
|
if(this.distToPlayer(p)>250)
|
|
{
|
|
direction = angleToPlayer(p);
|
|
super.move(-1);
|
|
if(this.checkCollision(p))
|
|
{
|
|
p.takeDamage();
|
|
this.takeDamage();
|
|
if(isAlive==false)
|
|
{
|
|
enemy.remove(this);
|
|
}
|
|
if(!p.isAlive)
|
|
{
|
|
wave.setGameMode(2);
|
|
}
|
|
}
|
|
}
|
|
t.x=this.x;
|
|
t.y=this.y;
|
|
t.direction=this.angleToPlayer(p);
|
|
}
|
|
|
|
}
|
|
|
|
private class Wave extends DrawableElement
|
|
{
|
|
/*fields time is continous while playing, gameMode(1=playing,
|
|
2=paused, 3=menu. spawntime keeps a countdown until next spawn,
|
|
kills keeps track of kills duh.
|
|
*/
|
|
int timeCount, kills, gameMode, waveNum;
|
|
Timer spawn, time;
|
|
|
|
//constuctor
|
|
public Wave()
|
|
{
|
|
timeCount=0;
|
|
kills=0;
|
|
gameMode=1;
|
|
waveNum=1;
|
|
|
|
imageLocation = "wave.jpg";
|
|
super.loadImage();
|
|
|
|
//actionlistener calls spawn every 2 seconds
|
|
ActionListener s = new ActionListener()
|
|
{
|
|
|
|
@Override
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
spawn();
|
|
}
|
|
|
|
};
|
|
|
|
//action listener increments time
|
|
spawn = new Timer(2000,s);
|
|
spawn.start();
|
|
ActionListener t = new ActionListener()
|
|
{
|
|
|
|
@Override
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
if(gameMode==1)
|
|
{
|
|
timeCount++;
|
|
}
|
|
}
|
|
|
|
};
|
|
time = new Timer(1000,t);
|
|
time.start();
|
|
}
|
|
public void setGameMode(int newGameMode)
|
|
{
|
|
gameMode = newGameMode;
|
|
if(gameMode == 2)
|
|
{
|
|
//Player has died, ending the game
|
|
time.stop();
|
|
move.stop();
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//spawn method checks if spawn timer ==0 and if so then spawns an
|
|
//enemy
|
|
public void spawn()
|
|
{
|
|
|
|
Enemy temp = new Zombie();
|
|
temp.spawn(frame);
|
|
enemy.add(temp);
|
|
enemy.add(new Tank());
|
|
|
|
}
|
|
|
|
|
|
//timer
|
|
}
|
|
}
|
|
|