Logo der Hochschule  
 aufwärts

Objektorientierte Programmierung

Stand der Entwicklung des Spiels "Vier gewinnt"

Im Folgenden sind die bisher gemeinsam entwickelten Klassen für unsere Implementierung des Spiels Vier gewinnt dokumentiert (Stand der Entwicklung: 10.05.2017).

Klasse Board

 

Board.java
import java.util.Observable;

// repräsentiert das Spielbrett (als Model im Model-View-Controller-Softwaremuster);
// das Model ist "Observable" - es wird vom View (dem "Observer") beobachtet;
// bei Änderungen wird mit notifyObservers die Methode update dsr Observers aufgerufen
public class Board extends Observable
{
    public static final int ROWS=6, COLS=7;
    public int[][] b;    // Belegung des Spielbretts (-1 = frei, 0 = rot, 1= gelb)
    public int[] h;      // Höhen der Säulen von Spielsteinen in den Spalten

    public Board()
    {
        b=new int[ROWS][COLS];
        h=new int[COLS];
    }

    // Factory-Methode: liefert ein leeres Spielbrett
    public static Board emptyBoard()
    {
        Board board=new Board();
        board.clear();
        return board;
    }

    // leert das Spielbrett
    public void clear()
    {
        for (int i=0; i<ROWS; i++)
            for (int j=0; j<COLS; j++)
                b[i][j]=-1;

        for (int j=0; j<COLS; j++)
            h[j]=0;
    }

    // liefert eine Kopie des Spielbretts
    public Board copy()
    {
        Board board=new Board();

        for (int i=0; i<ROWS; i++)
            for (int j=0; j<COLS; j++)
                board.b[i][j]=b[i][j];

        for (int j=0; j<COLS; j++)
            board.h[j]=h[j];

        return board;
    }

    // führt den Spielzug move auf dem Spielbrett aus
    public void applyMove(Move move)
    {
        int j=move.s;
        int i=h[j];
        if (i<ROWS)
        {
            b[ROWS-i-1][j]=move.c;
            h[j]++;
        }
        this.setChanged();
        this.notifyObservers();
    }

    @Override
    public String toString()
    {
        String s="";
        for (int i=0; i<ROWS; i++)
        {
            for (int j=0; j<COLS; j++)
                s+=b[i][j]+" ";
            s+="\n";
        }
        return s;
    }
}

Klasse Circle

 

Circle.java
import java.awt.Color;
import java.awt.Graphics;

// repräsentiert einen Kreis auf dem Bildschirm
// mit Koordinaten x und y sowie Durchmesser d
public class Circle
{
    // Attribute
    public int left, top, diameter;
    public Color fill=Color.WHITE;   // Initialisierung des Attributs fill

    // Konstruktor
    public Circle(int l, int t, int d)
    {
        left=l;
        top=t;
        diameter=d;
    }

    // Farbe festlegen
    public void setFill(Color f)
    {
        fill=f;
    }

    // liefert true, wenn die Klick-Koordinaten x und y innerhalb des
    // den Kreis umschließenden Quadrats liegen
    public boolean clicked(int x, int y)
    {
        return x>=left && x<=left+diameter && y>=top && y<=top+diameter;
    }

    // gefüllten Kreis zeichnen
    public void draw(Graphics gr)
    {
        gr.setColor(fill);
        gr.fillOval(left, top, diameter, diameter);
    }

}

Klasse CircleGrid

 

CircleGrid.java
import java.awt.Color;
import java.awt.Graphics;


// repräsentiert eine mxn-Matrix von Kreisen
public class CircleGrid
{
    public int m, n;
    public int left=40, top=20, diameter=40, space=10;
    public Circle[][] grid;

    // Konstruktor
    public CircleGrid(int m, int n)
    {
        this.m=m;
        this.n=n;
        grid=new Circle[m][n];
        for (int i=0; i<m; i++)
            for (int j=0; j<n; j++)
                grid[i][j]=new Circle(j*(space+diameter)+left, i*(space+diameter)+top, diameter);
    }

    // zeichnet das CircleGrid this
    public void draw(Graphics gr)
    {
        for (int i=0; i<m; i++)
            for (int j=0; j<n; j++)
                grid[i][j].draw(gr);
    }

    // liefert die Position (Zeile und Spalte) eines angeklickten Kreises
    // innerhalb des CircleGrids, bzw. null, wenn danebengeklickt wurde
    public Position clicked(int x, int y)
    {
        for (int i=0; i<m; i++)
            for (int j=0; j<n; j++)
                if (grid[i][j].clicked(x, y))
                        return new Position(i, j);
        return null;
    }

    // setzt die Füllfarbe des Kreises an Position (i, j) auf die Farbe f
    public void fill(int i, int j, Color f)
    {
        grid[i][j].setFill(f);
    }
    public void fill(Position p, Color f)
    {
        fill(p.z, p.s, f);
    }

    // überführt die datenmäßige Darstellung des Spielbretts (das Board)
    // in die Bildschirmdarstellung als CircleGrid
    public void display(Board board)
    {
        for (int i=0; i<m; i++)
            for (int j=0; j<n; j++)
                fill(i, j, color(board.b[i][j]));
    }

    // übersetzt 0, 1 und -1 in entsprechende Farben 
    private Color color(int i)
    {
        if (i==0)
            return Color.RED;
        if (i==1)
            return Color.YELLOW;
        return Color.WHITE;
    }

}

Klasse Move

 

Move.java
// repräsentiert einen Spielzug des Spiels "Vier gewinnt" durch
// Angabe der Spalte s, in die der Spielstein geworfen wird, und
// der Farbe c des Spielsteins
public class Move
{
    public int s;   // Spalte
    public int c;   // Farbe

    // Konstruktor
    public Move(int s, int c)
    {
        this.s=s;
        this.c=c;
    }

    @Override
    public String toString()
    {
        return s+" "+c;
    }

}

Klasse PaintPanel

 

PaintPanel.java
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JPanel;

// Zeichenfläche zur Darstellung des Spielbretts (der View),
// reagiert auf Mausklicks sowie als Observer auf Änderungen
// des Models (des Boards).
public class PaintPanel extends JPanel implements MouseListener, Observer
{
    // Attribute: View und Model
    private CircleGrid circlegrid;
    private Board board;

    // Konstruktor
    public PaintPanel()
    {
        board=Board.emptyBoard();
        circlegrid=new CircleGrid(Board.ROWS, Board.COLS);
        board.addObserver(this);    // als Observer beim Observable board anmelden
        addMouseListener(this);
    }

    @Override
    public void paint(Graphics gr)
    {
        super.paint(gr);
        circlegrid.draw(gr);
    }

    @Override
    public void mouseClicked(MouseEvent arg0)
    {
    }

    @Override
    public void mouseEntered(MouseEvent arg0)
    {
    }

    @Override
    public void mouseExited(MouseEvent arg0)
    {
    }

    // angeklickten Kreis ermitteln und Spielzug auf dem Board ausführen
    @Override
    public void mousePressed(MouseEvent evt)
    {
        int x=evt.getX();
        int y=evt.getY();
        Position p=circlegrid.clicked(x, y);
        if (p!=null)
            board.applyMove(new Move(p.s, 0));
    }

    @Override
    public void mouseReleased(MouseEvent arg0)
    {
    }

    // diese Methode wird immer dann automatisch ausgeführt,
    // wenn sich auf dem Board etwas geändert hat; dann
    // aktualisieren wir das CircleGrid entsprechend und
    // zeichnen es neu
    @Override
    public void update(Observable arg0, Object arg1)
    {
        circlegrid.display(board);
        repaint();
    }

}

Klasse Position

 

Position.java
// repräsentiert eine Position auf dem Spielbrett
// bestehend aus Zeilenindex z und Spaltenindex s
public class Position
{
    public int z, s;

    // Konstruktor
    public Position(int z, int s)
    {
        this.z=z;
        this.s=s;
    }

    @Override
    public String toString()
    {
        return z+" "+s;
    }
}

 

up

 

homeH.W. Lang   Hochschule Flensburg   lang@hs-flensburg.de   Impressum   ©  
Valid HTML 4.01 Transitional