Grafik-Programmierung

Transkript

1 Grafik-Programmierung In dieser Übung fahren wir mit den Grundlagen der Grafikprogrammierung aus Übung 6 fort und wenden dies auf Spiele an. Aufgabe 1: Zeichenbare Game-Objekte Zunächst definieren wir ein Interface PaintableGameObject mit der Methode paintcomponent. Unsere Spielobjekte (vom Typ GameObject) sollen dieses Interface implementieren und dadurch grafisch darstellbar sein. Die eigentliche Darstellung erfolgt jeweils spezifisch für jedes Spielobjekt. In unserem Spiel brauchen wir uns dann nicht mehr weiter darum zu kümmern, wie die Spielobjekte gezeichnet werden, da aufgrund der dynamischen Bindung jedes Objekt weiß, wie es sich selbst zeichnen soll. Wir erweitern danach das Interface GraphicsObject um dieses Interface, damit alle Spielobjekte gezeichnet werden können. Da durch diese Interfaces-Erweiterung die implementierenden Klassen abstrakt geworden sind, müssen wir noch die Methode paintcomponent jeweils spezifisch implementieren. Hinweis: Falls Sie Ihre Lösung von Übung 4 nicht vollständig realisiert haben, können Sie von der Webseite der Veranstaltung eine Beispielvorgabe der bereits in den Übungen realisierten Interfaces und Klassen herunterladen. a) Erstellen Sie ein Interface PaintableGameObject im Paket games.basic.gameobjects.interfaces. Diese soll die Methode public void paintcomponent(graphics g) bereitstellen. b) Leiten Sie das Interface games.basic.gameobjects.interfaces. GameObject (siehe Übung 4) neben SimpleGameObject auch von PaintableGameObject ab. c) Passen Sie dann die Klassen RectangularGameObject und CircularGameObject aus dem Paket games.basic.gameobjects entsprechend an, indem Sie dort jeweils die Methode paintcomponent implementieren. S. 1 / 14

2 Dabei soll die Farbe des Rechteckes bzw. Kreises jeweils per Attribut wählbar sein, ebenso ob die Figuren ausgefüllt sein sollen oder nicht. Hinweis: Zum Zeichnen eines ausgefüllten Rechteckes bzw. Kreises können Sie die Methoden fillrect(x, y, width, height) bzw. filloval(x, y, width, height) aus der Klasse java.awt.graphics verwenden (siehe während drawrect bzw. drawoval jeweils nur den Rahmen der Figuren zeichnet. Hinweis: Zum Festlegen der Strichdicke können Sie die Methode setstroke(new BasicStroke( <<Strichdicke>> ) aus der Klasse Graphics2D verwenden. d) Erstellen Sie eine (analog zu RectangularGameObject) eine von AbstractGameObject abgeleitete Klasse CrossGameObject, welche ein Kreuz (d.h. 2 Linien) darstellt. games.basic.gameobjects.interfaces.paintablegameobject.java: package games.basic.gameobjects.interfaces; import java.awt.graphics; public interface PaintableGameObject { public abstract void paintcomponent(graphics g); games.basic.gameobjects.interfaces.gameobject.java: package games.basic.gameobjects.interfaces; public interface GameObject extends SimpleGameObject, PaintableGameObject { public abstract boolean isleftof(gameobject other); public abstract boolean isrightof(gameobject other); public abstract boolean isaboveof(gameobject other); public abstract boolean isbelowof(gameobject other); public abstract boolean touches(gameobject other); S. 2 / 14

3 games.basic.gameobjects.rectangulargameobject.java: package games.basic.gameobjects; import java.awt.basicstroke; import java.awt.color; import java.awt.graphics; import java.awt.graphics2d; import java.awt.stroke; import games.basic.position.interfaces.positionable; public class RectangularGameObject extends AbstractGameObject { private int width; private int height; private Color color; boolean filled; final static float STROKE = 3.0f; // Strichdicke // Konstruktor public RectangularGameObject(Positionable pos, int width, int height, Color color, boolean filled) { super(pos); // Aufruf: AbstractGameObject(pos); this.width = width; this.height = height; this.color = color; this.filled = filled; public int getwidth() { return this.width; public int getheight() { return this.height; public void paintcomponent(graphics g) { Color oldcolor = g.getcolor(); // alte Farbeeinstellung sichern // Rechteck zeichnen g.setcolor(color); if (filled) { g.fillrect( getpos().getx(), getpos().gety(), width, height); else { Graphics2D g2d = (Graphics2D) g; Stroke oldstroke = g2d.getstroke(); // alte Strichdicke sichern g2d.setstroke( new BasicStroke(STROKE) ); g.drawrect( getpos().getx(), getpos().gety(), width, height); g2d.setstroke( oldstroke ); // Strichdicke wiederherstellen S. 3 / 14

4 g.setcolor(oldcolor); // Farbe wiederherstellen public String tostring() { // verwende tostring-methode aus Positionable return ("pos = " + this.getpos() + ", size = " + this.getwidth() + " x " + this.getheight()+ ")"); public boolean equals(object other) { if (other == null!(other instanceof RectangularGameObject)) return false; RectangularGameObject otherrect = (RectangularGameObject)other; Positionable thispos = this.getpos(); // Beachte: this.pos funktioniert nicht, da Attribut pos // in Oberklasse private ist! // --> getpos() funktioniert, egal ob // Attribut pos hier oder in Oberklasse // definiert ist Positionable otherpos = otherrect.getpos(); return // vergleiche aktuelle Position // verwende equals-methode von Positionable thispos.equals( otherpos ) // vergleiche Breite/Höhe && this.getwidth() == otherrect.getwidth() && this.getheight() == otherrect.getheight() && this.color == otherrect.color && this.filled == otherrect.filled; games.basic.gameobjects.circulargameobject.java: package games.basic.gameobjects; import java.awt.basicstroke; import java.awt.color; import java.awt.graphics; import java.awt.graphics2d; import java.awt.stroke; import games.basic.position.interfaces.positionable; public class CircularGameObject extends AbstractGameObject { private int radius; private Color color; private boolean filled; final static float STROKE = 3.0f; // Strichdicke // Konstruktor public CircularGameObject(Positionable pos, int radius, Color color, boolean filled) { super(pos); // Aufruf: AbstractGameObject(pos); S. 4 / 14

5 this.radius = radius; this.color = color; this.filled = filled; public int getwidth() { return 2 * this.radius; public int getheight() { return 2 * this.radius; public void paintcomponent(graphics g) { Color oldcolor = g.getcolor(); // alte Farbeeinstellung sichern // Kreis zeichnen g.setcolor(color); if (filled) { g.filloval( getpos().getx(), getpos().gety(), 2 * radius, 2 * radius); else { Graphics2D g2d = (Graphics2D) g; Stroke oldstroke = g2d.getstroke(); // alte Strichdicke sichern g2d.setstroke( new BasicStroke(STROKE) ); g.drawoval( getpos().getx(), getpos().gety(), 2 * radius, 2 * radius); g2d.setstroke( oldstroke ); // Strichdicke wiederherstellen g.setcolor(oldcolor); // Farbe wiederherstellen public String tostring() { // verwende tostring-methode aus Positionable return ("pos = " + this.getpos() + ", radius = " + this.radius + ")"); public boolean equals(object other) { if (other == null!(other instanceof CircularGameObject)) return false; CircularGameObject othercirc = (CircularGameObject)other; // Beachte: this.pos funktioniert nicht, da Attribut pos // in Oberklasse private ist! // --> getpos() funktioniert, egal ob // Attribut pos hier oder in Oberklasse // definiert ist Positionable thispos = this.getpos(); Positionable otherpos = othercirc.getpos(); S. 5 / 14

6 return // vergleiche aktuelle Position // verwende equals-methode von Positionable thispos.equals( otherpos ) // vergleiche Breite/Höhe && this.radius == othercirc.radius && this.color == othercirc.color && this.filled == othercirc.filled; games.basic.gameobjects.crossgameobject.java: package games.basic.gameobjects; import games.basic.position.interfaces.positionable; import java.awt.basicstroke; import java.awt.color; import java.awt.graphics; import java.awt.graphics2d; import java.awt.stroke; public class CrossGameObject extends AbstractGameObject { private int width; private int height; private Color color; boolean filled; final static float STROKE = 3.0f; // Strichdicke public CrossGameObject(Positionable pos, int width, int height, Color color, boolean filled) { super(pos); this.width = width; this.height = height; this.color = color; this.filled = filled; public int getwidth() { return this.width; public int getheight() { return this.height; public void paintcomponent(graphics g) { Color oldcolor = g.getcolor(); // alte Farbeeinstellung sichern // Kreuz zeichnen g.setcolor(color); if (filled) { S. 6 / 14

7 g.fillrect( getpos().getx(), getpos().gety(), width, height); else { Graphics2D g2d = (Graphics2D) g; Stroke oldstroke = g2d.getstroke(); // alte Strichdicke sichern g2d.setstroke( new BasicStroke(STROKE) ); g.drawline( getpos().getx(), getpos().gety(), getpos().getx() + getwidth(), getpos().gety() + getheight()); g.drawline( getpos().getx() + getwidth(), getpos().gety(), getpos().getx(), getpos().gety() + getheight()); g2d.setstroke( oldstroke ); // Strichdicke wiederherstellen g.setcolor(oldcolor); // Farbe wiederherstellen public String tostring() { return ("pos = (" + this.getpos().getx() + ", " + this.getpos().gety() + ", size = " + this.getwidth() + " x " + this.getheight()+ ")"); public boolean equals(object other) { if (other == null!(other instanceof CrossGameObject)) return false; CrossGameObject othercross = (CrossGameObject)other; Positionable thispos = this.getpos(); Positionable otherpos = othercross.getpos(); return (thispos.getx() == otherpos.getx()) && (thispos.gety() == otherpos.gety()) && this.getwidth() == othercross.getwidth() && this.getheight() == othercross.getheight() && this.color == othercross.color && this.filled == othercross.filled; Aufgabe 2: Grafik für Tic Tac Toe Tic Tac Toe (auch Drei gewinnt oder Kreis und Kreuz ) ist ein Spiel für zwei Personen. Dabei machen auf einem 3 3 Felder großen Spielfeld die beiden Spieler abwechselnd ihre Zeichen (ein Spieler Kreuze, der andere Kreise). Der Spieler, der als erstes drei seiner Zeichen in eine Reihe, Spalte oder eine der beiden Hauptdiagonalen setzen kann, gewinnt. [wikipedia] S. 7 / 14

8 Implementieren Sie die grafische Darstellung für das Spiel Tic Tac Toe. Dabei sollen geeignete Spielobjekte jeweils (rote) Kreuze sowie (blaue) Kreise zur Darstellung der Züge der beiden Gegner verwendet werden. a) Erstellen Sie eine von JPanel abgeleitete Klasse TicPanel im Paket games.examples.tictactoe. Übergeben Sie der Klasse eine Liste von darzustellenden Spielobjekten, d.h. von Objekten vom Typ games.basic.gameobjects.interfaces.gameobject. Hinweis: Für Listen bietet Java u.a. die generische Klasse ArrayList (java.util.arraylist<gameobject>, siehe Diese besitzt u.a. die folgenden für diese Aufgabe relevanten Funktionen: new ArrayList<GameObject>() erzeugt eine leere Liste von GameObject-Objekten. boolean add(gameobject elem) fügt ein Element zur Liste hinzu for (GameObject elem : liste) { iteriert über alle Elemente einer Liste von GameObject-Elementen. Weitere wichtige Methoden aus ArrayList sind u.a. GameObject get(int index) liest das Element an Position index aus int size() liefert die Anzahl der Elemente in der Liste boolean remove(gameobject elem) löscht das Element aus der Liste, sofern es enthalten ist. Überschreiben Sie dann die Methode public void paintcomponent(graphics g) und zeichne Sie dort zunächst die Trennlinen für das 3 x 3-Feld. Zeichnen Sie ferner in das übergebene Graphics-Objekt g alle darzustellenden S. 8 / 14

9 Spielobjekte (aus der ArrayList). b) Erzeugen Sie schließlich (in einer Klasse games.examples.tictactoe.tictactoe) ein JFrame-Fenster, fügen Sie ein Objekt der Klasse TicPanel zu diesem JFrame hinzu und zeigen Sie das Fenster auf dem Bildschirm an. c) Erzeugen Sie zum Testen eine Liste von Spielobjekten (Kreuze und Kreise), welche Sie sich auf dem Panel darstellen lassen. Hinweis: Zum Neuzeichnen des Fensters können Sie die Methode frame.repaint() aufrufen. TicTacToe main(string[] args) { Jframe frame = TicPanel panel = new TicPanel( objliste); TicPanel objliste : ArrayList<GameObject> +paintcomponent(graphics g) GameObject +paintcomponent(graphics g) AbstractGameObject -pos: Positionable CrossGameObject -width, height: int -color: java.awt.color +paintcomponent(graphics g) CircularGameObject -radius: int -color: java.awt.color -filled: boolean +paintcomponent(graphics g) d) Nicht ausgelastet? Lassen Sie beim Zeichnen der Kreise und Kreuze einen Abstand zum Rand des jeweiligen Feldes, d.h. zu den Rahmenlinien des 3x3-Feldes. S. 9 / 14

10 games.examples.tictactoe.cross.java: package games.examples.tictactoe; import java.awt.color; import games.basic.gameobjects.crossgameobject; import games.basic.position.interfaces.positionable; import games.basic.position.position; public class Cross extends CrossGameObject { public static final Color CROSS_COLOR = Color.red; private static final int GAP = TicTacToe.GAP; public Cross(int x, int y, int size) { super(new Position(x+GAP, y+gap), size - GAP*2, size - GAP*2, CROSS_COLOR, false); games.examples.tictactoe.dot.java: package games.examples.tictactoe; import games.basic.gameobjects.circulargameobject; import games.basic.position.interfaces.positionable; import games.basic.position.position; import java.awt.color; import java.awt.graphics; public class Dot extends CircularGameObject { public static final Color CIRC_COLOR = Color.blue; private static final int GAP = TicTacToe.GAP; public Dot(int x, int y, int size) { super(new Position(x+GAP, y+gap), size - GAP*2, CIRC_COLOR, false); games.examples.tictactoe.ticpanel.java: package games.examples.tictactoe; import java.util.arraylist; import javax.swing.jpanel; S. 10 / 14

11 import java.awt.color; import java.awt.graphics; import games.basic.gameobjects.interfaces.*; class TicPanel extends JPanel { private ArrayList<GameObject> components; private int componentsize; public TicPanel(int componentsize, ArrayList<GameObject> components) { this.componentsize = componentsize; this.components = components; public void paintcomponent(graphics g) { // Zeichne Trennlinien für 3x3-Feld g.setcolor(color.black); g.drawline(componentsize, 0, componentsize, componentsize * 3); g.drawline(componentsize * 2, 0, componentsize * 2, componentsize * 3); g.drawline(0, componentsize, componentsize * 3, componentsize); g.drawline(0, componentsize * 2, componentsize * 3, componentsize * 2); // Zeichne Komponenten for (GameObject component : components) { component.paintcomponent(g); // class TicPanel games.examples.tictactoe.tictactoe.java: package games.examples.tictactoe; import games.basic.gameobjects.interfaces.gameobject; import java.awt.color; import java.awt.graphics; import java.util.arraylist; import java.util.scanner; import javax.swing.jframe; import javax.swing.jpanel; public class TicTacToe { public static final int GAP = 5; private ArrayList<GameObject> components = new ArrayList<GameObject>(); private int componentsize = 60; private int xframesize = componentsize*3 + 10; S. 11 / 14

12 private int yframesize = componentsize*3 + 30; JFrame frame; public static void main(string[] args) { TicTacToe prog = new TicTacToe(); prog.run(); public void run() { frame = new JFrame("Tic Tac Toe"); frame.setdefaultcloseoperation(jframe.exit_on_close); TicPanel panel = new TicPanel(); frame.add( panel ); frame.setsize(xframesize, yframesize); frame.setvisible(true); play(); public void play() { Dot meinzug1 = new Dot(0, 0, componentsize); Cross gegnerzug1 = new Cross(componentSize, componentsize, componentsize); components.add(meinzug1); components.add(gegnerzug1); frame.repaint(); Dot meinzug2 = new Dot(0, componentsize*2, componentsize); Cross gegnerzug2 = new Cross(componentSize*2, componentsize*2, componentsize); components.add(meinzug2); components.add(gegnerzug2); frame.repaint(); Scanner scanner = new Scanner(System.in); System.out.print("x = "); int x = scanner.nextint(); System.out.print("y = "); int y = scanner.nextint(); Dot meinzug = new Dot(componentSize * x, componentsize * y, componentsize); components.add(meinzug); frame.repaint(); class TicPanel extends JPanel { public void paintcomponent(graphics g) { // Zeichne Trennlinien für 3x3-Feld g.setcolor(color.black); S. 12 / 14

13 g.drawline(componentsize, 0, componentsize, componentsize * 3); g.drawline(componentsize * 2, 0, componentsize * 2, componentsize * 3); g.drawline(0, componentsize, componentsize * 3, componentsize); g.drawline(0, componentsize * 2, componentsize * 3, componentsize * 2); // Zeichne Komponenten for (GameObject component : components) { component.paintcomponent(g); // inner class TicPanel Zusatz-Aufgabe 3: Spielsteuerung für Tic Tac Toe Erweitern Sie die Klasse TicTacToe um die Spielsteuerung für das Spiel TicTacToe. Dazu können Sie von Tastatur jeweils das Feld einlesen und abwechselnd (für jeden Spieler) Kreuze bzw. Punkte in dieses Feld setzen. Wer alle Felder einer Zeile, Spalte oder Diagonale besetzt hat, hat das Spiel gewonnen. S. 13 / 14

14 Zusatz-Aufgabe 4 (für Java-Experten): Java-Rätsel Was gibt das folgende Java-Programm aus und warum verhält es sich so seltsam? package click; public class CodeTalk { public void doit() { printmessage(); void printmessage() { System.out.println("Click"); package hack; import click.codetalk; public class TypeIt { private static class ClickIt extends CodeTalk { void printmessage() { System.out.println("Hack"); public static void main(string[] args) { ClickIt clickit = new ClickIt(); clickit.doit(); Ausgabe: Click Lösung: Die Methode printmessage ist nicht public, sondern (ohne expliziten Sichtbarkeitsmodifizierer) nur innerhalb des jeweiligen Paketes sichtbar. Die Klassen CodeTalk und dessen Unterklasse ClickIt (als innere Klasse von TypeIt) liegen jedoch in verschiedenen Paketen (click bzw. hack). Folglich ist die Methode printmessage in der Klasse ClickIt nicht überschrieben (da die geerbte Methode nicht sichtbar ist, handelt es sich hier aus Sicht des Aufrufers um eine neue Methode!). Die Methode doit verwendet deshalb die Methode printmessage aus CodeTalk (mit der Ausgabe Click ) und nicht die Methode aus der Unterklasse ClickIt (mit der Ausgabe Hack ). Ausgabe: Click (und nicht wie vielleicht vermutet Hack) S. 14 / 14