inital commit

src/main/java/objects/DebugPos.java

@@ -0,0 +1,26 @@
+package objects;
+
+import core.Master;
+import core.Vector2D;
+
+import java.awt.*;
+
+/**
+ * A GameObject used for debugging
+ */
+public class DebugPos extends GameObject {
+    public DebugPos(Vector2D position, Vector2D size) {
+        super(position.copy(), size);
+        this.velocity = new Vector2D();
+    }
+
+    @Override
+    public void draw(Graphics2D g2d, int w, Master master) {
+        g2d.setPaint(Color.green);
+        g2d.drawOval((int) (position.x + size.x / 2), (int) (position.y + size.y / 2), (int) size.x, (int) size.y);
+    }
+
+    @Override
+    public void update(Master master) {
+    }
+}

src/main/java/objects/GameObject.java

@@ -0,0 +1,67 @@
+package objects;
+
+import core.Master;
+import core.Vector2D;
+
+import java.awt.*;
+
+/**
+ * The GameObject class is the superclass of every GameObject that can be displayed on screen. It has the 2
+ * {@link #update(Master)} and {@link #draw(Graphics2D, int, Master)} methods that have to be
+ */
+public abstract class GameObject {
+
+    protected int w;
+    protected int h;
+
+    protected Vector2D position;
+    protected Vector2D size;
+
+    protected Vector2D velocity;
+
+    public GameObject(double x, double y, double xSize, double ySize) {
+        this(new Vector2D(x, y), new Vector2D(xSize, ySize));
+    }
+
+    public GameObject(Vector2D position, Vector2D size) {
+        this.position = position;
+        this.size = size;
+        this.velocity = new Vector2D();
+    }
+
+    public abstract void draw(Graphics2D g2d, int w, Master master);
+    public abstract void update(Master master);
+
+
+    public double getMapCoords(double value, boolean isX){
+        if (isX){
+            return (position.x + value / 100 * size.x);
+        } else {
+            return (position.y + value / 100 * size.y);
+        }
+    }
+
+    public double getMapCoordsSize(double value, boolean useX){
+        if (useX){
+            return (value / 100 * size.x);
+        } else {
+            return (value / 100 * size.y);
+        }
+    }
+
+    public double getWorldCoords(double value, boolean isX){
+        if (isX){
+            return (value / 100 * w);
+        } else {
+            return (value / 100 * h);
+        }
+    }
+
+    public int getWorldCoordsFromLocal(double value, boolean isX){
+        return (int) getWorldCoords(getMapCoords(value, isX), isX);
+    }
+
+    public int getWorldCoordsFromLocalSize(double value, boolean useX){
+        return (int) getWorldCoords(getMapCoordsSize(value, useX), useX);
+    }
+}

src/main/java/objects/ships/BattleShip.java

@@ -0,0 +1,54 @@
+package objects.ships;
+
+import core.Master;
+import objects.GameObject;
+
+import java.awt.*;
+import java.util.ArrayList;
+
+/**
+ * A Battleship that can have several turrets
+ */
+public class BattleShip extends GameObject {
+
+    private Color mainColor;
+    private ArrayList<Turret> turrets;
+
+    public BattleShip(Color mainColor) {
+        super(20, 20, 5, 40);
+        turrets = new ArrayList<>();
+        turrets.add(new Turret(this, 25, 25, 50, 1));
+        //turrets.add(new Turret(this, 25, 10, 50, 2));
+        //turrets.add(new Turret(this, 25, 70, 50, 2));
+        this.mainColor = mainColor;
+    }
+
+    public BattleShip(double x, double y, double xSize, double ySize, Color mainColor) {
+        super(x, y, xSize, ySize);
+        turrets = new ArrayList<>();
+        this.mainColor = mainColor;
+    }
+
+    @Override
+    public void draw(Graphics2D g2d, int w, Master master) {
+        this.w = w;
+        h = w/16*9;
+        g2d.setPaint(mainColor);
+        int xAbs = (int) getWorldCoords(position.x, true);
+        int yAbs = (int) getWorldCoords(position.y, false);
+        int sizeXAbs = (int) getWorldCoords(size.x, true);
+        int sizeYAbs = (int) getWorldCoords(size.y, false);
+        g2d.fillRoundRect(xAbs, yAbs, sizeXAbs, sizeYAbs, w/10, w/10);
+
+        turrets.forEach((turret -> turret.draw(g2d, w, master)));
+    }
+
+    @Override
+    public void update(Master master) {
+        turrets.forEach((turret -> turret.update(master)));
+    }
+
+    public void addTurret(Turret turret){
+        turrets.add(turret);
+    }
+}

src/main/java/objects/ships/Shell.java

@@ -0,0 +1,27 @@
+package objects.ships;
+
+import core.Master;
+import core.Vector2D;
+import objects.GameObject;
+
+import java.awt.*;
+
+public class Shell extends GameObject {
+
+
+    public Shell(Vector2D position, Vector2D size, Vector2D velocity) {
+        super(position, size);
+        this.velocity = velocity;
+    }
+
+    @Override
+    public void draw(Graphics2D g2d, int w, Master master) {
+        g2d.setPaint(Color.orange);
+        g2d.fillOval((int) position.x, (int) position.y, (int) size.x, (int) size.y);
+    }
+
+    @Override
+    public void update(Master master) {
+        position.add(velocity);
+    }
+}

src/main/java/objects/ships/Turret.java

@@ -0,0 +1,103 @@
+package objects.ships;
+
+import core.Master;
+import core.Vector2D;
+import objects.GameObject;
+
+import java.awt.*;
+
+/**
+ * A Turret that can shoot projectiles
+ */
+public class Turret extends GameObject {
+
+    BattleShip battleShip;
+
+    private int barrelAmount = 3;
+
+    private Color mainColor;
+
+    private long lastShot = 0;
+    private static int SHOT_EFFECT_TIME = 300;
+    private static int SHELL_SPEED = 10;
+    private double rotation;
+
+    public Turret(BattleShip battleShip, double x, double y, double size, int barrelAmount) {
+        super(x, y, size, size);
+        this.battleShip = battleShip;
+        this.barrelAmount = barrelAmount;
+        mainColor = Color.GRAY;
+    }
+
+    public Turret(BattleShip battleShip) {
+        super(25, 50, 50, 50);
+        this.battleShip = battleShip;
+        mainColor = Color.GRAY;
+    }
+
+    @Override
+    public void draw(Graphics2D g2d, int w, Master master) {
+        //TODO draw should be draw only for better everything
+        h = w / 16 * 9;
+        g2d.setPaint(mainColor);
+        int xAbs = battleShip.getWorldCoordsFromLocal(position.x, true);
+        int yAbs = battleShip.getWorldCoordsFromLocal(position.y, false);
+        int sizeAbs = battleShip.getWorldCoordsFromLocalSize(size.x, true);
+        int xCenterAbs = xAbs + sizeAbs / 2;
+        int yCenterAbs = yAbs + sizeAbs / 2;
+
+        g2d.fillOval(xAbs, yAbs, sizeAbs, sizeAbs);
+
+        g2d.setStroke(new BasicStroke(battleShip.getWorldCoordsFromLocalSize(10, true), BasicStroke.CAP_BUTT,
+                BasicStroke.JOIN_BEVEL));
+
+        //BARRELS---------------------------------------
+
+        g2d.setPaint(Color.BLACK);
+        int barrelSpacing = sizeAbs / (barrelAmount + 1);
+        g2d.rotate(rotation, xCenterAbs, yCenterAbs);
+        for (int i = 0; i < barrelAmount; i++) {
+            int barrelX = xAbs + (i + 1) * barrelSpacing;
+            int frontPosY = yAbs - sizeAbs / 2;
+            g2d.drawLine(barrelX, yCenterAbs, barrelX, frontPosY);
+
+            if (lastShot + SHOT_EFFECT_TIME > System.currentTimeMillis()) {
+                g2d.setPaint(Color.YELLOW);
+                g2d.fillOval(barrelX - 5, frontPosY - 5, 10, 10);
+                g2d.setPaint(Color.BLACK);
+            }
+        }
+        g2d.rotate(-rotation, xCenterAbs, yCenterAbs);
+    }
+
+    @Override
+    public void update(Master master) {
+
+        int xAbs = battleShip.getWorldCoordsFromLocal(position.x, true);
+        int yAbs = battleShip.getWorldCoordsFromLocal(position.y, false);
+        int sizeAbs = battleShip.getWorldCoordsFromLocalSize(size.x, true);
+        int xCenterAbs = xAbs + sizeAbs / 2;
+        int yCenterAbs = yAbs + sizeAbs / 2;
+
+        Point msLoc = master.getMouseLocation();
+        rotation = -Math.atan2(xCenterAbs - msLoc.x, yCenterAbs - msLoc.y);
+
+        int barrelSpacing = sizeAbs / (barrelAmount + 1);
+
+        for (int i = 0; i < barrelAmount; i++) {
+            int barrelX = xAbs + (i + 1) * barrelSpacing;
+            int frontPosY = yAbs - sizeAbs / 2;
+
+            if (master.isMousePressed()) {
+                lastShot = System.currentTimeMillis();
+
+                Vector2D shellVel = new Vector2D(xCenterAbs - msLoc.x, yCenterAbs - msLoc.y).normalized().negative().multiply(SHELL_SPEED);
+                Vector2D pos = Vector2D.rotateAround(new Vector2D(xCenterAbs, yCenterAbs), new Vector2D(barrelX, frontPosY), rotation, Vector2D.CLOCKWISE);
+
+                master.debugPos(pos);
+
+                master.create(new Shell(pos, new Vector2D(10, 10), shellVel));
+            }
+        }
+    }
+}

src/main/java/objects/world/Grid.java

@@ -0,0 +1,47 @@
+package objects.world;
+
+import core.Master;
+import objects.GameObject;
+
+import java.awt.*;
+
+/**
+ * A basic background grid
+ */
+public class Grid extends GameObject {
+
+    private int gridSpacing = 50;
+
+    public Grid() {
+        super(0, 0, 0, 0);
+    }
+
+    @Override
+    public void draw(Graphics2D g2d, int w, Master master) {
+        g2d.setPaint(Color.LIGHT_GRAY);
+
+        this.w = w;
+        h = w/16*9;
+
+        g2d.drawRect(0, 0, w, h);
+
+        int verticalLines = w / gridSpacing;
+        int horizontalLines = h / gridSpacing;
+
+        for (int i = 0; i < horizontalLines; i++) {
+            int y = i * h / horizontalLines;
+            g2d.drawLine(0, y, w, y);
+        }
+
+        for (int i = 0; i < verticalLines; i++) {
+            int x = i * w / verticalLines;
+            g2d.drawLine(x, 0, x, h);
+        }
+
+    }
+
+    @Override
+    public void update(Master master) {
+
+    }
+}