Guten Tag,
nachdem ich nun ein Semester gar kein praktisches programmieren mehr hatte wollte ich mir nun
mal wieder was anschaun, merke aber das das gar nichts mehr wird und hoffe nun auf Hilfe von hier.
Ich hab mir eine Jawbreaker Übungsaufgabe rausgesucht, aber ich komme gar nich klar
was die Implementierung der Spiellogik angeht.
Ich weiß was zu tun ist, aber ich weiß einfach nicht wie ich es Implementier.
Hoffe ihr koennt mir weiter Helfen, jedoch nicht zu viel verraten, kleine Denkanstoesse wären am
besten
Klasse die auf meinen Mist gewachsen ist:
Ich bin hier total überfordert mit der Maustasten abfrage und dem Color package.
Sowie hab ich nicht wirklich Ahnung wie ich mit dem Array Arbeiten muss, da
die Oberfläche des spiels gegeben ist und ich nicht weiß wie ich genau
die Punkte einfärbe, wenn sie überhaupt schon existieren. Verwirrt mich etwas.
Folgende Klassen waren als Hilfe vorgegeben, jedoch verwirren sie mich mehr, da ich
keinen Überblick habe.
Statistic Klasse
Jawbreaker Klasse
Jawbreaker-Panel Klasse
Vielen Dank schonmal im Vorraus für euren Aufwand,
Liebe Grüße Latsch
nachdem ich nun ein Semester gar kein praktisches programmieren mehr hatte wollte ich mir nun
mal wieder was anschaun, merke aber das das gar nichts mehr wird und hoffe nun auf Hilfe von hier.
Ich hab mir eine Jawbreaker Übungsaufgabe rausgesucht, aber ich komme gar nich klar
was die Implementierung der Spiellogik angeht.
Ich weiß was zu tun ist, aber ich weiß einfach nicht wie ich es Implementier.
Hoffe ihr koennt mir weiter Helfen, jedoch nicht zu viel verraten, kleine Denkanstoesse wären am
besten
Klasse die auf meinen Mist gewachsen ist:
Java:
package de.logic;
import java.awt.Color;
public class JawbreakerGame {
int height;
int width;
public JawbreakerGame(int nWidth, int nHeight)
{
setHeight(nHeight);
setWidth(nWidth);
int[][] spielfeld = new int[width][height];
//Spielfeld mit Punkten fuellen die zufällige Farben haben
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
spielfeld[i][j] = color(random); //Farbe zuweisen?
}
}
}
public void setHeight(int nHeight)
{
this.height = nHeight;
}
public int getHeight()
{
return height;
}
public void setWidth(int nWidth)
{
this.width = nWidth;
}
public int getWidth()
{
return width;
}
public boolean isCellSelected(int x, int y)
{
if (/*Zelle ist selektiert*/)
return true;
else
return false;
}
public Color getCellColor(int x, int y)
{
return null;
}
public void click(int x, int y)
{
// Mausklick an der Stelle x,y
}
public boolean isGameOver()
{
if ( /* kein punkt hat einen nachbar -> Methode zum pruefen*/)
return true;
else
return false;
}
//Objektuebergabe an JawbreakerPanel Beispiel JawbreakerPanel Zeile 174
public Statistics getStatistics()
{
Statistics stc = new Statistics();
return stc;
}
}Ich bin hier total überfordert mit der Maustasten abfrage und dem Color package.
Sowie hab ich nicht wirklich Ahnung wie ich mit dem Array Arbeiten muss, da
die Oberfläche des spiels gegeben ist und ich nicht weiß wie ich genau
die Punkte einfärbe, wenn sie überhaupt schon existieren. Verwirrt mich etwas.
Folgende Klassen waren als Hilfe vorgegeben, jedoch verwirren sie mich mehr, da ich
keinen Überblick habe.
Statistic Klasse
Java:
/*
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Generation - Code and Comments
*/
package de.logic;
/**
*
*
*
* Statistiken aller Spiele.
*/
public class Statistics {
private int gamesPlayed = 0;
private int maxPoints = 0;
private int prevGamePoints = 0;
private int currentSelectionPoints = 0;
private int currentGamePoints = 0;
private int allPoints = 0;
/**
* Loescht die komplette Statistik.
*/
public void clear() {
gamesPlayed = 0;
maxPoints = 0;
prevGamePoints = 0;
currentSelectionPoints = 0;
currentGamePoints = 0;
allPoints = 0;
}
/**
* Liest die Anzahl gespielter Runden.
* @return Die Anzahl gespielter Runden.
*/
public int getGamesPlayed() {
return gamesPlayed;
}
/**
* Liest den hoechsten Spielstand aller Spiele.
* @return Der hoechste Spielstand.
*/
public int getHighscore() {
return maxPoints;
}
/**
* Liest den Spielstand des letzten Spiels.
* @return Spielstand des letzten Spiels.
*/
public int getScoreLastGame() {
return prevGamePoints;
}
/**
* Beendet ein Spiel. Der Spielstand des laufenden Spiels
* wird als Ergebnis uebernommen.
* Dabei wird der Highscore neu gesetzt, falls in der letzten
* Runde mehr Punkte als beim bisherigen Hoechststand erreicht
* wurden. Weiterhin wird die Anzahl der gespielten Spiele erhoeht.
*/
public void finishGame() {
this.prevGamePoints = currentGamePoints;
allPoints += currentGamePoints;
if (prevGamePoints > maxPoints) {
maxPoints = prevGamePoints;
}
gamesPlayed++;
currentGamePoints = 0;
}
/**
* Liest die Punkte der aktuell selektierten Zellen.
* @return Punkte der aktuell selektierten Zellen.
*/
public int getCurrentSelectionPoints() {
return currentSelectionPoints;
}
/**
* Schreibt die Punkte der aktuell selektierten Zellen.
* @param currentSelectionPoints Punkte fuer die aktuelle Selektion.
*/
public void setCurrentSelectionPoints(int currentSelectionPoints) {
this.currentSelectionPoints = currentSelectionPoints;
}
/**
* Ermittelt die Anzahl Punkte im jetzt laufenden Spiel.
* @return Anzahl Punkte im laufenden Spiel.
*/
public int getCurrentGamePoints() {
return currentGamePoints;
}
/**
* Addiert einen Wert zur Anzahl Punkte im laufenden Spiel.
* @param addGamePoints Anzahl zu addierender Punkte.
*/
public void addToCurrentGamePoints(int addGamePoints) {
this.currentGamePoints += addGamePoints;
}
/**
* Ermittelt den Mittelwert aller Punkte.
* @return Mittelwert.
*/
public int getAverage() {
return gamesPlayed > 0 ? allPoints / gamesPlayed : 0;
}
}Jawbreaker Klasse
Java:
package de.visual;
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import de.hska.faki.logic.JawbreakerGame;
/**
* Erzeugen des Spiels in einem Fenster.
*
*
*/
public class Jawbreaker extends JFrame {
/**
* Feldbreite in Zellen.
*/
private static final int WIDTH = 11;
/**
* Feldhoehe in Zellen.
*/
private static final int HEIGHT = 12;
/**
* Referenz auf die Spiellogik.
*/
private JawbreakerGame breakerGame;
/**
* Referenz auf das Panel, das die Ausgaben vornimmt.
*/
private JawbreakerPanel breakerPanel;
/**
* Erzeugt das komplette Spiel.
*/
public Jawbreaker() {
super("Jawbreaker");
breakerGame = new JawbreakerGame(WIDTH, HEIGHT);
breakerPanel = new JawbreakerPanel(breakerGame);
getContentPane().setLayout(new BorderLayout());
getContentPane().add(breakerPanel);
JLabel points = new JLabel("0");
breakerPanel.setScoreLabel(points);
points.setHorizontalAlignment(SwingConstants.RIGHT);
getContentPane().add(points, BorderLayout.SOUTH);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/**
* Die Methode wird beim Start des Programms aufgerufen.
* @param args Kommandozeilenparameter
*/
public static void main(String[] args) {
Jawbreaker breaker = new Jawbreaker();
breaker.pack();
breaker.setVisible(true);
}
}Jawbreaker-Panel Klasse
Java:
package de.visual;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashMap;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import de.logic.JawbreakerGame;
/**
* Visualisierung des Jawbreaker-Spiels.
*
*
*/
public class JawbreakerPanel extends JPanel implements MouseListener {
/**
* Referenz auf das Spiel des Benutzers.
*/
private JawbreakerGame breakerGame;
private JLabel scoreLabel;
private Point clickedCell = null;
private Font font = null;
/**
* Cache fuer die Farben und deren Abstufungen, um nicht permanent neue Farbobjekte
* mit brighter() und darker() zu erzeugen.
*/
private HashMap<Color, Color> selectedColors = new HashMap<Color, Color>();
private HashMap<Color, Color> darkerColors = new HashMap<Color, Color>();
private HashMap<Color, Color> brighterColors = new HashMap<Color, Color>();
/**
* Erzeugt ein neues Panel.
* Die Groesse des Panels berechnet sich aus der Anzahl
* der Zellen im Spiel sowie der Groesse der einzelnen Zellen.
*
* @param nBreakerGame Referenz auf das Spiel, das angezeigt werden soll.
*/
public JawbreakerPanel(JawbreakerGame nBreakerGame) {
breakerGame = nBreakerGame;
addMouseListener(this);
setPreferredSize(new Dimension(600, 605));
}
/**
* Neuzeichnen des Panel.
* Die Zeichenmethode wird intern vom Browser aufgerufen,
* wenn ein Neuzeichnen notwendig ist.
*
* @param gr Referenz auf den Grafikkontext.
*/
public void paintComponent(Graphics gr) {
Graphics2D graphics = (Graphics2D) gr;
boolean selection = false;
int cellSize = getCellSize();
// Hintergrund loeschen
graphics.setColor(Color.white);
graphics.fillRect(0, 0, getSize().width, getSize().height);
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
for (int x = 0; x < breakerGame.getWidth(); x++) {
for (int y = 0; y < breakerGame.getHeight(); y++) {
Color col = breakerGame.getCellColor(x, y);
if (col != null) {
if (breakerGame.isCellSelected(x, y)) {
Color selectedCellColor = selectedColors.get(col);
if (selectedCellColor == null) {
selectedCellColor = col.darker().darker().darker();
selectedColors.put(col, selectedCellColor);
}
col = selectedCellColor;
selection = true;
}
// Dunklere Farbe erzeugen bzw. lesen
Color darkerColor = darkerColors.get(col);
if (darkerColor == null) {
darkerColor = col.darker();
darkerColors.put(col, darkerColor);
}
// Hellere Farbe erzeugen bzw. lesen
Color brighterColor = brighterColors.get(col);
if (brighterColor == null) {
brighterColor = col.brighter();
brighterColors.put(col, brighterColor);
}
graphics.setPaint(new GradientPaint(2 + x * cellSize, 2 + y * cellSize, darkerColor,
2 + x * cellSize + cellSize - 2,
2 + y * cellSize + cellSize - 2, brighterColor));
graphics.fillOval(2 + x * cellSize,
2 + y * cellSize,
cellSize - 2, cellSize - 2);
graphics.setColor(darkerColor);
graphics.drawOval(2 + x * cellSize,
2 + y * cellSize,
cellSize - 2, cellSize - 2);
}
}
}
// Mindestens eine Zelle ist selektiert: Punkte anzeigen
if (selection) {
String selectedCellPoints = String.valueOf(breakerGame.getStatistics().getCurrentSelectionPoints());
graphics.setColor(Color.white);
if (font == null || font.getSize() != cellSize / 3) {
font = new Font(Font.SANS_SERIF, Font.BOLD, cellSize / 3);
}
graphics.setFont(font);
FontMetrics fm = graphics.getFontMetrics();
graphics.drawString(selectedCellPoints,
(int) (clickedCell.x * cellSize + (cellSize - fm.stringWidth(selectedCellPoints)) / 2),
(int) (clickedCell.y * cellSize + (cellSize - fm.getHeight())));
selection = false;
}
}
/**
* Ermittelt die Ausmasse einer Zelle.
* @return Die Ausmasse einer Zelle.
*/
private int getCellSize() {
int cellSize = Math.min(getSize().width / breakerGame.getWidth(),
getSize().height / breakerGame.getHeight());
return cellSize;
}
/**
* Mausklick: Bildschirmposition in Feldposition umrechnen.
* @param event Systemereignis
*/
public void mouseClicked(MouseEvent event) {
int cellSize = getCellSize();
int xField = event.getX() / cellSize;
int yField = event.getY() / cellSize;
// Click ausserhalb?
if ((xField >= breakerGame.getWidth()) || (yField >= breakerGame.getHeight())) {
return;
}
if (clickedCell == null) {
clickedCell = new Point(xField, yField);
}
else {
clickedCell.x = xField;
clickedCell.y = yField;
}
breakerGame.click(xField, yField);
// Aktuelle Punktezahl anzeigen
scoreLabel.setText(String.valueOf(breakerGame.getStatistics().getCurrentGamePoints()));
repaint();
if (breakerGame.isGameOver()) {
scoreLabel.setText(String.valueOf(breakerGame.getStatistics().getScoreLastGame()));
JOptionPane.showMessageDialog(null, "Game over!");
removeMouseListener(this);
}
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void setScoreLabel(JLabel points) {
scoreLabel = points;
}
}Vielen Dank schonmal im Vorraus für euren Aufwand,
Liebe Grüße Latsch
