Weltgeneration und kleines Refactoring

src/main/java/controller/GameController.java

@@ -1,10 +1,10 @@
 package controller;
 
 import controller.tiles.interactive.*;
-import controller.tiles.interactive.AnimalEnclosureController;
+import controller.tiles.interactive.upgradeable.*;
 import model.GameModel;
 import model.GameSaver;
-import model.Item;
+import model.items.Item;
 import model.items.ITEM_NAME;
 import model.tiles.InteractiveTileModel;
 import util.GAMESTATE;
@@ -14,14 +14,15 @@ import java.io.Serializable;
 import java.util.ArrayList;
 
 public class GameController implements Runnable, Serializable {
-
-    private transient KeyHandler keyHandler;
+    public final String worldPath = "gamefiles/worlds/world_0.txt";
     private GameModel gameModel;
-
-    private transient Thread gameThread; // transient to avoid serialization
-    private transient GamePanel view;
     private boolean running = true;
     private int fps = 60;
+
+
+    private transient KeyHandler keyHandler;
+    private transient Thread gameThread;
+    private transient GamePanel view;
     public transient ArrayList<InteractiveTileController> interactiveTileControllers;
 
     public GameController() {
@@ -31,6 +32,7 @@ public class GameController implements Runnable, Serializable {
         interactiveTileControllers = new ArrayList<>();
         setStartInventory();
         setupInteractiveTiles();
+        view.loadMap(worldPath);
     }
 
     private void setupInteractiveTiles() {
@@ -65,7 +67,6 @@ public class GameController implements Runnable, Serializable {
         gameModel.addModel(model);
         return model;
     }
-
     private void setStartInventory() {
         gameModel.getInventory().addToInventory(new Item(ITEM_NAME.stone));
         gameModel.getInventory().addToInventory(new Item(ITEM_NAME.water));
@@ -173,4 +174,11 @@ public class GameController implements Runnable, Serializable {
         interactiveTileControllers = new ArrayList<>();
         setupInteractiveTiles();
     }
+    public void loadWorld(){
+        if(view == null) this.view = new GamePanel(this);
+        view.loadMap(worldPath);
+    }
+    public void generateNewWorld() {
+        view.generateNewWorld();
+    }
 }

src/main/java/controller/tiles/interactive/InteractiveTileController.java

@@ -9,7 +9,7 @@ import view.tile.interactive.InteractiveTileView;
 
 import java.awt.*;
 
-public class InteractiveTileController {
+public abstract class InteractiveTileController {
     private GameController gameController;
     private InteractiveTileView view;
     private InteractiveTileModel model;
@@ -81,7 +81,7 @@ public class InteractiveTileController {
     public void drawTile(Graphics2D g2, Camera camera){
         view.drawTile(g2, camera);
     }
-    public void drawPopup(Graphics2D g2, Camera camera){
+    public void drawPopup(Graphics2D g2){
         if(onclicktype == ONCLICKTYPE.POPUP &&  clicked == true){
             view.drawPopUp(screenXClick, screenYClick, g2);
         }
@@ -94,4 +94,12 @@ public class InteractiveTileController {
     public void unClick() {
         clicked = false;
     }
+
+    public abstract void upgrade();
+
+    public abstract void collect();
+
+    public int getLevel() {
+        return model.getLevel();
+    }
 }

src/main/java/controller/tiles/interactive/MineController.java

@@ -1,25 +0,0 @@
-package controller.tiles.interactive;
-
-import controller.GameController;
-import model.tiles.InteractiveTileModel;
-import util.Translator;
-import view.Camera;
-import view.popUpMenu.PopupMenu;
-import view.popUpMenu.UpgradeMenu;
-import view.tile.interactive.InteractiveTileView;
-import view.tile.interactive.LighthouseView;
-import view.tile.interactive.MineView;
-
-import java.awt.*;
-import java.io.Serializable;
-
-public class MineController extends InteractiveTileController{
-
-    public MineController(GameController gc, InteractiveTileModel model) {
-        super(model, null, gc);
-        setView(new MineView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.mine"));
-        setPopupOnClick(popup);
-    }
-
-}

src/main/java/controller/tiles/interactive/AnimalEnclosureController.java → src/main/java/controller/tiles/interactive/upgradeable/AnimalEnclosureController.java

@@ -1,23 +1,29 @@
-package controller.tiles.interactive;
+package controller.tiles.interactive.upgradeable;
 
 import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
 import model.tiles.InteractiveTileModel;
 import util.Translator;
-import view.Camera;
 import view.popUpMenu.PopupMenu;
 import view.popUpMenu.UpgradeMenu;
 import view.tile.interactive.AnimalEnclosureView;
-import view.tile.interactive.InteractiveTileView;
-
-import java.awt.*;
 
 public class AnimalEnclosureController extends InteractiveTileController {
 
     public AnimalEnclosureController(GameController gc, InteractiveTileModel model) {
         super(model, null, gc);
         setView(new AnimalEnclosureView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.animal_enclosure"));
+        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.animal_enclosure"), this);
         setPopupOnClick(popup);
     }
 
+    @Override
+    public void upgrade() {
+
+    }
+
+    @Override
+    public void collect() {
+
+    }
 }

src/main/java/controller/tiles/interactive/BarracksController.java → src/main/java/controller/tiles/interactive/upgradeable/BarracksController.java

@@ -1,23 +1,29 @@
-package controller.tiles.interactive;
+package controller.tiles.interactive.upgradeable;
 
 import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
 import model.tiles.InteractiveTileModel;
 import util.Translator;
-import view.Camera;
 import view.popUpMenu.PopupMenu;
 import view.popUpMenu.UpgradeMenu;
 import view.tile.interactive.BarracksView;
-import view.tile.interactive.InteractiveTileView;
-import view.tile.interactive.LighthouseView;
-
-import java.awt.*;
 
 public class BarracksController extends InteractiveTileController {
 
     public BarracksController(GameController gc, InteractiveTileModel model) {
         super(model, null, gc);
         setView(new BarracksView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.barracks"));
+        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.barracks"), this);
         setPopupOnClick(popup);
     }
+
+    @Override
+    public void upgrade() {
+
+    }
+
+    @Override
+    public void collect() {
+
+    }
 }

src/main/java/controller/tiles/interactive/IronMineController.java → src/main/java/controller/tiles/interactive/upgradeable/IronMineController.java

@@ -1,6 +1,7 @@
-package controller.tiles.interactive;
+package controller.tiles.interactive.upgradeable;
 
 import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
 import model.tiles.InteractiveTileModel;
 import util.Translator;
 import view.popUpMenu.PopupMenu;
@@ -12,8 +13,18 @@ public class IronMineController extends InteractiveTileController {
     public IronMineController(GameController gc, InteractiveTileModel model) {
         super(model, null, gc);
         setView(new IronMineView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.iron_mine"));
+        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.iron_mine"), this);
 
         setPopupOnClick(popup);
     }
+
+    @Override
+    public void upgrade() {
+
+    }
+
+    @Override
+    public void collect() {
+
+    }
 }

src/main/java/controller/tiles/interactive/LighthouseController.java → src/main/java/controller/tiles/interactive/upgradeable/LighthouseController.java

@@ -1,6 +1,7 @@
-package controller.tiles.interactive;
+package controller.tiles.interactive.upgradeable;
 
 import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
 import model.tiles.InteractiveTileModel;
 import util.Translator;
 import view.popUpMenu.PopupMenu;
@@ -12,9 +13,18 @@ public class LighthouseController extends InteractiveTileController {
     public LighthouseController(GameController gc, InteractiveTileModel model) {
         super(model, null, gc);
         setView(new LighthouseView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 110, Translator.translate("popup.title.lighthouse"));
+        PopupMenu popup = new UpgradeMenu(100, 110, Translator.translate("popup.title.lighthouse"), this);
 
         setPopupOnClick(popup);
     }
 
+    @Override
+    public void upgrade() {
+
+    }
+
+    @Override
+    public void collect() {
+
+    }
 }

src/main/java/controller/tiles/interactive/upgradeable/MineController.java

@@ -0,0 +1,35 @@
+package controller.tiles.interactive.upgradeable;
+
+import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
+import model.tiles.InteractiveTileModel;
+import util.Translator;
+import view.popUpMenu.PopupMenu;
+import view.popUpMenu.UpgradeMenu;
+import view.tile.interactive.MineView;
+
+public class MineController extends InteractiveTileController {
+
+    public MineController(GameController gc, InteractiveTileModel model) {
+        super(model, null, gc);
+        setView(new MineView(gc, this));
+        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.mine"), this);
+        setPopupOnClick(popup);
+    }
+
+    @Override
+    public void upgrade() {
+        boolean condition = false;
+        if(condition){
+            getModel().upgrade();
+        }
+    }
+
+    @Override
+    public void collect() {
+        boolean condition = false;
+        if(condition){
+            getModel().collect();
+        }
+    }
+}

src/main/java/controller/tiles/interactive/SawmillController.java → src/main/java/controller/tiles/interactive/upgradeable/SawmillController.java

@@ -1,25 +1,30 @@
-package controller.tiles.interactive;
+package controller.tiles.interactive.upgradeable;
 
 import controller.GameController;
+import controller.tiles.interactive.InteractiveTileController;
 import model.tiles.InteractiveTileModel;
 import util.Translator;
-import view.Camera;
 import view.popUpMenu.PopupMenu;
 import view.popUpMenu.UpgradeMenu;
-import view.tile.interactive.InteractiveTileView;
-import view.tile.interactive.LighthouseView;
 import view.tile.interactive.SawmillView;
 
-import java.awt.*;
-
 public class SawmillController extends InteractiveTileController {
 
     public SawmillController(GameController gc, InteractiveTileModel model) {
         super(model, null, gc);
         setView(new SawmillView(gc, this));
-        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.sawmill"));
+        PopupMenu popup = new UpgradeMenu(100, 100, Translator.translate("popup.title.sawmill"), this);
 
         setPopupOnClick(popup);
     }
 
+    @Override
+    public void upgrade() {
+
+    }
+
+    @Override
+    public void collect() {
+
+    }
 }

src/main/java/main/Main.java

@@ -4,6 +4,7 @@ import controller.GameController;
 import model.GameModel;
 import model.GameSaver;
 import util.Translator;
+import util.WorldGenerator;
 import view.GamePanel;
 
 import javax.swing.*;
@@ -16,7 +17,11 @@ public class Main {
         Translator.load("lang/de_de.json");
 
         GameController gameController = GameSaver.loadGame();
+
+        //gameController.generateNewWorld();
+
         GamePanel gamePanel = gameController.getView();
+
         gameController.loadInteractiveTiles();
 
         System.out.println("Starte Spiel...");

src/main/java/model/GameSaver.java

@@ -1,12 +1,11 @@
 package model;
 
 import controller.GameController;
-import view.GamePanel;
 
 import java.io.*;
 
 public class GameSaver {
-    private static final String SAVE_FILE = "game.dat";
+    private static final String SAVE_FILE = "gamefiles/game.dat";
     private GameSaver(){
 
     }
@@ -19,6 +18,7 @@ public class GameSaver {
             e.printStackTrace();
         }
     }
+
     public static GameController loadGame() {
         File file = new File(SAVE_FILE);
 
@@ -28,7 +28,9 @@ public class GameSaver {
         }
 
         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
-            return (GameController) ois.readObject();
+            GameController controller = (GameController) ois.readObject();
+            controller.loadWorld();
+            return controller;
         } catch (Exception e) {
             System.out.println("Failed to load save file. Starting a new game...");
             e.printStackTrace();

src/main/java/model/Inventory.java

@@ -1,8 +1,7 @@
 package model;
 
 import model.items.ITEM_NAME;
-import view.GamePanel;
-import view.InventoryView;
+import model.items.Item;
 
 import java.io.Serializable;
 import java.util.ArrayList;

src/main/java/model/Entity.java → src/main/java/model/entity/Entity.java

@@ -1,4 +1,4 @@
-package model;
+package model.entity;
 
 import controller.KeyHandler;
 import view.GamePanel;

src/main/java/model/Item.java → src/main/java/model/items/Item.java

@@ -1,6 +1,4 @@
-package model;
-
-import model.items.ITEM_NAME;
+package model.items;
 
 import java.io.Serializable;
 

src/main/java/model/tiles/InteractiveTileModel.java

@@ -1,10 +1,15 @@
 package model.tiles;
 
-public class InteractiveTileModel {
+import model.items.Item;
+
+import java.io.Serializable;
+
+public class InteractiveTileModel implements Serializable {
     protected int worldGridX, worldGridY;
     protected int width, height;
     private boolean clicked;
     private int level;
+    private Item items;
 
     public InteractiveTileModel(int worldGridX, int worldGridY, int width, int height) {
         this.worldGridX = worldGridX;
@@ -45,4 +50,12 @@ public class InteractiveTileModel {
     public void setClicked(boolean clicked) {
         this.clicked = clicked;
     }
+
+    public void upgrade(){
+        level++;
+    }
+
+    public Item collect() {
+        return items.takeItems(items.getCount());
+    }
 }

src/main/java/util/WorldGenerator.java

@@ -0,0 +1,183 @@
+package util;
+
+import java.io.*;
+import java.util.*;
+
+import java.io.*;
+import java.util.*;
+
+public class WorldGenerator {
+    private static int worldGenNumber = 0;
+
+    public static String generateNewWorld(int worldWidth, int worldHeight, int seed) {
+        Random rand = new Random(seed);
+        int[][] world = new int[worldHeight][worldWidth];
+        initializeWorld(world);
+        createMainPath(world, worldWidth, worldHeight, rand);
+        addSecondaryPaths(world, worldWidth, worldHeight, rand);
+        addWater(world, worldWidth, worldHeight, rand);
+        addTrees(world, worldWidth, worldHeight, rand);
+        addEarthPatches(world, worldWidth, worldHeight, rand);
+        return writeWorldToFile(world, worldWidth, worldHeight);
+    }
+
+    private static void initializeWorld(int[][] world) {
+        for (int[] row : world) {
+            Arrays.fill(row, 0); // Fill with grass
+        }
+    }
+
+    private static void createMainPath(int[][] world, int width, int height, Random rand) {
+        int startX = width / 2;
+        int startY = height / 2;
+        // Create a winding main path with multiple segments
+        drunkardsWalk(world, startX, startY, 300, width, height, rand, true);
+    }
+
+    private static void addSecondaryPaths(int[][] world, int width, int height, Random rand) {
+        int numBranches = 10;
+        for (int i = 0; i < numBranches; i++) {
+            // Find a random point on the existing path
+            int startX, startY;
+            do {
+                startX = rand.nextInt(width);
+                startY = rand.nextInt(height);
+            } while (world[startY][startX] != 5);
+
+            drunkardsWalk(world, startX, startY, 50 + rand.nextInt(50), width, height, rand, false);
+        }
+    }
+
+    private static void drunkardsWalk(int[][] world, int startX, int startY, int steps,
+                                      int width, int height, Random rand, boolean isMain) {
+        int x = startX;
+        int y = startY;
+        for (int i = 0; i < steps; i++) {
+            int dir = rand.nextInt(4);
+            switch (dir) {
+                case 0 -> x = Math.min(x + 1, width - 1);
+                case 1 -> x = Math.max(x - 1, 0);
+                case 2 -> y = Math.min(y + 1, height - 1);
+                case 3 -> y = Math.max(y - 1, 0);
+            }
+            world[y][x] = 5; // Set to path
+
+            // Randomly widen path
+            if (rand.nextDouble() < (isMain ? 0.4 : 0.3)) {
+                int widen = rand.nextInt(2) + 1;
+                for (int dx = -widen; dx <= widen; dx++) {
+                    for (int dy = -widen; dy <= widen; dy++) {
+                        if (x + dx >= 0 && x + dx < width && y + dy >= 0 && y + dy < height) {
+                            if (world[y + dy][x + dx] == 0) {
+                                world[y + dy][x + dx] = 5;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static void addWater(int[][] world, int width, int height, Random rand) {
+        for (int i = 0; i < 5; i++) {
+            int x = rand.nextInt(width);
+            int y = rand.nextInt(height);
+            if (world[y][x] == 0) {
+                floodFill(world, x, y, 2, 50 + rand.nextInt(50), width, height);
+            }
+        }
+    }
+
+    private static void floodFill(int[][] world, int x, int y, int tile, int maxSize, int width, int height) {
+        Queue<Point> queue = new LinkedList<>();
+        Set<Point> visited = new HashSet<>();
+        queue.add(new Point(x, y));
+        int filled = 0;
+
+        while (!queue.isEmpty() && filled < maxSize) {
+            Point p = queue.poll();
+            if (visited.contains(p)) continue;
+            visited.add(p);
+
+            if (world[p.y][p.x] == 0) {
+                world[p.y][p.x] = tile;
+                filled++;
+                // Add neighbors
+                if (p.x > 0) queue.add(new Point(p.x - 1, p.y));
+                if (p.x < width - 1) queue.add(new Point(p.x + 1, p.y));
+                if (p.y > 0) queue.add(new Point(p.x, p.y - 1));
+                if (p.y < height - 1) queue.add(new Point(p.x, p.y + 1));
+            }
+        }
+    }
+
+    private static void addTrees(int[][] world, int width, int height, Random rand) {
+        for (int i = 0; i < 10; i++) {
+            int x = rand.nextInt(width);
+            int y = rand.nextInt(height);
+            if (world[y][x] == 0) {
+                generateTreeCluster(world, x, y, 4 + rand.nextInt(4), width, height, rand);
+            }
+        }
+    }
+
+    private static void generateTreeCluster(int[][] world, int x, int y, int size,
+                                            int width, int height, Random rand) {
+        for (int dx = -size; dx <= size; dx++) {
+            for (int dy = -size; dy <= size; dy++) {
+                if (x + dx >= 0 && x + dx < width && y + dy >= 0 && y + dy < height) {
+                    double dist = Math.sqrt(dx*dx + dy*dy);
+                    if (dist <= size && rand.nextDouble() < 0.7 - (dist / size) * 0.4) {
+                        if (world[y + dy][x + dx] == 0) {
+                            world[y + dy][x + dx] = 4;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static void addEarthPatches(int[][] world, int width, int height, Random rand) {
+        for (int i = 0; i < width * height / 20; i++) {
+            int x = rand.nextInt(width);
+            int y = rand.nextInt(height);
+            if (world[y][x] == 0) {
+                world[y][x] = 3; // Earth
+            }
+        }
+    }
+
+    private static String writeWorldToFile(int[][] world, int width, int height) {
+        String fileName = "gamefiles/worlds/world_" + worldGenNumber++ + ".txt";
+        try (PrintWriter writer = new PrintWriter(new File(fileName))) {
+            for (int[] row : world) {
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < row.length; i++) {
+                    sb.append(i > 0 ? " " : "").append(row[i]);
+                }
+                writer.println(sb);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return fileName;
+    }
+
+    private static class Point {
+        int x, y;
+        Point(int x, int y) { this.x = x; this.y = y; }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Point point = (Point) o;
+            return x == point.x && y == point.y;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+    }
+}

src/main/java/view/Camera.java

@@ -1,7 +1,7 @@
 package view;
 
 import controller.KeyHandler;
-import model.Entity;
+import model.entity.Entity;
 
 import javax.imageio.ImageIO;
 import java.awt.*;

src/main/java/view/GamePanel.java

@@ -5,10 +5,9 @@ import controller.MouseListener;
 import controller.MouseWheelZoom;
 import model.GameSaver;
 import model.Inventory;
+import util.WorldGenerator;
 import view.tile.TileManager;
 import util.GAMESTATE;
-import controller.KeyHandler;
-import view.util.screenCoordinatesToWorld;
 
 import javax.swing.*;
 import java.awt.*;
@@ -30,8 +29,9 @@ public class GamePanel extends JPanel{
     public int screenHeight = tileSize * maxScreenRow;
 
     // World Settings
-    public final int maxWorldCol = 50;
-    public final int maxWorldRow = 50;
+    public final static int maxWorldCol = 100;
+    public final static int maxWorldRow = 100;
+
     public final int worldWidth = tileSize * maxWorldCol;
     public final int worldHeight = tileSize * maxWorldRow;
 
@@ -69,6 +69,9 @@ public class GamePanel extends JPanel{
 
         gameState = GAMESTATE.PLAY;
     }
+    public void loadMap(String worldPath){
+        tileManager.loadMap(worldPath);
+    }
 
     public void zoomInOut(int i) {
         if (gameState != GAMESTATE.PLAY) {
@@ -132,4 +135,7 @@ public class GamePanel extends JPanel{
         }
     }
 
+    public void generateNewWorld() {
+        tileManager.generateNewWorld();
+    }
 }

src/main/java/view/popUpMenu/PopupMenu.java

@@ -36,7 +36,6 @@ public abstract class PopupMenu implements Serializable {
     public void draw(int x, int y, Graphics2D g2){
         FontMetrics fm = g2.getFontMetrics();
         int msgWidth = fm.stringWidth(title);
-        int msgHeight = fm.getAscent();
         if(overlayWidth < msgWidth) overlayWidth = msgWidth + 20;
 
         centerButtons();
@@ -55,7 +54,7 @@ public abstract class PopupMenu implements Serializable {
 
     }
 
-    private void centerButtons() {
+    protected void centerButtons() {
         for (Button button : buttonArrayList){
             button.centerToWidth(overlayWidth);
         }

src/main/java/view/popUpMenu/UpgradeMenu.java

@@ -1,22 +1,49 @@
 package view.popUpMenu;
 
 import controller.tiles.interactive.InteractiveTileController;
+import model.tiles.InteractiveTileModel;
 import util.Translator;
 import view.components.Button;
 
+import java.awt.*;
 import java.io.Serializable;
 
 public class UpgradeMenu extends PopupMenu {
-    public UpgradeMenu(int width, int height, String title) {
+    private InteractiveTileController controller;
+    public UpgradeMenu(int width, int height, String title, InteractiveTileController controller) {
         super(width, height, title);
+        this.controller = controller;
         addButton( new Button(80, 25, Translator.translate("popup.upgrade"), this::upgrade), 10, 40 );
         addButton( new Button(80,25, Translator.translate("popup.collect"),this::collect), 10, 70);
     }
+    @Override
+    public void draw(int x, int y, Graphics2D g2){
+        FontMetrics fm = g2.getFontMetrics();
+        int msgWidth = fm.stringWidth(title);
+        if(overlayWidth < msgWidth) overlayWidth = msgWidth + 20;
 
+        centerButtons();
+
+        g2.setColor(Color.GRAY);
+        g2.fillRoundRect(x,y, overlayWidth, overlayHeight, 15, 15);
+        g2.setColor(Color.WHITE);
+        g2.drawRoundRect(x,y,overlayWidth,overlayHeight, 15, 15);
+
+        g2.drawString(title, x + ((overlayWidth - msgWidth )/2), y+ 20);
+
+        String levelStr = "Level: " + controller.getLevel();
+        int lvlStrWidth = fm.stringWidth(levelStr);
+        g2.drawString(levelStr, x + ((overlayWidth - lvlStrWidth )/2), y+ 35);
+        for (Button button : buttonArrayList){
+            button.setRelativeScreenCoordinates(x,y);
+            button.draw(g2);
+        }
+
+    }
     private void upgrade(){
-        System.out.println("Upgrade");
+        controller.upgrade();
     }
     private void collect(){
-        System.out.println("Collect");
+        controller.collect();
     }
 }

src/main/java/view/tile/TileManager.java

@@ -4,13 +4,11 @@ import controller.tiles.interactive.InteractiveTileController;
 import model.Tile;
 import model.tiles.BackgroundTile;
 import model.tiles.InteractiveTileModel;
+import util.WorldGenerator;
 import view.GamePanel;
 
 import java.awt.*;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
+import java.io.*;
 
 public class TileManager {
 
@@ -22,9 +20,9 @@ public class TileManager {
     public TileManager(GamePanel gp){
         this.gamePanel = gp;
         tile = new Tile[10];
-        mapTileNum = new int[gp.maxWorldCol][gp.maxWorldRow];
+        mapTileNum = new int[GamePanel.maxWorldCol][GamePanel.maxWorldRow];
         getTileImage();
-        loadMap("/maps/world01.txt");
+
     }
     public int getTileSize(){
         return gamePanel.tileSize;
@@ -35,9 +33,10 @@ public class TileManager {
     }
 
     public void loadMap(String filePath){
+
         try{
             InputStream is = getClass().getResourceAsStream(filePath);
-            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
 
             int col = 0;
             int row = 0;
@@ -60,7 +59,9 @@ public class TileManager {
             br.close();
 
         }catch (Exception e){
-            e.printStackTrace();
+            System.out.println("Couldn't find world path... Creating new World...");
+            gamePanel.generateNewWorld();
+
         }
     }
 
@@ -101,7 +102,7 @@ public class TileManager {
             tile.drawTile(g2, gamePanel.camera);
         }
         for (InteractiveTileController tile : gamePanel.gameController.interactiveTileControllers) {
-            tile.drawPopup(g2, gamePanel.camera);
+            tile.drawPopup(g2);
         }
 
     }
@@ -139,5 +140,9 @@ public class TileManager {
         tile[index].setImage("/tiles/" + path + ".png");
     }
 
+    public void generateNewWorld() {
+        String filePath = WorldGenerator.generateNewWorld(GamePanel.maxWorldCol, GamePanel.maxWorldRow, (int) Math.floor(Math.random()*100000));
+        loadMap(filePath);
+    }
 }
 

src/main/java/view/util/screenCoordinatesToWorld.java

@@ -1,6 +0,0 @@
-package view.util;
-
-public interface screenCoordinatesToWorld {
-    int getWorldX(int screenX);
-    int getWorldY(int screenY);
-}

src/main/resources/maps/map01.txt

@@ -1,12 +0,0 @@
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 1 2 1 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0