'Vier Gewinnt' programmieren

[cplusplus]

Ich habe einige Probleme beim Programmieren des Spieles 4Gewinnt. Dass Spiel muss mit einer Grafischen Oberfläche erstellt werden und die Steine müssen per mouseevent eingefügt werden.

Außerdem muss dass Programm erkennen, wenn vier steine Waagerecht Senkrecht oder schräg gelegt worden sind und wenn dass der Fall ist, soll eine Nachricht erscheinen, dass derjenige dass Spiel gewonnen hat.

Außerdem muss ich auch noch einen Spielstand mit einbauen, der zählt, wie oft rot oder blau gewonnen haben. Diesen spielstand muss man mittels einen button aber auch wieder auf null setzen können.

Ich habe schon ein Code vorbereitet, aber irgendwie will er die Steine einfach nicht zeichnen. KAnn mir jemand helfen?

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class connect4 extends Applet implements MouseListener {
   /**
    *
    */
   private static final long serialVersionUID = 1L;
   int feld[][] = { { 0, 1, 2, 3, 4, 5, 6 },
                { 0, 0, 0, 0, 1, 0, 0 },
                { 2, 4, 0, 0, 1, 0, 0 },
                { 0, 0, 0, 0, 1, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0 },
                { 1, 1, 2, 0, 0, 0, 1 }
                };

   public void zeichneSpielfeld(Graphics g) {

      g.drawString("Vier Gewinnt", 260, 18);
      
      setSize(600,600);
      
      // g.drawRect(x, y, width, height)

      g.drawRect(85, 85, 420, 420);

      g.drawLine(85, 155, 505, 155);
      g.drawLine(85, 225, 505, 225);
      g.drawLine(85, 295, 505, 295);
      g.drawLine(85, 365, 505, 365);
      g.drawLine(85, 435, 505, 435);
      g.drawLine(85, 505, 505, 505);

      g.drawLine(145, 85, 145, 505);
      g.drawLine(205, 85, 205, 505);
      g.drawLine(265, 85, 265, 505);
      g.drawLine(325, 85, 325, 505);
      g.drawLine(385, 85, 385, 505);
      g.drawLine(445, 85, 445, 505);
   }

   public void paint(Graphics g) {
      Image rot = Toolkit.getDefaultToolkit().getImage("sonne.jpg");
      Image blau = Toolkit.getDefaultToolkit().getImage("mond.jpg");

      for (int x = 0; x < 7; x++) {
         for (int y = 0; y < 6; y++) {
            if (feld[y][x] == 1)
               g.drawImage(rot, 50 * x, 50 * y, this);
            if (feld[y][x] == 2)
               g.drawImage(blau, 50 * x, 50 * y, this);
         }
      }
      zeichneSpielfeld(g);
   }

   public void init() {
      addMouseListener(this);
   }

   public void mouseClicked(MouseEvent arg0) {
      // TODO Auto-generated method stub

   }

   public void mousePressed(MouseEvent arg0) {
      // TODO Auto-generated method stub

      int x = arg0.getX();

      if (x < 50)
         feld[0][0] = 1;
      if (x > 50 && x < 100)
         feld[0][1] = 1;
      if (x > 100 && x < 150)
         feld[0][2] = 1;
      repaint();
   }

   public void mouseReleased(MouseEvent arg0) {
      // TODO Auto-generated method stub

   }

   public void mouseEntered(MouseEvent arg0) {
      // TODO Auto-generated method stub

   }

   public void mouseExited(MouseEvent arg0) {
      // TODO Auto-generated method stub

   }

}

[L-ectron-X]

Augenblick, isch hab da mal was vorbereitet…

Eine Benutzer-Oberfläche mit einem Demo-Spiel von zwei Spielern.
Ich habe das Layout und die Funktionen an eines der bekanntesten „Vier Gewinnt“ Spiele angeleht/nachgeahmt. Das Setzen der Steine funktioniert für 2 Spieler entweder durch Klicken auf den Button über einer Spalte oder direkt auf die Spalte.
Dem Programm sind bisher noch keine Spielregeln bekannt, den Regelsatz und die Voraussetzungen für ein gewonnenes Spiel müsstest du also noch einbauen.
Damit solltest du einen soliden Grundstock haben, um dein Programm weiter-/fertigzubauen.

Sieht dann so aus:

Code kommt gleich, Moment.

[AndreUhres]

…inzwischen geh ich mal Gassi…

[L-ectron-X]

Immer mit der Ruhe, ich will ja auch kein Blödsinn posten…

So, versuchen wir’s mal.

Was zum Kern gehört:
Der logische Aufbau des Spiels, ein Gitter.

/**
 * GameMatrix speichert den aktuellen Spielzustand, also die Anordnung der 
 * Spielsteine auf dem Spielfeld.
 * @author L-ectron-X
 */
public class GameMatrix {
   private GamingPiece[][] matrix; //Spielgitter mit Spielsteinen
   private Rules rules; //Spielregeln
   
   /** Erzeugt ein Standardspielfeld. */
   public GameMatrix() {
      this(6, 7);
   }
   
   /** 
    * Erzeugt ein Spielfeld beliebiger Größe für Spielvariationen.
    * @param rows Anzahl der Reihen auf dem Spielfeld.
    * @param columns Anzahl der Spalten auf dem Spielfeld.
    */
   public GameMatrix(int rows, int columns) {
      matrix = new GamingPiece[rows][columns];
      rules = new Rules(this);
   }   
   
   /**
    * Setzt den Spielstein eines Spielers in die übergebene Spalte.
    * @param player Der ziehende Spieler.
    * @param column Die Spalte, in der der Zug gemacht werden soll.
    * @return true Bei Erfolg, false bei voller Spalte.
    */
   public boolean setGamingPiece(Player player, int column) {
      int maxRow = matrix.length-1;
      if(matrix[0][column] != null) { //Spalte ist voll
         return false;
      }
      
      //belegtes Feld suchen (von unten nach oben)
      while(matrix[maxRow][column] != null && maxRow > 0) { //Spalte noch nicht voll
         maxRow--;
      }
      
      //Spielstein in freies Feld über dem letzten Spielstein der Spalte setzen.
      matrix[maxRow][column] = new GamingPiece(player); //Spielstein eines Spielers Feld setzen
      
      return true;
   }
   
   /**
    * Löscht alle gesetzten Spielsteine vom Spielfeld.
    */
   public void clearMatrix() {
      for(int i = 0; i < matrix.length; i++) {
         for(int j = 0; j < matrix[0].length; j++) {
            matrix**[j] = null;
         }
      }
   }
   
   public GamingPiece[][] getMatrix() {
      return matrix;
   }

}


Der Spielstein:
package connect4.core;

/**
 * GamingPiece beschreibt einen Spielstein.
 * @author L-ectron-X
 */
public class GamingPiece {
   private Player owner; //der Eigentümer dieses Spielsteins
   
   /**
    * Erzeugt einen Spielstein, der dem übergebenen Spieler gehört.
    * @param owner Der Eigentümer dieses Spielsteins.
    */
   public GamingPiece(Player owner) {
      this.owner = owner;
   }
   
   /**
    * Gibt den Eigentümer (Spieler) dieses Spielsteins zurück.
    * @return Der Spieler dieses Spielsteins.
    */
   public Player getPlayer() {
      return owner;
   }

}


Der Spieler:
package connect4.core;

import java.awt.image.BufferedImage;

/**
 * Player beschreibt die allgemeinen Eigenschaften eines Spielers.
 * Neben dem Namen des Spielers wird auch die vom Spieler benutzte "Farbe"
 * in Form einer Grafikdatei gespeichert.
 * @author L-ectron-X
 */
public class Player {
   private String name;
   private BufferedImage pieceImage;
   private boolean isNext;
   
   /**
    * Erzeugt einen neuen Spieler mit dem übergebenen Namen.
    * Der Spieler hält im Spiel die Farbe des Spielsteins anhand 
    * der übergebenen Grafik.
    * @param name
    * @param pieceImage Die visualisierende Grafik für den Spielstein.
    */
   public Player(String name, BufferedImage pieceImage) {
      this.name = name;
      this.pieceImage = pieceImage;
   }
   
   /**
    * Gibt den Namen des Spielers zurück.
    * @return Der Name des Spielers.
    */
   public String getName() {
      return name;
   }         
   
   /**
    * Gibt die visualisierende Grafik für den Spielstein zurück.
    * @return Die Grafik für den Spielstein.
    */
   public BufferedImage getImage() {
      return pieceImage;
   }
   
   /**
    * Gibt zurück, ob ein Spieler am Zug ist, oder nicht.
    * @return true, wenn der Spieler am Zug ist, sonst false.
    */
   public boolean isNext() {
      isNext = !isNext;
      return isNext;
   }
}


Die Spielregeln (Implementierung noch notwendig):
package connect4.core;

/**
 * Rules beschreibt die Spielregeln für 4 Gewinnt.
 * @author L-ectron-X
 */
public class Rules {
   
   /**
    * Spielregeln für ein Spielfeld in der übergebenen Größe (Zeilen x Spalten)
    * @param matrix Das Spielfeld, für das die Spielregeln gelten.
    */
   public Rules(GameMatrix matrix) {

   }
}


Eine Klasse zum Abrufen einer Demonstration
package connect4.core;

import connect4.gui.MainFrame;

/**
 * Diese Klasse demonstriert ein laufendes Spiel.
 * @author L-ectron-X
 */
public class Demo extends Thread {
   private MainFrame frame;
   
   /**
    * 4 Gewinnt-Demo
    * @param frame Das Hauptfenster.
    */
   public Demo(MainFrame frame) {
      this.frame = frame;
   }
   
   @Override
   public void run() {
      try {
         frame.setGamingPiece(4);
         sleep(1000);
         frame.setGamingPiece(4);
         sleep(1000);
         frame.setGamingPiece(3);
         sleep(1000);
         frame.setGamingPiece(4);
         sleep(1000);
         frame.setGamingPiece(4);
         sleep(1000);
         frame.setGamingPiece(3);
         sleep(1000);
         frame.setGamingPiece(3);
         sleep(1000);
         frame.setGamingPiece(2);
         sleep(1000);
         frame.setGamingPiece(2);
         sleep(1000);
         frame.setGamingPiece(2);
         sleep(1000);
         frame.setGamingPiece(1);       
      }
      catch(InterruptedException ex) {
         interrupt();
      }
   }
}

[L-ectron-X]

Was zur Oberfläche gehört:
Das Spielfeld

package connect4.gui;

import connect4.core.GameMatrix;
import connect4.core.GamingPiece;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;

/**
 * Board ist die Visualisierung des Spielfeldes. Es zeichnet den aktuellen
 * Spielzustand aus den Daten, die in GameMatrix gespeichert sind.
 * @author L-ectron-X
 */
public class Board extends JPanel implements MouseListener {
   private MainFrame frame;
   private GameMatrix matrix;
   private BufferedImage blank;
   private int columnWidth, rowHeight;
   private int rows, columns;
   private GamingPiece[][] field;
   
   /**
    * Erzeugt das Spielfeld.
    * @param frame Das Hauptfenster.
    * @param matrix Der Spielzustand, Anordnung der Spielsteine.
    * @param blank Die Grafik repräsentiert ein leeres Spielfeld.
    */
   public Board(MainFrame frame, GameMatrix matrix, final BufferedImage blank) {
      setLayout(null);
      this.frame = frame;
      this.matrix = matrix;
      this.blank = blank;
      columnWidth = blank.getWidth();
      rowHeight = blank.getHeight();      
      
      field = matrix.getMatrix();
      rows = field.length;
      columns = field[0].length;
      
      setPreferredSize(new Dimension(columns * columnWidth, rows * rowHeight));
      
      addMouseListener(this);
   }
   
   /**
    * Zeichnet zeilenweise die aktuelle Spielansicht.
    * @param g Das Zeichenbrett - das Objekt auf dem gezeichnet wird.
    */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);
      int xPos = 0, yPos = 0;
      
      for(int i = 0; i < rows; i++) {
         for(int j = 0; j < columns; j++) {
            if(field**[j] == null) { //das Feld wurde von keinem Spieler belegt
               g.drawImage(blank, xPos, yPos, this);               
            }
            else { //das Feld ist von einem Spieler belegt
               g.drawImage(field**[j].getPlayer().getImage(), xPos, yPos, this);
            }
            xPos += columnWidth; //Position für Grafik Spalte rechts berechnen
         }
         xPos = 0; //neue Zeile, zeichnen wieder links beginnen
         yPos += rowHeight; //Position für Grafik Zeile tiefer berechnen
      }
   }

   public void mouseClicked(MouseEvent e) {
      int xPos = e.getX();

      for(int i = 0; i < columns; i++) {
         if(xPos > columnWidth * i && xPos < (columnWidth * i) + columnWidth) {
            frame.setGamingPiece(i);
         }
      }      
   }

   public void mousePressed(MouseEvent e) {
   }

   public void mouseReleased(MouseEvent e) {
   }

   public void mouseEntered(MouseEvent e) {
      setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
   }

   public void mouseExited(MouseEvent e) {
      setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
   }
}

Eine Leiste mit Buttons, zum Absetzen der Spielsteine

package connect4.gui;

import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JPanel;

/**
 * Stellt eine einzeilige Reihe mit Buttons in der Anzahl der Spalten zur Verfügung.
 * Die Buttons werden dazu benutzt, um einen Spielzug in der jeweilgen Spalte auszuführen.
 * @author L-ectron-X
 */
public class BoardButtonBar extends JPanel implements ActionListener {
   private JButton[] buttonBar;
   private MainFrame frame;
   
   /**
    * Erzeugt eine einzeilige Reihe mit Buttons in der Anzahl der Spalten.
    * @param frame Das Hauptfenster.
    * @param rows Die Anzahl der Spalten des Spielfeldes.
    */
   public BoardButtonBar(MainFrame frame, int rows) {
      super(new GridLayout());
      this.frame = frame;
      
      buttonBar = new JButton[rows];
      for(int i = 0; i < buttonBar.length; i++) {
         buttonBar** = new JButton(String.valueOf(i+1));
         buttonBar**.setMargin(new Insets(2, 2, 2, 2));
         buttonBar**.setFocusPainted(false);
         buttonBar**.addActionListener(this);
         add(buttonBar**);
      }
   }

   public void actionPerformed(ActionEvent e) {
      Object source = e.getSource();
      
      for(int i = 0; i < buttonBar.length; i++) {
         if(source == buttonBar**) {
            frame.setGamingPiece(i);
         }
      }
      
   }
}


Das Hauptfenster

package connect4.gui;

import connect4.core.Demo;
import connect4.core.GameMatrix;
import connect4.core.Player;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JOptionPane;

/**
 * MainFrame ist das Hauptfenster und gleichzeitig der Controller des Programms.
 * @author  L-ectron-X
 */
public class MainFrame extends javax.swing.JFrame implements ActionListener {
   
   /** 
    * Erzeugt ein neues Hauptfenster.
    * @param title Der Titel dieses Fensters.
    */
   public MainFrame(String title) {
      super(title);
      initComponents();
      setLocationRelativeTo(null);
   }
   
                       
   private void initComponents() {

      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
            exit();
         }
      });

      try {
         blank = ImageIO.read(getClass().getResource("leeresFeld.gif"));
         piece1 = ImageIO.read(getClass().getResource("rotesFeld.gif"));
         piece2 = ImageIO.read(getClass().getResource("gelbesFeld.gif"));
      }
      catch(IOException ex) {
         ex.printStackTrace();
         JOptionPane.showMessageDialog(this,
            "Ausnahmefehler beim Laden der Spielgrafiken!
Das Programm kann nicht ausgeführt werden.",
            "IOException",
            JOptionPane.ERROR_MESSAGE);

         System.exit(1);
      }
      catch(IllegalArgumentException ex) {
         ex.printStackTrace();
         JOptionPane.showMessageDialog(this,
            "Ausnahmefehler beim Laden der Spielgrafiken!
Mindestens eine Grafik konnte nicht gefunden werden! 
Das Programm kann nicht ausgeführt werden.",
            "IllegalArgumentException",
            JOptionPane.ERROR_MESSAGE);

         System.exit(1);
      }

      matrix = new GameMatrix();
      board = new Board(this, matrix, blank);
      add(board, BorderLayout.CENTER);

      buttonBar = new BoardButtonBar(this, matrix.getMatrix()[0].length);
      add(buttonBar, BorderLayout.NORTH);

      players = new Player[2];

      menuBar = new javax.swing.JMenuBar();
      gameMenu = new javax.swing.JMenu();
      newGame = new javax.swing.JMenuItem();
      demoGame = new javax.swing.JMenuItem();
      exitGame = new javax.swing.JMenuItem();

      setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);

      gameMenu.setText("Spiel");

      newGame.setText("Neues Spiel");
      newGame.addActionListener(this);
      gameMenu.add(newGame);

      demoGame.setText("Demo");
      demoGame.addActionListener(this);
      gameMenu.add(demoGame);

      exitGame.setText("Beenden");
      exitGame.addActionListener(this);
      gameMenu.add(exitGame);

      menuBar.add(gameMenu);

      setJMenuBar(menuBar);

      pack();
   }

   // Code for dispatching events from components to event handlers.

   public void actionPerformed(java.awt.event.ActionEvent evt) {
      if (evt.getSource() == newGame) {
         MainFrame.this.newGameActionPerformed(evt);
      }
      else if (evt.getSource() == demoGame) {
         MainFrame.this.demoGameActionPerformed(evt);
      }
      else if (evt.getSource() == exitGame) {
         MainFrame.this.exitGameActionPerformed(evt);
      }
   }                    

   private void exitGameActionPerformed(java.awt.event.ActionEvent evt) {                                         
      exit();
   }                                        

   private void demoGameActionPerformed(java.awt.event.ActionEvent evt) {                                         
      demo();
}                                        

   private void newGameActionPerformed(java.awt.event.ActionEvent evt) {                                        
      newGame();
   }                                       
   
   //beendet das Programm
   private void exit() {
      int result = JOptionPane.showConfirmDialog(this,
              "Möchtest du das Spiel jetzt wirklich beenden?",
              "Spiel beenden", 
              JOptionPane.YES_NO_OPTION,
              JOptionPane.QUESTION_MESSAGE);
      
      switch(result) {
         case JOptionPane.YES_OPTION:
            dispose();
      }
   }
   
   //Demonstration eines laufenden Spiels.
   private void demo() {
      matrix.clearMatrix();
      board.repaint();
      players[0] = new Player("Spieler 1", piece1);
      players[1] = new Player("Spieler 2", piece2);
      players[1].isNext();
      new Demo(this).start();
   }  
   
   //Öffnet ein neues Spiel.
   private void newGame() {
      matrix.clearMatrix();
      board.repaint();
      players[0] = new Player(
              JOptionPane.showInputDialog(this, "Wie lautet dein Name?", "Spieler 1", JOptionPane.QUESTION_MESSAGE),
              piece1);
      players[1] = new Player(
              JOptionPane.showInputDialog(this, "Wie lautet dein Name?", "Spieler 2", JOptionPane.QUESTION_MESSAGE), 
              piece2);
      players[1].isNext(); //Spieler2 zieht zuerst. (Welcher Spieler zuerst ziehen soll, könnte noch abgefragt werden.)

   }

   
   /**
    * Muss aufgerufen werden, wenn ein Spieler einen Spielzug macht.
    * @param column Die Spalte, in der der Zug ausgeführt werden soll.
    */
   public void setGamingPiece(int column) {
      for(int i = 0; i < players.length; i++) {
         if(players** == null) { //Es ist kein Spieler bekannt! (Name noch nicht eingegeben)
            newGame();
            break;
         }
         else if(players**.isNext()) {
            if(matrix.setGamingPiece(players**, column)) {
               board.repaint();         
            }
         }
      } 
   }
}

Ins Package connect4.gui setzt du dann noch Grafikdateien:
*gelbesFeld.gif
*rotesFeld.gif
*leeresFeld.gif

[AndreUhres]

Ja, klappt wie geschmiert, hier noch eine Hauptklasse zum Testen als Anwendung:

import javax.swing.*;
import connect4.gui.MainFrame;

public class VierGewinnt {
    public static void main(final String[] args) {
        Runnable gui = new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                new MainFrame("4 Gewinnt").setVisible(true);
            }
        };
        //GUI must start on EventDispatchThread:
        SwingUtilities.invokeLater(gui);
    }
}

[L-ectron-X]

Ist mir grad aufgefallen das die noch gefehlt hat, hatte sie eben im Clipboard, um sie noch nachzureichen.
Du warst da aber schneller.

[cplusplus]

dumme Frage, wie setze ich die Codes im Script ein? muss ich sie einfach alle in einer klasse reinsetzen oder wie geht dass?

Sorry wegen der dummen frage, bin noch ein anfänger in dem gebiet und versuche gerade den Quellcode nachzuvollziehen, den du gepostet hast.

könntest du eventl. die Datei hochladen? ^^

[L-ectron-X]

Jedes gepostetes Codestück (in den Code-Fenstern) ist eine einzelne Klasse, die in einer .java-Datei gespeichert ist. Die Package-Definitionen entsprechen den Verzeichnissen, in denen die Dateien abgelegt sind. Die Java-Dateien kannst du mit einem ganz normalen Texteditor anlegen.

Ich gebe dir ganz unten mal den Quellcode, dann kannst du den Aufbau vielleicht besser nachvollziehen. Der Code oben, wie in der unten bereitgestellten zip-Datei wurde nochmals gegenüber der zuerst geposteten Version leicht modifiziert.

Für den Anfang solltest du dich vielleicht nicht gleich an solche Sachen heran wagen, zumindest nicht solange, wie die Java-Basics nicht sitzen.

[cplusplus]

Also ich habe dass Programm in mein Verzeichnis kopiert und wird in Eclipse auch angezeigt. Ganz unten main.java und darüber noch Core und GUI.

Wenn ich dass Programm starten will, taucht eine Meldung auf, ob ichs als Java Projekt oder Aplet starten will. Bei beiden gibt er einen Fehler aus „Selection does not compain a main type“

Kann man dass überhaupt mit Eclipse starten?!? Da gibs ja verschiedene Programme für, liegt es daran oder hat dass damit nichts zu tun?

P.S:Vielen Dank nochmal für die Hilfe, du hast mir sehr seeehr weiter geholfen

hoffe, ich kann sowas in naher zukunft auch selbst programmieren ^^

So ein alter Hase wie du Programmiert so’n poppel spiel bestimmt mal kurz in 5 Minuten in der Mittagspause wa

[L-ectron-X]

@cplusplus

Wenn ich dass Programm starten will, taucht eine Meldung auf, ob ichs als Java Projekt oder Aplet starten will. Bei beiden gibt er einen Fehler aus „Selection does not compain a main type“

Ich kann da jetzt nur Vermuten, weil ich nicht mit Eclipse arbeite, sondern mit NetBeans. Ich denke, dass du die falsche Klasse zum Starten angegeben hast.
Die Main-Class, also die Klasse, die das Programm in Gang setzt, ist die Bytecode-Datei Main.class im Package connect4.

@cplusplus;7668

Kann man dass überhaupt mit Eclipse starten?!? Da gibs ja verschiedene Programme für, liegt es daran oder hat dass damit nichts zu tun?

Hat damit nichts zu tun, weil das allgemein gültger Code ist. Es ist also ganz egal, üb du das Programm in NetBeans, Eclipse oder über die Console kompilierst und startest.

[cplusplus]

Ich habe mir den Code mal angeschaut und dass ein oder andere nachgeguckt, aber der Code, den du gepostet hast, ist mir einfach noch zu viel, da blick ich einfach nicht durch. Und der Testlink funktioniert bei mir nicht, dass App wird zwar geladen, aber danach wird bei mir nichts angezeigt.

Ich hab hier noch einen weiteren Quellcode von Andre Uhres, aber der will irgendwie auch nicht funktionieren, dass spielfeld erscheint zwar, und wenn ich im Feld klicke, notiert dass programm auch die Werte der x achse, zeichnet aber keine Bilder aufs spielfeld.

Weiss du vielleicht wo der Wurm liegt?

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.InvocationTargetException;
import java.net.*;
public class viergewinnt extends Applet implements MouseListener {
    private static final long serialVersionUID = 1L;
    private int feld[][] = {
    	{0, 1, 2, 0, 2, 0, 1},
        {0, 0, 0, 0, 1, 0, 0},
        {2, 4, 0, 0, 1, 0, 0},
        {0, 0, 0, 0, 1, 0, 0},
        {0, 0, 0, 0, 0, 0, 0},
        {1, 1, 2, 0, 0, 0, 1}
    };
    private Image rot;
    private Image blau;
    public void zeichneSpielfeld(Graphics g, int x, int y) {
        g.drawString("Vier Gewinnt", 260, 18);
        setSize(600, 600);
        g.drawRect(x, y, 420, 420);
        g.drawLine(x, y + 70, x + 420, y + 70);
        g.drawLine(x, y + 140, x + 420, y + 140);
        g.drawLine(x, y + 210, x + 420, y + 210);
        g.drawLine(x, y + 280, x + 420, y + 280);
        g.drawLine(x, y + 350, x + 420, y + 350);
        g.drawLine(x, y + 420, x + 420, y + 420);
        g.drawLine(x + 60, y, x + 60, y + 420);
        g.drawLine(x + 120, y, x + 120, y + 420);
        g.drawLine(x + 180, y, x + 180, y + 420);
        g.drawLine(x + 240, y, x + 240, y + 420);
        g.drawLine(x + 300, y, x + 300, y + 420);
        g.drawLine(x + 360, y, x + 360, y + 420);
    }
    @Override
    public void paint(Graphics g) {
        int xA = 85;
        int yA = 85;
        zeichneSpielfeld(g, xA, yA);
        for (int x = 0; x < 6; x++) {
            for (int y = 0; y < 5; y++) {
                int x1 = xA + 60 * x + 1;
                int y1 = yA + 70 * y + 1;
                int x2 = x1 + 60 - 1;
                int y2 = y1 + 70 - 1;
                if (feld[x][y] == 1) {
                    g.drawImage(rot, x1, y1, x2, y2,
                            0, 0, rot.getWidth(this), rot.getWidth(this), this);
                }
                if (feld[x][y] == 2) {
                    g.drawImage(blau, x1, y1, x2, y2,
                            0, 0, blau.getWidth(this), blau.getWidth(this), this);
                }
            }
        }
    }
    @Override
    public void init() {
        Runnable init = new Runnable() {
            public void run() {
                try {
                    rot = getImage(new URL("file:/sonne.jpg"));
                    blau = getImage(new URL("file:/mond.jpg"));
                } catch (MalformedURLException ex) {
                    ex.printStackTrace();
                }
                viergewinnt.this.addMouseListener(viergewinnt.this);
            }
        };
        try {
            EventQueue.invokeAndWait(init);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        } catch (InvocationTargetException ex) {
            ex.printStackTrace();
        }
    }
    public void mouseClicked(MouseEvent arg0) {
    }

    public void mousePressed(MouseEvent arg0) {
        int x = arg0.getX();
        System.out.println("x = " + x);
        if (x < 50) {
            feld[0][0] = 1;
        }
        if (x > 50 && x < 100) {
            feld[0][1] = 1;
        }
        if (x > 100 && x < 150) {
            feld[0][2] = 1;
        }
        repaint();
    }
    public void mouseReleased(MouseEvent arg0) {
    }
    public void mouseEntered(MouseEvent arg0) {
    }
    public void mouseExited(MouseEvent arg0) {
    }
}

Die Bilder habe ich vorsichtshalber in alle verzeichnisse kopiert, daran liegt es schonmal nicht ^^

[L-ectron-X]

@cplusplus

Und der Testlink funktioniert bei mir nicht, dass App wird zwar geladen, aber danach wird bei mir nichts angezeigt.

Hinter dem Link steht eine JNLP-Datei (Java Webstart), die sollte sich um Herunterladen, Updaten und Starten kümmern können. Hat bei mir auch funktioniert…

Ich hab das mit Java 1.6 kompiliert, möglicherweise hast du eine ältere JRE?
Wenn ja, kann ich das Programm gerne noch mal für eine ältere JRE erzeugen.

Warum du mit André’s Code Probleme hast, müsste ich mir erst mal ansehen.
Vielleicht schafft er es ja noch vor mir, das Problem zu finden.

[cplusplus]

ich benutze die neueste jre, daran liegt es nicht

[system]

ahh jetzt funktioniert es :o

vielen dank =)

[L-ectron-X]

Bleibt also noch das Problem, mit André’s Code?
Wenn du mit dem Code von mir nicht klar kommst, brauchst du sicher noch etwas Übung in Java - speziell Grundlagen, Objektorientierung, GUI-Programmierung und Kenntnis der API.

[system]

also wenn du eine läsung für den code kennst, wäre es sehr schön, wenn du dir dass anschauen könntest.

Ja ich brauche noch viel übung in java, aber dass problem ist, dass ich dieses Spiel in kürze fertig stellen muss

hast du auch eine idee, wie man das ermitteln des siegers programmiert? bei deinem code ist mir aufgefallen, dass das spiel im falle eines sieges nicht endet.

[L-ectron-X]

Das sind die Problemzeilen:

rot = getImage(new URL("file:/sonne.jpg"));
blau = getImage(new URL("file:/mond.jpg"));

Die URL kann nicht ausgewertet werden.
Arbeite hier mit geCodeBase(), oder getDocumentBase().

[system]

vielen dank nochmal für die hilfe, hat mich echt weitergebracht =)

eine Frage hätte ich noch, wie mache ich sogennante Mouseover effekte in java?

Also, damit meine ich z.b. wenn man mit dem mauszeiger in einer bestimmten position im Feld fährt, soll da ein paint grafik aufpopen und wenn die maus wieder aus diesem berreich wegfährt soll dass bild wieder verschwinden, aber nur wie mache ich dass?

[L-ectron-X]

@Unregistriert

hast du auch eine idee, wie man das ermitteln des siegers programmiert? bei deinem code ist mir aufgefallen, dass das spiel im falle eines sieges nicht endet.

Ich hab mir darüber noch keine Gedanken gemacht. Das wäre noch zu implementieren.

[QUOTE=Unregistriert;7829]Also, damit meine ich z.b. wenn man mit dem mauszeiger in einer bestimmten position im Feld fährt, soll da ein paint grafik aufpopen und wenn die maus wieder aus diesem berreich wegfährt soll dass bild wieder verschwinden[/QUOTE]Hast du mal ein Funktionsbeispiel dazu? Kann mir das jetzt nicht so richtig vorstellen, was genau du suchst.