瓷磚遊戲上的重複瓷磚

我目前正在用Java2D在Java中進行基於瓷磚的遊戲。但是，我想我錯過了一些非常愚蠢的事情，或者不是，事情是我檢查了我的代碼幾千次，而且我沒有看到任何奇怪的東西。所以這是我的比賽的打印現在：瓷磚遊戲上的重複瓷磚

但它應該是這個樣子： enter image description here

嗯，我知道，這看起來不錯，但如果你看看了我的基於區塊的級別的圖像：

（灰色瓷磚磚，青瓦是牧草和棕色的瓷磚都是土）

所以磚瓦在一些奇怪的方式上被複制。所以，這裏是我的級別代碼：

import java.awt.Graphics2D; 
import java.awt.Point; 
import java.awt.Rectangle; 
import java.awt.image.BufferedImage; 
import java.util.ArrayList; 
import java.util.List; 

import com.wg.MainComponent; 
import com.wg.entity.Entity; 
import com.wg.entity.Particle; 
import com.wg.entity.Projectile; 
import com.wg.entity.mob.Mob; 
import com.wg.entity.mob.Player; 

public abstract class Level { 

    public BufferedImage levelImage; 
    public BufferedImage[][] tile; 
    public Rectangle[][] rect; 
    public int tileSize; 
    public float xOffset, yOffset; 
    public ArrayList<BufferedImage> collision = new ArrayList<BufferedImage>(); 

    public ArrayList<Player> players = new ArrayList<Player>(); 
    public ArrayList<Projectile> projectiles = new ArrayList<Projectile>(); 
    public ArrayList<Particle> particles = new ArrayList<Particle>(); 
    private List<Entity> entities = new ArrayList<Entity>(); 

    public BufferedImage[] tilesBufferedImages; 
    public int[] xCollisionOffset; 
    public int[] yCollisionOffset; 

    public Level(BufferedImage levelImage, int tileSize, BufferedImage[] tilesBufferedImages, int[] xCollisionOffset, int[] yCollisionOffset) { 
     this.tilesBufferedImages = tilesBufferedImages; 
     this.xCollisionOffset = xCollisionOffset; 
     this.yCollisionOffset = yCollisionOffset; 

     this.levelImage = levelImage; 
     this.tileSize = tileSize; 

     tile = new BufferedImage[levelImage.getWidth()][levelImage.getHeight()]; 
     rect = new Rectangle[levelImage.getWidth()][levelImage.getHeight()]; 

     generateLevel(); 
    } 

    public abstract void generateLevel(); 

    public void render(float xOffset, float yOffset, int scale, Graphics2D screen) { 
     this.xOffset = xOffset; 
     this.yOffset = yOffset; 

     for (int y = (int) Math.max(yOffset/(tileSize + scale), 0); y < Math.min((MainComponent.height + yOffset)/(tileSize + scale) + 1, levelImage.getHeight()); y++) { 
      for (int x = (int) Math.max(xOffset/(tileSize + scale), 0); x < Math.min((MainComponent.width + xOffset)/(tileSize + scale) + 1, levelImage.getWidth()); x++) { 
       if (tile[x][y] != null) 
        screen.drawImage(tile[x][y], (int) (x * (tileSize + scale) - xOffset), (int) (y * (tileSize + scale) - yOffset), (tileSize + scale), (tileSize + scale), null); 
      } 
     } 

     for (int i = 0; i < entities.size(); i++) { 
      entities.get(i).render(screen); 
     } 

     for (int i = 0; i < players.size(); i++) { 
      players.get(i).render(screen); 
     } 

     for (int i = 0; i < projectiles.size(); i++) { 
      projectiles.get(i).render(screen); 
     } 

     for (int i = 0; i < particles.size(); i++) { 
      particles.get(i).render(screen); 
     } 
    } 

    public void add(Entity e) { 
     if (e instanceof Particle) { 
      particles.add((Particle) e); 
     } else if (e instanceof Player) { 
      players.add((Player) e); 
     } else if (e instanceof Projectile) { 
      projectiles.add((Projectile) e); 
     } else { 
      entities.add(e); 
     } 
    } 

    public void update(int scale) { 
     for (int y = 0; y < levelImage.getHeight(); y++) { 
      for (int x = 0; x < levelImage.getWidth(); x++) { 
       if (tile[x][y] != null && rect[x][y] == null) { 
        for (int i = 0; i < tilesBufferedImages.length; i++) { 
         if (tilesBufferedImages[i] == tile[x][y]) 
          rect[x][y] = new Rectangle(x * (tileSize + scale) - Math.round(xOffset) + xCollisionOffset[i], y * (tileSize + scale) - Math.round(yOffset) + yCollisionOffset[i], (tileSize + scale) + xCollisionOffset[i], (tileSize + scale) + yCollisionOffset[i]); 
        } 
       } else if (tile[x][y] != null && rect[x][y] != null) { 
        for (int i = 0; i < tilesBufferedImages.length; i++) { 
         if (tilesBufferedImages[i] == tile[x][y]) 
          rect[x][y].setBounds(x * (tileSize + scale) - Math.round(xOffset) + xCollisionOffset[i], y * (tileSize + scale) - Math.round(yOffset) + xCollisionOffset[i], (tileSize + scale) + xCollisionOffset[i], (tileSize + scale) + yCollisionOffset[i]); 
        } 
       } 
      } 
     } 

     for (int i = 0; i < entities.size(); i++) { 
      entities.get(i).update(); 
     } 

     for (int i = 0; i < players.size(); i++) { 
      players.get(i).update(); 
     } 

     for (int i = 0; i < projectiles.size(); i++) { 
      projectiles.get(i).update(); 
     } 
     for (int i = 0; i < particles.size(); i++) { 
      particles.get(i).update(); 
     } 

     remove(); 
    } 

    public List<Player> getPlayers() { 
     return players; 
    } 

    public Player getPlayerAt(int index) { 
     return players.get(index); 
    } 

    public Player getClientPlayer() { 
     return players.get(0); 
    } 

    private void remove() { 
     for (int i = 0; i < entities.size(); i++) { 
      if (entities.get(i).isRemoved()) 
       entities.remove(i); 
     } 
     for (int i = 0; i < projectiles.size(); i++) { 
      if (projectiles.get(i).isRemoved()) 
       projectiles.remove(i); 
     } 
     for (int i = 0; i < players.size(); i++) { 
      if (players.get(i).isRemoved()) 
       players.remove(i); 
     } 
     for (int i = 0; i < particles.size(); i++) { 
      if (particles.get(i).isRemoved()) 
       particles.remove(i); 
     } 
    } 

    public boolean tileDownCollision(Mob en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x), Math.round(en.y + en.height)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - xOffset), Math.round(en.y + en.height - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean tileUpCollision(Mob en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x), Math.round(en.y - 1)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - xOffset), Math.round(en.y - 1 - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean tileLeftCollision(Mob en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x - 1), Math.round(en.y)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - 1 - xOffset), Math.round(en.y - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean tileRightCollision(Mob en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x + en.width), Math.round(en.y)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x + en.width - xOffset), Math.round(en.y - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean projectileDownCollision(Projectile en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x), Math.round(en.y + en.height)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - xOffset), Math.round(en.y + en.height - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean projectileUpCollision(Projectile en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x), Math.round(en.y - 1)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - xOffset), Math.round(en.y - 1 - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean projectileLeftCollision(Projectile en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x - 1), Math.round(en.y)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x - 1 - xOffset), Math.round(en.y - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean projectileRightCollision(Projectile en, boolean fixed) { 
     Point p = null; 
     if (fixed) 
      p = new Point(Math.round(en.x + en.width), Math.round(en.y)); 
     else if (!fixed) 
      p = new Point(Math.round(en.x + en.width - xOffset), Math.round(en.y - yOffset)); 
     try { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        if (tile[x][y] != null) { 
         if (rect[x][y] != null && rect[x][y].contains(p)) { 
          if (collision.contains(tile[x][y])) 
           return true; 
         } 
        } 
       } 
      } 
     } catch (ArrayIndexOutOfBoundsException e) { 
     } 
     return false; 
    } 

    public boolean mobProjectileCollision(Mob en, Projectile pr, boolean fixed) { 
     Rectangle p1 = null; 
     if (fixed) 
      p1 = new Rectangle(Math.round(en.x), Math.round(en.y), en.width, en.height); 
     else if (!fixed) 
      p1 = new Rectangle(Math.round(en.x - xOffset), Math.round(en.y - yOffset), en.width, en.height); 

     Rectangle p2 = null; 
     if (fixed) 
      p2 = new Rectangle(Math.round(pr.x), Math.round(pr.y), pr.width, pr.height); 
     else if (!fixed) 
      p2 = new Rectangle(Math.round(pr.x - xOffset), Math.round(pr.y - yOffset), pr.width, pr.height); 

     if (p1.intersects(p2)) 
      return true; 

     return false; 
    } 

    public double calcDistance(Entity e1, Entity e2) { 
     return Math.sqrt(((e1.x - e2.x) * (e1.x - e2.x)) + ((e1.y - e2.y) * (e1.y - e2.y))); 
    } 
}

Level被渲染到渲染（Graphics2D）方法中。它是一個抽象類，所以我有它的一個子類Level1，它是圖像中的一個。

import static com.wg.MainComponent.spritesheet; 

import java.awt.Color; 
import java.awt.image.BufferedImage; 

import com.wg.BufferedImageLoader; 
import com.wg.entity.mob.Player; 

public class Level1 extends Level { 

    public static final BufferedImage bricks = crop(0, 2); 
    public static final BufferedImage dirt = crop(1, 2); 
    public static final BufferedImage grass = crop(2, 2); 
    public static final BufferedImage[] tilesList = { bricks, dirt, grass }; 
    public static final int[] defaultxCollisionOffset = { 0, 0, 0 }; 
    public static final int[] defaultyCollisionOffset = { 0, 0, 0 }; 
    private static BufferedImage level = BufferedImageLoader.load("/level1.png"); 

    private static BufferedImage crop(int x, int y) { 
     return spritesheet.getSubimage(x * 16, y * 16, 16, 16); 
    } 

    public void generateLevel() { 
     for (int y = 0; y < levelImage.getHeight(); y++) { 
      for (int x = 0; x < levelImage.getWidth(); x++) { 
       Color c = new Color(level.getRGB(x, y)); 
       String data = String.format("%02x%02x%02x", c.getRed(), c.getGreen(), c.getBlue()); 
       if (data.equals("838383")) 
        tile[x][y] = bricks; 
       else if (data.equals("bea100")) 
        tile[x][y] = dirt; 
       else if (data.equals("23d200")) 
        tile[x][y] = grass; 
      } 
     } 
    } 

    public Level1(float xOffset, float yOffset) { 
     super(level, 16, tilesList, defaultxCollisionOffset, defaultyCollisionOffset); 
     collision.add(grass); 
     collision.add(dirt); 
     collision.add(bricks); 
     add(new Player(50, 20, 1, 2, 32 + 32, 32 + 32, this)); 
     this.xOffset = xOffset; 
     this.yOffset = yOffset; 
    } 
}

那麼，我知道這將是真的很難找到兩個類的錯誤，所以我做了一個MCVE :)。（要運行它創建一個名爲形象在你的文件夾C：這個內部調用level1.png這圖像稱爲tiles.png）

import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import java.net.URL; 

import javax.imageio.ImageIO; 
import javax.swing.JFrame; 

public class MCVE extends JFrame { 

    public static final int WIDTH = 800; 
    public static final int HEIGHT = 600; 
    private MCVELevel1 level1 = new MCVELevel1(0, 0); 

    public static void main(String[] args) { 
     MCVE mcve = new MCVE(); 
     mcve.setVisible(true); 
     mcve.setSize(WIDTH, HEIGHT); 
     mcve.setDefaultCloseOperation(EXIT_ON_CLOSE); 
    } 

    public void paint(Graphics g) { 
     level1.render(50, 400, 32, (Graphics2D) g); 
    } 

    private static class MCVELevel1 extends MCVELevel { 

     private static BufferedImage spritesheet = BufferedImageLoader.load("C://image//tiles.png"); 
     public static final BufferedImage bricks = crop(0, 0); 
     public static final BufferedImage dirt = crop(1, 0); 
     public static final BufferedImage grass = crop(2, 0); 
     public static final BufferedImage[] tilesList = { bricks, dirt, grass }; 
     public static final int[] defaultxCollisionOffset = { 0, 0, 0 }; 
     public static final int[] defaultyCollisionOffset = { 0, 0, 0 }; 
     private static BufferedImage level = BufferedImageLoader.load("C://image//level1.png"); 

     private static BufferedImage crop(int x, int y) { 
      return spritesheet.getSubimage(x * 16, y * 16, 16, 16); 
     } 

     public void generateLevel() { 
      for (int y = 0; y < levelImage.getHeight(); y++) { 
       for (int x = 0; x < levelImage.getWidth(); x++) { 
        Color c = new Color(level.getRGB(x, y)); 
        String data = String.format("%02x%02x%02x", c.getRed(), c.getGreen(), c.getBlue()); 
        if (data.equals("838383")) 
         tile[x][y] = bricks; 
        else if (data.equals("bea100")) 
         tile[x][y] = dirt; 
        else if (data.equals("23d200")) 
         tile[x][y] = grass; 
       } 
      } 
     } 

     public MCVELevel1(float xOffset, float yOffset) { 
      super(level, 16, tilesList, defaultxCollisionOffset, defaultyCollisionOffset); 
      this.xOffset = xOffset; 
      this.yOffset = yOffset; 
     } 
    } 

    public static class BufferedImageLoader { 
     public static BufferedImage load(String path) { 
      try { 
       return ImageIO.read(new File(path)); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
      throw new NullPointerException("No file found at: " + path); 
     } 

     public static BufferedImage load(URL url) { 
      try { 
       return ImageIO.read(url); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
      throw new NullPointerException("No file found at: " + url.getPath()); 
     } 
    } 
}

的MCVELevel類：

import java.awt.Graphics2D; 
import java.awt.Rectangle; 
import java.awt.image.BufferedImage; 

public abstract class MCVELevel { 

    public BufferedImage levelImage; 
    public BufferedImage[][] tile; 
    public Rectangle[][] rect; 
    public int tileSize; 
    public float xOffset, yOffset; 

    public BufferedImage[] tilesBufferedImages; 
    public int[] xCollisionOffset; 
    public int[] yCollisionOffset; 

    public MCVELevel(BufferedImage levelImage, int tileSize, BufferedImage[] tilesBufferedImages, int[] xCollisionOffset, int[] yCollisionOffset) { 
     this.tilesBufferedImages = tilesBufferedImages; 
     this.xCollisionOffset = xCollisionOffset; 
     this.yCollisionOffset = yCollisionOffset; 

     this.levelImage = levelImage; 
     this.tileSize = tileSize; 

     tile = new BufferedImage[levelImage.getWidth()][levelImage.getHeight()]; 
     rect = new Rectangle[levelImage.getWidth()][levelImage.getHeight()]; 

     generateLevel(); 
    } 

    public abstract void generateLevel(); 

    public void render(float xOffset, float yOffset, int scale, Graphics2D screen) { 
     this.xOffset = xOffset; 
     this.yOffset = yOffset; 

     for (int y = (int) Math.max(yOffset/(tileSize + scale), 0); y < Math.min((MCVE.HEIGHT + yOffset)/(tileSize + scale) + 1, levelImage.getHeight()); y++) { 
      for (int x = (int) Math.max(xOffset/(tileSize + scale), 0); x < Math.min((MCVE.WIDTH + xOffset)/(tileSize + scale) + 1, levelImage.getWidth()); x++) { 
       if (tile[x][y] != null) 
        screen.drawImage(tile[x][y], (int) (x * (tileSize + scale) - xOffset), (int) (y * (tileSize + scale) - yOffset), (tileSize + scale), (tileSize + scale), null); 
      } 
     } 
    } 

    public void update(int scale) { 
     for (int y = 0; y < levelImage.getHeight(); y++) { 
      for (int x = 0; x < levelImage.getWidth(); x++) { 
       if (tile[x][y] != null && rect[x][y] == null) { 
        for (int i = 0; i < tilesBufferedImages.length; i++) { 
         if (tilesBufferedImages[i] == tile[x][y]) 
          rect[x][y] = new Rectangle(x * (tileSize + scale) - Math.round(xOffset) + xCollisionOffset[i], y * (tileSize + scale) - Math.round(yOffset) + yCollisionOffset[i], (tileSize + scale) + xCollisionOffset[i], (tileSize + scale) + yCollisionOffset[i]); 
        } 
       } else if (tile[x][y] != null && rect[x][y] != null) { 
        for (int i = 0; i < tilesBufferedImages.length; i++) { 
         if (tilesBufferedImages[i] == tile[x][y]) 
          rect[x][y].setBounds(x * (tileSize + scale) - Math.round(xOffset) + xCollisionOffset[i], y * (tileSize + scale) - Math.round(yOffset) + xCollisionOffset[i], (tileSize + scale) + xCollisionOffset[i], (tileSize + scale) + yCollisionOffset[i]); 
        } 
       } 
      } 
     } 
    } 
}

非常感謝。

編輯：更新的代碼在MCVELevel：

public void render(float xOffset, float yOffset, int scale, Graphics2D screen) { 
     this.xOffset = xOffset; 
     this.yOffset = yOffset; 

     for (int y = 0; y < levelImage.getHeight(); y++) { 
      for (int x = 0; x < levelImage.getWidth(); x++) { 
       if (tile[x][y] != null) 
        screen.drawImage(tile[x][y], (int) (x * (tileSize + scale) - xOffset), (int) (y * (tileSize + scale) - yOffset), (tileSize + scale), (tileSize + scale), null); 
      } 
     } 
    }

來源

2014-07-17 A Cat

你能更詳細地瞭解什麼是不工作？「所以磚瓦片是以某種奇怪的方式複製的」並沒有真正讓我們繼續前進，我沒有看到任何在你的截圖中看起來重複的東西。這與你的期望有什麼不同？ – Tim

我仍然不確定我在找什麼。它是粉紅色角色左邊的牆，還是粉色角色右邊的類似牆？（如果是這樣，哪一個是重複的，哪一個是對的？）或者其他什麼？ – Tim

（我對方的回答是沒有錯的（我認爲），但它並沒有回答具體問題;它修復了稍後會變得明顯的問題。）

Your level1。PNG有一些不尋常的像素，它們的RGB值與磚塊相匹配，但看起來是空白的。我想有一個透明的事情發生，但我對pngs一無所知。無論如何，這個level1.png是乾淨的，並按預期工作：

花了一段時間才弄清楚這一點。我創建了一個更小的MCVE。這個版本可能會幫助未來的讀者用原始png調試問題（在問題中）。

import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import java.net.URL; 

import javax.imageio.ImageIO; 
import javax.swing.JFrame; 

public class MCVE extends JFrame { 
    private static final long serialVersionUID = 1L; 
    public static final int WIDTH = 800; 
    public static final int HEIGHT = 600; 

    public static void main(String[] args) { 
     MCVE mcve = new MCVE(); 
     mcve.setVisible(true); 
     mcve.setSize(WIDTH, HEIGHT); 
     mcve.setDefaultCloseOperation(EXIT_ON_CLOSE); 
    } 

    public void paint(Graphics g) { 
     render((Graphics2D) g); 
    } 

    public BufferedImage[][] tile; 
    public static final int TILE_SIZE = 16; 
    private static BufferedImage spritesheet = BufferedImageLoader 
      .load("tiles.png"); 
    private static final BufferedImage bricks = crop(0, 0); 
    private static final BufferedImage dirt = crop(1, 0); 
    private static final BufferedImage grass = crop(2, 0); 
    private static final BufferedImage levelImage = BufferedImageLoader.load("level1.png"); 
    int widthInTiles; 
    int heightInTiles; 

    private static BufferedImage crop(int x, int y) { 
     return spritesheet.getSubimage(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, 
       TILE_SIZE); 
    } 

    public MCVE() { 
     widthInTiles = levelImage.getWidth(); 
     heightInTiles = levelImage.getHeight(); 

     generateLevel(); 
    } 

    public void generateLevel() { 
     tile = new BufferedImage[widthInTiles][heightInTiles]; 
     for (int y = 0; y < heightInTiles; y++) { 
      for (int x = 0; x < widthInTiles; x++) { 
       Color c = new Color(levelImage.getRGB(x, y)); 
       switch (c.getRGB()) { 
       case -8158333: 
        tile[x][y] = bricks; 
        break; 
       case -14429696: 
        tile[x][y] = grass; 
        break; 
       case -4284160: 
        tile[x][y] = dirt; 
       } 
      } 
     } 
    } 

    public void render(Graphics2D screen) { 
     int scale = 16; 
     int yes = 0, no = 0; 
     for (int y = 0; y < heightInTiles; y++) { 
      for (int x = 0; x < widthInTiles; x++) { 
       if (tile[x][y] != null) { 
        screen.drawImage(tile[x][y], (int) (x * (TILE_SIZE + scale)), 
          (int) (y * (TILE_SIZE + scale)), 
          (TILE_SIZE + scale), (TILE_SIZE + scale), 
          Color.BLACK, null); 
       } 
      } 
     } 
    } 

    public static class BufferedImageLoader { 
     public static BufferedImage load(String path) { 
      try { 
       return ImageIO.read(new File(path)); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
      throw new NullPointerException("No file found at: " + path); 
     } 

     public static BufferedImage load(URL url) { 
      try { 
       return ImageIO.read(url); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
      throw new NullPointerException("No file found at: " + url.getPath()); 
     } 
    } 
}

來源

2014-07-18 03:40:33

感謝它現在正在工作！ +1。我仍然想知道我是如何製造這個奇怪的水平的。：d –

的問題是在這大塊的render方法中：

for (int y = (int) Math.max(yOffset/(tileSize + scale), 0); y < Math.min((MCVE.HEIGHT + yOffset)/(tileSize + scale) + 1, levelImage.getHeight()); y++) { 
    for (int x = (int) Math.max(xOffset/(tileSize + scale), 0); x < Math.min((MCVE.WIDTH + xOffset)/(tileSize + scale) + 1, levelImage.getWidth()); x++) { 
     if (tile[x][y] != null) 
      screen.drawImage(tile[x][y], (int) (x * (tileSize + scale) - xOffset), (int) (y * (tileSize + scale) - yOffset), (tileSize + scale), (tileSize + scale), null); 
    } 
}

這似乎在說：「對，我要畫的像素畫瓷磚「（雖然我可能是錯誤的..每當我讀到循環衛士時，我會得到不同的解釋）。問題是，您正在計算x和y的繪圖區域，但是您將它們用於tiles[]數組中的索引。你想要「我想繪製的瓷磚，繪製瓷磚」。

generateLevel()中的循環正在做正確的事情。使用那種循環（for (y = 0 y < levelImage.getHeight(); ++y)）。唯一需要擔心的代碼是yOffset,tileSize和scale是實際繪製瓦片的代碼。

這讓我想起再次爲什麼代碼應寫入可測試的，爲什麼測試應該寫成:)

來源

2014-07-18 00:04:53

那麼，for循環代碼所做的只是呈現屏幕內部的圖塊。但是，我不明白，我應該怎樣做我的代碼？ PS：謝謝你的回答... +1 –

是的。嘗試運行MCVE。：D –

無提示D :.我嘗試了黑屏......有一件事我沒有告訴，我正在與數組rect [] []和contains方法發生衝突。然而，碰撞工作正常，但不應該在屏幕上的瓷磚就像碰撞時「看不見」，我可以穿過它們。這是我能說的最好的暗示... –

瓷磚遊戲上的重複瓷磚

回答

相關問題