4. Canvas

Canvas

  • ?

    Hallo,

    ich hoffe mal ihr braucht jetzt nicht den Quellcode :). Also ich habe nen Programm
    und will, dass wenn ich auf ein Button drücke, dass das Canvas, was ebenfalls ins
    GUI des Programms eingearbeitet ist, geleert wird. Ich schaffe das, aber irgendwie
    nicht wirklich. Ich habe das Canvas als Klasse in meiner GUI Klasse erstellt und
    dann mal das Canvas als Instanzvariable deklariert, aber das funktioniert nicht
    (wollte einfach alles übermalen, mit drawRect()). Dann habe ich mir gedacht, dass
    ich dafür ja das Graphics Objekt benötige. Also habe ich das als Instanzvariable
    (für die Canvasklasse) deklariert und dann halt in der anderen aufgerufen. Als
    Ergebnis erhalte ich eine NullPointerException kann mir jemand weiter helfen? Gibt
    es für sowas eine konkrete Methode?

    Gruß
    al3pou

    0
  • I

    Dann habe ich mir gedacht, dass
    ich dafür ja das Graphics Objekt benötige. Also habe ich das als Instanzvariable
    (für die Canvasklasse) deklariert und dann halt in der anderen aufgerufen.

    Man sollte das Graphics-Objekt nie (gut, gibt wenige Ausnahmen fuer sehr fortgeschrittene Dinge bei denen es sinnvoll ist) selber definieren. Du solltest das Graphics-Objekt immer aus der paint-Methode fuer AWT bzw. painComponent()-Methode fuer Swing verwenden.

    Am besten postest du einen minimalen Code damit man sehen kann, was du genau gemacht hast.

    0
  • ?

    Okay, hier ist mein Code, aber bitte nicht über die Stümperhaftigkeit lächerlich
    machen, weil das bis dato mein erstes Projekt mit Java ist und ich mich erstmal mit allem vertraut machen muss.

    Das Programm soll, wenn ich auf "Neu starten" drücke das Spiel neu starten und somit das Canvas erst einmal leeren und anschließend das Gitter, welches vorher drauf war, auch wieder zeichnen (für das Gitter war zeichnen() gedacht).

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

// Hauptfenster von Klasse JFrame ableiten
public class Spiel extends JFrame {
  // Variablen um zu erkennen, welcher Spieler dran ist und ob Ende ist
  int player = 0, npc = 0, ende = 0;
  // Spielfeld anlegen
  Spielfeld s_spiel;
  Graphics g;
  // Textfeld für "Tutorial"
  private JLabel text;
  // Buttons als Instanzvariable anlegen
  JButton p1 = new JButton("Zug starten");
  JButton p2 = new JButton("Zug beenden");
  JButton s = new JButton("Spiel starten");
  JButton neu = new JButton("Neu starten");

  public static void main(String[] args) {
    Spiel fenster = new Spiel("blubb bla bla");
	fenster.pack();
	fenster.setSize(900,800);
	fenster.setVisible(true);
	fenster.setResizable(false);
  }

  // Konstruktor
  Spiel(String titel) {
    super(titel);

	// Layout-Manager
	setLayout(new FlowLayout());

	// Spielfeld erzeugen und einbinden
	s_spiel = new Spielfeld();
	add(s_spiel);
	s_spiel.unbenutzt();

	// Textfeld erzeugen und einbinden
	text = new JLabel("");
	text.setFont(new Font("Serif", Font.ITALIC, 12));
	text.setText("Drücke 'Spiel starten'");

	// Panel-Container für Schaltflächen
	JPanel panel = new JPanel();
	  // Gitter mit 3 Zeilen, 1 Spalte
	  panel.setLayout(new GridLayout(3,1,20,20));
	  // Buttons in Panel einbinden
	  panel.add(s);
	  panel.add(p1);
	  panel.add(p2);
	  panel.add(neu);
	  panel.add(text);

	  // zwei Buttons solange deaktivieren bis Spiel startet
	  p1.setEnabled(false);
	  p2.setEnabled(false);
	  neu.setEnabled(false);

	// Panels in Fenster aufnehmen
	add(panel);

	// Ereignisbehandlung für Buttons
	class start implements ActionListener {
	  public void actionPerformed(ActionEvent e) {
	    // Variable um zu erkennen, welcher Button benutzt wurde
		String label;

	    label = e.getActionCommand();

		if(label.equals("Spiel starten") && player == 0 && npc == 0 && ende == 0) {
		  p1.setEnabled(true);
		  s.setEnabled(false);
		  player = 1;
		}
		else if(label.equals("Zug starten") && player == 1 && ende == 0) {
		  p1.setEnabled(false);
		  p2.setEnabled(true);
		  npc = 1;
		}
		else if(label.equals("Zug beenden") && npc == 2 && ende == 0) {
		  p1.setEnabled(true);
		  p2.setEnabled(false);
		  player = 2;
		}
		else if(label.equals("Neu starten") && ende == 1) {
		  p1.setEnabled(true);
		  p2.setEnabled(false);
		  neu.setEnabled(false);
		  ende = 0;
		  player = 1;
		  npc = 0;
		  s_spiel.unbenutzt();
		}
	  }
	} 

	// Buttons für Ereignisbehandlung anmelden
	s.addActionListener(new start());
	p1.addActionListener(new start());
	p2.addActionListener(new start());
	neu.addActionListener(new start());

	// Spiel schließen, wenn Fenster geschlossen wird
    setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }

  class Spielfeld extends Canvas {
    // Arrays für das Feld (um zu zeichnen)
	int[] waage = new int[9];
	// Array um zu gucken, welche Felder belegt sind
	boolean[][] p_feld = new boolean[9][8];
	boolean[][] n_feld = new boolean[9][8];
	boolean[][] feld = new boolean[9][8];
	// Variable mit der später die Chips gezeichnet werden
    int m_Xpos;
	// Variable um festzustellen welches Kästchen benutzt wird
	int a,b;
	// Variablen für spätere Schleifen
	int x,y;

    class klick extends MouseAdapter {
      public void mousePressed(MouseEvent e1) {
		  // die aktuelle Position der Maus merken
		  m_Xpos = e1.getX();

		  // Malfläche aktualisieren
		  repaint();
	  }
	}

	public void unbenutzt() {
	  // Arrays initialisieren

	  x = 0;
	  for(a = 1; a <= 8; a += 1) {
	    waage[a] = x;
		x += 100;
	  }
	  if(ende == 0) {
	    // alle Felder auf unbenutzt setzen
	    for(a = 0; a <= 8; a += 1) { 
		  for(b = 0; b <= 7; b += 1) {
		    p_feld[a][b] = true;
		    n_feld[a][b] = true;
		    feld[a][b] = true;
		  }
	    }
	  }
	}

    // Konstruktor
	Spielfeld() {

	  // Ereignisbehandlung im Konstruktor implementieren,
	  // damit hier auch die Mauskoord. abgefangen werden
	  addMouseListener(new klick());

	  // Hintergrund auf grau setzen
	  setBackground(new Color(180,180,180));

	  // Vordergrund bzw. Zeichenfarbe
	  setForeground(Color.green);
	} // Ende des Konstruktors

	public void kontrolle(boolean[][] k, String n) {
	  for(a = 1; a <= 7; a += 1) {
	    for(b = 1; b <= 6; b += 1) {
		  // Kontrolle für die waagerechte
		  if(k[a][b] == false && k[a+1][b] == false && k[a+2][b] == false && k[a+3][b] == false) {
		    text.setText(n);
		    ende = 1;
			neu.setEnabled(true);
            break;
		  }
		  // Kontrolle für die senkrechte
		  else if(k[a][b] == false && k[a][b+1] == false && k[a][b+2] == false && k[a][b+3] == false) {
		    text.setText(n);
		    ende = 1;
			neu.setEnabled(true);
            break;
		  }
		  // Kontrolle für normaldiagonal
          else if(k[a][b] == false && k[a+1][b+1] == false && k[a+2][b+2] == false && k[a+3][b+3] == false) {
		    text.setText(n);
	        ende = 1;
			neu.setEnabled(true);
            break;
		  }
		  // Kontrolle für rückwärtsdiagonal
		  else if(k[a][b] == false && k[a-1][b+1] == false && k[a-2][b+2] == false && k[a-3][b+3] == false) {
		    text.setText(n);
		    ende = 1;
			neu.setEnabled(true);
            break;
		  }
		  else
	        continue;
		}
	  }
	} // Ende von kontrolle

	public void chipsSetzen(Graphics g, boolean[][] s) {
	  // wenn Spieler dran ist
	  if(player == 1 && npc == 1) {
	    npc = 2;
      }
	  // wenn NPC dran ist
	  else if(player == 2 && npc == 2) {
	    player = 1;
		npc = 0;
	  }

	  for(a = 1; a <= 7; a += 1) {
        // es wird geguckt welches Feld auf x-Aches gewählt wurde		
		if(m_Xpos >= waage[a] && m_Xpos <= waage[a+1]) {
	      m_Xpos = waage[a];
		  // es wird geguckt, ob eines der unteren Felder schon belegt ist
		  for(b = 6; b >= 1; b -= 1) {
		    if(feld[a][b] == true) {
			  g.fillOval(m_Xpos+4,((b-1)*100)+4,92,92);
			  // Feld wird als belegt deklariert
			  s[a][b] = false;
		      feld[a][b] = false;
			  break;
			}
			else
			  continue;
		  }
		}
		else
		  continue;
	    }

    } // Ende von chipsSetzen

    public void zeichnen(Graphics g) {
	  // x wird vor der Schleife initialisiert
	  x = 0;
	  for(y = 0; y <= 700; y += 100 ) {
	    // senkrechte Linien; mehrere, damit Linie dicker ist
		g.drawLine(x,0,x,600);
		g.drawLine(x+1,0,x+1,600);
		g.drawLine(x-1,0,x-1,600);
		x += 100;
		// waagerechte Linien; mehrere, damit Linie dicker ist
		g.drawLine(0,y,700,y);
		g.drawLine(0,y+1,700,y+1);
		g.drawLine(0,y-1,700,y-1);
	  }
	}

	// Spielfeld zeichnen
	public void paint(Graphics g) {
	  zeichnen(g);

	  // zeichnet einen Kreis wenn Spieler dran ist
	  // in das Feld auf das der Spieler mit der Maus klickt
	  if(player == 0 || npc == 0)
	    return;
	  else if(player == 1 && npc == 1){
		// Farbe von SP1
		g.setColor(new Color(10,105,225));

		// Falls gewonnen wird das angezeigt
		String sieg = "Gewonnen";

		chipsSetzen(g, p_feld);

		kontrolle(p_feld, sieg);

	  }
	  else if(npc == 2 && player == 2){
		// Farbe von NPC
		g.setColor(new Color(210,30,75));

		// Falls verloren wird das angezeigt
		String niederlage = "Verloren";

		chipsSetzen(g, n_feld);

		kontrolle(n_feld, niederlage);

	  }

	} // Ende von paint

	// Damit gezeichnetes erhalten bleibt, wenn neuer Zug beginnt.
	public void update(Graphics g) {
	  paint(g);
	}

	// Diese Methode liefert die minimale Größe der Canvas
	public Dimension getMinimumSize() {
	  return new Dimension(700,600);
	}

	// Die Lieblingsgröße wird auf die Minimalgröße gesetzt
	public Dimension getPreferredSize() {
	  return getMinimumSize();
	}

  } // Ende von Spielfeld

} // Ende von Spiel
    0
Anmelden zum Antworten