JPanelの

Question

上の座標系を描く私は私がこの（S =スタート）のような座標与えランダムダンジョンジェネレータ、書いた：（今、私はJPaneの私の座標を印刷したい

をか何でも共通していますが、どこから始めるべきか分かりません）;-(

私は、JPane上に長方形や三角形などをペイントすることができるので、 はGraphicsオブジェクトのpaintComponentメソッドを上書きしようとしました私のコンソール出力関数（これはまったく同じですが、print（）の代わりに描画します）

@Override 
    public void paintComponent (Graphics g) { 

    boolean tmpKoordinateExistiert = false; 
    boolean tmpSpielerKoordiante = false; 

    for(int y =0;y <=20; y++) { 
     for(int x = 0; x <=20; x++) { 
      if(this.sindKoordinatenEinTreffer(x,y,this.spielerKoordinaten.x,this.spielerKoordinaten.y)) { 
       tmpSpielerKoordiante = true; 
      }else {     
       for(Point p: this.koordinatenListe) { 

        if(this.sindKoordinatenEinTreffer(x,y,p.x,p.y)) { 
         tmpKoordinateExistiert = true; 
        } 

       } 
      }   
      if(tmpSpielerKoordiante) { 
       g.drawOval(x+10, y+10, 1, 1); 
       tmpSpielerKoordiante = false; 
      }else if(!tmpKoordinateExistiert) { 
        this.repaint(); 
        }else { 
         g.drawRect(x+10, y+10, 1, 1); 
         tmpKoordinateExistiert = false; 
        }  

     } 
     System.out.println(""); 
    } 
} 

が、私は唯一のオリジナルのもののveeeryのSmaIバージョンを取得：

が、私はそれを変更するために何ができるの？ （申し訳ありませんが、それは愚かな質問ですが、私は時間のためにここに座って、私は右の解決策を見つけるために、ブラインドだ場合）

私は私が手に長方形/楕円のサイズを大きくした場合： 全体ダンジョンジェネレータクラス：

package de.projekt.dungeon; 

    import java.awt.Point; 
    import java.util.ArrayList; 
    import java.util.Random; 

    import de.projekt.gui.MiniMap; 
    import de.projekt.map.DungeonMap; 


    public class DungeonGenerator { 
     /** 
     * startposition des Dungeons 
     * Kann im Norden, Sueden, osten, Westen liegen (Random) 
     */ 
     private Point start; 
     private Point aktuelleKoordinaten; 

     /** 
     * Liste aller Dungeonfelder (bzw. die Koordinaten von denen) 
     */ 
     ArrayList<Point> koordinatenListe ; 

     public ArrayList<Point> getKoordinatenListe() { 
      return koordinatenListe; 
     } 

     public Point getStart() { 
      return start; 
     } 
     /** 
     * 0 = Norden, 1 = Westen, 2 = Sueden, 3 = Osten 
     */ 
     private int himmelsrichtung; 
     private Random rHimmelsrichtung; 
     private Random neueKoordinaten; 
     private int xFaktor = 0; 
     private int yFaktor = 0; 
     private Random tmpz = new Random(); 
     /** 
     * Standardkonstruktor, es werden alles Objekte instanziert, die 
     * fuer den DungeonGenerator noetig sind. 
     * 
     * himmelsrichtung ergibt sich aus einer Zahl zwischen 0-4. 
     * Dadurch wird Random entschieden, an welcher Stelle der Dungeon startet. 
     * (N,S,O,W) 
     * Es wird fuer jeden Startpunkt ein Faktor gesetzt, mit dem im Generator die 
     * x/y Koordinate multipliziert wird. Dadurch wird sichergestellt, das man nicht im 
     * Osten startet, und der Dungeon dann in eben diese Richtung generiert wird. 
     * 
     * Der Startpunkt wird als erste Koordinate der KoordinatenListe hinzugefuegt. 
     * Anschliessend beginnt das generieren. 
     * 
     * Spaeter koennte man die Mapgroeße ueber das ueberladen des Konstruktors Variabel machen, 
     * Falls das dann Sinn ergibt. 
     * 
     * Jeder Dungeon (Stockwerk?) hat genau eine Map! 
     */ 
     public DungeonGenerator(int anzahlMaximalKoordinaten){ 
      this.koordinatenListe = new ArrayList<Point>(); 
      this.rHimmelsrichtung = new Random(); 
      this.neueKoordinaten = new Random(); 
      this.start = new Point(); 

      this.himmelsrichtung = this.rHimmelsrichtung.nextInt(3); 
      switch(this.himmelsrichtung){ 
       // Norden 
       case(0): this.start.x = 10; 
         this.start.y = 0; 
         this.yFaktor = 1; 
        break; 
       // Westen 
       case(1): this.start.x = 0; 
         this.start.y = 10; 
         this.xFaktor = 1; 
        break; 
       // Sueden 
       case(2): this.start.x = 10; 
         this.start.y = 20; 
         this.yFaktor = -1; 
        break; 
       // Osten 
       case(3): this.start.x = 20; 
         this.start.y = 10; 
         this.xFaktor = -1; 
        break; 
      } 
      koordinatenListe.add(this.start); 
      this.aktuelleKoordinaten = new Point(this.start); 

      this.startGenerate(anzahlMaximalKoordinaten); 
     } 

     /** 
     * Generiere den Dungeon und uebergebe den Dungeon(Koordinaten) an die Map. 
     * (Auch SpielerAnfangskoordinaten) 
     */ 
     private void startGenerate(int anzahlMaximalKoordinaten) { 
      this.generateDungeon(this.start.x, this.start.y, 0, anzahlMaximalKoordinaten);  
     } 
     /** 
     * Gebe das zu dem Dungeon gehoerige Mapobjekt zurueck. 
     * @return Rueckgabe der Map 
     */ 
     public DungeonMap getMap() { 
      return null; 
      //return map; 
     } 

     /** 
     * Hier werden die Koordinaten generiert. 
     * 
     * Derzeit werden y Koordinaten bevorzugt. (da X nur incr/decr wird, wenn Y == 0 --> Nur eine 50% Chance) 
     * 
     * Die Methode wird abgebrochen, sollte eine Wand erreicht werden. 
     * Die Methode ruft sich ansonsten sooft auf, bis die aktuelle Koordinatenmenge der Maximalen Koordinatenanzahl entspricht 
     * 
     * @param x aktuelle x Koordinate 
     * @param y aktuelle y Koordinate 
     * @param aktuelleKoordinatenMenge Wieviele Koordinaten umfasst der Dungeon derzeit 
     * @param anzahlMaximalKoordinaten Wieviele "Spielfelder(Koordinaten)" hat der Dungeon maximal 
     */ 
     private void generateDungeon(int x, int y,int aktuelleKoordinatenMenge, int anzahlMaximalKoordinaten) { 

      int tempX = 0; 
      int tempY = 0; 

      while(tempX == 0 && tempY== 0) { 
       tempX = this.neueKoordinaten.nextInt(2); 
       tempY = this.neueKoordinaten.nextInt(2); 
      } 
      // gehen wir evtl links oder rechts usw., mal sehen 
      int tmp = this.tmpz.nextInt(3)-1; 

      // Erlaube es, auf der X/Y Achse zurueckzugehen, fuer verzweigungen 
      if(this.yFaktor == -1){ 
       this.xFaktor = tmp; 
      } 
      if(this.yFaktor == 1){ 
       this.xFaktor = tmp; 
      } 
      if(this.xFaktor == -1){ 
       this.yFaktor = tmp; 
      } 
      if(this.xFaktor == 1){ 
       this.yFaktor = tmp; 
      } 
      // Wenn ich zuerst Nach Y abfrage, wird Y bevorzugt, wenn ich zuerst nach X abfrage halt X 
      // wenn ich einfach ein Random 0/1 vorklatsche, und nach 0/1 Abfrage, dann ist das Ergebniss 
      // nicht von zuerst X/Y abhaengig. 
      int randomRichtung = this.neueKoordinaten.nextInt(2); 

      if(randomRichtung == 0) { 
       if(tempY==1) { 
        y = y + (1 * this.yFaktor); 
       }else if(tempX == 1) { 
        x = x + (1 * this.xFaktor); 
       } 
      }else { 
       if(tempX==1) { 
        x = x + (1 * this.xFaktor); 
       }else if(tempY == 1) { 
        y = y + (1 * this.yFaktor); 
       } 
      } 

      // Anomalie, bin betrunken, forsche spaeter 
      if(x == -1) 
       x=0; 
      // lul? 
      if(y == -1) 
       y=0; 

      this.aktuelleKoordinaten = new Point(x,y); 
      //System.out.println("aktuelleKoordinaten: " +this.aktuelleKoordinaten); 
      this.koordinatenListe.add(this.aktuelleKoordinaten); 

      if((this.aktuelleKoordinaten.x == 20 && this.start.x !=20) 
       || this.aktuelleKoordinaten.y == 20 && this.start.y !=20 
       || this.aktuelleKoordinaten.x == 0 && this.start.x !=0 
       || this.aktuelleKoordinaten.y == 0 && this.start.y !=0) { 
       return; 
      } 

      aktuelleKoordinatenMenge++; 
      if(aktuelleKoordinatenMenge <= anzahlMaximalKoordinaten) { 
       this.generateDungeon(x, y,aktuelleKoordinatenMenge, anzahlMaximalKoordinaten); 
      } else 
       return; 

     } 



    } 


My Gui Class: 
    package de.projekt.gui; 

    import java.awt.BorderLayout; 
    import java.awt.Dimension; 

    import javax.swing.JFrame; 

    public class Gui extends JFrame{ 
     MiniMap miau = new MiniMap(); 
     private static final int N = 256; 

     public Gui() { 
      this.setSize(400,400); 
      this.setDefaultCloseOperation(EXIT_ON_CLOSE); 
      this.setLayout(new BorderLayout()); 
      this.add(this.miau); 


     } 

     @Override 
     public Dimension getPreferredSize() { 
      return new Dimension(2 * N, 2 * N); 
     } 


} 

そして、私の出力クラス：

package de.projekt.gui; 

    import java.awt.Graphics; 
    import java.awt.Graphics2D; 
    import java.awt.Point; 
    import java.util.ArrayList; 

    import javax.swing.JPanel; 

    import de.projekt.dungeon.DungeonGenerator; 
    import de.projekt.map.DungeonMap; 

    public class MiniMap extends JPanel{ 

     private ArrayList<Point> koordinatenListe ; 
     private Point spielerKoordinaten; 
     private DungeonGenerator map; 

     MiniMap(){ 
      this.map = new DungeonGenerator(400); 
      this.spielerKoordinaten = this.map.getStart(); 
      this.koordinatenListe = this.map.getKoordinatenListe(); 
     } 


     @Override 
     public void paintComponent (Graphics g) { 
      super.paintComponent(g); 


      boolean tmpKoordinateExistiert = false; 
      boolean tmpSpielerKoordiante = false; 

      for(int y =0;y <=20; y++) 

{ 
      for(int x = 0; x <=20; x++) { 
       if(this.sindKoordinatenEinTreffer(x,y,this.spielerKoordinaten.x,this.spielerKoordinaten.y)) { 
        tmpSpielerKoordiante = true; 
       }else {     
        for(Point p: this.koordinatenListe) { 

         if(this.sindKoordinatenEinTreffer(x,y,p.x,p.y)) { 
          tmpKoordinateExistiert = true; 
         } 

        } 
       }   
       if(tmpSpielerKoordiante) { 
        g.drawOval(x, y, 10, 10); 
        tmpSpielerKoordiante = false; 
       }else if(!tmpKoordinateExistiert) { 
         this.repaint(); 
         }else { 
          g.drawRect(x+10, y+10, 10, 10); 
          tmpKoordinateExistiert = false; 
         }  

      } 
      System.out.println("test"); 
     } 
     System.out.println("enhde"); 
    } 






    public void setStartPunkt(Point startPunkt) { 
     this.spielerKoordinaten = startPunkt; 
    } 

    public ArrayList<Point> getKoordinatenListe() { 
     return koordinatenListe; 
    } 

    public void setKoordinatenListe(ArrayList<Point> koordinatenListe) { 
     this.koordinatenListe = koordinatenListe; 
    } 
    /** 
    * Da ein Koordinatenvergleich mindestens 2 mal gebraucht wird, in einer Methode 
    * @param x aktueller x Wert der Schleife 
    * @param y aktueller y Wert der Schleife 
    * @param koordx koordinaten vom Punkt 
    * @param koordy koordinaten vom Punkt 
    * @return 
    */ 
    private boolean sindKoordinatenEinTreffer(int x, int y, int koordx, int koordy) { 
     if(x == koordx && y == koordy) { 
      return true; 
     }else { 
      return false; 
     } 
    } 

    /** 
    * Erstmal nur eine Testausgabe usw. in der Konsole, halt bis wir GUI's haben 
    */ 
    public void printTest() { 

    } 

} 

Answer 1

smallesレンダリングユニットはピクセルで、引数として1x1の小さな正方形です。

何かをレンダリングするときは、必要に応じて形状を大きくする必要があります。はい、ピクセルを使用できますが、私のようなもので画面を見ている時間があればおそらく盲目的になるので、少し大きめのものがほしいかもしれません。

これを行うときは、シェイプの位置をオフセットして、塗りつぶしたものを上書きしないようにする必要があります。

たとえば、10x20で描かれた正方形が10x10である場合、次の要素は20x20で次の列に描画するか、次の行に描画するには10x30にする必要があります。

ここでは、基本的に質問とは無関係なので、迷路/モデルを一緒にハックしました。そして、列と情報の列を描くという概念を実演しました。今

import java.awt.Color; 
import java.awt.Dimension; 
import java.awt.EventQueue; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.UIManager; 
import javax.swing.UnsupportedLookAndFeelException; 

public class Test { 

    public static void main(String[] args) { 
     new Test(); 
    } 

    public Test() { 
     EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
       } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) { 
        ex.printStackTrace(); 
       } 

       JFrame frame = new JFrame("Testing"); 
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
       frame.add(new TestPane()); 
       frame.pack(); 
       frame.setLocationRelativeTo(null); 
       frame.setVisible(true); 
      } 
     }); 
    } 

    public static class TestPane extends JPanel { 

     private String[] maze = { 
      "..........#S##........", 
      "..........##.#........", 
      "...........#.#........", 
      ".............#........", 
      ".....##......#........", 
      "....#####.###.........", 
      "#####.###.#####.......", 
      "....###.########......", 
      "......####.####.......", 
      "......####..###.......", 
      "......#####..###......", 
      "......#####...##......", 
      "......######..........", 
      ".......######.........", 
      ".......######.........", 
      ".......#######........", 
      "........#######.......", 
      "........###...........", 
      "........###...........", 
      "......................", 
     }; 

     protected static final int CELL_SIZE = 10; 

     public TestPane() { 
      setBackground(Color.DARK_GRAY); 
     } 

     @Override 
     public Dimension getPreferredSize() { 
      return new Dimension(22 * CELL_SIZE, 21 * CELL_SIZE); 
     } 

     protected void paintComponent(Graphics g) { 
      super.paintComponent(g); 
      Graphics2D g2d = (Graphics2D) g.create(); 
      int y = 0; 
      for (String line : maze) { 
       int x = 0; 
       for (char element : line.toCharArray()) { 
        switch (element) { 
         case '.': 
          paintSpace(g2d, x, y); 
          break; 
         case '#': 
          paintHash(g2d, x, y); 
          break; 
         case 'S': 
          paintStart(g2d, x, y); 
          break; 
        } 
        x += CELL_SIZE; 
       } 
       y += CELL_SIZE; 
      } 
      g2d.dispose(); 
     } 

     protected void paintSpace(Graphics2D g2d, int x, int y) { 
      g2d.setColor(Color.DARK_GRAY); 
      g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
     } 

     protected void paintHash(Graphics2D g2d, int x, int y) { 
      g2d.setColor(Color.LIGHT_GRAY); 
      g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
     } 

     protected void paintStart(Graphics2D g2d, int x, int y) { 
      g2d.setColor(Color.LIGHT_GRAY); 
      g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
      g2d.setColor(Color.RED); 
      g2d.fillOval(x, y, CELL_SIZE, CELL_SIZE); 
     } 
    } 

} 

、あなたは直線的に維持されていない何かを必要とする、またはランダムにそれの一部を更新する必要がある場合。モデル座標を物理座標に変換する必要があります。

Iは、行5、列15の要素をペイントしたい場合、上記の例に基づいて、私は私の物理座標を与えるCELL_SIZEすることにより、複数のこれら二つの点に必要だろう

Answer 2

MadProgrammerから溶液（しかし、私のコードで）：

@Override 
public void paintComponent (Graphics g) { 
    super.paintComponent(g); 



    Graphics2D g2d = (Graphics2D) g.create(); 

    boolean tmpKoordinateExistiert = false; 
    boolean tmpSpielerKoordiante = false; 
    int shapesizeY = 0; 
    for(int y =0;y <=20; y++) { 
     int shapesizeX = 0; 
     for(int x = 0; x <=20; x++) { 
      if(this.sindKoordinatenEinTreffer(x,y,this.spielerKoordinaten.x,this.spielerKoordinaten.y)) { 
       tmpSpielerKoordiante = true; 
      }else {     
       for(Point p: this.koordinatenListe) { 

        if(this.sindKoordinatenEinTreffer(x,y,p.x,p.y)) { 
         tmpKoordinateExistiert = true; 
        } 

       } 
      }   
      if(tmpSpielerKoordiante) { 
       paintStart(g2d, shapesizeX, shapesizeY); 
       tmpSpielerKoordiante = false; 
      }else if(!tmpKoordinateExistiert) { 
        paintSpace(g2d, shapesizeX, shapesizeY); 
      }else { 
       paintHash(g2d, shapesizeX, shapesizeY); 


       tmpKoordinateExistiert = false; 
      } 
      shapesizeX += CELL_SIZE; 


     } 
     shapesizeY += CELL_SIZE; 

    } 

} 

protected void paintSpace(Graphics2D g2d, int x, int y) { 
    g2d.setColor(Color.DARK_GRAY); 
    g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
} 
protected void paintHash(Graphics2D g2d, int x, int y) { 
    g2d.setColor(Color.LIGHT_GRAY); 
    g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
} 

protected void paintStart(Graphics2D g2d, int x, int y) { 
    g2d.setColor(Color.LIGHT_GRAY); 
    g2d.fillRect(x, y, CELL_SIZE, CELL_SIZE); 
    g2d.setColor(Color.RED); 
    g2d.fillOval(x, y, CELL_SIZE, CELL_SIZE); 
} 

ありがとう、ありがとう！