Hilfe bei GUI

[radiac]

Hallo Leute.

Ich stehe vor einem seltsamen Problem:
Und zwar habe ich ein JFrame Fenster im FullScreenExclusiveMode.

Jetzt wollte ich da 2 JTextfields reinzeichnen lassen. Hab in meinem Frame PaintComponents verwendet.

Jetzt wenn ich die Anwendung starte, wird alles schöngezeichnet. Jedoch flackert der Background (BgColor) und sobald man Zeichen in die Textboxen eingibt, flackern diese auch. Nach einiger Zeit, bekomme ich einen FreezeScreen und muss das Programm unterbrechen. Ich hab alles mögliche versucht.
Könnt Ihr mir helfen?

Hier der Quelltext:

package Main;


import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import javax.swing.*;


public class NetState extends GameState implements ActionListener {

    private JTextField txtUsername;
    private JTextField txtPassword;
    private JButton btnBack;
    private JPanel pnlNet;

    public NetState(ScrollGame game) {
        super(game);
    }


    @Override
    public void init() {
        txtUsername = new JTextField();
        txtPassword = new JTextField();
        txtUsername.setPreferredSize(new Dimension(200, 20));
        txtPassword.setPreferredSize(new Dimension(200, 20));

        btnBack = new JButton("Zurück");
        //btnBack.setPreferredSize(new Dimension(100, 20));
        btnBack.setVerifyInputWhenFocusTarget(false);


        btnBack.registerKeyboardAction(btnBack.getActionForKeyStroke(
            KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0, false)),
            KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, false),
            JComponent.WHEN_FOCUSED);

        btnBack.registerKeyboardAction(btnBack.getActionForKeyStroke(
            KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0, true)),
            KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, true),
            JComponent.WHEN_FOCUSED);

        pnlNet = new JPanel(true);
        //pnlNet.setLayout(new FlowLayout(FlowLayout.CENTER));
        pnlNet.add(txtUsername);
        pnlNet.add(txtPassword);
        pnlNet.add(btnBack);

    }

    @Override
    public void onLoad() {
        scrollGame.getContentPane().add(pnlNet);
        btnBack.addActionListener(this);
    }


    @Override
    public void onUnload() {
        btnBack.removeActionListener(this);
        scrollGame.getContentPane().remove(pnlNet);
    }

    
    @Override
    public void doLogic(long delta) {
       if (isKeyHit(KeyEvent.VK_ESCAPE)) {
           changeGameState(scrollGame.menuState);
       }
       else if (isKeyHit(KeyEvent.VK_ENTER)) {
           if (btnBack.isFocusOwner()) {
               changeGameState(scrollGame.menuState);
           }
       }
    }

    @Override
   public boolean render(Graphics g) {
        //g.clearRect(0, 0, screenWidth(), screenHeight());
        return true; // bei true wird dann super.paint aufgerufen
   }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == btnBack) {
            changeGameState(scrollGame.menuState);
            scrollGame.requestFocus();
        }
    }

}

Viele Grüße Radiac

 

[Gast2]

Jetzt wollte ich da 2 JTextfields reinzeichnen lassen. Hab in meinem Frame PaintComponents verwendet.
Viele Grüße Radiac

Warum lässt du Textfelder zeichnen? Ein einfaches add reicht hier...

 

[radiac]

Hi,


das Problem ist, das mein Programm im FSEM läuft.
Ds heisst, das ich ein eigenes Paint habe.
Repaint wird ignoriert und Paint ist ausgeschaltet.

Somit muss man die Felder doch Zeichnen, oder?

Vielleicht muss ich irgend etwas im FSEM beachten, um die Textfelder dastellen zu können?
Zu vergessen ist auch nicht, das im oben genannten Code die Felder angezeigt werden.
Diese jedoch, so scheint es mir, ettliche male gezeichnet werden...

 

[Java@home]

Hi, das Contantpane holen, das JPanel dort adden und dann einfach alles(z.B das JTextField) mit this.add(dein JTextField);
Was ist den GameState(klar ist das deine Klasse)? Wovon erbt die, von JApplet? wenn ja, nimm JFrame(oder muss es ein Applet sein) dan hast du damit auch keine Probleme, vorallem muss auch nichts gepaint werden!
P.s auf keinen Fall AWT mit Swing mischen!
MFG

 

[Gast2]

Seit Java1.5 muss man sich kein contentpane mehr holen.
des weiteren ist egal ob JFrame oder JApplet einfach deine Componenten adden nicht in paint malen. außerdem seh ich hier keine paint methode von dem her kann ich mit dem code nichts anfangen

 

[radiac]

Ich habe doch eine eigene Paintmethode Namens Render.

Einfach die Componente adden geht so nicht. Sie werden zwar angezeigt, jedoch frisst irgend etwas die Ressourcen bis zum Abstürtz.

Es handelt sich im üprigen um eine Applikation und kein Applet.

Habt ihr schonmal ein FSEM benutzt? Dann willst ihr ja, das man die paints/ repaints abschalten soll.

 

[Java@home]

Ich habe doch eine eigene Paintmethode Namens Render.

Einfach die Componente adden geht so nicht. Sie werden zwar angezeigt, jedoch frisst irgend etwas die Ressourcen bis zum Abstürtz.

Es handelt sich im üprigen um eine Applikation und kein Applet.

Habt ihr schonmal ein FSEM benutzt? Dann willst ihr ja, das man die paints/ repaints abschalten soll.

Zeig doch mal den Gesamtcode, dann können wir ja mal :rtfm: und evtl. besser helfen!
MFG

 

[hdi]

Seit Java1.5 muss man sich kein contentpane mehr holen.

Auch wenn das jetzt wohl nix mit der Frage zu tun hat: Das gilt für's adden, und soweit ich weiß nur für's adden. D.h. die add() Methode sieht so aus:

public void add(Component c){
    getContentPane().add(c);
}

Bei allem anderen, zB remove(), oder setBackground() oder sonst was musst du dir das ContentPane explizit holen, sonst führst du die Befehle direkt auf dem Frame aus.

...ich wollte es nur anbringen weil ich mich erinnern kann mal verzweifelt versucht habe Komponenten zu löschen und es nicht geschafft hab xD Ist ziemlich inkonsequent gemacht von den Sun-Leuten, also das sollte man im Hinterkopf haben.

 

[Gast2]

Auch wenn das jetzt wohl nix mit der Frage zu tun hat: Das gilt für's adden, und soweit ich weiß nur für's adden. D.h. die add() Methode sieht so aus:

public void add(Component c){
    getContentPane().add(c);
}

Bei allem anderen, zB remove(), oder setBackground() oder sonst was musst du dir das ContentPane explizit holen, sonst führst du die Befehle direkt auf dem Frame aus.

...ich wollte es nur anbringen weil ich mich erinnern kann mal verzweifelt versucht habe Komponenten zu löschen und es nicht geschafft hab xD Ist ziemlich inkonsequent gemacht von den Sun-Leuten, also das sollte man im Hinterkopf haben.

kann ich nicht bestätigen das tut genau so weil der Container immer auf seinen parent abfrägt...

 

[radiac]

Den Code hier zu addn, würde den Thread sprengen.

Die Wurzel des Problems sitzt ja hier in der oben gezeigten Klasse.

Andere Dinge funktioneren ja wunderbar.
Das einzige was ich sagen kann ist, das es sich hier um ein Spiel handelt.

Ich habe ein Menü gebaut. Dort soll ein GUI eingebaut werden, um mit einem Server zu connecten.
Das Menü wird also in das MainJFrame-Fenster vom Spiel gezeichnet. Spiel wird angezeigt im FSEM. Das ganze Programm läuft damit.
Damit ich den FSEM Nutzen konnte musste ich einige Sachen selbst in die Hand nehmen.

Es gibt wirklich nur Probleme beim Anzeigen der Buttons und TextFields...
Wie gesagt, sie werden angezeigt, aber flimmern rum. Und wenn man da was eingibt, flimmert es mehr. Und wenn mans übertreibt mit der eingabe, kommt der Freeze.

Das heisst, es wird irgendwo unendlich lang neu gezeichnet. Das GUI ist komplett in der oben genannten Klasse eingebaut. Nirgendswo anders.

Das heisst, es kommt irgendwo aus dieser Klasse her.
Und wie man sieht ist die Render Methode im moment leer. Da hatte ich mal zum test ein Screencleaner eingebaut.

Die Klasse selbst erbt von der MainKlasse, die den FSEM aber beinhaltet.

 

[radiac]

Ich hab hier mal den FSEM so gut es ging gepostet:

public abstract class GamePanel extends JFrame implements Runnable {

	private static final long	serialVersionUID	= 1L;

        private static final int NUM_BUFFERS = 2;
        public int pWidth, pHeight;     // panel dimensions

        private Thread animator; // the thread that performs the animation
        public volatile boolean running = false; // used to stop the animation thread

        private boolean finishedOff = false;


        // used for full-screen exclusive mode
        private GraphicsDevice gd;
        public Graphics gScr;
        public BufferStrategy bufferStrategy;

                         ....

public GamePanel()
  {
    super("Spiel");
    
    initFullScreen();

    Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run()
        {
            running = false;
            finishOff();
        }
    });    

        running = true;
        gameStart();
        
  }

              ...

//___________________________initFullScreen();__________________________________

private void initFullScreen() {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    gd = ge.getDefaultScreenDevice();

    setUndecorated(true);
    setIgnoreRepaint(true);
    setResizable(false);

    if (!gd.isFullScreenSupported()) {
      System.out.println("Full-screen exclusive mode not supported");
      System.exit(0);
    }
    gd.setFullScreenWindow(this); // switch on full-screen exclusive mode

    setDisplayMode(800, 600, 16);   // or try 8 bits
    //setDisplayMode(1024, 768, 16);
    //setDisplayMode(1152, 867 ,32);
    //setDisplayMode(1280,1024,32);


    pWidth = getBounds().width;
    pHeight = getBounds().height;

    setBufferStrategy();
    }
//_________________________initFullScreen(); ENDE_______________________________



//___________________________setBufferStrategy();_______________________________

  private void setBufferStrategy(){
      try {
      EventQueue.invokeAndWait( new Runnable() {
        public void run()
        { createBufferStrategy(NUM_BUFFERS);  }
      });
    }
    catch (Exception e) {
      System.out.println("Error while creating buffer strategy");
      System.exit(0);
    }

    try {  // sleep to give time for the buffer strategy to be carried out
      Thread.sleep(500);  // 0.5 sec
    }
    catch(InterruptedException ex){}

    bufferStrategy = getBufferStrategy();  // store for later
  }  // end of setBufferStrategy()

//_________________________setBufferStrategy(); ENDE____________________________




//______________________________screenUpdate();_________________________________

  protected void screenUpdate()
  // use active rendering
  { try {
      gScr = bufferStrategy.getDrawGraphics();
      gameRender(gScr);
      gScr.dispose();
      if (!bufferStrategy.contentsLost())
        bufferStrategy.show();
      else
        System.out.println("Contents Lost");
      // Sync the display on some systems.
      // (on Linux, this fixes event queue problems)
      Toolkit.getDefaultToolkit().sync();
    }
    catch (Exception e)
    { e.printStackTrace();
      running = false;
    }
  }
//_________________________screenUpdate(); ENDE_________________________________




//_______________________setDisplayMode(); _____________________________________

  private void setDisplayMode(int width, int height, int bitDepth)
  // attempt to set the display mode to the given width, height, and bit depth
  {
    if (!gd.isDisplayChangeSupported()) {
      return;
    }

      if (!isDisplayModeAvailable(width, height, bitDepth)) {
      return;
      }

      DisplayMode dm = new DisplayMode(width, height, bitDepth,
      DisplayMode.REFRESH_RATE_UNKNOWN);   // any refresh rate
      try {
      gd.setDisplayMode(dm);
      }
      catch (IllegalArgumentException e)
      {}

      try {  // sleep to give time for the display to be changed
      Thread.sleep(1000);  // 1 sec
      }
      catch(InterruptedException ex){}
  }
//_______________________setDisplayMode(); ENDE_________________________________




//_____________________isDisplayModeAvailable();________________________________

    private boolean isDisplayModeAvailable(int width, int height, int bitDepth)

    { DisplayMode[] modes = gd.getDisplayModes();


    for(int i = 0; i < modes.length; i++) {
    if (width == modes[i].getWidth() && height == modes[i].getHeight() &&
    bitDepth == modes[i].getBitDepth())
    return true;
    }
    return false;
    }
//_______________________isDisplayModeAvailable(); ENDE_________________________




//____________________________finishOff(); _____________________________________

  public void finishOff()

  {
    if (!finishedOff) {
      finishedOff = true;
      restoreScreen();
      System.exit(0);
    }
  }
//_________________________finishOff(); ENDE__________________________________




//____________________________restoreScreen();__________________________________
  private void restoreScreen()
  /* Switch off full screen mode. This also resets the
     display mode if it's been changed.
  */
  { Window w = gd.getFullScreenWindow();
    if (w != null)
      w.dispose();
    gd.setFullScreenWindow(null);
  }
//_______________________restoreScreen(); ENDE _________________________________

Das ist der FSEM.

Mehr ist denke ich mal nicht nötig.
Viellicht noch, das diese Klasse abstract ist und scrollGame davon erbt und das Programm ausführt.

 

[hdi]

kann ich nicht bestätigen das tut genau so weil der Container immer auf seinen parent abfrägt...

Ich hab's grad nochmal versucht, also seltsamerweise funktioniert remove() tatsächlich. Ich könnte schwören ich hatte damit Probleme...

Naja, aber setBackground() und removeAll() zB beziehen sich nicht auf's ContentPane.

 

[Gast2]

Ich hab's grad nochmal versucht, also seltsamerweise funktioniert remove() tatsächlich. Ich könnte schwören ich hatte damit Probleme...

Naja, aber setBackground() und removeAll() zB beziehen sich nicht auf's ContentPane.

Des kann sein weiß ich nicht

back to topic...

also du hast ein JFrame darauf würde ich mein JPanel adden ...

 

[radiac]

Okay, jetzt mal ein Beispiel das übersichtlicher ist:

Hab hier den FSEM drin, und dann ein paar Componenten:

package fsemtest;

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

public class MyFrame extends JFrame implements Runnable, KeyListener {

    private GraphicsDevice gd;
    private Graphics gScr;
    private BufferStrategy bufferStrategy;
    private volatile boolean running;
    private volatile boolean finishedOff;
    private int x;
    private JTextField txtUsername;

    public MyFrame() {
        super("FSEM example");

        initFullScreen();

        readyForTermination();

        gameStart();
    }

    private void initFullScreen() {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        gd = ge.getDefaultScreenDevice();

        setUndecorated(true);
        setIgnoreRepaint(true);
        setResizable(false);

        if (!gd.isFullScreenSupported()) {
            System.out.println("FSEM not supported.");
            System.exit(0);
        }

        gd.setFullScreenWindow(this);

        this.createBufferStrategy(2);
        bufferStrategy = this.getBufferStrategy();
    }

    private void readyForTermination() {

        this.addKeyListener(this);

        this.addWindowListener(new WindowListener() {

            public void windowOpened(WindowEvent e) {

            }

            public void windowClosing(WindowEvent e) {

            }

            public void windowClosed(WindowEvent e) {
                finishOff();
            }

            public void windowIconified(WindowEvent e) {

            }

            public void windowDeiconified(WindowEvent e) {

            }

            public void windowActivated(WindowEvent e) {

            }

            public void windowDeactivated(WindowEvent e) {

            }
        });
    }

    private void gameStart() {

        txtUsername = new JTextField();
        txtUsername.setPreferredSize(new Dimension(100, 20));
        
        this.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
        this.getContentPane().add(txtUsername);

        running = true;
        Thread t = new Thread(this);
        t.run();
    }

    public void run() {
        while (running) {
            gameUpdate();
            screenUpdate();
        }

        finishOff();
    }

    private void gameUpdate() {
        x += 1;
    }

    private void screenUpdate() {
        try {
            gScr = bufferStrategy.getDrawGraphics();
            gameRender(gScr);
            gScr.dispose();

            if (!bufferStrategy.contentsLost()) {
                bufferStrategy.show();
            }
            else {
                System.out.println("Contents lost");
            }

            Toolkit.getDefaultToolkit().sync();
        }
        catch (Exception e) {
            e.printStackTrace();
            running = false;
        }
    }

    private void gameRender(Graphics g) {
        g.setColor(Color.black);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(Color.white);
        g.drawString("Hallo", 10, 10);
        g.fillRect(x, 100, 20, 20);
        this.paintComponents(g);
    }

    private void finishOff() {
        if (!finishedOff) {
            finishedOff = true;
            Window w = gd.getFullScreenWindow();
            if (w != null) w.dispose();

            gd.setFullScreenWindow(null);
            bufferStrategy.dispose();
            System.exit(0);
        }
    }

    public void keyTyped(KeyEvent e) {

    }

    public void keyPressed(KeyEvent e) {
    }

    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            running = false;
        }
    }
}

Und die Ausgeführte Datei:

package fsemtest;

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        MyFrame myFrame = new MyFrame();
    }

}

Kann jetzt sein das da irgendwas fehlt.

Jedenfalls habe ich hier den gleichen effekt. Freeze nach ein paar Aktivitäten.
Jetzt seid Ihr gefragt. Ich schnalls einfach nicht .

Danke

 

[Michael...]

So ganz steigt ich nicht durch, was Du da treibst bzw. wo Dein Problem ist. Was hast Du eigentlich vor?

Jetzt noch ein paar Anmerkungen zum Code:
WindowAdapter anstelle von WindowListener verwenden, wenn man nur einige wenige Methoden des Interfaces überschreibt (erleichtert zumindest anderen das Lesen)

[JAVA=51]
this.addWindowListener(new WindowListener() {
public void windowOpened(WindowEvent e) {}
public void windowClosing(WindowEvent e) {}
public void windowClosed(WindowEvent e) {
finishOff();
}
public void windowIconified(WindowEvent e) {}

public void windowDeiconified(WindowEvent e) {}

public void windowActivated(WindowEvent e) {}

public void windowDeactivated(WindowEvent e) {}
});
}[/code]

Thread werden mit start() und nicht mit run() gestartet.

[JAVA=92]Thread t = new Thread(this);
t.run();[/code]

Der Thread läuft die ganze Zeit auf Vollast ohne, dass was sichtbares passiert (ist das vielleicht das Problem??) Ist das Absicht sollte er nicht zwischendurch mal pausieren? Was soll er überhaupt machen?

[JAVA=96] public void run() {
while (running) {
gameUpdate();
screenUpdate();
}

finishOff();
}[/code]

 

[Michael...]

Ahh! hab gerade mal Zeile 136 "this.paintComponents(g);" auskommtiert!
Ist das Absicht, dass alles was Du vorher manuell gezeichnet hast überschrieben werden soll? Ist der ganze Aufwand wirklich nur um ein Quadrat über den Bildschirm laufen zu lassen?

 

[radiac]

Hi Michael, danke fürs angucken.

Das was du gelesen hast, ist nur eine massiv abgespeckte Version vom Problem.
Normalerweise hat der Thread mins. 1 Sekunde Pause im richtigen Programm.

Was bei diesem Code nicht funktioniert, ist das darstellen von Textfeldern.

Könntest du dir den Code mal importieren und versuchen im FSEM Textfelder zu zeichnen?
Ohne das es abstürtzt oder bei der eingabe flackert.

Den Code darfst auch verändern, jedoch sollte der FSEM weiterhin funktionieren.

 

[Michael...]

Also wenn ich bei mir den Code ausführe sehe ich entwender das Textfeld auf grauem Hintergrund oder wenn ich oben genannte Zeile auskommentiere ein Hallo ein wanderndes Quadrat auf schwarzem Hintergrund. Flackern tut bei mir nichts.

 

[radiac]

Der ganze Aufwand ist nur zum test xD

Ich habe das rausgeholt aus meinem Spiel das viel zu komplex ist um da den fehler zu finden.

Es kommt auf jedenfall vom FSEM. Weil ich ja FSEM habe muss ich um Probleme zu meiden die PaintMethoden aus machen.

Jedoch gibtes irgendwie keine andere Möglichkeit Componente anders anzuzeigen, als mit Paint...

Kann es sein, das paint mit den Componenten zusammen hängen? Oder gar die Componente eine eigene paintMethode haben??? DIe dann die eigene oder vorhandene Überschreibt???

Ich bin echt am Ende mit meinem Latein

 

[radiac]

@ Michael.

Joa, und jetzt soll beides angezeigt werden... geht das?
Und vorher aber wie WIld da Zeichen eingeben und mit der Maus über das Textfeld huschen, um zu sehen ob er einfriert oder nicht.

 

[Michael...]

Hier mal wie ich das machen würde, allerdings hatte ich mit FSEM nix grossartig zu tun.
Und mit dieser BufferStrategy Geschicht kenne ich mich ehrlich gesagt gar nicht aus.

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class FullScreenDemo extends JFrame {
	private JTextField textField;
	private DrawingPanel drawPanel;
	private int posX = 0, posY = 0;

	public FullScreenDemo() {
		this.setFullScreenMode();
		this.getContentPane().setBackground(Color.BLACK);
		JPanel panel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 5, 20));
		panel.setOpaque(false);
		panel.add(textField = new JTextField());
		textField.setPreferredSize(new Dimension(200, 26));
		JButton button = new JButton("OK");
		panel.add(button);
		button.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				drawPanel.setText(textField.getText());
			}
		});
		button = new JButton("BYE");
		panel.add(button);
		button.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				System.exit(0);
			}
		});
		this.getContentPane().add(panel, BorderLayout.NORTH);
		this.getContentPane().add(drawPanel = new DrawingPanel(),
				BorderLayout.CENTER);

		this.startRenderingLoop();
	}
	
	private void startRenderingLoop() {
		new Thread(new Runnable() {
			public void run() {
				while(true) {
					drawPanel.setPosition(posX+=5, posY+=5);
					drawPanel.repaint();
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}

	private void setFullScreenMode() {
		GraphicsEnvironment ge = GraphicsEnvironment
				.getLocalGraphicsEnvironment();
		GraphicsDevice gd = ge.getDefaultScreenDevice();

		setUndecorated(true);
		setIgnoreRepaint(true);
		setResizable(false);

		if (!gd.isFullScreenSupported()) {
			System.out.println("FSEM not supported.");
			System.exit(0);
		}
		gd.setFullScreenWindow(this);
		this.validate();
	}

	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() { 
            public void run() { 
            	new FullScreenDemo().setVisible(true);
            }
		});
	}
}

class DrawingPanel extends JPanel {
	private String text = "Hallo";
	private int x = 10, y = 10;
	
	public DrawingPanel() {
		this.setOpaque(false);
	}

	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.setColor(Color.WHITE);
		g.fillRect(x, x, 20, 20);
		g.drawString(text, this.getWidth()/2, this.getHeight()/2);
	}

	public void setText(String text) {
		this.text = text;
	}

	public void setPosition(int x, int y) {
		this.x = x;
		this.y = y;
	}
}

 

[radiac]

Hmm, also das sieht schon ziemlich gut aus .

Jetzt muss ich das mal irgendwie in das Spiel einbringen.
Wenn das jetzt geht, hast du echt Sau gute Arbeit geleistet.
Weist du, was mein Problem war?

Hab auch gesehen das da DrawingPanel angewendet wird. Hab das noch nie verwendet... äusserst Interessant alles


Vielen Dank!!! Wenn das im Spiel auch funktioniert, sag ich bescheid . :applaus:

 

[radiac]

Huhu,

also im SPiel geht das immer noch nicht, das heisst das dein Code tortzdem funktioniert.
Es liegt also irgendwie am überschreiben von PaintComponent oder so...

Das Problem ist echt verwirrend. Ich muss erstmal weiter versuchen um evt. das Thema abzuschreiben.


Viele Grüße Radiac