Java Turtle Grafiken Benutzereingabe

Question

Ich versuche, ein Turtle-Grafikprogramm in Java zu schreiben. Es muss in der Lage sein, 2D-Grafiken zu erstellen, indem Befehle gelesen werden, die vom Benutzer über ein JTextField eingegeben wurden. Ich habe die GUI erstellt und die verschiedenen Methoden für jeden Befehl wie turnRight, turnLeft, forward etc geschrieben. Das Problem, das ich habe, ist, dass ich eine if/else-Anweisung mit Action-Listenern auf dem JTextField erstellt habe, damit es die Befehle, die vom Benutzer angegeben wurden und versucht haben, die Methoden aufzurufen, die ich geschrieben habe, als dieser Text empfangen wurde. Trotzdem wird das Programm immer noch nicht zeichnen und ich bin mir nicht sicher, was ich falsch mache. Jede Hilfe wäre willkommen.

import java.awt.Color; 
import java.awt.Dimension; 
import java.awt.Graphics; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.awt.image.BufferedImage; 
import javax.swing.JOptionPane; 
import javax.swing.JPanel; 
import javax.swing.JTextField; 



//Represents the graphics display panel within the turtle program. This panel contains an image which is updated to reflect user commands. 

@SuppressWarnings("serial") 
public class GraphicPanel extends JPanel 
{ 
    private int xPos = 0, yPos=0; 
    private boolean penUp = true; 
    private final static int DOWN = 0; 
    private final static int UP = 1; 
    private final static int LEFT = 2; 
    private final static int RIGHT = 3; 
    private int direction = DOWN; 


GraphicPanel() { 

    setPreferredSize(new Dimension(800, 600)); 

    image = new BufferedImage(700, 600, BufferedImage.TYPE_INT_RGB); 

    // Set max size of the panel, so that is matches the max size of the image. 
    setMaximumSize(new Dimension(image.getWidth(), image.getHeight())); 

    clear(); 

JTextField console = new JTextField(15); 
    console.addActionListener(new ActionListener() 
    { 
     public void actionPerformed(ActionEvent arg0) 
      { 
        if(console.getText().contains("penup")) { 
         penUp(); 
        } 

        else if (console.getText().contains("pendown")) { 
         penDown(); 
        } 

        else if (console.getText().contains("turnleft")) { 
         JOptionPane.showMessageDialog(console, "turnleft works"); 
        } 

        else if (console.getText().contains("turnright")) { 
         JOptionPane.showMessageDialog(console, "turnright works"); 
        } 

        else if (console.getText().contains("forward")) { 
         forward(direction); 
        } 

        else if (console.getText().contains("backward")) { 
         JOptionPane.showMessageDialog(console, "backward works"); 
        } 

        else if (console.getText().contains("black")) { 
         JOptionPane.showMessageDialog(console, "black works"); 
        } 

        else if (console.getText().contains("green")) { 
         JOptionPane.showMessageDialog(console, "green works"); 
        } 

        else if (console.getText().contains("red")) { 
         JOptionPane.showMessageDialog(console, "red works"); 
        } 

        else if (console.getText().contains("reset")) { 
         JOptionPane.showMessageDialog(console, "reset works"); 
        } 

        else { 
         JOptionPane.showMessageDialog(console, "Invalid command, try again"); 
        } 
      } 
    }); 

    add(console); 
} 

//private JTextField console = new JTextField(15); 


//The default BG colour of the image. 

private final static Color BACKGROUND_COL = Color.DARK_GRAY; 


// The underlying image used for drawing. This is required so any previous drawing activity is persistent on the panel. 

private BufferedImage image; 

/* 
* Draw a line on the image using the given colour. 
* 
* @param color 
* @param x1 
* @param y1 
* @param x2 
* @param y2 
*/ 

// place pen onto canvas 
public void penDown() 
{ 
    penUp = false; 
} 

//raise pen from canvas 
public void penUp() 
{ 
    penUp = true; 
} 

// turn right from current position 
public void turnRight() 
{ 
    switch(direction) 
    { 
     case UP: 
       direction = RIGHT; 
       break; 
     case DOWN: 
       direction = LEFT; 
       break; 
     case LEFT: 
       direction = UP; 
       break; 
     case RIGHT: 
       direction = DOWN; 
       break; 
     default: 
       break; 

    } 
} 

// turn left from current position 
public void turnLeft() 
{ 
    switch(direction) 
    { 
     case UP: 
       direction = LEFT; 
       break; 
     case DOWN: 
       direction = RIGHT; 
       break; 
     case LEFT: 
       direction = DOWN; 
       break; 
     case RIGHT: 
       direction = UP; 
       break; 
     default: 
       break; 

    } 
} 

// draw forward a certain amount 
public void forward(int amount) 
{ 

    if(penUp) 
     return; 

    if (direction == DOWN) 
    { 
     drawLine(Color.red, xPos, yPos, xPos, yPos + amount); 
     yPos = yPos + amount; 
    } 

    else if (direction == UP) 
    { 
     drawLine(Color.red, xPos, yPos, xPos, yPos - amount); 
     yPos = yPos - amount; 
    } 

    else if (direction == LEFT)  
    { 
     drawLine(Color.red, xPos, yPos, xPos - amount, yPos); 
     xPos = xPos - amount; 
    } 

    else if (direction == RIGHT)   
    { 
     drawLine(Color.red, xPos, yPos, xPos + amount, yPos); 
     xPos = xPos + amount; 
    } 

} 

// draw backwards a certain amount 
public void backward(int amount) 
{ 
    if(penUp) 
     return; 

    if (direction == DOWN) 
    { 
     drawLine(Color.red, xPos, yPos, xPos, yPos - amount); 
     yPos = yPos - amount; 
    } 

    else if (direction == UP) 
    { 
     drawLine(Color.red, xPos, yPos, xPos, yPos + amount); 
     yPos = yPos + amount; 
    } 

    else if (direction == LEFT)  
    { 
     drawLine(Color.red, xPos, yPos, xPos + amount, yPos); 
     xPos = xPos + amount; 
    } 

    else if (direction == RIGHT)   
    { 
     drawLine(Color.red, xPos, yPos, xPos - amount, yPos); 
     xPos = xPos - amount; 
    } 
} 

// change colour to black 
public void black() 
{ 
    Graphics g = image.getGraphics(); 
    g.setColor(Color.black); 
} 

//change colour to green 
public void green() 
{ 
    Graphics g = image.getGraphics(); 
    g.setColor(Color.green); 
} 

// change colour to red 
public void red() 
{ 
    Graphics g = image.getGraphics(); 
    g.setColor(Color.red); 
} 

// draw lines to xy co-ordinates 
public void drawLine(Color color, int x1, int y1, int x2, int y2) { 

    Graphics g = image.getGraphics(); 

    g.setColor(color); 

    g.drawLine(x1, y1, x2, y2); 
} 

//Clears the image contents. 

public void clear() { 

    Graphics g = image.getGraphics(); 

    g.setColor(BACKGROUND_COL); 

    g.fillRect(0, 0, image.getWidth(), image.getHeight()); 
} 

@Override 
public void paint(Graphics g) { 

    // render the image on the panel. 
    g.drawImage(image, 0, 0, null); 
} 

//Constructor. 

}

Answer 1

bekam ich diesen Lauf, aber ich hatte es auseinander zu nehmen und sie wieder zusammensetzen. Einige Dinge ergaben für mich keinen Sinn und es scheint, dass du viel zu viel Code geschrieben hast, ohne einen funktionierenden Kern zu haben.

Ich teile das Texteingabefeld aus dem Grafikbereich und erstellte ein umfassendes Bedienfeld, TurtlePanel, um beide zu enthalten. Ich habe die Farblogik überarbeitet und einige Dinge optimiert. Einige der Sachen habe ich war nur in der Lage sein, den Beispielcode Standalone laufen:

import javax.swing.*; 
import java.awt.event.*; 
import java.awt.*; 

import java.awt.image.BufferedImage; 

public class TurtlePanel extends JPanel 
{ 
    private GraphicPanel graphics = new GraphicPanel(); 
    private JTextField console = new JTextField(15); 

    public TurtlePanel() { 
     add(graphics); 
     add(console); 

     console.addActionListener(new ActionListener() 
     { 
      public void actionPerformed(ActionEvent arg0) 
      { 
       if (console.getText().contains("penup")) 
       { 
        graphics.penUp(); 
       } 
       else if (console.getText().contains("pendown")) 
       { 
        graphics.penDown(); 
       } 
       else if (console.getText().contains("turnleft")) 
       { 
        graphics.turnLeft(); 
       } 
       else if (console.getText().contains("turnright")) 
       { 
        graphics.turnRight(); 
       } 
       else if (console.getText().contains("forward")) 
       { 
        graphics.forward(50); 
       } 
       else if (console.getText().contains("backward")) 
       { 
        graphics.backward(50); 
       } 
       else if (console.getText().contains("black")) 
       { 
        graphics.black(); 
       } 
       else if (console.getText().contains("green")) 
       { 
        graphics.green(); 
       } 
       else if (console.getText().contains("red")) 
       { 
        graphics.red(); 
       } 
       else if (console.getText().contains("reset")) 
       { 
        graphics.clear(); 
       } 
       else 
       { 
        JOptionPane.showMessageDialog(console, "Invalid command, try again"); 
       } 

       console.setText(""); 
       graphics.repaint(); 
      } 
     }); 
    } 

    public static void main(String[] args) { 
     TurtlePanel mainPanel = new TurtlePanel(); 

     JFrame frame = new JFrame("Simple Testing Frame"); 
     frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
     frame.getContentPane().add(mainPanel); 
     frame.pack(); 
     frame.setVisible(true); 
    } 
} 

class GraphicPanel extends JPanel 
{ 
    private int xPos = 400, yPos = 300; 
    private boolean penUp = false; 
    private Color color = Color.black; 

    private BufferedImage image; 
    private final static Color BACKGROUND_COLOR = Color.LIGHT_GRAY; 

    private enum Direction { 
     UP, DOWN, LEFT, RIGHT 
    } 

    private Direction direction = Direction.DOWN; 

    GraphicPanel() { 

     setPreferredSize(new Dimension(800, 600)); 

     image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB); 

     setMaximumSize(new Dimension(image.getWidth(), image.getHeight())); 

     clear(); 
    } 

    // place pen onto canvas 
    public void penDown() 
    { 
     penUp = false; 
    } 

    // raise pen from canvas 
    public void penUp() 
    { 
     penUp = true; 
    } 

    // turn right from current position 
    public void turnRight() 
    { 
     switch (direction) 
     { 
      case UP: 
       direction = Direction.RIGHT; 
       break; 
      case RIGHT: 
       direction = Direction.DOWN; 
       break; 
      case DOWN: 
       direction = Direction.LEFT; 
       break; 
      case LEFT: 
       direction = Direction.UP; 
       break; 
     } 
    } 

    // turn left from current position 
    public void turnLeft() 
    { 
     switch (direction) 
     { 
      case UP: 
       direction = Direction.LEFT; 
       break; 
      case LEFT: 
       direction = Direction.DOWN; 
       break; 
      case DOWN: 
       direction = Direction.RIGHT; 
       break; 
      case RIGHT: 
       direction = Direction.UP; 
       break; 
     } 
    } 

    // draw forward a certain amount 
    public void forward(int amount) 
    { 
     if (penUp) 
     { 
      return; 
     } 

     switch (direction) 
     { 
      case UP: 
       drawLine(xPos, yPos, xPos, yPos - amount); 
       yPos = yPos - amount; 
       break; 
      case DOWN: 
       drawLine(xPos, yPos, xPos, yPos + amount); 
       yPos = yPos + amount; 
       break; 
      case LEFT: 
       drawLine(xPos, yPos, xPos - amount, yPos); 
       xPos = xPos - amount; 
       break; 
      case RIGHT: 
       drawLine(xPos, yPos, xPos + amount, yPos); 
       xPos = xPos + amount; 
       break; 
     } 
    } 

    // draw backwards a certain amount 
    public void backward(int amount) 
    { 
     if (penUp) 
     { 
      return; 
     } 

     switch (direction) 
     { 
      case UP: 
       drawLine(xPos, yPos, xPos, yPos + amount); 
       yPos = yPos + amount; 
      case DOWN: 
       drawLine(xPos, yPos, xPos, yPos - amount); 
       yPos = yPos - amount; 
       break; 
      case LEFT: 
       drawLine(xPos, yPos, xPos + amount, yPos); 
       xPos = xPos + amount; 
      case RIGHT: 
       drawLine(xPos, yPos, xPos - amount, yPos); 
       xPos = xPos - amount; 
       break; 
     } 
    } 

    // change colour to black 
    public void black() 
    { 
     color = Color.black; 
    } 

    // change colour to green 
    public void green() 
    { 
     color = Color.green; 
    } 

    // change colour to red 
    public void red() 
    { 
     color = Color.red; 
    } 

    // draw lines to xy co-ordinates 
    public void drawLine(int x1, int y1, int x2, int y2) { 

     Graphics g = image.getGraphics(); 

     g.setColor(color); 
     g.drawLine(x1, y1, x2, y2); 
    } 

    // Clears the image contents. 
    public void clear() { 

     Graphics g = image.getGraphics(); 

     g.setColor(BACKGROUND_COLOR); 
     g.fillRect(0, 0, image.getWidth(), image.getHeight()); 
    } 

    @Override 
    public void paintComponent(Graphics g) { 

     super.paintComponent(g); 

     // render the image on the panel. 
     g.drawImage(image, 0, 0, null); 
    } 
}