diff --git a/.classpath b/.classpath index fb50116..f5785bc 100644 --- a/.classpath +++ b/.classpath @@ -2,5 +2,6 @@ + diff --git a/bin/.gitignore b/bin/.gitignore new file mode 100644 index 0000000..8c2bbc4 --- /dev/null +++ b/bin/.gitignore @@ -0,0 +1 @@ +/MAndApps/ diff --git a/src/MAndApps/apps/spacewars/Entity.java b/src/MAndApps/apps/spacewars/Entity.java new file mode 100644 index 0000000..6ff6987 --- /dev/null +++ b/src/MAndApps/apps/spacewars/Entity.java @@ -0,0 +1,33 @@ +package MAndApps.apps.spacewars; + +import java.awt.Rectangle; +import java.awt.event.KeyEvent; +import java.util.Random; + +import MAndApps.apps.spacewars.tools.BasicTickAndRender; + +public abstract class Entity extends BasicTickAndRender{ + private Rectangle boundingBox; + private Random r = new Random(); + public Entity(int x, int y, int width, int height){ + boundingBox = new Rectangle(x, y, width, height); + } + + public void updateBoundingBox(int x, int y, int width, int height){ + boundingBox.setBounds(x, y, width, height); + } + public void keyPressed(KeyEvent e){} + public void keyReleased(KeyEvent e){} + public final double getX(){ + return boundingBox.getX(); + } + public final double getY(){ + return boundingBox.getY(); + } + public int rand(int i, int j){ + return r.nextInt(j-i) + i; + } + public Rectangle getBoundingBox(){ + return boundingBox; + } +} diff --git a/src/MAndApps/apps/spacewars/SpaceWars.java b/src/MAndApps/apps/spacewars/SpaceWars.java new file mode 100644 index 0000000..9ce05fe --- /dev/null +++ b/src/MAndApps/apps/spacewars/SpaceWars.java @@ -0,0 +1,344 @@ +package MAndApps.apps.spacewars; + +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Font; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Image; +import java.awt.Rectangle; +import java.awt.RenderingHints; +import java.awt.event.KeyEvent; +import java.awt.image.BufferedImage; +import java.net.URL; +import java.util.Random; +import java.util.Stack; + +import javax.imageio.ImageIO; + +import MAndApps.apps.spacewars.entity.Enemy; +import MAndApps.apps.spacewars.entity.Player; +import MAndApps.apps.spacewars.shop.Shop; +import MAndApps.apps.spacewars.tools.Explosion; +import MAndEngine.BasicApp; +import MAndEngine.Engine; + +public class SpaceWars implements BasicApp { + + // + private static boolean paused = false, debug = false; + private static int redPoints = 0, bluePoints = 0, greenPoints = 0, time = 0; + private static final int WIDTH = 1024, HEIGHT = 600; + private static Player player = new Player(); + private static Image background; + private static Random r = new Random(); + private static Stack enemies = new Stack(); + private static Stack explosions = new Stack(); + private static Stack logs = new Stack(); + private static int lvl = 1, xpToNextLVL = getMaxXPForLvl(lvl), xp = 0, expBar = 424; + private static boolean shopping = false; + private Shop shop = new Shop(); + + // + public static final Font defaultFont = new Font("Ubuntu", Font.BOLD, 10); + public static final Font moneyFont = new Font("Ubuntu", Font.BOLD, 20); + public static final Font levelFont = new Font("Ubuntu", Font.BOLD, 40); + public static final Font pausedFont = new Font("Ubuntu", Font.BOLD, 60); + + @Override + public void tick() { + addEXP(1); + if (!paused && !shopping) { + time++; + // ticks enemy stack + for (int i = 0; i < enemies.size(); i++) + enemies.elementAt(i).tick(); + // tick explosions + for (int i = 0; i < explosions.size(); i++) + explosions.elementAt(i).tick(); + // tick player class + player.tick(); + Rectangle playerRect = player.getBoundingBox(); + if (player.getAlive()) + for (int i = 0; i < enemies.size(); i++) + if (enemies.elementAt(i).getBoundingBox().intersects(playerRect)) + player.collideWithEnemy(enemies.elementAt(i).getX(), enemies.elementAt(i).getY()); + int i = 0; + while (i < enemies.size()) { + if (!enemies.elementAt(i).getAlive()) { + /* + * BOOM( 75, 1.2, + * enemies.elementAt(i).getColor().getRed()-50, + * enemies.elementAt(i).getColor().getGreen()-50, + * enemies.elementAt(i).getColor().getBlue()-50, 50, + * (int)enemies.elementAt(i).getX(), + * (int)enemies.elementAt(i).getY(), 550, true, true, 10 ); + */ + + addRedPoints(enemies.elementAt(i).getColor().getRed()); + addGreenPoints(enemies.elementAt(i).getColor().getGreen()); + addBluePoints(enemies.elementAt(i).getColor().getBlue()); + log("You gained " + enemies.elementAt(i).getWorth() + " exp."); + addEXP(enemies.elementAt(i).getWorth()); + + //enemies.remove(i); + + } else + i++; + } + + i = 0; + while (i < explosions.size()) { + if (!explosions.elementAt(i).getAlive()) { + explosions.remove(i); + } else { + i++; + } + } + + expBar += ((int) (((double) xp / (double) xpToNextLVL) * 424) - expBar) / 10; + } + shop.tick(); + // check if there are any new items to log + int cap = logs.size(); + for (int i = 0; i < cap; i++) + Engine.log(logs.pop()); + } + + public static void log(String s) { + logs.push(s); + } + + public static Stack getEnemies() { + return enemies; + } + + @Override + public void render(Graphics2D g) { + + try { + + g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); + + g.setFont(defaultFont); + g.drawImage(background, 0, 0, WIDTH, HEIGHT, null); + + for (int i = 0; i < explosions.size(); i++) + explosions.elementAt(i).render(g, i); + + player.render(g); + for (int i = 0; i < enemies.size(); i++) + enemies.elementAt(i).render(g); + + // render points + g.setFont(moneyFont); + g.setColor(Color.RED); + g.drawString(redPointsToString(), 10, HEIGHT - 10 - (20 * 3)); + g.setColor(Color.GREEN); + g.drawString(greenPointsToString(), 10, HEIGHT - 10 - (20 * 2)); + g.setColor(Color.BLUE); + g.drawString(bluePointsToString(), 10, HEIGHT - 10 - (20 * 1)); + g.setFont(defaultFont); + + // render level and xp bar. + g.setFont(levelFont); + g.setColor(Color.WHITE); + g.drawString("" + lvl, 300 - ((("" + lvl).length() - 1) * 20), 40); + g.drawRect(330, 18, 424, 15); + g.fillRect(330, 18, expBar, 15); + g.setFont(defaultFont); + + if (paused) { + g.setFont(pausedFont); + g.setColor(Color.WHITE); + g.drawString("Paused", 410, 280); + g.setFont(defaultFont); + } + shop.render(g, WIDTH); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public void resumeApp() { + + } + + @Override + public void pauseApp() { + + } + + public static Player getPlayer() { + return player; + } + + public boolean getDebug() { + return debug; + } + + @Override + public Dimension getResolution() { + return new Dimension(WIDTH, HEIGHT); + } + + @Override + public void initialize() { + try { + background = ImageIO.read(new URL("http://wallpapersus.com/wallpapers/2012/10/Cool-Wave-600x1024.jpg")); + } catch (Exception e) { + background = (Image) new BufferedImage(1024, 600, BufferedImage.TRANSLUCENT); + Graphics g = background.getGraphics(); + g.setColor(Color.BLUE); + g.fillRect(0, 0, 1024, 600); + } + } + + @Override + public void keyPressed(KeyEvent e) { + player.keyPressed(e); + for (int i = 0; i < enemies.size(); i++) + enemies.elementAt(i).keyPressed(e); + if (e.getKeyCode() == KeyEvent.VK_P || e.getKeyCode() == KeyEvent.VK_SPACE) { + paused = !paused; + } else if (e.getKeyCode() == KeyEvent.VK_E) { + xp = xpToNextLVL - 1; + } else if (e.getKeyCode() == KeyEvent.VK_Q) { + debug = !debug; + } else if (e.getKeyCode() == KeyEvent.VK_ESCAPE) { + shopping = !shopping; + shop.toggleState(); + } + } + + @Override + public void keyReleased(KeyEvent e) { + player.keyReleased(e); + for (int i = 0; i < enemies.size(); i++) + enemies.elementAt(i).keyReleased(e); + shop.keyReleased(e); + } + + @Override + public String getTitle() { + return "Space Wars"; + } + + @Override + public Color getColor() { + return new Color(88, 128, 255); + } + + @Override + public int getFramerate() { + return 50; + } + + @Override + public boolean getResizable() { + return false; + } + + public static void BOOM(double speed, double decay, int r, int g, int b, int variant, int x, int y, int size, boolean singleVariant, boolean bubble, int sizeOfParticles) { + explosions.push(new Explosion(speed, decay, r, g, b, variant, singleVariant)); + explosions.peek().goBoom(x, y, size, bubble, sizeOfParticles); + } + + public void addRedPoints(int d) { + redPoints += d; + } + + public void addGreenPoints(int d) { + greenPoints += d; + } + + public void addBluePoints(int d) { + bluePoints += d; + } + + private String redPointsToString() { + String _return = "$" + redPoints / 100d; + if (_return.length() == ("" + redPoints).length() + 1 || _return.length() == ("" + redPoints).length() + 3) + _return += "0"; + return _return; + } + + private String greenPointsToString() { + String _return = "$" + greenPoints / 100d; + if (_return.length() == ("" + greenPoints).length() + 1 || _return.length() == ("" + greenPoints).length() + 3) + _return += "0"; + return _return; + } + + private String bluePointsToString() { + String _return = "$" + bluePoints / 100d; + if (_return.length() == ("" + bluePoints).length() + 1 || _return.length() == ("" + bluePoints).length() + 3) + _return += "0"; + return _return; + } + + private static int getMaxXPForLvl(int lvl) { + return (int)(Math.pow(lvl, 1.618)); + } + + public void addEXP(int i) { + xp += i; + while (xp >= xpToNextLVL) { + xp -= xpToNextLVL; + lvl++; + xpToNextLVL = getMaxXPForLvl(lvl); + for (int j = 0; j < 424; j += 100) { + BOOM(75, 1.618, 255, 255, 255, 0, 300 + (j), 20, 200, true, false, 2); + } + } + } + + // i got bored and made logic methods... so? + + public boolean or(boolean a, boolean b) { + return a || b; + } + + public boolean not(boolean a) { + return !a; + } + + public boolean and(boolean a, boolean b) { + return not(or(not(a), not(b))); + } + + public boolean xor(boolean a, boolean b) { + return not(or(not(or(not(a), not(b))), not(or(a, b)))); + // return !((!((!a)||(!b)))||(!(a||b))); + // return or(not(or(not(a),b)),not(or(not(b),a))); + // return ((!(a||!(b)))||(!(b||!(a)))); + } + + @Override + public boolean visibleInMenu() { + // TODO Auto-generated method stub + return true; + } + + public static int getHEIGHT() { + return HEIGHT; + } + + public static int getWIDTH() { + return WIDTH; + } + + @Override + public void resized(int width, int height) { + // TODO Auto-generated method stub + + } + + @Override + public void click() { + // TODO Auto-generated method stub + + } +} diff --git a/src/MAndApps/apps/spacewars/entity/Bullet.java b/src/MAndApps/apps/spacewars/entity/Bullet.java new file mode 100644 index 0000000..b5957db --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/Bullet.java @@ -0,0 +1,193 @@ +package MAndApps.apps.spacewars.entity; + +import MAndApps.apps.spacewars.Entity; +import MAndApps.apps.spacewars.entity.bullet.BasicPlayerBullet; +import MAndApps.apps.spacewars.entity.bullet.PlayerExplodeBullet; +import MAndApps.apps.spacewars.entity.bullet.PlayerImpactBullet; +import MAndApps.apps.spacewars.entity.bullet.PlayerPiercingBullet; + +public abstract class Bullet extends Entity { + //these are the bullet identities. i think its fairly self explanatory.. + //public static final int NAME_OF_BULLET_TYPE = some_number_not_being_used_as_another_id; + public static final int BASIC = 0; + public static final int PLAYER_PIERCE_ONE = 1; + public static final int PLAYER_PIERCE_TWO = 2; + public static final int PLAYER_PIERCE_THREE = 3; + public static final int PLAYER_PIERCE_FOUR = 4; + public static final int PLAYER_PIERCE_FIVE = 5; + public static final int PLAYER_PIERCE_SIX = 6; + public static final int PLAYER_PIERCE_SEVEN = 7; + public static final int PLAYER_PIERCE_EIGHT = 8; + public static final int PLAYER_PIERCE_NINE = 9; + public static final int PLAYER_PIERCE_TEN = 10; + public static final int PLAYER_EXPLOSIVE_ONE = 11; + public static final int PLAYER_EXPLOSIVE_TWO = 12; + public static final int PLAYER_EXPLOSIVE_THREE = 13; + public static final int PLAYER_EXPLOSIVE_FOUR = 14; + public static final int PLAYER_EXPLOSIVE_FIVE = 15; + public static final int PLAYER_EXPLOSIVE_SIX = 16; + public static final int PLAYER_EXPLOSIVE_SEVEN = 17; + public static final int PLAYER_EXPLOSIVE_EIGHT = 18; + public static final int PLAYER_EXPLOSIVE_NINE = 19; + public static final int PLAYER_EXPLOSIVE_TEN = 20; + public static final int PLAYER_IMPACT_ONE = 21; + public static final int PLAYER_IMPACT_TWO = 22; + public static final int PLAYER_IMPACT_THREE = 23; + public static final int PLAYER_IMPACT_FOUR = 24; + public static final int PLAYER_IMPACT_FIVE = 25; + public static final int PLAYER_IMPACT_SIX = 26; + public static final int PLAYER_IMPACT_SEVEN = 27; + public static final int PLAYER_IMPACT_EIGHT = 28; + public static final int PLAYER_IMPACT_NINE = 29; + public static final int PLAYER_IMPACT_TEN = 30; + public static final int PLAYER_GODMODE = 31; + public Bullet(int x, int y, int width, int height) { + super(x, y, width, height); + } + + /** + * bullet class now references here to get the cool down for the current bullet + * updates upon ammo change or initialization of a gun type. + * @param bulletType + * @return + */ + public static int getCooldown(int bulletType){ + switch (bulletType){ + case BASIC: + return 25; + case PLAYER_PIERCE_ONE: + return 20; + case PLAYER_PIERCE_TWO: + return 18; + case PLAYER_PIERCE_THREE: + return 16; + case PLAYER_PIERCE_FOUR: + return 14; + case PLAYER_PIERCE_FIVE: + return 12; + case PLAYER_PIERCE_SIX: + return 10; + case PLAYER_PIERCE_SEVEN: + return 8; + case PLAYER_PIERCE_EIGHT: + return 6; + case PLAYER_PIERCE_NINE: + return 4; + case PLAYER_PIERCE_TEN: + return 2; + case PLAYER_EXPLOSIVE_ONE: + return 50; + case PLAYER_EXPLOSIVE_TWO: + return 48; + case PLAYER_EXPLOSIVE_THREE: + return 46; + case PLAYER_EXPLOSIVE_FOUR: + return 44; + case PLAYER_EXPLOSIVE_FIVE: + return 42; + case PLAYER_EXPLOSIVE_SIX: + return 40; + case PLAYER_EXPLOSIVE_SEVEN: + return 38; + case PLAYER_EXPLOSIVE_EIGHT: + return 36; + case PLAYER_EXPLOSIVE_NINE: + return 34; + case PLAYER_EXPLOSIVE_TEN: + return 32; + case PLAYER_GODMODE: + return 0; + default: + return 25; + } + } + + public static Bullet getNewBullet(int bulletType, int x, int y, int direction){ + switch(bulletType){ + //this is the literal bit that goes through and indexes what to do + //with certain IDs that you defined above.. + //formatting is simple, cases can not go after the default so + //they must be added in between it and the last "case" + + //return new PlayerPiercingBullet(direction, x, y, 2); + + //this returns a new pierce bullet at position x(this parameter + //was passed via the function...) and y(also passed), with a + //direction, direction(also passed in..), with a pierce amount of + //whatever is entered in place of the 2. + //inside the parenthesis, in the returns, are called + //"arguments" or "parameters". + case BASIC: + return new BasicPlayerBullet(direction, x, y); + case PLAYER_PIERCE_ONE: + return new PlayerPiercingBullet(direction, x, y, 2, false); + case PLAYER_PIERCE_TWO: + return new PlayerPiercingBullet(direction, x, y, 3, false); + case PLAYER_PIERCE_THREE: + return new PlayerPiercingBullet(direction, x, y, 4, false); + case PLAYER_PIERCE_FOUR: + return new PlayerPiercingBullet(direction, x, y, 5, false); + case PLAYER_PIERCE_FIVE: + return new PlayerPiercingBullet(direction, x, y, 6, false); + case PLAYER_PIERCE_SIX: + return new PlayerPiercingBullet(direction, x, y, 7, false); + case PLAYER_PIERCE_SEVEN: + return new PlayerPiercingBullet(direction, x, y, 8, false); + case PLAYER_PIERCE_EIGHT: + return new PlayerPiercingBullet(direction, x, y, 9, false); + case PLAYER_PIERCE_NINE: + return new PlayerPiercingBullet(direction, x, y, 10, false); + case PLAYER_PIERCE_TEN: + return new PlayerPiercingBullet(direction, x, y, 15, true); + case PLAYER_EXPLOSIVE_ONE: + return new PlayerExplodeBullet(direction, x, y, 2); + case PLAYER_EXPLOSIVE_TWO: + return new PlayerExplodeBullet(direction, x, y, 3); + case PLAYER_EXPLOSIVE_THREE: + return new PlayerExplodeBullet(direction, x , y, 4); + case PLAYER_EXPLOSIVE_FOUR: + return new PlayerExplodeBullet(direction, x, y, 5); + case PLAYER_EXPLOSIVE_FIVE: + return new PlayerExplodeBullet(direction, x, y, 6); + case PLAYER_EXPLOSIVE_SIX: + return new PlayerExplodeBullet(direction, x, y, 7); + case PLAYER_EXPLOSIVE_SEVEN: + return new PlayerExplodeBullet(direction, x, y, 8); + case PLAYER_EXPLOSIVE_EIGHT: + return new PlayerExplodeBullet(direction, x, y, 9); + case PLAYER_EXPLOSIVE_NINE: + return new PlayerExplodeBullet(direction, x, y, 10); + case PLAYER_EXPLOSIVE_TEN: + return new PlayerExplodeBullet(direction, x, y, 15); + case PLAYER_IMPACT_ONE: + return new PlayerImpactBullet(direction, x, y, 1); + case PLAYER_IMPACT_TWO: + return new PlayerImpactBullet(direction, x, y, 2); + case PLAYER_IMPACT_THREE: + return new PlayerImpactBullet(direction, x, y, 3); + case PLAYER_IMPACT_FOUR: + return new PlayerImpactBullet(direction, x, y, 4); + case PLAYER_IMPACT_FIVE: + return new PlayerImpactBullet(direction, x, y, 5); + case PLAYER_IMPACT_SIX: + return new PlayerImpactBullet(direction, x, y, 6); + case PLAYER_IMPACT_SEVEN: + return new PlayerImpactBullet(direction, x, y, 7); + case PLAYER_IMPACT_EIGHT: + return new PlayerImpactBullet(direction, x, y, 8); + case PLAYER_IMPACT_NINE: + return new PlayerImpactBullet(direction, x, y, 9); + case PLAYER_IMPACT_TEN: + return new PlayerImpactBullet(direction, x, y, 10); + case PLAYER_GODMODE: + return new PlayerExplodeBullet(direction, x, y, 200); + default://if the bullet type passed in for this function is not one of the above cases.. + return new BasicPlayerBullet(direction, x, y);//return it a basic bullet. + } + } + + public abstract boolean getAlive(); + public abstract int getDamage(); + public abstract int getWIDTH(); + public abstract int getHEIGHT(); +} diff --git a/src/MAndApps/apps/spacewars/entity/Enemy.java b/src/MAndApps/apps/spacewars/entity/Enemy.java new file mode 100644 index 0000000..f060569 --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/Enemy.java @@ -0,0 +1,58 @@ +package MAndApps.apps.spacewars.entity; + +import java.awt.Color; + +import MAndApps.apps.spacewars.entity.enemy.BlueEnemy; +import MAndApps.apps.spacewars.entity.enemy.GreenEnemy; +import MAndApps.apps.spacewars.entity.enemy.NormalEnemy; +import MAndApps.apps.spacewars.entity.enemy.RedEnemy; +import MAndApps.apps.spacewars.tools.Entity; + +public abstract class Enemy extends Entity { + public static final int NORMAL = 0; + public static final int + RED_TIER_ONE = 1, + RED_TIER_TWO = 2, + RED_TIER_THREE = 3, + RED_TIER_FOUR = 4, + RED_TIER_FIVE = 5; + public static final int + BLUE_TIER_ONE = 6, + BLUE_TIER_TWO = 7, + BLUE_TIER_THREE = 8, + BLUE_TIER_FOUR = 9, + BLUE_TIER_FIVE = 10; + public static final int + GREEN_TIER_ONE = 11, + GREEN_TIER_TWO = 12, + GREEN_TIER_THREE = 13, + GREEN_TIER_FOUR = 14, + GREEN_TIER_FIVE = 15; + + public Enemy(int x, int y, int width, int height) { + super(x, y, width, height); + } + + public final static Enemy getNewEnemy(int type, int x, int y){ + switch(type){ + case NORMAL: + return new NormalEnemy(x, y); + case BLUE_TIER_ONE: + return new BlueEnemy(x, y, 2); + case RED_TIER_ONE: + return new RedEnemy(x, y, 2); + case GREEN_TIER_ONE: + return new GreenEnemy(x, y, 2); + default: + return new NormalEnemy(x, y); + } + } + public abstract boolean getAlive(); + public abstract Color getColor(); + + public int getWorth() { + return 1; + } + + public abstract void damage(int damage); +} diff --git a/src/MAndApps/apps/spacewars/entity/Player.java b/src/MAndApps/apps/spacewars/entity/Player.java new file mode 100644 index 0000000..18604b3 --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/Player.java @@ -0,0 +1,268 @@ +package MAndApps.apps.spacewars.entity; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.event.KeyEvent; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.gun.Gun; +import MAndApps.apps.spacewars.tools.Direction; +import MAndApps.apps.spacewars.tools.Entity; + +public class Player extends Entity { + private final static int WIDTH = 16, HEIGHT = 16; + private double x = 512, y = 550; + private static final double ACC = 0.5, MAXSPEED = 5; + private double dx = 0, dy = 0; + private boolean A = false, S = false, D = false, W = false, alive = true; + private Random r = new Random(); + private Gun gun = new Gun(Bullet.BASIC, 25, (int)x, (int)y); + private boolean goBoom = false; + + public Player() { + super((int) 512, (int) 550, WIDTH, HEIGHT); + } + + @Override + public int tick() { + if (goBoom) { + SpaceWars.BOOM(50, 1.2, 50, 50, 50, 30, (int) x, (int) y, 550, true, + false, 3); + goBoom = false; + } + gun.tick(); + if (alive) { + + if (time != 1) + time -= 0.05d; + if (time < 1) + time = 1; + + if (D && !A) + dx += ACC; + else if (A && !D) { + dx -= ACC; + } else { + if ((int) (dx * 100) > 0) + dx -= ACC; + else if ((int) (dx * 100) < 0) + dx += ACC; + else + dx = 0; + } + + if (S && !W) + dy += ACC; + else if (W && !S) { + dy -= ACC; + } else { + if ((int) (dy * 100) > 0) + dy -= ACC; + else if ((int) (dy * 100) < 0) + dy += ACC; + else + dy = 0; + } + + if (dx > MAXSPEED) + while (dx > MAXSPEED) + dx -= ACC; + if (dx < 0 - MAXSPEED) + while (dx < 0 - MAXSPEED) + dx += ACC; + if (dy > MAXSPEED) + while (dy > MAXSPEED) + dy -= ACC; + if (dy < 0 - MAXSPEED) + while (dy < 0 - MAXSPEED) + dy += ACC; + + y += dy; + x += dx; + + if (x > SpaceWars.getWIDTH() - WIDTH) + while (x > SpaceWars.getWIDTH() - WIDTH) + x--; + if (x < 0) + while (x < 0) + x++; + + if (y > SpaceWars.getHEIGHT() - HEIGHT) + while (y > SpaceWars.getHEIGHT() - HEIGHT) + y--; + if (y < 0) + while (y < 0) + y++; + + } else { + x = -1; + y = -1; + if (timer > 4 * 50) { + alive = true; + x = 512; + y = 550; + } + timer++; + } + updateBoundingBox((int) x, (int) y, WIDTH, HEIGHT); + + return 0; + } + + private int timer = 0; + + @Override + public void render(Graphics g) { + g.setColor(Color.BLACK); + if (alive) { + int temp; + try { + temp = r.nextInt((int) time); + } catch (Exception e) { + temp = 1; + } + if (temp == 0) + g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + } + gun.render(g); + } + + private double time = 0; + + @Override + public void keyPressed(KeyEvent e) { + switch (e.getKeyCode()) { + case KeyEvent.VK_W: + W = true; + break; + case KeyEvent.VK_D: + D = true; + break; + case KeyEvent.VK_S: + S = true; + break; + case KeyEvent.VK_A: + A = true; + break; + case KeyEvent.VK_I: + shoot(Direction.UP); + break; + case KeyEvent.VK_J: + shoot(Direction.LEFT); + break; + case KeyEvent.VK_K: + shoot(Direction.DOWN); + break; + case KeyEvent.VK_L: + shoot(Direction.RIGHT); + break; + } + } + + private void shoot(int direction) { + gun.updatePosition((int)x + WIDTH/2, (int)y + HEIGHT/2); + gun.shoot(direction); + } + + @Override + public void keyReleased(KeyEvent e) { + switch (e.getKeyCode()) { + case KeyEvent.VK_W: + W = false; + break; + case KeyEvent.VK_D: + D = false; + break; + case KeyEvent.VK_S: + S = false; + break; + case KeyEvent.VK_A: + A = false; + break; + } + + } + + public void collideWithEnemy(double x, double y) { + goBoom = true; + timer = 0; + alive = false; + time = 5; + } + + public boolean getAlive() { + return alive; + } + + public void setLevel(int i) { + switch (i) { + case 2: + gun.switchAmmo(Bullet.PLAYER_PIERCE_ONE); + break; + case 3: + gun.switchAmmo(Bullet.PLAYER_PIERCE_TWO); + break; + case 4: + gun.switchAmmo(Bullet.PLAYER_PIERCE_THREE); + break; + case 5: + gun.switchAmmo(Bullet.PLAYER_PIERCE_FOUR); + break; + case 6: + gun.switchAmmo(Bullet.PLAYER_PIERCE_FIVE); + break; + case 7: + gun.switchAmmo(Bullet.PLAYER_PIERCE_SIX); + break; + case 8: + gun.switchAmmo(Bullet.PLAYER_PIERCE_SEVEN); + break; + case 9: + gun.switchAmmo(Bullet.PLAYER_PIERCE_EIGHT); + break; + case 10: + gun.switchAmmo(Bullet.PLAYER_PIERCE_NINE); + break; + case 11: + gun.switchAmmo(Bullet.PLAYER_PIERCE_TEN); + break; + case 12: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_ONE); + break; + case 13: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_TWO); + break; + case 14: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_THREE); + break; + case 15: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_FOUR); + break; + case 16: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_FIVE); + break; + case 17: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_SIX); + break; + case 18: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_SEVEN); + break; + case 19: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_EIGHT); + break; + case 20: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_NINE); + break; + case 21: + gun.switchAmmo(Bullet.PLAYER_EXPLOSIVE_TEN); + break; + case 22: + gun.switchAmmo(Bullet.PLAYER_GODMODE); + break; + } + if(i >= 22){ + gun.switchAmmo(Bullet.PLAYER_GODMODE); + } + } +} diff --git a/src/MAndApps/apps/spacewars/entity/bullet/BasicPlayerBullet.java b/src/MAndApps/apps/spacewars/entity/bullet/BasicPlayerBullet.java new file mode 100644 index 0000000..120a85d --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/bullet/BasicPlayerBullet.java @@ -0,0 +1,85 @@ +package MAndApps.apps.spacewars.entity.bullet; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Rectangle; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Bullet; +import MAndApps.apps.spacewars.tools.Direction; + +public class BasicPlayerBullet extends Bullet { + private final int direction; + private final int WIDTH, HEIGHT; + private final static int SPEED = 10; + private double x, y; + private boolean alive = true; + + public BasicPlayerBullet(int direction, int x, int y) { + super(x, y, 1, 1); + this.x = x; + this.y = y; + this.direction = direction; + if (direction == Direction.UP || direction == Direction.DOWN) { + WIDTH = 3; + HEIGHT = 8; + } else { + WIDTH = 8; + HEIGHT = 3; + } + updateBoundingBox((int) this.x, (int) this.y, WIDTH, HEIGHT); + } + + public int tick() { + if (alive) { + if (direction == Direction.UP) { + y -= SPEED; + } else if (direction == Direction.DOWN) { + y += SPEED; + } else if (direction == Direction.LEFT) { + x -= SPEED; + } else if (direction == Direction.RIGHT) { + x += SPEED; + } + + updateBoundingBox((int) x, (int) y, WIDTH, HEIGHT); + Rectangle r = getBoundingBox(); + for (int i = 0; i < SpaceWars.getEnemies().size(); i++) { + if (r.intersects(SpaceWars.getEnemies().elementAt(i).getBoundingBox())) { + SpaceWars.getEnemies().elementAt(i).damage(getDamage()); + alive = false; + i = SpaceWars.getEnemies().size(); + } + } + if(x > SpaceWars.getWIDTH() || x < 0 - WIDTH || y > SpaceWars.getHEIGHT() || y < 0 - HEIGHT){ + alive = false; + } + } + return 0; + } + + public void render(Graphics g) { + g.setColor(Color.BLACK); + if (alive) + g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public int getDamage() { + return 1; + } + + public int getWIDTH(){ + return WIDTH; + } + + public int getHEIGHT(){ + return HEIGHT; + } + +} diff --git a/src/MAndApps/apps/spacewars/entity/bullet/PlayerExplodeBullet.java b/src/MAndApps/apps/spacewars/entity/bullet/PlayerExplodeBullet.java new file mode 100644 index 0000000..f890f2e --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/bullet/PlayerExplodeBullet.java @@ -0,0 +1,94 @@ +package MAndApps.apps.spacewars.entity.bullet; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Rectangle; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Bullet; +import MAndApps.apps.spacewars.tools.BulletExplosion; +import MAndApps.apps.spacewars.tools.Direction; + +public class PlayerExplodeBullet extends Bullet { + private BulletExplosion bulletExplosion; + private final int direction; + private final int WIDTH, HEIGHT; + private final static int SPEED = 10; + private double x, y; + private boolean alive = true; + private final int size; + private static final double PHI = 1.618033988749894848204586; + + public int getWIDTH(){ + return WIDTH; + } + + public int getHEIGHT(){ + return HEIGHT; + } + + public PlayerExplodeBullet(int direction, int x, int y, int i) { + super(x, y, 1, 1); + this.x = x; + this.y = y; + this.direction = direction; + if (direction == Direction.UP || direction == Direction.DOWN) { + WIDTH = 3; + HEIGHT = 8; + } else { + WIDTH = 8; + HEIGHT = 3; + } + updateBoundingBox((int) this.x, (int) this.y, WIDTH, HEIGHT); + bulletExplosion = new BulletExplosion(i, 1.02, 100, 100, 100, 0, false, i); + size = i; + + } + + public int tick() { + if (alive) { + if (direction == Direction.UP) { + y -= SPEED; + } else if (direction == Direction.DOWN) { + y += SPEED; + } else if (direction == Direction.LEFT) { + x -= SPEED; + } else if (direction == Direction.RIGHT) { + x += SPEED; + } + + updateBoundingBox((int) x, (int) y, WIDTH, HEIGHT); + Rectangle r = getBoundingBox(); + for (int i = 0; i < SpaceWars.getEnemies().size(); i++) { + if (r.intersects(SpaceWars.getEnemies().elementAt(i).getBoundingBox())) { + SpaceWars.getEnemies().elementAt(i).damage(getDamage()); + bulletExplosion.goBoom((int)x, (int)y, size * 10, false, size+2); + alive = false; + i = SpaceWars.getEnemies().size(); + } + } + if(x > SpaceWars.getWIDTH() || x < 0 - WIDTH || y > SpaceWars.getHEIGHT() || y < 0 - HEIGHT){ + alive = false; + } + } + bulletExplosion.tick(); + return 0; + } + + public void render(Graphics g) { + g.setColor(Color.BLACK); + if (alive) + g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + bulletExplosion.render(g); + } + + @Override + public boolean getAlive() { + return alive || bulletExplosion.getAlive(); + } + + @Override + public int getDamage() { + return 1; + } +} diff --git a/src/MAndApps/apps/spacewars/entity/bullet/PlayerImpactBullet.java b/src/MAndApps/apps/spacewars/entity/bullet/PlayerImpactBullet.java new file mode 100644 index 0000000..92db12d --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/bullet/PlayerImpactBullet.java @@ -0,0 +1,87 @@ +package MAndApps.apps.spacewars.entity.bullet; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Rectangle; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Bullet; +import MAndApps.apps.spacewars.tools.Direction; + +public class PlayerImpactBullet extends Bullet { + private final int direction; + private final int WIDTH, HEIGHT; + private final static int SPEED = 10; + private double x, y; + private boolean alive = true; + private final int level; + + public int getWIDTH(){ + return WIDTH; + } + + public int getHEIGHT(){ + return HEIGHT; + } + + public PlayerImpactBullet(int direction, int x, int y, int level) { + super(x, y, 1, 1); + this.x = x; + this.y = y; + this.direction = direction; + if (direction == Direction.UP || direction == Direction.DOWN) { + WIDTH = 3; + HEIGHT = 8; + } else { + WIDTH = 8; + HEIGHT = 3; + } + updateBoundingBox((int) this.x, (int) this.y, WIDTH, HEIGHT); + this.level = level; + } + + public int tick() { + if (alive) { + if (direction == Direction.UP) { + y -= SPEED; + } else if (direction == Direction.DOWN) { + y += SPEED; + } else if (direction == Direction.LEFT) { + x -= SPEED; + } else if (direction == Direction.RIGHT) { + x += SPEED; + } + + updateBoundingBox((int) x, (int) y, WIDTH, HEIGHT); + Rectangle r = getBoundingBox(); + for (int i = 0; i < SpaceWars.getEnemies().size(); i++) { + if (r.intersects(SpaceWars.getEnemies().elementAt(i).getBoundingBox())) { + SpaceWars.getEnemies().elementAt(i).damage(getDamage()); + alive = false; + i = SpaceWars.getEnemies().size(); + } + } + if(x > SpaceWars.getWIDTH() || x < 0 - WIDTH || y > SpaceWars.getHEIGHT() || y < 0 - HEIGHT){ + alive = false; + } + } + return 0; + } + + public void render(Graphics g) { + g.setColor(Color.BLACK); + if (alive) + g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public int getDamage() { + return 1; + } + +} diff --git a/src/MAndApps/apps/spacewars/entity/bullet/PlayerPiercingBullet.java b/src/MAndApps/apps/spacewars/entity/bullet/PlayerPiercingBullet.java new file mode 100644 index 0000000..c7f593f --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/bullet/PlayerPiercingBullet.java @@ -0,0 +1,97 @@ +package MAndApps.apps.spacewars.entity.bullet; + +import java.awt.Color; +import java.awt.Graphics; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Bullet; +import MAndApps.apps.spacewars.tools.Direction; + +public class PlayerPiercingBullet extends Bullet { + private final int direction, MAX_HITS; + private final int WIDTH, HEIGHT; + private final static int SPEED = 10; + private double x, y, oldX, oldY; + private boolean alive = true; + private int hits = 0; + private final boolean INFINISHOT; + final boolean lolface = true; + + public int getWIDTH(){ + return WIDTH; + } + + public int getHEIGHT(){ + return HEIGHT; + } + + public PlayerPiercingBullet(int direction, int x, int y, int pierce, boolean b) { + super(x, y, 1, 1); + this.x = x; + this.y = y; + MAX_HITS = pierce; + this.direction = direction; + if (direction == Direction.UP || direction == Direction.DOWN) { + WIDTH = 3; + HEIGHT = 8; + } else { + WIDTH = 8; + HEIGHT = 3; + } + updateBoundingBox((int) this.x, (int) this.y, WIDTH, HEIGHT); + INFINISHOT = b; + } + + public int tick() { + oldX = x; + oldY = y; + if (alive) { + switch(direction){ + case Direction.UP: + y -= SPEED; + break; + case Direction.DOWN: + y += SPEED; + break; + case Direction.LEFT: + x -= SPEED; + break; + case Direction.RIGHT: + x += SPEED; + break; + } + updateBoundingBox((int) x, (int) y, WIDTH, HEIGHT); + for (int i = 0; i < SpaceWars.getEnemies().size() && hits < MAX_HITS; i++) { + if (SpaceWars.getEnemies().elementAt(i).getBoundingBox().intersectsLine((int)x, (int)y, (int)oldX, (int)oldY)) { + hits++; + SpaceWars.getEnemies().elementAt(i).damage(getDamage()); + if(hits >= MAX_HITS){ + alive = false; + i = SpaceWars.getEnemies().size(); + } + } + } + if(x > SpaceWars.getWIDTH() || x < 0 - WIDTH || y > SpaceWars.getHEIGHT() || y < 0 - HEIGHT){ + alive = false; + } + } + return 0; + } + + @Override + public void render(Graphics g) { + g.setColor(Color.CYAN); + if (alive) + g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public int getDamage(){ + return 2; + } +} diff --git a/src/MAndApps/apps/spacewars/entity/enemy/BlueEnemy.java b/src/MAndApps/apps/spacewars/entity/enemy/BlueEnemy.java new file mode 100644 index 0000000..62400f3 --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/enemy/BlueEnemy.java @@ -0,0 +1,177 @@ +package MAndApps.apps.spacewars.entity.enemy; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Enemy; + +public class BlueEnemy extends Enemy { + private int health = 2; + private final int MAX_HEALTH = health; + private static final int WIDTH = 16, HEIGHT = 16, PROXIMITY = 200; + private double x, y, time = 0, desiredX, desiredY, Xmod, Ymod, dx = 0, + dy = 0; + private static final double ACC = 0.005, MAXSPEED = 1, DEAD_ACC = 0.5d, + DEAD_MAXSPEED = 5; + private Color color; + private boolean debug = false, alive = true; + private double healthBar = 1; + + public BlueEnemy(int x, int y, int i) { + super(x, y, 16, 16); + this.x = x; + this.y = y; + final int LOW = 200, HIGH = 256, color = rand(LOW, HIGH); + this.color = new Color(color, color, color); + + } + + @Override + public int tick() { + // epic AI + if((int)healthBar <= 0){ + alive = false; + } + if (alive) { + if (SpaceWars.getPlayer().getAlive()) { + if (time > 0.4d) { + time = 0; + Xmod = rand(-PROXIMITY, PROXIMITY); + Ymod = rand(-PROXIMITY, PROXIMITY); + } + + desiredX = SpaceWars.getPlayer().getX() + Xmod; + desiredY = SpaceWars.getPlayer().getY() + Ymod; + + if ((int) desiredX > (int) x) + dx += ACC; + else if ((int) desiredX < (int) x) { + dx -= ACC; + } + if ((int) desiredY > (int) y) + dy += ACC; + else if ((int) desiredY < (int) y) { + dy -= ACC; + } + + if (dx > MAXSPEED) + while (dx > MAXSPEED) + dx -= ACC; + if (dx < 0 - MAXSPEED) + while (dx < 0 - MAXSPEED) + dx += ACC; + if (dy > MAXSPEED) + while (dy > MAXSPEED) + dy -= ACC; + if (dy < 0 - MAXSPEED) + while (dy < 0 - MAXSPEED) + dy += ACC; + + } else { + + if (time > 0.4d) { + time = 0; + Xmod = rand(0, 1024); + Ymod = rand(0, 200); + } + + desiredX = Xmod; + desiredY = Ymod; + + if ((int) desiredX > (int) x) + dx += DEAD_ACC; + else if ((int) desiredX < (int) x) { + dx -= DEAD_ACC; + } + if ((int) desiredY > (int) y) + dy += DEAD_ACC; + else if ((int) desiredY < (int) y) { + dy -= DEAD_ACC; + } + + if (dx > DEAD_MAXSPEED) + while (dx > DEAD_MAXSPEED) + dx -= DEAD_ACC; + if (dx < 0 - DEAD_MAXSPEED) + while (dx < 0 - DEAD_MAXSPEED) + dx += DEAD_ACC; + if (dy > DEAD_MAXSPEED) + while (dy > DEAD_MAXSPEED) + dy -= DEAD_ACC; + if (dy < 0 - DEAD_MAXSPEED) + while (dy < 0 - DEAD_MAXSPEED) + dy += DEAD_ACC; + + } + + x += dx; + y += dy; + + if (x > SpaceWars.getWIDTH() - WIDTH) + while (x > SpaceWars.getWIDTH() - WIDTH) + x--; + if (x < 0) + while (x < 0) + x++; + + if (y > SpaceWars.getHEIGHT() - HEIGHT) + while (y > SpaceWars.getHEIGHT() - HEIGHT) + y--; + if (y < 0) + while (y < 0) + y++; + } + time += 0.01; + absoluteTime++; + updateBoundingBox((int) x, (int) y, 16, 16); + return 0; + } + + private Random r = new Random(); + private int absoluteTime = 0; + + @Override + public void render(Graphics g) { + g.setColor(color); + int temp; + try{ + temp = r.nextInt((int)(0-((double)absoluteTime/20d))+5); + }catch(Exception e){ + temp = 0; + } + + if (temp == 0) if (alive) g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + if (debug) g.drawLine((int) x, (int) y, (int) desiredX, (int) desiredY); + + healthBar += ((((double)health/(double)MAX_HEALTH)*16) - healthBar)/6; + //healthbar + g.setColor(Color.RED); + g.fillRect((int)x, (int)y, WIDTH - 1, 3); + g.setColor(Color.GREEN); + g.fillRect((int)x, (int)y, (int)healthBar, 3); + g.setColor(Color.BLACK); + g.drawRect((int)x, (int)y, WIDTH - 1, 3); + } + + @Override + public void damage(int i) { + health -= i; + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public Color getColor() { + return color; + } + + @Override + public int getWorth(){ + return r.nextInt(3)+1; + } +} diff --git a/src/MAndApps/apps/spacewars/entity/enemy/GreenEnemy.java b/src/MAndApps/apps/spacewars/entity/enemy/GreenEnemy.java new file mode 100644 index 0000000..62f8bfe --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/enemy/GreenEnemy.java @@ -0,0 +1,183 @@ +package MAndApps.apps.spacewars.entity.enemy; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Enemy; + +public class GreenEnemy extends Enemy { + private int health = 2; + private final int MAX_HEALTH = health; + private static final int WIDTH = 16, HEIGHT = 16, PROXIMITY = 200; + private double x, y, time = 0, desiredX, desiredY, Xmod, Ymod, dx = 0, + dy = 0; + private static final double ACC = 0.005, MAXSPEED = 1, DEAD_ACC = 0.5d, + DEAD_MAXSPEED = 5; + private Color color; + private boolean debug = false, alive = true; + private double healthBar = 1; + + public GreenEnemy(int x, int y, int i) { + super(x, y, WIDTH, HEIGHT); + this.x = x; + this.y = y; + this.color = new Color(rand(50, 75), 255, rand(50, 75)); + + } + + @Override + public int tick() { + // epic AI + if((int)healthBar <= 0){ + alive = false; + } + if (alive) { + //UIFM + if (SpaceWars.getPlayer().getAlive()) { + if (time > 0.4d) { + time = 0; + Xmod = rand(-PROXIMITY, PROXIMITY); + Ymod = rand(-PROXIMITY, PROXIMITY); + } + + desiredX = SpaceWars.getPlayer().getX() + Xmod; + desiredY = SpaceWars.getPlayer().getY() + Ymod; + + //UIFM + if ((int) desiredX > (int) x) + dx += ACC; + else if ((int) desiredX < (int) x) { + dx -= ACC; + } + if ((int) desiredY > (int) y) + dy += ACC; + else if ((int) desiredY < (int) y) { + dy -= ACC; + } + + //UIFM + if (dx > MAXSPEED) + while (dx > MAXSPEED) + dx -= ACC; + if (dx < 0 - MAXSPEED) + while (dx < 0 - MAXSPEED) + dx += ACC; + if (dy > MAXSPEED) + while (dy > MAXSPEED) + dy -= ACC; + if (dy < 0 - MAXSPEED) + while (dy < 0 - MAXSPEED) + dy += ACC; + + } else { + //UIFM + if (time > 0.4d) { + time = 0; + Xmod = rand(0, 1024); + Ymod = rand(0, 200); + } + + desiredX = Xmod; + desiredY = Ymod; + + if ((int) desiredX > (int) x) + dx += DEAD_ACC; + else if ((int) desiredX < (int) x) { + dx -= DEAD_ACC; + } + if ((int) desiredY > (int) y) + dy += DEAD_ACC; + else if ((int) desiredY < (int) y) { + dy -= DEAD_ACC; + } + + if (dx > DEAD_MAXSPEED) + while (dx > DEAD_MAXSPEED) + dx -= DEAD_ACC; + if (dx < 0 - DEAD_MAXSPEED) + while (dx < 0 - DEAD_MAXSPEED) + dx += DEAD_ACC; + if (dy > DEAD_MAXSPEED) + while (dy > DEAD_MAXSPEED) + dy -= DEAD_ACC; + if (dy < 0 - DEAD_MAXSPEED) + while (dy < 0 - DEAD_MAXSPEED) + dy += DEAD_ACC; + + //UIFMMMMMMMMM + } + + //UIFMMMMM + x += dx; + y += dy; + + if (x > SpaceWars.getWIDTH() - WIDTH) + while (x > SpaceWars.getWIDTH() - WIDTH) + x--; + if (x < 0) + while (x < 0) + x++; + + //UIFM UNIDENTIFIED FLYING MATH + if (y > SpaceWars.getHEIGHT() - HEIGHT) + while (y > SpaceWars.getHEIGHT() - HEIGHT) + y--; + if (y < 0) + while (y < 0) + y++; + } + time += 0.01; + absoluteTime++; + updateBoundingBox((int) x, (int) y, 16, 16); + return 0; + } + + private Random r = new Random(); + private int absoluteTime = 0; + + @Override + public void render(Graphics g) { + g.setColor(color); + int temp; + try{ + temp = r.nextInt((int)(0-((double)absoluteTime/20d))+5); + }catch(Exception e){ + temp = 0; + } + + //uifm + if (temp == 0) if (alive) g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + if (debug) g.drawLine((int) x, (int) y, (int) desiredX, (int) desiredY); + + healthBar += ((((double)health/(double)MAX_HEALTH)*16) - healthBar)/6; + //healthbar + g.setColor(Color.RED); + g.fillRect((int)x, (int)y, WIDTH - 1, 3); + g.setColor(Color.GREEN); + g.fillRect((int)x, (int)y, (int)healthBar, 3); + g.setColor(Color.BLACK); + g.drawRect((int)x, (int)y, WIDTH - 1, 3); + } + + @Override + public void damage(int i) { + health -= i; + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public Color getColor() { + return color; + } + + @Override + public int getWorth(){ + return r.nextInt(3)+1; + } +} diff --git a/src/MAndApps/apps/spacewars/entity/enemy/NormalEnemy.java b/src/MAndApps/apps/spacewars/entity/enemy/NormalEnemy.java new file mode 100644 index 0000000..fa1df78 --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/enemy/NormalEnemy.java @@ -0,0 +1,177 @@ +package MAndApps.apps.spacewars.entity.enemy; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Enemy; + +public class NormalEnemy extends Enemy { + private int health = 2; + private final int MAX_HEALTH = health; + private static final int WIDTH = 16, HEIGHT = 16, PROXIMITY = 200; + private double x, y, time = 0, desiredX, desiredY, Xmod, Ymod, dx = 0, + dy = 0; + private static final double ACC = 0.005, MAXSPEED = 1, DEAD_ACC = 0.5d, + DEAD_MAXSPEED = 5; + private Color color; + private boolean debug = false, alive = true; + private double healthBar = 1; + + public NormalEnemy(int x, int y) { + super(x, y, 16, 16); + this.x = x; + this.y = y; + final int LOW = 200, HIGH = 256, color = rand(LOW, HIGH); + this.color = new Color(color, color, color); + + } + + @Override + public int tick() { + // epic AI + if((int)healthBar <= 0){ + alive = false; + } + if (alive) { + if (SpaceWars.getPlayer().getAlive()) { + if (time > 0.4d) { + time = 0; + Xmod = rand(-PROXIMITY, PROXIMITY); + Ymod = rand(-PROXIMITY, PROXIMITY); + } + + desiredX = SpaceWars.getPlayer().getX() + Xmod; + desiredY = SpaceWars.getPlayer().getY() + Ymod; + + if ((int) desiredX > (int) x) + dx += ACC; + else if ((int) desiredX < (int) x) { + dx -= ACC; + } + if ((int) desiredY > (int) y) + dy += ACC; + else if ((int) desiredY < (int) y) { + dy -= ACC; + } + + if (dx > MAXSPEED) + while (dx > MAXSPEED) + dx -= ACC; + if (dx < 0 - MAXSPEED) + while (dx < 0 - MAXSPEED) + dx += ACC; + if (dy > MAXSPEED) + while (dy > MAXSPEED) + dy -= ACC; + if (dy < 0 - MAXSPEED) + while (dy < 0 - MAXSPEED) + dy += ACC; + + } else { + + if (time > 0.4d) { + time = 0; + Xmod = rand(0, 1024); + Ymod = rand(0, 200); + } + + desiredX = Xmod; + desiredY = Ymod; + + if ((int) desiredX > (int) x) + dx += DEAD_ACC; + else if ((int) desiredX < (int) x) { + dx -= DEAD_ACC; + } + if ((int) desiredY > (int) y) + dy += DEAD_ACC; + else if ((int) desiredY < (int) y) { + dy -= DEAD_ACC; + } + + if (dx > DEAD_MAXSPEED) + while (dx > DEAD_MAXSPEED) + dx -= DEAD_ACC; + if (dx < 0 - DEAD_MAXSPEED) + while (dx < 0 - DEAD_MAXSPEED) + dx += DEAD_ACC; + if (dy > DEAD_MAXSPEED) + while (dy > DEAD_MAXSPEED) + dy -= DEAD_ACC; + if (dy < 0 - DEAD_MAXSPEED) + while (dy < 0 - DEAD_MAXSPEED) + dy += DEAD_ACC; + + } + + x += dx; + y += dy; + + if (x > SpaceWars.getWIDTH() - WIDTH) + while (x > SpaceWars.getWIDTH() - WIDTH) + x--; + if (x < 0) + while (x < 0) + x++; + + if (y > SpaceWars.getHEIGHT() - HEIGHT) + while (y > SpaceWars.getHEIGHT() - HEIGHT) + y--; + if (y < 0) + while (y < 0) + y++; + } + time += 0.01; + absoluteTime++; + updateBoundingBox((int) x, (int) y, 16, 16); + return 0; + } + + private Random r = new Random(); + private int absoluteTime = 0; + + @Override + public void render(Graphics g) { + g.setColor(color); + int temp; + try{ + temp = r.nextInt((int)(0-((double)absoluteTime/20d))+5); + }catch(Exception e){ + temp = 0; + } + + if (temp == 0) if (alive) g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + if (debug) g.drawLine((int) x, (int) y, (int) desiredX, (int) desiredY); + + healthBar += ((((double)health/(double)MAX_HEALTH)*16) - healthBar)/6; + //healthbar + g.setColor(Color.RED); + g.fillRect((int)x, (int)y, WIDTH - 1, 3); + g.setColor(Color.GREEN); + g.fillRect((int)x, (int)y, (int)healthBar, 3); + g.setColor(Color.BLACK); + g.drawRect((int)x, (int)y, WIDTH - 1, 3); + } + + @Override + public void damage(int i) { + health -= i; + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public Color getColor() { + return color; + } + + @Override + public int getWorth(){ + return r.nextInt(3)+1; + } +} diff --git a/src/MAndApps/apps/spacewars/entity/enemy/RedEnemy.java b/src/MAndApps/apps/spacewars/entity/enemy/RedEnemy.java new file mode 100644 index 0000000..7b9a412 --- /dev/null +++ b/src/MAndApps/apps/spacewars/entity/enemy/RedEnemy.java @@ -0,0 +1,174 @@ +package MAndApps.apps.spacewars.entity.enemy; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; +import MAndApps.apps.spacewars.entity.Enemy; + +public class RedEnemy extends Enemy { + private int health = 2; + private final int MAX_HEALTH = health; + private static final int WIDTH = 16, HEIGHT = 16, PROXIMITY = 200; + private double x, y, time = 0, desiredX, desiredY, Xmod, Ymod, dx = 0, + dy = 0; + private static final double ACC = 0.005, MAXSPEED = 1, DEAD_ACC = 0.5d, + DEAD_MAXSPEED = 5; + private Color color; + private boolean debug = false, alive = true; + private double healthBar = 1; + + public RedEnemy(int x, int y, int i) { + super(x, y, WIDTH, HEIGHT); + this.x = x; + this.y = y; + this.color = new Color(255, rand(50, 75), rand(50, 75)); + + } + + public int tick() { + // epic AI + if((int)healthBar <= 0){ + alive = false; + } + if (alive) { + if (SpaceWars.getPlayer().getAlive()) { + if (time > 0.4d) { + time = 0; + Xmod = rand(-PROXIMITY, PROXIMITY); + Ymod = rand(-PROXIMITY, PROXIMITY); + } + + desiredX = SpaceWars.getPlayer().getX() + Xmod; + desiredY = SpaceWars.getPlayer().getY() + Ymod; + + if ((int) desiredX > (int) x) + dx += ACC; + else if ((int) desiredX < (int) x) { + dx -= ACC; + } + if ((int) desiredY > (int) y) + dy += ACC; + else if ((int) desiredY < (int) y) { + dy -= ACC; + } + + if (dx > MAXSPEED) + while (dx > MAXSPEED) + dx -= ACC; + if (dx < 0 - MAXSPEED) + while (dx < 0 - MAXSPEED) + dx += ACC; + if (dy > MAXSPEED) + while (dy > MAXSPEED) + dy -= ACC; + if (dy < 0 - MAXSPEED) + while (dy < 0 - MAXSPEED) + dy += ACC; + + } else { + + if (time > 0.4d) { + time = 0; + Xmod = rand(0, 1024); + Ymod = rand(0, 200); + } + + desiredX = Xmod; + desiredY = Ymod; + + if ((int) desiredX > (int) x) + dx += DEAD_ACC; + else if ((int) desiredX < (int) x) { + dx -= DEAD_ACC; + } + if ((int) desiredY > (int) y) + dy += DEAD_ACC; + else if ((int) desiredY < (int) y) { + dy -= DEAD_ACC; + } + + if (dx > DEAD_MAXSPEED) + while (dx > DEAD_MAXSPEED) + dx -= DEAD_ACC; + if (dx < 0 - DEAD_MAXSPEED) + while (dx < 0 - DEAD_MAXSPEED) + dx += DEAD_ACC; + if (dy > DEAD_MAXSPEED) + while (dy > DEAD_MAXSPEED) + dy -= DEAD_ACC; + if (dy < 0 - DEAD_MAXSPEED) + while (dy < 0 - DEAD_MAXSPEED) + dy += DEAD_ACC; + + } + + x += dx; + y += dy; + + if (x > SpaceWars.getWIDTH() - WIDTH) + while (x > SpaceWars.getWIDTH() - WIDTH) + x--; + if (x < 0) + while (x < 0) + x++; + + if (y > SpaceWars.getHEIGHT() - HEIGHT) + while (y > SpaceWars.getHEIGHT() - HEIGHT) + y--; + if (y < 0) + while (y < 0) + y++; + } + time += 0.01; + absoluteTime++; + updateBoundingBox((int) x, (int) y, 16, 16); + return 0; + } + + private Random r = new Random(); + private int absoluteTime = 0; + + public void render(Graphics g) { + g.setColor(color); + int temp; + try{ + temp = r.nextInt((int)(0-((double)absoluteTime/20d))+5); + }catch(Exception e){ + temp = 0; + } + + if (temp == 0) if (alive) g.fillRect((int) x, (int) y, WIDTH, HEIGHT); + if (debug) g.drawLine((int) x, (int) y, (int) desiredX, (int) desiredY); + + healthBar += ((((double)health/(double)MAX_HEALTH)*16) - healthBar)/6; + //healthbar + g.setColor(Color.RED); + g.fillRect((int)x, (int)y, WIDTH - 1, 3); + g.setColor(Color.GREEN); + g.fillRect((int)x, (int)y, (int)healthBar, 3); + g.setColor(Color.BLACK); + g.drawRect((int)x, (int)y, WIDTH - 1, 3); + } + + @Override + public void damage(int i) { + health -= i; + } + + @Override + public boolean getAlive() { + return alive; + } + + @Override + public Color getColor() { + return color; + } + + @Override + public int getWorth(){ + return (int)(Math.random() * 3)+1; + } +} diff --git a/src/MAndApps/apps/spacewars/gun/Gun.java b/src/MAndApps/apps/spacewars/gun/Gun.java new file mode 100644 index 0000000..71d062e --- /dev/null +++ b/src/MAndApps/apps/spacewars/gun/Gun.java @@ -0,0 +1,58 @@ +package MAndApps.apps.spacewars.gun; + +import java.awt.Graphics; +import java.util.Stack; + +import MAndApps.apps.spacewars.entity.Bullet; + +public class Gun { + private Stack bullets = new Stack(); + private int bulletType; + private int MAX_COOLDOWN; + private int cooldown = 0, x, y; + public Gun(int bulletType, int cooldown, int x, int y){ + MAX_COOLDOWN = cooldown; + this.bulletType = bulletType; + this.x = x; + this.y = y; + } + + public void updatePosition(int x, int y){ + this.x = x; + this.y = y; + } + + public void render(Graphics g){ + for(int i = 0; i < bullets.size(); i ++) + bullets.elementAt(i).render(g); + } + + public void tick(){ + cooldown ++; + //tick bullets + for(int i = 0; i < bullets.size(); i++) + bullets.elementAt(i).tick(); + for(int i = 0; i < bullets.size(); i++){ + if(!bullets.elementAt(i).getAlive()) + bullets.remove(i); + else + i++; + } + } + + public void shoot(int direction){ + if(cooldown >= MAX_COOLDOWN){ + cooldown = 0; + bullets.push(Bullet.getNewBullet(bulletType, x-(Bullet.getNewBullet(bulletType, x, y, direction).getWIDTH()/2), y-(Bullet.getNewBullet(bulletType, x, y, direction).getHEIGHT()/2), direction)); + } + } + + public void switchAmmo(int bulletType){ + this.bulletType = bulletType; + MAX_COOLDOWN = Bullet.getCooldown(bulletType); + } + + public void setCooldown(int i) { + MAX_COOLDOWN = i; + } +} \ No newline at end of file diff --git a/src/MAndApps/apps/spacewars/shop/Shop.java b/src/MAndApps/apps/spacewars/shop/Shop.java new file mode 100644 index 0000000..d318857 --- /dev/null +++ b/src/MAndApps/apps/spacewars/shop/Shop.java @@ -0,0 +1,59 @@ +package MAndApps.apps.spacewars.shop; + + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.event.KeyEvent; + +public class Shop { + private final int ON = 17, OFF = 64, BOX_WIDTH = 500, BOX_HEIGHT = 200, BOX_Y_OFFSET = 50, BOX_Y_MULTIPLIER = 250, MAX_ANIMATION_TIME = BOX_WIDTH; + private int state = OFF, selection = 0; + private double animationTime = 0; + public void render(Graphics g, final int WIDTH){ + g.setColor(selection == 0 ? Color.CYAN : Color.BLUE); + g.fillRect((int)animationTime-BOX_WIDTH, BOX_Y_OFFSET, BOX_WIDTH, BOX_HEIGHT); + g.setColor(selection == 2 ? Color.CYAN : Color.BLUE); + g.fillRect((int)animationTime-BOX_WIDTH, BOX_Y_OFFSET+BOX_Y_MULTIPLIER, BOX_WIDTH, BOX_HEIGHT); + g.setColor(selection == 1 ? Color.CYAN : Color.BLUE); + g.fillRect(WIDTH - (int)animationTime, BOX_Y_OFFSET, BOX_WIDTH, BOX_HEIGHT); + g.setColor(selection == 3 ? Color.CYAN : Color.BLUE); + g.fillRect(WIDTH - (int)animationTime, BOX_Y_OFFSET+BOX_Y_MULTIPLIER, BOX_WIDTH, BOX_HEIGHT); + } + + public void tick(){ + if(state == ON && !(animationTime > BOX_WIDTH)){ + animationTime+=(double)(MAX_ANIMATION_TIME-animationTime)/6; + }else if(state == OFF && !(animationTime < 0)){ + animationTime+=(double)(0-animationTime)/6; + } + if(animationTime < 0.49d){ + selection = 0; + } + } + + public void toggleState(){ + if(state == ON){ + state = OFF; + }else if(state == OFF){ + state = ON; + } + } + + public void keyReleased(KeyEvent e) { + if(e.getKeyCode() == KeyEvent.VK_W){ + selection += 2; + selection %= 4; + }else if(e.getKeyCode() == KeyEvent.VK_D){ + selection += 1; + if(selection == 2) selection = 0; + else if(selection == 4) selection = 2; + }else if(e.getKeyCode() == KeyEvent.VK_A){ + selection -= 1; + if(selection == -1) selection = 1; + else if(selection == 1) selection = 3; + }else if(e.getKeyCode() == KeyEvent.VK_S){ + selection -= 2; + if(selection < 0) selection += 4; + } + } +} diff --git a/src/MAndApps/apps/spacewars/tools/BasicTickAndRender.java b/src/MAndApps/apps/spacewars/tools/BasicTickAndRender.java new file mode 100644 index 0000000..cf54595 --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/BasicTickAndRender.java @@ -0,0 +1,9 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Graphics; + + +public abstract class BasicTickAndRender { + public abstract int tick(); + public abstract void render(Graphics g); +} diff --git a/src/MAndApps/apps/spacewars/tools/BulletExplosion.java b/src/MAndApps/apps/spacewars/tools/BulletExplosion.java new file mode 100644 index 0000000..e04afcd --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/BulletExplosion.java @@ -0,0 +1,81 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Graphics; +import java.util.Random; +import java.util.Stack; + + +public class BulletExplosion { + private Stack bits = new Stack(); + private Random rand = new Random(); + private final double SPEED, DECAY; + private final int r, g, b, variant; + private final boolean singleVariant; + private final int damage; + public BulletExplosion(double speed, double decay, int r, int g, int b, int variant, boolean singleVariant, int damage){ + SPEED = speed; + DECAY = decay; + this.r = r; + this.g = g; + this.b = b; + this.variant = variant; + this.singleVariant = singleVariant; + this.damage = damage; + } + public void tick() { + for(int i = 0; i < bits.size(); i++) + bits.elementAt(i).tick(); + int i = 0; + while(i < bits.size()){ + if(!bits.elementAt(i).getAlive()){ + bits.remove(i); + }else{ + i++; + } + } + } + + public void render(Graphics g) { + for(int i = 0; i < bits.size(); i++) + bits.elementAt(i).render(g); + //g.setColor(Color.WHITE); + //g.drawString("particles: " + bits.size(), 920 - (int)(Math.floor((double)line/20) * 100), 15 + ((line%20)*12)); + } + + public void reset() { + bits.clear(); + } + + public void goBoom(double x, double y, int size, boolean bubble, int sizeOfParticles) { + for(int i = 0; i < size; i++){ + bits.push( + new CollisionParticle( + rand.nextInt(360), + (rand.nextDouble()*1000)%SPEED, + rand.nextInt(100), + rand.nextInt(50) + 100, + (int)x, + (int)y, + DECAY, + r, + g, + b, + variant, + singleVariant, + bubble, + sizeOfParticles, + damage + ) + ); + } + } + + public boolean getAlive(){ + boolean alive = false; + for(int i = 0; i < bits.size(); i++) + if(bits.elementAt(i).getAlive()) + alive = true; + return alive; + } + +} diff --git a/src/MAndApps/apps/spacewars/tools/CollisionParticle.java b/src/MAndApps/apps/spacewars/tools/CollisionParticle.java new file mode 100644 index 0000000..4ee169c --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/CollisionParticle.java @@ -0,0 +1,116 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Rectangle; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; + + +public class CollisionParticle extends Entity { + private double x, y, life, speed; + private final int angleDeg, moveLife, renderLife, size; + private final double DECAY; + private boolean alive = false, bubble; + private Random rand = new Random(); + private Color color; + private final int damage; + private boolean active = true; + + public CollisionParticle(int angle, double speed, int movelife, + int renderlife, int x, int y, double speedDecay, int r, int g, + int b, int variant, boolean singleVariant, boolean bubble, + int sizeOfParticles, int damage) { + super(0, 0, 1, 1); + renderLife = renderlife; + this.speed = speed; + angleDeg = angle; + this.x = x; + moveLife = movelife; + this.y = y; + alive = true; + size = rand.nextInt(sizeOfParticles); + DECAY = speedDecay; + int i = 0; + this.bubble = bubble; + if (!bubble) { + if (!singleVariant) { + while (i < 10) { + try { + color = new Color(r + rand.nextInt(variant * 2) + - variant, g + rand.nextInt(variant * 2) + - variant, b + rand.nextInt(variant * 2) + - variant); + i = 10; + } catch (IllegalArgumentException e) { + i++; + if (i >= 10) { + color = new Color(r, g, b); + } + } + } + } else { + while (i < 10) { + try { + int tempVar = rand.nextInt(variant * 2) - variant; + color = new Color(r + tempVar, g + tempVar, b + tempVar); + i = 10; + } catch (IllegalArgumentException e) { + i++; + if (i >= 10) { + color = new Color(r, g, b); + } + } + } + } + } else { + color = new Color(rand(0, 256), rand(0, 256), rand(0, 256)); + } + this.damage = damage; + } + + public int tick() { + if (life < moveLife) { + x += Math.cos(((double) angleDeg * Math.PI) / 180d) * speed; + y += Math.sin(((double) angleDeg * Math.PI) / 180d) * speed; + } + speed /= DECAY; + if (life > renderLife) + alive = false; + if(life > moveLife){ + active = false; + } + if (x > SpaceWars.getWIDTH() || x < 0 - size + || y > SpaceWars.getHEIGHT() || y < 0 - size) { + alive = false; + } + life++; + if(active){ + Rectangle r = getBoundingBox(); + for (int i = 0; i < SpaceWars.getEnemies().size(); i++) { + if (r.intersects(SpaceWars.getEnemies().elementAt(i).getBoundingBox())) { + SpaceWars.getEnemies().elementAt(i).damage(damage); + //active = false; + i = SpaceWars.getEnemies().size(); + } + } + } + updateBoundingBox((int) x, (int) y, size, size); + return 0; + } + + public void render(Graphics g) { + if (alive) { + g.setColor(color); + if (bubble) + g.drawOval((int) x, (int) y, size, size); + else + g.fillRect((int) x, (int) y, size, size); + } + } + + public boolean getAlive() { + return alive; + } +} diff --git a/src/MAndApps/apps/spacewars/tools/Direction.java b/src/MAndApps/apps/spacewars/tools/Direction.java new file mode 100644 index 0000000..8143caf --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/Direction.java @@ -0,0 +1,12 @@ +package MAndApps.apps.spacewars.tools; + +public class Direction { + private final int direction; + public static final int UP = 0, DOWN = 1, LEFT = 2, RIGHT = 3; + public Direction(int i){ + direction = i; + } + public int getDirection() { + return direction; + } +} diff --git a/src/MAndApps/apps/spacewars/tools/Entity.java b/src/MAndApps/apps/spacewars/tools/Entity.java new file mode 100644 index 0000000..15b8c90 --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/Entity.java @@ -0,0 +1,32 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Rectangle; +import java.awt.event.KeyEvent; +import java.util.Random; + + +public abstract class Entity extends BasicTickAndRender{ + private Rectangle boundingBox; + private Random r = new Random(); + public Entity(int x, int y, int width, int height){ + boundingBox = new Rectangle(x, y, width, height); + } + + public void updateBoundingBox(int x, int y, int width, int height){ + boundingBox.setBounds(x, y, width, height); + } + public void keyPressed(KeyEvent e){} + public void keyReleased(KeyEvent e){} + public final double getX(){ + return boundingBox.getX(); + } + public final double getY(){ + return boundingBox.getY(); + } + public int rand(int i, int j){ + return r.nextInt(j-i) + i; + } + public Rectangle getBoundingBox(){ + return boundingBox; + } +} diff --git a/src/MAndApps/apps/spacewars/tools/Explosion.java b/src/MAndApps/apps/spacewars/tools/Explosion.java new file mode 100644 index 0000000..7714307 --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/Explosion.java @@ -0,0 +1,79 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; +import java.util.Stack; + + +public class Explosion { + private Stack bits = new Stack(); + private Random rand = new Random(); + private final double SPEED, DECAY; + private final int r, g, b, variant; + private final boolean singleVariant; + public Explosion(double speed, double decay, int r, int g, int b, int variant, boolean singleVariant){ + SPEED = speed; + DECAY = decay; + this.r = r; + this.g = g; + this.b = b; + this.variant = variant; + this.singleVariant = singleVariant; + } + public void tick() { + for(int i = 0; i < bits.size(); i++) + bits.elementAt(i).tick(); + int i = 0; + while(i < bits.size()){ + if(!bits.elementAt(i).getAlive()){ + bits.remove(i); + }else{ + i++; + } + } + } + + public void render(Graphics g, int line) { + for(int i = 0; i < bits.size(); i++) + bits.elementAt(i).render(g); + g.setColor(Color.WHITE); + g.drawString("particles: " + bits.size(), 920 - (int)(Math.floor((double)line/20) * 100), 15 + ((line%20)*12)); + } + + public void reset() { + bits.clear(); + } + + public void goBoom(double x, double y, int size, boolean bubble, int sizeOfParticles) { + for(int i = 0; i < size; i++){ + bits.push( + new Particle( + rand.nextInt(360), + (rand.nextDouble()*1000)%SPEED, + rand.nextInt(100), + rand.nextInt(50) + 100, + (int)x, + (int)y, + DECAY, + r, + g, + b, + variant, + singleVariant, + bubble, + sizeOfParticles + ) + ); + } + } + + public boolean getAlive(){ + boolean alive = false; + for(int i = 0; i < bits.size(); i++) + if(bits.elementAt(i).getAlive()) + alive = true; + return alive; + } + +} diff --git a/src/MAndApps/apps/spacewars/tools/Particle.java b/src/MAndApps/apps/spacewars/tools/Particle.java new file mode 100644 index 0000000..65cc29f --- /dev/null +++ b/src/MAndApps/apps/spacewars/tools/Particle.java @@ -0,0 +1,101 @@ +package MAndApps.apps.spacewars.tools; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +import MAndApps.apps.spacewars.SpaceWars; + + +public class Particle extends Entity{ + private double x, y, life, speed; + private final int angleDeg, moveLife, renderLife, size; + private final double DECAY; + private boolean alive = false, bubble; + private Random rand = new Random(); + private Color color; + + public Particle(int angle, double speed, int movelife, int renderlife, + int x, int y, double speedDecay, int r, int g, int b, int variant, + boolean singleVariant, boolean bubble, int sizeOfParticles) { + super(0, 0, 1, 1); + renderLife = renderlife; + this.speed = speed; + angleDeg = angle; + this.x = x; + moveLife = movelife; + this.y = y; + alive = true; + size = rand.nextInt(sizeOfParticles); + DECAY = speedDecay; + int i = 0; + this.bubble = bubble; + if (!bubble) { + if (!singleVariant) { + while (i < 10) { + try { + color = new Color(r + rand.nextInt(variant * 2) + - variant, g + rand.nextInt(variant * 2) + - variant, b + rand.nextInt(variant * 2) + - variant); + i = 10; + } catch (IllegalArgumentException e) { + i++; + if (i >= 10) { + color = new Color(r, g, b); + } + } + } + } else { + while (i < 10) { + try { + int tempVar = rand.nextInt(variant * 2) - variant; + color = new Color(r + tempVar, g + tempVar, b + tempVar); + i = 10; + } catch (IllegalArgumentException e) { + i++; + if (i >= 10) { + color = new Color(r, g, b); + } + } + } + } + } else { + color = new Color(rand(0, 256), rand(0, 256), rand(0, 256)); + } + updateBoundingBox((int)x, (int)y, size , size); + + } + + private static final double PHI = 1.618033988749894848204586; + + public int tick() { + if (life < moveLife) { + x += Math.cos(((double) angleDeg * Math.PI) / 180d) * speed; + y += Math.sin(((double) angleDeg * Math.PI) / 180d) * speed; + } + speed /= PHI; + if (life > renderLife) + alive = false; + + if (x > SpaceWars.getWIDTH() || x < 0 - size + || y > SpaceWars.getHEIGHT() || y < 0 - size) { + alive = false; + } + + life++; + return 0; + } + + public void render(Graphics g) { + if (alive) { + g.setColor(color); + if(bubble) g.drawOval((int) x, (int) y, size, size); + else g.fillRect((int) x, (int) y, size, size); + } + } + + public boolean getAlive() { + return alive; + } +} diff --git a/src/Main.java b/src/Main.java new file mode 100644 index 0000000..957ee89 --- /dev/null +++ b/src/Main.java @@ -0,0 +1,11 @@ +import MAndEngine.Engine; + + +public class Main { + public static void main(String[] args) { + + Engine engine = new Engine(new String[] {"MAndApps.apps.SpaceWars"}, false); + engine.run(); + + } +}