Szene verschieben und Anfang von Interactive Tiles

src/main/java/ui/Camera.java

@@ -21,7 +21,7 @@ public class Camera extends Entity {
         keyH = keyHandler;
         screenX = gp.screenWidth/2 - gamePanel.tileSize/2;
         screenY = gp.screenHeight/2 - gamePanel.tileSize/2;
-        getPlayerImage();
+        //getPlayerImage();
         setDefaultValues();
     }
     private void getPlayerImage(){
@@ -37,6 +37,11 @@ public class Camera extends Entity {
         speed = 4;
     }
 
+    public void move(int x, int y){
+        worldY += y;
+        worldX += x;
+    }
+
     public void update(){
         if(keyH.upPressed){
             worldY -= speed;

src/main/java/ui/Entry.java

@@ -10,6 +10,7 @@ public class Entry {
         window.setTitle("Tiny Settlement");
 
         GamePanel gamePanel = new GamePanel();
+        window.setPreferredSize(gamePanel.getPreferredSize());
         window.add(gamePanel);
 
         window.pack();

src/main/java/ui/GamePanel.java

@@ -11,7 +11,7 @@ public class GamePanel extends JPanel implements Runnable{
 
     //Screen Settings
     final int originalTileSize = 16;
-    final int scale = 3;
+    final int scale = 4;
 
     int fps = 60;
 
@@ -40,6 +40,11 @@ public class GamePanel extends JPanel implements Runnable{
     public Camera camera = new Camera(this, keyH);
 
     public GamePanel(){
+        MouseDragListener mdl = new MouseDragListener(this, camera, tileManager);
+        this.addMouseListener(mdl);
+        this.addMouseMotionListener(mdl);
+        this.addMouseWheelListener(new MouseWheelZoom(this));
+
         this.setPreferredSize(new Dimension(screenWidth, screenHeight));
         this.setBackground(Color.BLACK);
         this.setDoubleBuffered(true);
@@ -50,12 +55,16 @@ public class GamePanel extends JPanel implements Runnable{
     }
 
     public void zoomInOut(int i){
+        if(gameState != GAMESTATE.PLAY){
+            return;
+        }
         int oldWorldWidth = tileSize * maxWorldCol;
-        if((tileSize > 1 && i < 0) || (tileSize < (originalTileSize * scale)*3 && i > 0)){
+        if((tileSize >= originalTileSize*scale/4 && i < 0) || (tileSize < (originalTileSize * scale) && i > 0)){
             tileSize += i;
         }
 
 
+
         int newWorldWidth = tileSize * maxWorldCol;
 
         double multiplier = (double)newWorldWidth/oldWorldWidth;
@@ -70,6 +79,11 @@ public class GamePanel extends JPanel implements Runnable{
         gameThread = new Thread(this);
         gameThread.start();
     }
+
+    public void clearAll(Graphics g){
+        super.paintComponent(g);
+    }
+
     public void paintComponent(Graphics g){
         super.paintComponent(g);
 
@@ -107,7 +121,7 @@ public class GamePanel extends JPanel implements Runnable{
                 drawCount++;
             }
             if(timer >= 1000000000){
-                System.out.println("FPS: " + drawCount);
+                //System.out.println("FPS: " + drawCount);
                 drawCount = 0;
                 timer = 0;
             }

src/main/java/ui/MouseDragListener.java

@@ -0,0 +1,76 @@
+package ui;
+
+import ui.tile.InteractiveTile;
+import ui.tile.Tile;
+import ui.tile.TileManager;
+
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionAdapter;
+
+public class MouseDragListener extends MouseMotionAdapter implements MouseListener {
+    private int startX;
+    private int startY;
+
+    Camera camera;
+    TileManager tileManager;
+    GamePanel gp;
+    public MouseDragListener(GamePanel gp, Camera camera, TileManager tm){
+        this.camera = camera;
+        this.tileManager = tm;
+        this.gp = gp;
+    }
+    @Override
+    public void mouseDragged(MouseEvent e) {
+        int diffY = startY - e.getY();
+        int diffX = startX - e.getX();
+
+        camera.move(diffX, diffY);
+
+        startX = e.getX();
+        startY = e.getY();
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {
+        startX = e.getX();
+        startY = e.getY();
+
+        int worldX = (int) (startX + camera.worldX - camera.screenX);
+        int worldY = (int) (startY + camera.worldY - camera.screenY);
+
+        int tileCol = worldX / gp.tileSize;
+        int tileRow = worldY / gp.tileSize;
+
+        if (tileCol >= 0 && tileCol < gp.maxWorldCol &&
+                tileRow >= 0 && tileRow < gp.maxWorldRow) {
+
+            int tileIndex = tileManager.mapTileNum[tileCol][tileRow];
+            Tile tile = tileManager.tile[tileIndex];
+
+            if(tile instanceof InteractiveTile it) {
+                it.onClick(); // Consumer wird aufgerufen
+            }
+        }
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+
+    }
+}

src/main/java/ui/MouseWheelZoom.java

@@ -0,0 +1,18 @@
+package ui;
+
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
+
+public class MouseWheelZoom implements MouseWheelListener {
+    GamePanel gp;
+    public MouseWheelZoom(GamePanel gamePanel){
+        gp = gamePanel;
+    }
+
+    @Override
+    public void mouseWheelMoved(MouseWheelEvent e) {
+        for(int i = 0; i < e.getScrollAmount(); i++){
+            gp.zoomInOut(-e.getWheelRotation());
+        }
+    }
+}

src/main/java/ui/UI.java

@@ -37,13 +37,13 @@ public class UI {
         String text = "PAUSED";
         int x = getXForCenteredText(text);
         int y = gp.screenHeight / 2;
+        gp.clearAll(g2);
 
         g2.setColor(new Color(25,31,52, 80));
         g2.fillRect(0, 0, gp.screenWidth, gp.screenHeight);
 
         g2.setColor(Color.WHITE);
         g2.drawString(text, x, y);
-
     }
     public int getXForCenteredText(String text){
         int length = (int)g2.getFontMetrics().getStringBounds(text, g2).getWidth();

src/main/java/ui/tile/BackgroundTile.java

@@ -0,0 +1,4 @@
+package ui.tile;
+
+public class BackgroundTile extends Tile{
+}

src/main/java/ui/tile/InteractiveTile.java

@@ -0,0 +1,16 @@
+package ui.tile;
+
+import java.util.function.Consumer;
+
+public class InteractiveTile extends Tile{
+    private Consumer<Tile> onClick;
+    public InteractiveTile(){
+        interactive = true;
+    }
+    public void addOnClick(Consumer<Tile> c){
+        onClick = c;
+    }
+    public void onClick(){
+        onClick.accept(this);
+    }
+}

src/main/java/ui/tile/Tile.java

@@ -1,9 +1,21 @@
 package ui.tile;
 
+import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
+import java.io.IOException;
 
-public class Tile {
-
+public abstract class Tile {
     public BufferedImage image;
-    public boolean collision = false;
+    public boolean interactive = false;
+
+    public int worldX;
+    public int worldY;
+
+    public void setImage(String imagePath) {
+        try {
+            image = ImageIO.read(getClass().getResourceAsStream(imagePath));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
 }

src/main/java/ui/tile/TileManager.java

@@ -4,17 +4,20 @@ import ui.GamePanel;
 
 import javax.imageio.ImageIO;
 import java.awt.*;
+import java.awt.image.BufferedImage;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.nio.Buffer;
+import java.util.function.Consumer;
 
 public class TileManager {
 
     GamePanel gamePanel;
-    Tile[] tile;
-    int mapTileNum[] [];
-
+    public Tile[] tile;
+    public int[][] mapTileNum;
+    public int mapTileOverflow = 1;
     public TileManager(GamePanel gp){
         this.gamePanel = gp;
         tile = new Tile[10];
@@ -67,10 +70,11 @@ public class TileManager {
             double screenY = worldY - gamePanel.camera.worldY + gamePanel.camera.screenY;
 
 
-            if(worldX + gamePanel.tileSize > gamePanel.camera.worldX - gamePanel.camera.screenX &&
-               worldX - gamePanel.tileSize < gamePanel.camera.worldX + gamePanel.camera.screenX &&
-               worldY + gamePanel.tileSize > gamePanel.camera.worldY - gamePanel.camera.screenY &&
-               worldY - gamePanel.tileSize < gamePanel.camera.worldY + gamePanel.camera.screenY   ) {
+            if(worldX + gamePanel.tileSize*mapTileOverflow > gamePanel.camera.worldX - gamePanel.camera.screenX &&
+               worldX - gamePanel.tileSize*mapTileOverflow < gamePanel.camera.worldX + gamePanel.camera.screenX &&
+               worldY + gamePanel.tileSize*mapTileOverflow > gamePanel.camera.worldY - gamePanel.camera.screenY &&
+               worldY - gamePanel.tileSize*mapTileOverflow < gamePanel.camera.worldY + gamePanel.camera.screenY   ) {
+
 
                 g2.drawImage(tile[tileNum].image, (int) screenX, (int) screenY, gamePanel.tileSize, gamePanel.tileSize, null);
             }
@@ -90,14 +94,27 @@ public class TileManager {
             setupTile(1, "/tiles/wall.png");
             setupTile(2, "/tiles/water.png");
             setupTile(3, "/tiles/earth.png");
-            setupTile(4, "/tiles/tree.png");
+
+            setupTile(4, "/tiles/tree.png", true, (tile) -> System.out.println("Clicked! x:"+ tile.worldX + ", y:" + tile.worldY));
+
             setupTile(5, "/tiles/sand.png");
+
         }catch (IOException e){
             e.printStackTrace();
         }
     }
     private void setupTile(int index, String path) throws IOException {
-        tile[index] = new Tile();
-        tile[index].image = ImageIO.read(getClass().getResourceAsStream(path));
+        tile[index] = new BackgroundTile();
+        tile[index].setImage(path);
+    }
+    private void setupTile(int index, String path, boolean interactive, Consumer<Tile> consumer) throws IOException {
+        if(!interactive){
+            tile[index] = new BackgroundTile();
+        }else{
+            InteractiveTile t = new InteractiveTile();
+            t.addOnClick(consumer);
+            tile[index] = t;
+        }
+        tile[index].setImage(path);
     }
 }