Compare commits

..

No commits in common. "main" and "devShowFieldNumbers" have entirely different histories.

31 changed files with 843 additions and 13583 deletions

Binary file not shown.

Binary file not shown.

View File

@ -1,5 +1,2 @@
JFileChoser in UI: (mit GPT) JFileChoser in UI: (mit GPT)
Prompt: "Wie kann ich in swing in java Files aus einem Explorer auswählen und speichern?". Prompt: "Wie kann ich in swing in java Files aus einem Explorer auswählen und speichern?".
JButton mit Text und Icon gleichzeitig belegen:
Pompt: "Kann ich einem button einen text und ein bild gleichzeigtig geben?".

View File

@ -1,32 +1,25 @@
package de.mannheim.th.chess; package de.mannheim.th.chess;
import java.io.IOException;
import de.mannheim.th.chess.ui.MainFrame; import de.mannheim.th.chess.ui.MainFrame;
import de.mannheim.th.chess.utl.OpeningRecognizer;
// import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
// import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
/** /**
* Eine einfache Schach App mithilfe von * Eine einfache Schach App mithilfe von {@linkplain https://github.com/bhlangonijr/chesslib} entwickelt.
* {@linkplain https://github.com/bhlangonijr/chesslib} entwickelt.
*
* @author Matias Mas Viehl, Dominik Stuck und Marius Guendel * @author Matias Mas Viehl, Dominik Stuck und Marius Guendel
* @version 0.0.1 * @version 0.0.1
*/ */
public class App { public class App {
// private static final Logger logger = LogManager.getLogger(App.class); private static final Logger logger = LogManager.getLogger(App.class);
/** private static MainFrame userinterface;
* Main-Methode. /**
* * Main-Methode.
* @param args * @param args
* @throws IOException */
*/ public static void main(String[] args) {
public static void main(String[] args) throws IOException { userinterface = new MainFrame();
OpeningRecognizer.loadOpenings(); }
new MainFrame();
}
} }

View File

@ -46,7 +46,6 @@ public class ButtonAufgebenListener extends JFrame implements ActionListener {
} }
this.sf.setBoardMode(BoardMode.finished); this.sf.setBoardMode(BoardMode.finished);
this.sf.enableControlPanelButtons();
sf.setButtonsActions(); sf.setButtonsActions();

View File

@ -14,43 +14,41 @@ import javax.swing.JOptionPane;
import de.mannheim.th.chess.ui.ModeSelectionFrame; import de.mannheim.th.chess.ui.ModeSelectionFrame;
public class ButtonFileLoaderListener implements ActionListener { public class ButtonFileLoaderListener implements ActionListener{
private ModeSelectionFrame msf;
public ButtonFileLoaderListener(ModeSelectionFrame msf) {
this.msf = msf;
}
private ModeSelectionFrame msf; @Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
JFileChooser dateiWaehler = new JFileChooser();
JFrame jfFile = new JFrame();
int auswahl = dateiWaehler.showOpenDialog(jfFile);
public ButtonFileLoaderListener(ModeSelectionFrame msf) { if (auswahl == JFileChooser.APPROVE_OPTION) {
this.msf = msf; File ausgewaehlteDatei = dateiWaehler.getSelectedFile();
JOptionPane.showMessageDialog(jfFile, "Gewählte Datei:\n" + ausgewaehlteDatei.getAbsolutePath());
} try {
BufferedReader br = new BufferedReader(new FileReader(ausgewaehlteDatei));
@Override
public void actionPerformed(ActionEvent e) { msf.setFen(br.readLine());
// TODO Auto-generated method stub
} catch (FileNotFoundException e1) {
JFileChooser dateiWaehler = new JFileChooser(); // TODO Auto-generated catch block
JFrame jfFile = new JFrame(); e1.printStackTrace();
int auswahl = dateiWaehler.showOpenDialog(jfFile); } catch (IOException e1) {
// TODO Auto-generated catch block
if (auswahl == JFileChooser.APPROVE_OPTION) { e1.printStackTrace();
File ausgewaehlteDatei = dateiWaehler.getSelectedFile(); }
JOptionPane.showMessageDialog(jfFile, "Gewählte Datei:\n" + ausgewaehlteDatei.getAbsolutePath()); }
try { }
BufferedReader br = new BufferedReader(new FileReader(ausgewaehlteDatei));
msf.setFen(br.readLine());
br.close();
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
} }

View File

@ -6,6 +6,7 @@ import java.io.BufferedWriter;
import java.io.File; import java.io.File;
import java.io.FileWriter; import java.io.FileWriter;
import java.io.IOException; import java.io.IOException;
import java.util.List;
import javax.swing.JFileChooser; import javax.swing.JFileChooser;
import javax.swing.JFrame; import javax.swing.JFrame;
@ -13,46 +14,48 @@ import javax.swing.JFrame;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import com.github.bhlangonijr.chesslib.move.Move;
import de.mannheim.th.chess.App; import de.mannheim.th.chess.App;
import de.mannheim.th.chess.domain.Game; import de.mannheim.th.chess.domain.Game;
public class ButtonFileSaverListener implements ActionListener { public class ButtonFileSaverListener implements ActionListener{
private static final Logger logger = LogManager.getLogger(App.class);
private Game g;
private JFrame sf;
public ButtonFileSaverListener(JFrame sf, Game g) {
this.sf = sf;
this.g = g;
}
private static final Logger logger = LogManager.getLogger(App.class); @Override
public void actionPerformed(ActionEvent e) {
logger.info("Spiel wird gespeichert.");
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File(System.getProperty("user.home") + "/Documents"));
chooser.setDialogTitle("Datei speichern");
int userSelection = chooser.showSaveDialog(sf);
private Game g; if (userSelection == JFileChooser.APPROVE_OPTION) {
private JFrame sf; File fileToSave = chooser.getSelectedFile();
public ButtonFileSaverListener(JFrame sf, Game g) { try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileToSave))) {
this.sf = sf;
this.g = g; writer.write(g.getFen());
}
logger.info(g.getFen());
@Override } catch (IOException e1) {
public void actionPerformed(ActionEvent e) { e1.printStackTrace();
}
logger.info("Spiel wird gespeichert."); } else {
logger.info("Speichern fehlgeschlagen.");
JFileChooser chooser = new JFileChooser(); }
chooser.setCurrentDirectory(new File(System.getProperty("user.home") + "/Documents")); }
chooser.setDialogTitle("Datei speichern");
int userSelection = chooser.showSaveDialog(sf);
if (userSelection == JFileChooser.APPROVE_OPTION) {
File fileToSave = chooser.getSelectedFile();
try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileToSave))) {
writer.write(g.getFen());
logger.info(g.getFen());
} catch (IOException e1) {
e1.printStackTrace();
}
} else {
logger.info("Speichern fehlgeschlagen.");
}
}
} }

View File

@ -27,33 +27,31 @@ public class ButtonMovePieceListener implements ActionListener {
else else
this.game.playMove(this.mv); this.game.playMove(this.mv);
this.game.setViewPointer(this.game.getMoveList().size() - 1);
if (this.game.isDraw()) { if (this.game.isDraw()) {
this.game.stopClock(); this.game.stopClock();
this.sf.setBoardMode(BoardMode.finished);
this.sf.enableControlPanelButtons();
this.sf.showResult("Unentschieden!"); this.sf.showResult("Unentschieden!");
this.sf.setBoardMode(BoardMode.gameEnd);
} else if (this.game.isMate()) { } else if (this.game.isMate()) {
this.game.stopClock(); this.game.stopClock();
this.sf.setBoardMode(BoardMode.finished); this.sf.showResult("Spieler "+game.getActivePlayer()+" hat gewonnen!");
this.sf.enableControlPanelButtons();
this.sf.showResult("Spieler " + game.getActivePlayer() + " hat gewonnen!");
} else { this.sf.setBoardMode(BoardMode.gameEnd);
this.sf.setBoardMode(BoardMode.normal);
if (game.getLastMove() != null) {
sf.aktualisiereAusgabe();
}
} }
this.sf.setBoardMode(BoardMode.normal);
this.sf.setCursor(null); this.sf.setCursor(null);
// hier rotieren markieren //hier rotieren markieren
if (game.isRotieren()) if(game.isRotieren())sf.setWechsel(!sf.isWechsel());
sf.setWechsel(!sf.isWechsel());
this.sf.erstelleBrett(); this.sf.erstelleBrett();
if (game.getLastMove() != null) {
sf.aktualisiereAusgabe();
}
} }
} }

View File

@ -3,6 +3,7 @@ package de.mannheim.th.chess.controller;
import java.awt.event.ActionEvent; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame; import de.mannheim.th.chess.ui.SpielFrame;
import de.mannheim.th.chess.ui.SpielFrame.BoardMode; import de.mannheim.th.chess.ui.SpielFrame.BoardMode;
@ -19,7 +20,7 @@ public class ButtonToNormalListener implements ActionListener {
this.sf.setSelectedSquare(null); this.sf.setSelectedSquare(null);
this.sf.setCursor(null); this.sf.setCursor(null);
this.sf.erstelleBrett(); this.sf.erstelleBrett();
} }
} }

View File

@ -1,24 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import de.mannheim.th.chess.ui.SpielFrame;
import de.mannheim.th.chess.domain.Game;
public abstract class BaseButtonViewListener {
protected SpielFrame sf;
protected Game game;
public BaseButtonViewListener(Game game, SpielFrame sf) {
this.sf = sf;
this.game = game;
}
/**
* Loads the gamestate and renders the board
*/
protected void updateView() {
this.game.loadView();
this.sf.setDefaultButtons();
this.sf.applyBoardButtons();
this.sf.ladeBrett();
}
}

View File

@ -1,24 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame;
public class ButtonQuickloadListener implements ActionListener {
private Game game;
private SpielFrame sf;
public ButtonQuickloadListener(Game game, SpielFrame sf) {
this.game = game;
this.sf = sf;
}
@Override
public void actionPerformed(ActionEvent e) {
this.game.quickload();
this.sf.erstelleBrett();
this.sf.aktualisiereAusgabe();
}
}

View File

@ -1,19 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
public class ButtonQuicksaveListener implements ActionListener {
private Game game;
public ButtonQuicksaveListener(Game game) {
this.game = game;
}
@Override
public void actionPerformed(ActionEvent e) {
this.game.quicksave();
}
}

View File

@ -1,24 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame;
public class ButtonViewBackListener extends BaseButtonViewListener implements ActionListener {
public ButtonViewBackListener(Game game, SpielFrame sf) {
super(game, sf);
}
@Override
public void actionPerformed(ActionEvent e) {
if (this.game.getViewPointer() > 0) {
this.game.setViewPointer(this.game.getViewPointer() - 1);
updateView();
}
}
}

View File

@ -1,21 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame;
public class ButtonViewFirstListener extends BaseButtonViewListener implements ActionListener {
public ButtonViewFirstListener(Game game, SpielFrame sf) {
super(game, sf);
}
@Override
public void actionPerformed(ActionEvent e) {
this.game.setViewPointer(0);
updateView();
}
}

View File

@ -1,24 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame;
public class ButtonViewForwardListener extends BaseButtonViewListener implements ActionListener {
public ButtonViewForwardListener(Game game, SpielFrame sf) {
super(game, sf);
}
@Override
public void actionPerformed(ActionEvent e) {
if (this.game.getMoveList().size() > this.game.getViewPointer()) {
this.game.setViewPointer(this.game.getViewPointer() + 1);
updateView();
}
}
}

View File

@ -1,22 +0,0 @@
package de.mannheim.th.chess.controller.controlPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.ui.SpielFrame;
public class ButtonViewLastListener extends BaseButtonViewListener implements ActionListener {
public ButtonViewLastListener(Game game, SpielFrame sf) {
super(game, sf);
}
@Override
public void actionPerformed(ActionEvent e) {
this.game.setViewPointer(this.game.getMoveList().size());
updateView();
}
}

View File

@ -1,6 +1,5 @@
package de.mannheim.th.chess.domain; package de.mannheim.th.chess.domain;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -16,6 +15,7 @@ import com.github.bhlangonijr.chesslib.move.Move;
import com.github.bhlangonijr.chesslib.move.MoveList; import com.github.bhlangonijr.chesslib.move.MoveList;
import de.mannheim.th.chess.App; import de.mannheim.th.chess.App;
import de.mannheim.th.chess.ui.SpielFrame;
import de.mannheim.th.chess.utl.Clock; import de.mannheim.th.chess.utl.Clock;
/** /**
@ -28,31 +28,25 @@ public class Game {
private Board board; private Board board;
private Clock clock; private Clock clock;
private SpielFrame sp;
private String modus;
private boolean rotieren, zuruecknahme; private boolean rotieren, zuruecknahme;
ArrayList<Piece> removedPieces;
private MoveList movelist; private MoveList movelist;
private int viewPointer;
private MoveList savestate;
private String startPosFen;
/**
* Conststructs a new standard GameBoard.
*/
public Game() { public Game() {
this.board = new Board(); this.board = new Board();
this.movelist = new MoveList(); this.movelist = new MoveList();
this.startPosFen = this.board.getFen();
removedPieces = new ArrayList<>();
clock = new Clock("blitz"); clock = new Clock("blitz");
clock.start(); clock.start();
} }
/**
* Conststructs a new standard GameBoard.
*/
public Game(String modus, boolean rotieren, boolean zuruecknahme, String fen) { public Game(String modus, boolean rotieren, boolean zuruecknahme, String fen) {
this.modus = modus;
this.rotieren = rotieren; this.rotieren = rotieren;
this.zuruecknahme = zuruecknahme; this.zuruecknahme = zuruecknahme;
@ -63,11 +57,12 @@ public class Game {
this.board.loadFromFen(fen); this.board.loadFromFen(fen);
this.startPosFen = this.board.getFen();
this.movelist = new MoveList(); this.movelist = new MoveList();
clock = new Clock(modus); clock = new Clock(modus);
removedPieces = new ArrayList<>();
sp = new SpielFrame(this);
} }
/** /**
@ -78,14 +73,14 @@ public class Game {
public Game(MoveList movelist) { public Game(MoveList movelist) {
this.board = new Board(); this.board = new Board();
this.startPosFen = this.board.getFen();
this.movelist = movelist; this.movelist = movelist;
for (Move move : movelist) { for (Move move : movelist) {
this.board.doMove(move); this.board.doMove(move);
} }
this.clock = new Clock("blitz"); // this.clockPlayer1 = new Clock();
// this.clockPlayer2 = new Clock();
} }
/** /**
@ -98,7 +93,10 @@ public class Game {
this.board.loadFromFen(fen); this.board.loadFromFen(fen);
this.movelist = new MoveList(); this.movelist = new MoveList();
this.startPosFen = this.board.getFen(); // this.sp = new SpielFrame();
// this.clockPlayer1 = new Clock();
// this.clockPlayer2 = new Clock();
} }
/** /**
@ -107,14 +105,6 @@ public class Game {
* @param move the move to be played * @param move the move to be played
*/ */
public void playMove(Move move) { public void playMove(Move move) {
Piece removedPiece = board.getPiece(move.getTo());
if (removedPiece != Piece.NONE) {
int removedPiecesCount = removedPieces.size();
removedPieces.add(removedPiece);
if (removedPiecesCount + 1 < removedPieces.size()) {
removedPieces.removeLast();
}
}
this.board.doMove(move); this.board.doMove(move);
this.movelist.add(move); this.movelist.add(move);
clock.pressClock(); clock.pressClock();
@ -129,115 +119,22 @@ public class Game {
public void undo() { public void undo() {
this.board.undoMove(); this.board.undoMove();
Move lastMove = this.movelist.removeLast(); this.movelist.removeLast();
Piece removedPiece = board.getPiece(lastMove.getTo());
if (removedPiece != Piece.NONE) {
removedPieces.remove(removedPiece);
}
}
/**
* Copies the current move list to the savestate
*/
public void quicksave() {
// TODO: save the current clocktime
this.savestate = new MoveList(this.movelist);
logger.info("Quicksaved...");
}
/**
* Loads the save state
*
* @brief creates a new board with the startPosFen and then plays all the moves
* from the savestate
*/
public void quickload() {
if (this.savestate != null) {
this.board = new Board();
this.movelist.clear();
this.board.loadFromFen(startPosFen);
for (Move move : savestate) {
this.playMove(move);
}
logger.info("Quickloaded...");
}
} }
/** /**
* Plays the move on the board and adds it to the movelist * Plays the move on the board and adds it to the movelist
* *
* @param origin The square from which it moves from. * @param origin The square from wich it moves from.
* @param desination The square where it will move to. * @param desination The square where it will move to.
*/ */
public void playMove(Square origin, Square desination) { public void playMove(Square origin, Square desination) {
Move move = new Move(origin, desination); Move move = new Move(origin, desination);
Piece removedPiece = board.getPiece(desination);
if (removedPiece != Piece.NONE) {
int removedPiecesCount = removedPieces.size();
removedPieces.add(removedPiece);
if (removedPieces.size() > removedPiecesCount + 1) {
removedPieces.removeLast();
}
}
this.board.doMove(move); this.board.doMove(move);
this.movelist.add(move); this.movelist.add(move);
clock.pressClock();
} }
public void doPromotionMove(int piece, Square origin, Square destination) {
System.out.println(piece);
Piece promotedTo;
switch (piece) {
case 7:
promotedTo = Piece.BLACK_KNIGHT;
break;
case 4:
promotedTo = Piece.BLACK_QUEEN;
break;
case 5:
promotedTo = Piece.BLACK_ROOK;
break;
case 6:
promotedTo = Piece.BLACK_BISHOP;
break;
case 3:
promotedTo = Piece.WHITE_KNIGHT;
break;
case 0:
promotedTo = Piece.WHITE_QUEEN;
break;
case 1:
promotedTo = Piece.WHITE_ROOK;
break;
case 2:
promotedTo = Piece.WHITE_BISHOP;
break;
default:
promotedTo = Piece.WHITE_QUEEN;
}
Move promotionMove = new Move(origin, destination, promotedTo);
playMove(promotionMove);
}
/**
* Loads the current view
*
* @brief Creates a new gameboard from the start pos and playes moves until it
* reaches the viewPointer
*/
public void loadView() {
this.board = new Board();
this.board.loadFromFen(this.startPosFen);
for (int i = 0; i < this.viewPointer; i++) {
this.board.doMove(this.movelist.get(i));
}
}
public boolean isMate() { public boolean isMate() {
return board.isMated(); return board.isMated();
} }
@ -297,6 +194,45 @@ public class Game {
.collect(Collectors.toList()); .collect(Collectors.toList());
} }
public void doPromotionMove(int piece, Square origin, Square destination) {
System.out.println(piece);
Piece promotedTo;
switch (piece) {
case 7:
promotedTo = Piece.BLACK_KNIGHT;
break;
case 4:
promotedTo = Piece.BLACK_QUEEN;
break;
case 5:
promotedTo = Piece.BLACK_ROOK;
break;
case 6:
promotedTo = Piece.BLACK_BISHOP;
break;
case 3:
promotedTo = Piece.WHITE_KNIGHT;
break;
case 0:
promotedTo = Piece.WHITE_QUEEN;
break;
case 1:
promotedTo = Piece.WHITE_ROOK;
break;
case 2:
promotedTo = Piece.WHITE_BISHOP;
break;
default:
promotedTo = Piece.WHITE_QUEEN;
}
Move promotionMove = new Move(origin, destination, promotedTo);
playMove(promotionMove);
}
public void setModus(String modus) {
this.modus = modus;
}
public Clock getClock() { public Clock getClock() {
return this.clock; return this.clock;
} }
@ -326,6 +262,7 @@ public class Game {
} }
public Board getBoard() { public Board getBoard() {
// TODO Auto-generated method stub
return this.board; return this.board;
} }
@ -334,24 +271,16 @@ public class Game {
return board.getFen(); return board.getFen();
} }
// public Square getSelectedSquare() {
// return this.getSelectedSquare();
// }
public String getUnicodeFromMove(Move move) { public String getUnicodeFromMove(Move move) {
return board.getPiece(move.getTo()).getFanSymbol().toUpperCase(); return board.getPiece(move.getTo()).getFanSymbol().toUpperCase();
} }
public void setViewPointer(int i) {
this.viewPointer = i;
}
public int getViewPointer() {
return this.viewPointer;
}
public ArrayList<Piece> getRemovedPieces() {
return removedPieces;
}
public boolean isRotieren() { public boolean isRotieren() {
return rotieren; return rotieren;
} }
} }

View File

@ -0,0 +1,8 @@
package de.mannheim.th.chess.domain;
/**
* Ueberprueft, ob ein Zug gueltig ist.
*/
public class MoveChecker{
}

View File

@ -0,0 +1,8 @@
package de.mannheim.th.chess.domain;
/**
* Liest einen Zug ein.
*/
public class MoveReader{
}

View File

@ -0,0 +1,11 @@
package de.mannheim.th.chess.model;
/**
* Speichert Spielstaende, bisher gespielte Spiele und weiteres in einem File.
*/
public class Database{
public Database() {
}
}

View File

@ -0,0 +1,11 @@
package de.mannheim.th.chess.ui;
import de.mannheim.th.chess.model.Database;
/**
* ???
*/
public class Creator{
private Database database = new Database();
}

View File

@ -0,0 +1,16 @@
package de.mannheim.th.chess.ui;
import de.mannheim.th.chess.domain.Game;
/**
* Zeigt das Spielbrett mit den Stats rechts daneben an.
*/
public class GameWindow{
//private Game gamelogic = new Game();
public GameWindow() {
}
}

View File

@ -4,158 +4,105 @@ import javax.swing.JFrame;
import javax.swing.JPanel; import javax.swing.JPanel;
import javax.swing.border.EmptyBorder; import javax.swing.border.EmptyBorder;
// import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
// import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
// import de.mannheim.th.chess.App; import de.mannheim.th.chess.App;
import de.mannheim.th.chess.domain.Game;
import javax.swing.JLabel; import javax.swing.JLabel;
import java.awt.event.ActionEvent; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; import java.awt.event.ActionListener;
import java.io.IOException;
import javax.swing.Box; import javax.swing.Box;
import javax.swing.BoxLayout; import javax.swing.BoxLayout;
import javax.swing.JButton; import javax.swing.JButton;
import java.awt.Component;
import java.awt.Font; import java.awt.Font;
import java.awt.Color; import java.awt.Color;
public class MainFrame extends JFrame { public class MainFrame extends JFrame {
private static final Logger logger = LogManager.getLogger(App.class);
// private static final Logger logger = LogManager.getLogger(App.class); private static final long serialVersionUID = 1L;
private JPanel contentPane;
private static final long serialVersionUID = 1L; /**
private JPanel contentPane; * Create the frame.
private Game game; */
public MainFrame() {
/** setBackground(Color.LIGHT_GRAY);
* Create the frame. setResizable(true);
* @throws IOException setAlwaysOnTop(true);
*/ setTitle("Schach");
public MainFrame() { setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 500, 500);
setBackground(Color.LIGHT_GRAY); contentPane = new JPanel();
setResizable(true); contentPane.setBackground(new Color(90, 90, 90));
setAlwaysOnTop(true); contentPane.setForeground(Color.BLACK);
setTitle("Schach"); contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setDefaultCloseOperation(EXIT_ON_CLOSE);
setBounds(100, 100, 500, 500);
contentPane = new JPanel(); setContentPane(contentPane);
contentPane.setBackground(new Color(90, 90, 90));
contentPane.setForeground(Color.BLACK);
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane); contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS)); contentPane.add(Box.createVerticalStrut(10));
contentPane.add(Box.createVerticalStrut(10)); JLabel lblNewLabel = new JLabel("Schach");
lblNewLabel.setForeground(Color.BLACK);
lblNewLabel.setFont(new Font("Serif", Font.BOLD, 60));
lblNewLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(lblNewLabel);
JLabel lblNewLabel = new JLabel("Schach"); contentPane.add(Box.createVerticalStrut(10));
lblNewLabel.setForeground(Color.BLACK);
lblNewLabel.setFont(new Font("Serif", Font.BOLD, 60));
lblNewLabel.setAlignmentX(CENTER_ALIGNMENT);
contentPane.add(lblNewLabel);
contentPane.add(Box.createVerticalStrut(10)); JLabel lblNewLabel_1 = new JLabel("by Dominik, Marius und Matias");
lblNewLabel_1.setFont(new Font("Calibri", Font.ITALIC, 24));
lblNewLabel_1.setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(lblNewLabel_1);
JLabel lblNewLabel_1 = new JLabel("by Dominik, Marius und Matias"); contentPane.add(Box.createVerticalStrut(75));
lblNewLabel_1.setFont(new Font("Calibri", Font.ITALIC, 24));
lblNewLabel_1.setAlignmentX(CENTER_ALIGNMENT);
contentPane.add(lblNewLabel_1);
contentPane.add(Box.createVerticalStrut(75)); JButton btnNewButton = new JButton("Neues Spiel starten");
btnNewButton.setBackground(Color.LIGHT_GRAY);
btnNewButton.setForeground(Color.BLACK);
btnNewButton.setFont(new Font("Tahoma", Font.BOLD, 16));
btnNewButton.setAlignmentX(Component.CENTER_ALIGNMENT);
btnNewButton.addActionListener(new ActionListener() {
JButton btnNewButton = new JButton("Neues Spiel starten"); @Override
public void actionPerformed(ActionEvent e) {
btnNewButton.setBackground(Color.LIGHT_GRAY); ModeSelectionFrame ms = new ModeSelectionFrame();
btnNewButton.setForeground(Color.BLACK);
btnNewButton.setFont(new Font("Tahoma", Font.BOLD, 16));
btnNewButton.setAlignmentX(CENTER_ALIGNMENT);
btnNewButton.addActionListener(new ActionListener() {
@Override }
public void actionPerformed(ActionEvent e) {
openSelectModeFrame();
}
}); });
contentPane.add(btnNewButton); contentPane.add(btnNewButton);
contentPane.add(Box.createVerticalStrut(15)); contentPane.add(Box.createVerticalStrut(15));
JButton pgnLoaderButton = new JButton("Lade aus PGN Datei"); JButton btnNewButton_2 = new JButton("App beenden");
pgnLoaderButton.setBackground(Color.LIGHT_GRAY);
pgnLoaderButton.setForeground(Color.BLACK); btnNewButton_2.setBackground(Color.LIGHT_GRAY);
pgnLoaderButton.setFont(new Font("Tahoma", Font.BOLD, 16)); btnNewButton_2.setForeground(Color.BLACK);
pgnLoaderButton.setAlignmentX(CENTER_ALIGNMENT); btnNewButton_2.setFont(new Font("Tahoma", Font.BOLD, 16));
pgnLoaderButton.addActionListener(e -> openPgnSelectFrame()); btnNewButton_2.setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(pgnLoaderButton); btnNewButton_2.addActionListener(new ActionListener() {
contentPane.add(Box.createVerticalStrut(15)); @Override
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
JButton btnNewButton_2 = new JButton("App beenden"); });
btnNewButton_2.setBackground(Color.LIGHT_GRAY); contentPane.add(btnNewButton_2);
btnNewButton_2.setForeground(Color.BLACK); setVisible(true);
btnNewButton_2.setFont(new Font("Tahoma", Font.BOLD, 16)); }
btnNewButton_2.setAlignmentX(CENTER_ALIGNMENT);
btnNewButton_2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
contentPane.add(btnNewButton_2);
setVisible(true);
}
/**
* Starts the spielframe and game in playmode
* @throws IOException
*/
public void startGame() {
if (this.game != null) {
//this.game.stopClock();
new SpielFrame(this.game);
}
}
/**
* Starts the spielframe and game in view mode
*/
public void startView() {
if (this.game != null) {
this.game.stopClock();
SpielFrame sf = new SpielFrame(this.game);
sf.setMode(SpielFrame.BoardMode.finished);
sf.enableControlPanelButtons();
}
}
public void setGame(Game game) {
this.game = game;
}
/**
* opens the selectmodeframe
*/
private void openSelectModeFrame() {
new ModeSelectionFrame(this);
}
/**
* Opens the pgnselectorframe
*/
private void openPgnSelectFrame() {
new PGNLoaderFrame(this);
}
} }

View File

@ -3,130 +3,135 @@ package de.mannheim.th.chess.ui;
import java.awt.*; import java.awt.*;
import java.awt.event.ActionEvent; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.*; import javax.swing.*;
import javax.swing.border.EmptyBorder; import javax.swing.border.EmptyBorder;
// import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
// import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
// import de.mannheim.th.chess.App; import de.mannheim.th.chess.App;
import de.mannheim.th.chess.controller.ButtonFileLoaderListener; import de.mannheim.th.chess.controller.ButtonFileLoaderListener;
import de.mannheim.th.chess.domain.Game; import de.mannheim.th.chess.domain.Game;
public class ModeSelectionFrame extends JFrame { public class ModeSelectionFrame extends JFrame {
private static final Logger logger = LogManager.getLogger(App.class);
// private static final Logger logger = LogManager.getLogger(App.class); private static final long serialVersionUID = 1L;
private final JPanel contentPane;
private final ArrayList<Game> spiele = new ArrayList<>();
private String fen;
private static final long serialVersionUID = 1L; public ModeSelectionFrame() {
private final JPanel contentPane; // Frame-Eigenschaften
private String fen; setTitle("Modusauswahl");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setBounds(100, 100, 500, 500);
setResizable(true);
setAlwaysOnTop(true);
public ModeSelectionFrame(MainFrame mf) { // Panel konfigurieren
// Frame-Eigenschaften contentPane = new JPanel();
setTitle("Modusauswahl"); contentPane.setBackground(new Color(90, 90, 90));
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); contentPane.setBorder(new EmptyBorder(20, 20, 20, 20));
setBounds(100, 100, 600, 600); contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
setResizable(true); setContentPane(contentPane);
setAlwaysOnTop(true);
// Panel konfigurieren // Überschrift
contentPane = new JPanel(); JLabel jl = new JLabel("Welchen Modus wollen Sie spielen?");
contentPane.setBackground(new Color(90, 90, 90)); jl.setFont(new Font("Calibri", Font.BOLD, 20));
contentPane.setBorder(new EmptyBorder(20, 20, 20, 20)); jl.setForeground(Color.BLACK);
contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS)); jl.setAlignmentX(Component.CENTER_ALIGNMENT);
setContentPane(contentPane); contentPane.add(jl);
contentPane.add(Box.createVerticalStrut(15));
// Überschrift // Modusauswahl
JLabel jl = new JLabel("Welchen Modus wollen Sie spielen?"); String[] modi = {"Blitz", "Schnellschach", "Klassisch"};
jl.setFont(new Font("Calibri", Font.BOLD, 20)); JComboBox<String> jcb1 = new JComboBox<>(modi);
jl.setForeground(Color.BLACK); jcb1 .setMaximumSize(new Dimension(150, 30));
jl.setAlignmentX(CENTER_ALIGNMENT); jcb1 .setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(jl); contentPane.add(jcb1 );
contentPane.add(Box.createVerticalStrut(15)); contentPane.add(Box.createVerticalStrut(15));
// Modusauswahl // Spielbrettdrehen
String[] modi = { "Blitz", "Schnellschach", "Klassisch" }; JLabel jl2 = new JLabel("Soll das Spielbrett nach jedem Zug gedreht werden?");
JComboBox<String> jcb1 = new JComboBox<>(modi); jl2 .setFont(new Font("Calibri", Font.BOLD, 20));
jcb1.setMaximumSize(new Dimension(150, 30)); jl2 .setForeground(Color.BLACK);
jcb1.setAlignmentX(CENTER_ALIGNMENT); jl2 .setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(jcb1); contentPane.add(jl2 );
contentPane.add(Box.createVerticalStrut(15));
// Spielbrettdrehen JCheckBox jb1 = new JCheckBox();
JLabel jl2 = new JLabel("Soll das Spielbrett nach jedem Zug gedreht werden?"); jb1.setOpaque(false);
jl2.setFont(new Font("Calibri", Font.BOLD, 20)); jb1.setFocusPainted(false);
jl2.setForeground(Color.BLACK); jb1.setForeground(Color.BLACK);
jl2.setAlignmentX(CENTER_ALIGNMENT); jb1 .setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(jl2); jb1 .setMaximumSize(new Dimension(30, 30));
contentPane.add(jb1 );
contentPane.add(Box.createVerticalStrut(15));
JCheckBox jb1 = new JCheckBox(); // Zurücknahmeoption
jb1.setOpaque(false); JLabel jl3 = new JLabel("Sollen Zurücknahmen erlaubt sein?");
jb1.setFocusPainted(false); jl3.setFont(new Font("Calibri", Font.BOLD, 20));
jb1.setForeground(Color.BLACK); jl3.setForeground(Color.BLACK);
jb1.setAlignmentX(CENTER_ALIGNMENT); jl3.setAlignmentX(Component.CENTER_ALIGNMENT);
jb1.setMaximumSize(new Dimension(30, 30)); contentPane.add(jl3);
contentPane.add(jb1);
contentPane.add(Box.createVerticalStrut(15));
// Zurücknahmeoption JCheckBox jb2 = new JCheckBox();
JLabel jl3 = new JLabel("Sollen Zurücknahmen erlaubt sein?"); jb2.setOpaque(false);
jl3.setFont(new Font("Calibri", Font.BOLD, 20)); jb2.setFocusPainted(false);
jl3.setForeground(Color.BLACK); jb2.setForeground(Color.BLACK);
jl3.setAlignmentX(CENTER_ALIGNMENT); jb2.setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(jl3); jb2.setMaximumSize(new Dimension(30, 30));
contentPane.add(jb2);
contentPane.add(Box.createVerticalStrut(15));
JCheckBox jb2 = new JCheckBox(); JButton btnNewButton_1 = new JButton("Vergangenes Spiel laden");
jb2.setOpaque(false);
jb2.setFocusPainted(false); btnNewButton_1.setBackground(Color.LIGHT_GRAY);
jb2.setForeground(Color.BLACK); btnNewButton_1.setForeground(Color.BLACK);
jb2.setAlignmentX(CENTER_ALIGNMENT); btnNewButton_1.setFont(new Font("Tahoma", Font.BOLD, 16));
jb2.setMaximumSize(new Dimension(30, 30)); btnNewButton_1.setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(jb2); btnNewButton_1.addActionListener(new ButtonFileLoaderListener(this));
contentPane.add(Box.createVerticalStrut(15)); contentPane.add(btnNewButton_1);
contentPane.add(Box.createVerticalStrut(25));
JButton btnNewButton_1 = new JButton("Vergangenes Spiel laden"); // Spiel starten Button
JButton btnNewButton = new JButton("Spiel starten");
btnNewButton .setBackground(Color.LIGHT_GRAY);
btnNewButton .setForeground(Color.BLACK);
btnNewButton .setFont(new Font("Tahoma", Font.BOLD, 16));
btnNewButton .setAlignmentX(Component.CENTER_ALIGNMENT);
contentPane.add(btnNewButton );
btnNewButton_1.setBackground(Color.LIGHT_GRAY); // Button-Listener
btnNewButton_1.setForeground(Color.BLACK); btnNewButton .addActionListener(new ActionListener() {
btnNewButton_1.setFont(new Font("Tahoma", Font.BOLD, 16)); @Override
btnNewButton_1.setAlignmentX(CENTER_ALIGNMENT); public void actionPerformed(ActionEvent e) {
btnNewButton_1.addActionListener(new ButtonFileLoaderListener(this)); String modus = (String) jcb1.getSelectedItem();
boolean rotieren = jb1.isSelected();
boolean zuruecknahme = jb2.isSelected();
contentPane.add(btnNewButton_1); Game game = new Game(modus, rotieren, zuruecknahme, fen);
spiele.add(game);
contentPane.add(Box.createVerticalStrut(25)); dispose();
}
});
// Spiel starten Button setVisible(true);
JButton btnNewButton = new JButton("Spiel starten"); }
btnNewButton.setBackground(Color.LIGHT_GRAY);
btnNewButton.setForeground(Color.BLACK); public void setFen(String fen) {
btnNewButton.setFont(new Font("Tahoma", Font.BOLD, 16)); this.fen = fen;
btnNewButton.setAlignmentX(CENTER_ALIGNMENT); }
contentPane.add(btnNewButton);
// Button-Listener
btnNewButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String modus = (String) jcb1.getSelectedItem();
boolean rotieren = jb1.isSelected();
boolean zuruecknahme = jb2.isSelected();
Game game = new Game(modus, rotieren, zuruecknahme, fen);
mf.setGame(game);
mf.startGame();
// spiele.add(game);
dispose();
}
});
setVisible(true);
}
public void setFen(String fen) {
this.fen = fen;
}
} }

View File

@ -1,154 +0,0 @@
package de.mannheim.th.chess.ui;
import java.util.List;
import java.io.File;
import javax.swing.BoxLayout;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.SwingWorker;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.github.bhlangonijr.chesslib.game.Game;
import com.github.bhlangonijr.chesslib.pgn.PgnHolder;
import com.github.bhlangonijr.chesslib.pgn.PgnLoadListener;
public class PGNLoaderFrame extends JFrame {
private static final Logger logger = LogManager.getLogger(PGNLoaderFrame.class);
private PgnHolder pgn;
private File selectedFile;
private List<Game> games;
private DefaultListModel<String> gameListModel;
private JPanel contentPane;
private JList<String> gameList;
private JProgressBar progressBar;
/**
* Opens the PNGLoaderFrame
*/
public PGNLoaderFrame(MainFrame mf) {
// ----- Style -----
setResizable(true);
setAlwaysOnTop(true);
setTitle("PGNLoader");
setBounds(100, 100, 500, 500);
// ----- contentPane -----
contentPane = new JPanel();
contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
setContentPane(contentPane);
// ----- FileSelector -----
JButton fileSelectButton = new JButton("Select File");
fileSelectButton.addActionListener(e -> {
JFileChooser fileChooser = new JFileChooser();
int returnValue = fileChooser.showOpenDialog(null);
if (returnValue == JFileChooser.APPROVE_OPTION) {
selectedFile = fileChooser.getSelectedFile();
}
});
contentPane.add(fileSelectButton);
// ----- LoadButton -----
JButton loadPgnButton = new JButton("Load file");
loadPgnButton.addActionListener(e -> loadFile());
contentPane.add(loadPgnButton);
// ----- SelectionList -----
gameListModel = new DefaultListModel<>();
gameList = new JList<>(gameListModel);
gameList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
gameList.setVisibleRowCount(5);
JScrollPane scrollPane = new JScrollPane(gameList);
contentPane.add(scrollPane);
// ----- ProgressBar -----
progressBar = new JProgressBar(0, 100);
progressBar.setValue(0);
progressBar.setStringPainted(true);
contentPane.add(progressBar);
// ----- StartButton -----
JButton startGameButton = new JButton("Starte Spiel");
startGameButton.addActionListener(e -> {
int index = gameList.getSelectedIndex();
de.mannheim.th.chess.domain.Game game = new de.mannheim.th.chess.domain.Game(games.get(index).getHalfMoves());
mf.setGame(game);
mf.startView();
});
contentPane.add(startGameButton);
this.setVisible(true);
}
private void loadFile() {
if (this.selectedFile != null) {
pgn = new PgnHolder(this.selectedFile.getAbsolutePath());
LoadPGNWorker loadPGNWorker = new LoadPGNWorker();
loadPGNWorker.addPropertyChangeListener(e -> {
progressBar.setIndeterminate(true);
});
pgn.getListener().add(loadPGNWorker);
loadPGNWorker.execute();
gameList.revalidate();
}
}
private class LoadPGNWorker extends SwingWorker<Integer, Integer> implements PgnLoadListener {
@Override
protected Integer doInBackground() throws Exception {
try {
pgn.loadPgn();
games = pgn.getGames();
int totalGames = games.size();
for (int i = 0; i < totalGames; i++) {
publish(i);
}
} catch (Exception e) {
logger.info("Could not load pgn file!");
}
return pgn.getSize();
}
@Override
protected void process(List<Integer> chunks) {
for (Integer index : chunks) {
gameListModel.addElement("Game: " + index);
setProgress(Math.min(90, index * 100 / games.size()));
}
}
@Override
protected void done() {
setProgress(100);
progressBar.setValue(100);
progressBar.setIndeterminate(false);
}
@Override
public void notifyProgress(int games) {
setProgress(Math.min(90, games));
progressBar.setValue(Math.min(90, games));
}
}
}

View File

@ -1,29 +1,21 @@
package de.mannheim.th.chess.ui; package de.mannheim.th.chess.ui;
// import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
// import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import com.github.bhlangonijr.chesslib.Square; import com.github.bhlangonijr.chesslib.Square;
import com.github.bhlangonijr.chesslib.move.Move; import com.github.bhlangonijr.chesslib.move.Move;
import com.github.bhlangonijr.chesslib.move.MoveList; import com.github.bhlangonijr.chesslib.move.MoveList;
import com.github.bhlangonijr.chesslib.Piece;
import com.github.bhlangonijr.chesslib.Side;
import de.mannheim.th.chess.App;
import de.mannheim.th.chess.domain.Game; import de.mannheim.th.chess.domain.Game;
import de.mannheim.th.chess.utl.Clock; import de.mannheim.th.chess.utl.Clock;
import de.mannheim.th.chess.utl.OpeningRecognizer;
import de.mannheim.th.chess.controller.ButtonAufgebenListener; import de.mannheim.th.chess.controller.ButtonAufgebenListener;
import de.mannheim.th.chess.controller.ButtonFileSaverListener; import de.mannheim.th.chess.controller.ButtonFileSaverListener;
import de.mannheim.th.chess.controller.ButtonMovePieceListener; import de.mannheim.th.chess.controller.ButtonMovePieceListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonQuickloadListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonQuicksaveListener;
import de.mannheim.th.chess.controller.ButtonSelectPieceListener; import de.mannheim.th.chess.controller.ButtonSelectPieceListener;
import de.mannheim.th.chess.controller.ButtonToNormalListener; import de.mannheim.th.chess.controller.ButtonToNormalListener;
import de.mannheim.th.chess.controller.ButtonUndoMoveListener; import de.mannheim.th.chess.controller.ButtonUndoMoveListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonViewBackListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonViewFirstListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonViewForwardListener;
import de.mannheim.th.chess.controller.controlPanel.ButtonViewLastListener;
import java.awt.Font; import java.awt.Font;
@ -44,27 +36,24 @@ import javax.swing.SwingConstants;
import java.awt.BorderLayout; import java.awt.BorderLayout;
import java.awt.Color; import java.awt.Color;
import java.awt.Component; import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.awt.GridLayout; import java.awt.GridLayout;
import java.awt.Toolkit;
public class SpielFrame extends JFrame { public class SpielFrame extends JFrame {
// private static final Logger logger = LogManager.getLogger(App.class); private static final Logger logger = LogManager.getLogger(App.class);
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private ArrayList<JButton> buttons = new ArrayList<>(); private ArrayList<JButton> buttons = new ArrayList<>();
private HashMap<JButton, String> belegungen = new HashMap<>(); private HashMap<JButton, String> belegungen = new HashMap<>();
private JPanel panelLinks, panelRechts, contentPane, controlPanel; private JPanel panelLinks, panelRechts, contentPane;
private JButton undo, undo2, aufgeben, aufgeben2; private JButton undo, undo2, aufgeben, aufgeben2;
private JTextArea ausgabe, blackRemovedPieces, whiteRemovedPieces; private JTextArea ausgabe;
private Game game; private Game game;
private Clock clock; private Clock clock;
private String opening;
private ArrayList<String> anzeigeMoves = new ArrayList<String>(); private ArrayList<String> anzeigeMoves = new ArrayList<String>();
private boolean wechsel = false; private boolean wechsel = false;
@ -72,26 +61,22 @@ public class SpielFrame extends JFrame {
private Square selectedSquare; private Square selectedSquare;
public enum BoardMode { public enum BoardMode {
normal, pieceSelected, finished normal, pieceSelected, finished, gameEnd
} }
/** /**
* Create the frame. * Create the frame.
*/ */
public SpielFrame(Game game) { public SpielFrame(Game game) {
opening = "unbekannte Eröffnung";
this.game = game; this.game = game;
this.clock = game.getClock(); this.clock = game.getClock();
this.clock.start(); this.clock.start();
mode = BoardMode.normal; mode = BoardMode.normal;
setDefaultCloseOperation(DISPOSE_ON_CLOSE); setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setBounds(100, 100, 1920, 1080);
//setBounds(100, 100, 1920, 1080);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
setBounds(0,0, d.width, d.height);
setExtendedState(JFrame.MAXIMIZED_BOTH);
setTitle("Schach"); setTitle("Schach");
setAlwaysOnTop(true); setAlwaysOnTop(true);
@ -112,8 +97,6 @@ public class SpielFrame extends JFrame {
// Panel für alle Eingaben von Player 2 // Panel für alle Eingaben von Player 2
panelRechts.add(getUiPlayerTwo()); panelRechts.add(getUiPlayerTwo());
panelRechts.add(createControlPanel());
// Panel für Statistikanzeigen // Panel für Statistikanzeigen
panelRechts.add(getUiStatistik()); panelRechts.add(getUiStatistik());
@ -137,26 +120,25 @@ public class SpielFrame extends JFrame {
*/ */
public void erstelleBrett() { public void erstelleBrett() {
this.setDefaultButtons(); this.clearButtons();
this.setDefaultBackground();
this.setButtonsActions(); this.setButtonsActions();
this.applyBoardButtons();
this.ladeBrett(); ladeBrett();
panelLinks.revalidate();
panelLinks.repaint();
} }
/** private int mirrowedGrid(int i) {
* Sets the to default buttons return 63 - (((i / 8) * 8) + (7 - i % 8));
*/
public void setDefaultButtons() {
this.clearButtons();
this.setDefaultBackground();
} }
/** /**
* holt sich FEN-Zeichenkette und extrahiert daraus die Positionen der Figuren * holt sich FEN-Zeichenkette und extrahiert daraus die Positionen der Figuren
*/ */
public void ladeBrett() { private void ladeBrett() {
char[] fen = game.toFEN().replaceAll("/", "").split(" ")[0].toCharArray(); char[] fen = game.toFEN().replaceAll("/", "").split(" ")[0].toCharArray();
int i = 0; int i = 0;
for (int j = 0; j < fen.length; j++) { for (int j = 0; j < fen.length; j++) {
@ -198,11 +180,87 @@ public class SpielFrame extends JFrame {
} }
} }
/**
* Clears the existing buttons from the button list, panellinks and fills them
* with new blank ones.
*/
private void clearButtons() {
buttons.clear();
panelLinks.removeAll();
for (int i = 0; i < 64; i++) {
JButton b = new JButton();
b.setEnabled(false);
// style
b.setFocusPainted(false);
b.setFont(new Font("Arial", Font.PLAIN, 20));
b.setForeground(Color.WHITE);
b.setBorder(BorderFactory.createLineBorder(Color.BLACK, 1));
b.setName(i + "");
buttons.add(b);
}
}
/**
* Sets the default background color for the buttons in the grid.
*/
private void setDefaultBackground() {
int counter = 8;
for (int i = 0; i < 64; i++) {
JButton b = buttons.get(i);
if ((i / 8 + i % 8) % 2 == 0) {
// logger.info("Helles Feld erstellt." + i);
b.setBackground(new Color(90, 90, 90));
} else {
// logger.info("Dunkles Feld erstellt." + i);
b.setBackground(new Color(65, 65, 65));
}
if(i % 8 == 0) {
b.setHorizontalAlignment(SwingConstants.CENTER);
b.setVerticalAlignment(SwingConstants.CENTER);
b.setHorizontalTextPosition(SwingConstants.LEFT); // Text rechts vom Icon
b.setVerticalTextPosition(SwingConstants.BOTTOM);
b.setIconTextGap(5);
b.setText(String.valueOf(counter)+b.getText());
counter--;
}
}
char buchstabe = 'a';
for(int j=0;j<8;j++) {
JButton button = buttons.get(mirrowedGrid(j));
button.setHorizontalAlignment(SwingConstants.CENTER);
button.setVerticalAlignment(SwingConstants.CENTER);
button.setHorizontalTextPosition(SwingConstants.RIGHT); // Text rechts vom Icon
button.setVerticalTextPosition(SwingConstants.BOTTOM);
button.setIconTextGap(5);
button.setText(String.valueOf(buchstabe));
buchstabe++;
}
}
/* /*
* Switches the button actions depending on the boardmode * Switches the button actions depending on the boardmode
*/ */
public void setButtonsActions() { public void setButtonsActions() {
List<Square> selectables; List<Square> selectables;
switch (this.mode) { switch (this.mode) {
@ -251,37 +309,26 @@ public class SpielFrame extends JFrame {
break; break;
case finished: case finished:
clearButtons();
break;
case gameEnd:
panelLinks.setEnabled(false);
panelRechts.setEnabled(false);
break; break;
default: default:
break; break;
} }
}
/**
* Inverts the Enabled property of the controlpanelButtons
*/
public void enableControlPanelButtons() {
for (Component c : this.controlPanel.getComponents()) {
if (c instanceof JButton) {
c.setEnabled(!c.isEnabled());
}
}
}
/**
* Adds the buttons to the boardpanel
*/
public void applyBoardButtons() {
for (JButton b : buttons) { for (JButton b : buttons) {
panelLinks.add(b); panelLinks.add(b);
} }
} }
@Deprecated
public void showWin(int player) { public void showWin(int player) {
JFrame frame = new JFrame("Result"); JFrame frame = new JFrame("Result");
frame.setDefaultCloseOperation(EXIT_ON_CLOSE); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 150); frame.setSize(300, 150);
frame.setLayout(null); frame.setLayout(null);
@ -315,6 +362,7 @@ public class SpielFrame extends JFrame {
jb.setIcon(new ImageIcon("src/main/resources/" + pictures[index] + ".png")); jb.setIcon(new ImageIcon("src/main/resources/" + pictures[index] + ".png"));
int selectedPiece = index; int selectedPiece = index;
jb.addActionListener(e -> { jb.addActionListener(e -> {
System.out.println("Test");
result[0] = selectedPiece; result[0] = selectedPiece;
dialog.dispose(); dialog.dispose();
}); });
@ -327,12 +375,205 @@ public class SpielFrame extends JFrame {
return result[0]; return result[0];
} }
public HashMap<JButton, String> getBelegung() { private JPanel getUiPlayerTwo() {
return this.belegungen;
JPanel playerTwo = new JPanel();
playerTwo.setBackground(new Color(90, 90, 90));
playerTwo.setLayout(new BoxLayout(playerTwo, BoxLayout.Y_AXIS));
playerTwo.add(Box.createVerticalStrut(15));
JLabel pl2 = new JLabel("Player 2:");
pl2.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
pl2.setFont(new Font("Calibri", Font.BOLD, 35));
pl2.setForeground(Color.BLACK);
pl2.setAlignmentX(Component.CENTER_ALIGNMENT);
playerTwo.add(pl2);
playerTwo.add(Box.createVerticalStrut(10));
JLabel clock1 = clock.getClock2();
playerTwo.add(clock1);
playerTwo.add(Box.createVerticalStrut(10));
// Button zurücknahme und aufgeben für Player 2
JPanel aufgebenUndo = new JPanel();
aufgebenUndo.setBackground(new Color(90, 90, 90));
aufgebenUndo.setLayout(new BoxLayout(aufgebenUndo, BoxLayout.X_AXIS));
if (game.isZuruecknahme()) {
undo = new JButton("Zug zurücknehmen");
undo.setBackground(Color.LIGHT_GRAY);
undo.setForeground(Color.BLACK);
undo.setFont(new Font("Tahoma", Font.BOLD, 16));
undo.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgebenUndo.add(undo);
// Button-Listener
undo.addActionListener(new ButtonUndoMoveListener(this, this.game));
}
aufgebenUndo.add(Box.createHorizontalStrut(10));
aufgeben2 = new JButton("Aufgeben");
aufgeben2.setBackground(Color.LIGHT_GRAY);
aufgeben2.setForeground(Color.BLACK);
aufgeben2.setFont(new Font("Tahoma", Font.BOLD, 16));
aufgeben2.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgeben2.addActionListener(new ButtonAufgebenListener(this, this.game));
aufgebenUndo.add(aufgeben2);
aufgebenUndo.add(Box.createHorizontalStrut(10));
JButton safe = new JButton("Spielstand sichern");
safe.setBackground(Color.LIGHT_GRAY);
safe.setForeground(Color.BLACK);
safe.setFont(new Font("Tahoma", Font.BOLD, 16));
safe.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgebenUndo.add(safe);
// Button-Listener
safe.addActionListener(new ButtonFileSaverListener(this, this.game));
playerTwo.add(aufgebenUndo);
playerTwo.add(Box.createVerticalStrut(10));
return playerTwo;
} }
public boolean isWechsel() { private JPanel getUiStatistik() {
return wechsel;
JPanel statistik = new JPanel();
statistik.setBackground(new Color(90, 90, 90));
statistik.setLayout(new BoxLayout(statistik, BoxLayout.Y_AXIS));
ausgabe = new JTextArea();
ausgabe.setEditable(false);
ausgabe.setBackground(new Color(75, 75, 75));
ausgabe.setBorder(BorderFactory.createLineBorder(Color.BLACK, 1));
ausgabe.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 20));
ausgabe.setForeground(Color.BLACK);
ausgabe.setText("\n Bisherige Züge:\n");
JScrollPane scrollPane = new JScrollPane(ausgabe);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
statistik.add(scrollPane);
return statistik;
}
public void aktualisiereAusgabe() {
StringBuilder sb = new StringBuilder();
sb.append("\n Bisherige Züge:\n");
MoveList l = game.getMoveList();
anzeigeMoves.add(" " + game.getUnicodeFromMove(l.getLast()) + ": " + l.getLast().toString() + "\n");
for (String line : anzeigeMoves) {
sb.append(line);
}
ausgabe.setText(sb.toString());
}
public void deleteLastAusgabe() {
String[] zeilen = ausgabe.getText().split("\n");
// es müssen immer mind 5 Zeilen existieren, dass also 1 Zug löschbar ist
if (zeilen.length <= 2)
return;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < zeilen.length - 1; i++) {
sb.append(zeilen[i]).append("\n");
}
ausgabe.setText(sb.toString());
}
private JPanel getUiPlayerOne() {
JPanel playerOne = new JPanel();
playerOne.setBackground(new Color(90, 90, 90));
playerOne.setLayout(new BoxLayout(playerOne, BoxLayout.Y_AXIS));
playerOne.add(Box.createVerticalStrut(10));
// Button zurücknahme und aufgeben für Player 1
JPanel aufgebenUndo = new JPanel();
aufgebenUndo.setBackground(new Color(90, 90, 90));
aufgebenUndo.setLayout(new BoxLayout(aufgebenUndo, BoxLayout.X_AXIS));
if (game.isZuruecknahme()) {
undo2 = new JButton("Zug zurücknehmen");
undo2.setBackground(Color.LIGHT_GRAY);
undo2.setForeground(Color.BLACK);
undo2.setFont(new Font("Tahoma", Font.BOLD, 16));
undo2.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgebenUndo.add(undo2);
// Button-Listener
undo2.addActionListener(new ButtonUndoMoveListener(this, this.game));
}
aufgebenUndo.add(Box.createHorizontalStrut(10));
aufgeben = new JButton("Aufgeben");
aufgeben.setBackground(Color.LIGHT_GRAY);
aufgeben.setForeground(Color.BLACK);
aufgeben.setFont(new Font("Tahoma", Font.BOLD, 16));
aufgeben.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgeben.addActionListener(new ButtonAufgebenListener(this, this.game));
aufgebenUndo.add(aufgeben);
aufgebenUndo.add(Box.createHorizontalStrut(10));
JButton safe = new JButton("Spielstand sichern");
safe.setBackground(Color.LIGHT_GRAY);
safe.setForeground(Color.BLACK);
safe.setFont(new Font("Tahoma", Font.BOLD, 16));
safe.setAlignmentX(Component.CENTER_ALIGNMENT);
aufgebenUndo.add(safe);
// Button-Listener
safe.addActionListener(new ButtonFileSaverListener(this, this.game));
playerOne.add(aufgebenUndo);
playerOne.add(Box.createVerticalStrut(15));
JLabel clock1 = clock.getClock1();
playerOne.add(clock1);
playerOne.add(Box.createVerticalStrut(10));
JLabel pl2 = new JLabel("Player 1:");
pl2.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
pl2.setFont(new Font("Calibri", Font.BOLD, 35));
pl2.setForeground(Color.BLACK);
pl2.setAlignmentX(Component.CENTER_ALIGNMENT);
playerOne.add(pl2);
return playerOne;
}
public void setBoardMode(BoardMode bm) {
this.mode = bm;
}
public void setSelectedSquare(Square sq) {
this.selectedSquare = sq;
}
public HashMap<JButton, String> getBelegung() {
return this.belegungen;
} }
public JButton getUndo() { public JButton getUndo() {
@ -355,26 +596,14 @@ public class SpielFrame extends JFrame {
return aufgeben; return aufgeben;
} }
public JButton getAufgeben2() {
return aufgeben2;
}
public void setMode(BoardMode mode) {
this.mode = mode;
}
public void setBoardMode(BoardMode bm) {
this.mode = bm;
}
public void setSelectedSquare(Square sq) {
this.selectedSquare = sq;
}
public void setAufgeben(JButton aufgeben) { public void setAufgeben(JButton aufgeben) {
this.aufgeben = aufgeben; this.aufgeben = aufgeben;
} }
public JButton getAufgeben2() {
return aufgeben2;
}
public void setAufgeben2(JButton aufgeben2) { public void setAufgeben2(JButton aufgeben2) {
this.aufgeben2 = aufgeben2; this.aufgeben2 = aufgeben2;
} }
@ -383,377 +612,8 @@ public class SpielFrame extends JFrame {
this.wechsel = wechsel; this.wechsel = wechsel;
} }
private int mirrowedGrid(int i) { public boolean isWechsel() {
return 63 - (((i / 8) * 8) + (7 - i % 8)); return wechsel;
}
/**
* Creates the controlPanel and its Buttons
*/
private JPanel createControlPanel() {
this.controlPanel = new JPanel();
this.controlPanel.setBackground(new Color(90, 90, 90));
this.controlPanel.setLayout(new FlowLayout());
this.controlPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, controlPanel.getPreferredSize().height));
// ----- ViewQuicksaveButton -----
JButton quicksave = new JButton("Quicksave");
quicksave.setBackground(Color.LIGHT_GRAY);
quicksave.setForeground(Color.BLACK);
quicksave.setFont(new Font("Tahoma", Font.BOLD, 16));
quicksave.setAlignmentX(CENTER_ALIGNMENT);
quicksave.setEnabled(true);
quicksave.addActionListener(new ButtonQuicksaveListener(this.game));
this.controlPanel.add(quicksave);
// ----- ViewFirstButton -----
JButton viewFirstButton = new JButton("<<");
viewFirstButton.setBackground(Color.LIGHT_GRAY);
viewFirstButton.setForeground(Color.BLACK);
viewFirstButton.setFont(new Font("Calibri", Font.BOLD, 16));
viewFirstButton.setAlignmentX(CENTER_ALIGNMENT);
viewFirstButton.setEnabled(false);
viewFirstButton.addActionListener(new ButtonViewFirstListener(this.game, this));
this.controlPanel.add(viewFirstButton);
// ----- ViewBackButton -----
JButton viewBackButton = new JButton("←");
viewBackButton.setBackground(Color.LIGHT_GRAY);
viewBackButton.setForeground(Color.BLACK);
viewBackButton.setFont(new Font("Calibri", Font.BOLD, 16));
viewBackButton.setAlignmentX(CENTER_ALIGNMENT);
viewBackButton.setEnabled(false);
viewBackButton.addActionListener(new ButtonViewBackListener(this.game, this));
this.controlPanel.add(viewBackButton);
// ----- ViewForwardButton -----
JButton viewForwardButton = new JButton("→");
viewForwardButton.setBackground(Color.LIGHT_GRAY);
viewForwardButton.setForeground(Color.BLACK);
viewForwardButton.setFont(new Font("Calibri", Font.BOLD, 16));
viewForwardButton.setAlignmentX(CENTER_ALIGNMENT);
viewForwardButton.setEnabled(false);
viewForwardButton.addActionListener(new ButtonViewForwardListener(this.game, this));
this.controlPanel.add(viewForwardButton);
// ----- ViewLastButton -----
JButton viewLastButton = new JButton(">>");
viewLastButton.setBackground(Color.LIGHT_GRAY);
viewLastButton.setForeground(Color.BLACK);
viewLastButton.setFont(new Font("Calibri", Font.BOLD, 16));
viewLastButton.setAlignmentX(CENTER_ALIGNMENT);
viewLastButton.setEnabled(false);
viewLastButton.addActionListener(new ButtonViewLastListener(this.game, this));
this.controlPanel.add(viewLastButton);
// ----- ViewQuickloadButton -----
JButton quickload = new JButton("Quickload");
quickload.setBackground(Color.LIGHT_GRAY);
quickload.setForeground(Color.BLACK);
quickload.setFont(new Font("Tahoma", Font.BOLD, 16));
quickload.setAlignmentX(CENTER_ALIGNMENT);
quickload.setEnabled(true);
quickload.addActionListener(new ButtonQuickloadListener(this.game, this));
this.controlPanel.add(quickload);
return controlPanel;
}
private JPanel getUiPlayerTwo() {
JPanel playerTwo = new JPanel();
playerTwo.setBackground(new Color(90, 90, 90));
playerTwo.setLayout(new BoxLayout(playerTwo, BoxLayout.Y_AXIS));
playerTwo.add(Box.createVerticalStrut(15));
JLabel pl2 = new JLabel("Player 2:");
pl2.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
pl2.setFont(new Font("Calibri", Font.BOLD, 35));
pl2.setForeground(Color.BLACK);
pl2.setAlignmentX(CENTER_ALIGNMENT);
playerTwo.add(pl2);
playerTwo.add(Box.createVerticalStrut(10));
JLabel clock1 = clock.getClock2();
playerTwo.add(clock1);
playerTwo.add(Box.createVerticalStrut(10));
// Button zurücknahme und aufgeben für Player 2
JPanel aufgebenUndo = new JPanel();
aufgebenUndo.setBackground(new Color(90, 90, 90));
aufgebenUndo.setLayout(new BoxLayout(aufgebenUndo, BoxLayout.X_AXIS));
if (game.isZuruecknahme()) {
undo = new JButton("Zug zurücknehmen");
undo.setBackground(Color.LIGHT_GRAY);
undo.setForeground(Color.BLACK);
undo.setFont(new Font("Tahoma", Font.BOLD, 16));
undo.setAlignmentX(CENTER_ALIGNMENT);
aufgebenUndo.add(undo);
// Button-Listener
undo.addActionListener(new ButtonUndoMoveListener(this, this.game));
}
aufgebenUndo.add(Box.createHorizontalStrut(10));
aufgeben2 = new JButton("Aufgeben");
aufgeben2.setBackground(Color.LIGHT_GRAY);
aufgeben2.setForeground(Color.BLACK);
aufgeben2.setFont(new Font("Tahoma", Font.BOLD, 16));
aufgeben2.setAlignmentX(CENTER_ALIGNMENT);
aufgeben2.addActionListener(new ButtonAufgebenListener(this, this.game));
aufgebenUndo.add(aufgeben2);
aufgebenUndo.add(Box.createHorizontalStrut(10));
JButton safe = new JButton("Spielstand sichern");
safe.setBackground(Color.LIGHT_GRAY);
safe.setForeground(Color.BLACK);
safe.setFont(new Font("Tahoma", Font.BOLD, 16));
safe.setAlignmentX(CENTER_ALIGNMENT);
aufgebenUndo.add(safe);
// Button-Listener
safe.addActionListener(new ButtonFileSaverListener(this, this.game));
playerTwo.add(aufgebenUndo);
playerTwo.add(Box.createVerticalStrut(10));
return playerTwo;
}
private JPanel getUiStatistik() {
JPanel statistik = new JPanel();
statistik.setBackground(new Color(90, 90, 90));
statistik.setLayout(new BoxLayout(statistik, BoxLayout.Y_AXIS));
ausgabe = new JTextArea();
ausgabe.setEditable(false);
ausgabe.setBackground(new Color(75, 75, 75));
ausgabe.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
ausgabe.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 20));
ausgabe.setForeground(Color.BLACK);
ausgabe.setText("\n Bisherige Züge:\n");
whiteRemovedPieces = new JTextArea();
whiteRemovedPieces.setPreferredSize(new Dimension(300, 100));
whiteRemovedPieces.setEditable(false);
whiteRemovedPieces.setBackground(new Color(75, 75, 75));
whiteRemovedPieces.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
whiteRemovedPieces.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 40));
whiteRemovedPieces.setForeground(Color.WHITE);
blackRemovedPieces = new JTextArea();
blackRemovedPieces.setPreferredSize(new Dimension(300, 100));
blackRemovedPieces.setEditable(false);
blackRemovedPieces.setBackground(new Color(75, 75, 75));
blackRemovedPieces.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
blackRemovedPieces.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 40));
blackRemovedPieces.setForeground(Color.BLACK);
JScrollPane scrollPane = new JScrollPane(ausgabe);
scrollPane.setPreferredSize(new Dimension(500, 1000));
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
statistik.add(whiteRemovedPieces);
statistik.add(scrollPane);
statistik.add(blackRemovedPieces);
return statistik;
}
public void aktualisiereAusgabe() {
StringBuilder sb = new StringBuilder();
opening = OpeningRecognizer.compareOpening(game.getMoveList(), opening);
sb.append("\n Bisherige Züge: " + opening + "\n");
MoveList l = game.getMoveList();
anzeigeMoves.add(" " + game.getUnicodeFromMove(l.getLast()) + ": " + l.getLast().toString() + "\n");
for (String line : anzeigeMoves) {
sb.append(line);
}
StringBuilder whitePieces = new StringBuilder();
StringBuilder blackPieces = new StringBuilder();
for (Piece piece: game.getRemovedPieces()) {
if (piece.getPieceSide() == Side.BLACK) {
blackPieces.append(piece.getFanSymbol().toUpperCase());
} else {
whitePieces.append(piece.getFanSymbol().toUpperCase());
}
}
blackRemovedPieces.setText(blackPieces.toString());
whiteRemovedPieces.setText(whitePieces.toString());
ausgabe.setText(sb.toString());
}
public void deleteLastAusgabe() {
String[] zeilen = ausgabe.getText().split("\n");
// es müssen immer mind 5 Zeilen existieren, dass also 1 Zug löschbar ist
if (zeilen.length <= 2)
return;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < zeilen.length - 1; i++) {
sb.append(zeilen[i]).append("\n");
}
ausgabe.setText(sb.toString());
anzeigeMoves.removeLast();
}
private JPanel getUiPlayerOne() {
JPanel playerOne = new JPanel();
playerOne.setBackground(new Color(90, 90, 90));
playerOne.setLayout(new BoxLayout(playerOne, BoxLayout.Y_AXIS));
playerOne.add(Box.createVerticalStrut(10));
// Button zurücknahme und aufgeben für Player 1
JPanel aufgebenUndo = new JPanel();
aufgebenUndo.setBackground(new Color(90, 90, 90));
aufgebenUndo.setLayout(new BoxLayout(aufgebenUndo, BoxLayout.X_AXIS));
if (game.isZuruecknahme()) {
undo2 = new JButton("Zug zurücknehmen");
undo2.setBackground(Color.LIGHT_GRAY);
undo2.setForeground(Color.BLACK);
undo2.setFont(new Font("Tahoma", Font.BOLD, 16));
undo2.setAlignmentX(CENTER_ALIGNMENT);
aufgebenUndo.add(undo2);
// Button-Listener
undo2.addActionListener(new ButtonUndoMoveListener(this, this.game));
}
aufgebenUndo.add(Box.createHorizontalStrut(10));
aufgeben = new JButton("Aufgeben");
aufgeben.setBackground(Color.LIGHT_GRAY);
aufgeben.setForeground(Color.BLACK);
aufgeben.setFont(new Font("Tahoma", Font.BOLD, 16));
aufgeben.setAlignmentX(CENTER_ALIGNMENT);
aufgeben.addActionListener(new ButtonAufgebenListener(this, this.game));
aufgebenUndo.add(aufgeben);
aufgebenUndo.add(Box.createHorizontalStrut(10));
JButton safe = new JButton("Spielstand sichern");
safe.setBackground(Color.LIGHT_GRAY);
safe.setForeground(Color.BLACK);
safe.setFont(new Font("Tahoma", Font.BOLD, 16));
safe.setAlignmentX(CENTER_ALIGNMENT);
aufgebenUndo.add(safe);
// Button-Listener
safe.addActionListener(new ButtonFileSaverListener(this, this.game));
playerOne.add(aufgebenUndo);
playerOne.add(Box.createVerticalStrut(15));
JLabel clock1 = clock.getClock1();
playerOne.add(clock1);
playerOne.add(Box.createVerticalStrut(10));
JLabel pl2 = new JLabel("Player 1:");
pl2.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
pl2.setFont(new Font("Calibri", Font.BOLD, 35));
pl2.setForeground(Color.BLACK);
pl2.setAlignmentX(CENTER_ALIGNMENT);
playerOne.add(pl2);
return playerOne;
}
/**
* Sets the default background color for the buttons in the grid.
*/
private void setDefaultBackground() {
int counter = 8;
for (int i = 0; i < 64; i++) {
JButton b = buttons.get(i);
if ((i / 8 + i % 8) % 2 == 0) {
// logger.info("Helles Feld erstellt." + i);
b.setBackground(new Color(90, 90, 90));
} else {
// logger.info("Dunkles Feld erstellt." + i);
b.setBackground(new Color(65, 65, 65));
}
if (i % 8 == 0) {
b.setHorizontalAlignment(SwingConstants.CENTER);
b.setVerticalAlignment(SwingConstants.CENTER);
b.setHorizontalTextPosition(SwingConstants.LEFT); // Text rechts vom Icon
b.setVerticalTextPosition(SwingConstants.BOTTOM);
b.setIconTextGap(5);
b.setText(String.valueOf(counter) + b.getText());
counter--;
}
}
char buchstabe = 'a';
for (int j = 0; j < 8; j++) {
JButton button = buttons.get(mirrowedGrid(j));
button.setHorizontalAlignment(SwingConstants.CENTER);
button.setVerticalAlignment(SwingConstants.CENTER);
button.setHorizontalTextPosition(SwingConstants.RIGHT); // Text rechts vom Icon
button.setVerticalTextPosition(SwingConstants.BOTTOM);
button.setIconTextGap(5);
button.setText(String.valueOf(buchstabe));
buchstabe++;
}
}
/**
* Clears the existing buttons from the button list, panellinks and fills them
* with new blank ones.
*/
private void clearButtons() {
buttons.clear();
panelLinks.removeAll();
for (int i = 0; i < 64; i++) {
JButton b = new JButton();
b.setEnabled(false);
// style
b.setFocusPainted(false);
b.setFont(new Font("Arial", Font.PLAIN, 30));
b.setForeground(Color.WHITE);
b.setBorder(BorderFactory.createLineBorder(Color.BLACK, 1));
b.setName(i + "");
buttons.add(b);
}
} }
} }

View File

@ -3,152 +3,157 @@ package de.mannheim.th.chess.utl;
/** /**
* Zeigt die Zeitangabe während eines Spiels eines Spielers an. * Zeigt die Zeitangabe während eines Spiels eines Spielers an.
*/ */
import java.awt.BorderLayout;
import java.awt.Color; import java.awt.Color;
import java.awt.Component; import java.awt.Component;
import java.awt.Font; import java.awt.Font;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import javax.swing.BorderFactory; import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel; import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.Timer; import javax.swing.Timer;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import de.mannheim.th.chess.ui.SpielFrame;
public class Clock extends Thread implements Runnable { public class Clock extends Thread implements Runnable {
private volatile boolean whiteToMove = true; private volatile boolean whiteToMove = true;
private volatile boolean gameHasFinished = false; private volatile boolean gameHasFinished = false;
private static final Logger clockLogger = LogManager.getLogger(Clock.class); private static final Logger clockLogger = LogManager.getLogger(Clock.class);
private int minutes; private int minutes;
private StringBuilder clockShower; private StringBuilder clockShower;
private JLabel clock1, clock2; private JLabel clock1, clock2;
public Clock(String mode) { public Clock(String mode) {
setMode(mode);
}
setMode(mode); public void pressClock() {
} whiteToMove = !whiteToMove;
if (whiteToMove) {
clockLogger.info("Weiß ist am Zug");
} else {
clockLogger.info("Schwarz ist am Zug");
}
}
public void pressClock() { public void endGame() {
whiteToMove = !whiteToMove; gameHasFinished = true;
if (whiteToMove) { }
clockLogger.info("Weiß ist am Zug");
} else {
clockLogger.info("Schwarz ist am Zug");
}
}
public void endGame() { public void run() {
gameHasFinished = true; // JFrame clockFrame = new JFrame("Clock");
} //
// JPanel player1Panel = new JPanel();
// player1Panel.setBackground(Color.BLACK);
// JPanel player2Panel = new JPanel();
// player2Panel.setBackground(Color.BLACK);
// clockFrame.setBounds(1000, 500, 10000, 10000);
// clockFrame.setLayout(new BorderLayout());
clock1 = new JLabel("" + minutes + ":00 ");
clock1.setBorder(BorderFactory.createEmptyBorder(0, 40, 0, 0));
clock1.setForeground(Color.BLACK);
clock1.setFont(new Font("Calibri", Font.BOLD, 40));
clock1.setAlignmentX(Component.CENTER_ALIGNMENT);
clock2 = new JLabel("" + minutes + ":00 ");
clock2.setBorder(BorderFactory.createEmptyBorder(0, 40, 0, 0));
clock2.setForeground(Color.BLACK);
clock2.setFont(new Font("Calibri", Font.BOLD, 40));
clock2.setAlignmentX(Component.CENTER_ALIGNMENT);
// player1Panel.add(clock1);
// player2Panel.add(clock2);
// JSplitPane split = new JSplitPane(JSplitPane.VERTICAL_SPLIT, player1Panel, player2Panel);
// split.setFont(new Font("Arial", Font.BOLD, 50));
// clockFrame.add(split);
public void run() { var min1 = new AtomicInteger(minutes);
// JFrame clockFrame = new JFrame("Clock"); var sec1 = new AtomicInteger(0);
// var min2 = new AtomicInteger(minutes);
// JPanel player1Panel = new JPanel(); var sec2 = new AtomicInteger(0);
// player1Panel.setBackground(Color.BLACK);
// JPanel player2Panel = new JPanel();
// player2Panel.setBackground(Color.BLACK);
// clockFrame.setBounds(1000, 500, 10000, 10000);
// clockFrame.setLayout(new BorderLayout());
clock1 = new JLabel("" + minutes + ":00 ");
clock1.setBorder(BorderFactory.createEmptyBorder(0, 40, 0, 0));
clock1.setForeground(Color.BLACK);
clock1.setFont(new Font("Calibri", Font.BOLD, 40));
clock1.setAlignmentX(Component.CENTER_ALIGNMENT);
clock2 = new JLabel("" + minutes + ":00 "); var t = new Timer(1000, (ae) -> {
clock2.setBorder(BorderFactory.createEmptyBorder(0, 40, 0, 0));
clock2.setForeground(Color.BLACK);
clock2.setFont(new Font("Calibri", Font.BOLD, 40));
clock2.setAlignmentX(Component.CENTER_ALIGNMENT);
// player1Panel.add(clock1);
// player2Panel.add(clock2);
// JSplitPane split = new JSplitPane(JSplitPane.VERTICAL_SPLIT, player1Panel,
// player2Panel);
// split.setFont(new Font("Arial", Font.BOLD, 50));
// clockFrame.add(split);
var min1 = new AtomicInteger(minutes); if (!gameHasFinished) {
var sec1 = new AtomicInteger(0);
var min2 = new AtomicInteger(minutes);
var sec2 = new AtomicInteger(0);
var t = new Timer(1000, (ae) -> { clockShower = new StringBuilder();
if (whiteToMove) {
if (sec1.intValue() == 00) {
sec1.set(60);
min1.decrementAndGet();
}
if (min1.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(min1.get());
clockShower.append(":");
if (sec1.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(sec1.decrementAndGet());
clock1.setText(clockShower.toString());
if (!gameHasFinished) { } else {
if (sec2.intValue() == 00) {
sec2.set(60);
min2.decrementAndGet();
}
if (min2.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(min2.get());
clockShower.append(":");
if (sec2.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(sec2.decrementAndGet());
clock2.setText(clockShower.toString());
}
//sp.repaint();
if ((sec1.intValue() == 0 && min1.intValue() == 0) || (sec2.intValue() == 0 && min2.intValue() == 0)) {
endGame();
}
}
});
clockShower = new StringBuilder(); t.start();
if (whiteToMove) { }
if (sec1.intValue() == 00) {
sec1.set(60);
min1.decrementAndGet();
}
if (min1.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(min1.get());
clockShower.append(":");
if (sec1.intValue() < 10) {
clockShower.append("0");
}
clockShower.append(sec1.decrementAndGet());
clock1.setText(clockShower.toString());
} else { private void setMode(String mode) {
if (sec2.intValue() == 00) { switch (mode.toLowerCase()) {
sec2.set(60); case "blitz":
min2.decrementAndGet(); minutes = 5;
} clockLogger.info("Neue Blitz-Uhr wurde erstellt");
if (min2.intValue() < 10) { break;
clockShower.append("0"); case "schnellschach":
} minutes = 10;
clockShower.append(min2.get()); clockLogger.info("Neue Schnellschach-Uhr wurde erstellt");
clockShower.append(":"); break;
if (sec2.intValue() < 10) { case "klassisch":
clockShower.append("0"); minutes = 120;
} clockLogger.info("Neue klassische Schachuhr wurde erstellt");
clockShower.append(sec2.decrementAndGet()); break;
clock2.setText(clockShower.toString()); }
} }
// sp.repaint();
if ((sec1.intValue() == 0 && min1.intValue() == 0) || (sec2.intValue() == 0 && min2.intValue() == 0)) { public void switchClock() {
endGame(); whiteToMove = !whiteToMove;
} }
}
});
t.start(); public JLabel getClock1() {
}
private void setMode(String mode) { return clock1;
switch (mode.toLowerCase()) { }
case "blitz":
minutes = 5;
clockLogger.info("Neue Blitz-Uhr wurde erstellt");
break;
case "schnellschach":
minutes = 10;
clockLogger.info("Neue Schnellschach-Uhr wurde erstellt");
break;
case "klassisch":
minutes = 120;
clockLogger.info("Neue klassische Schachuhr wurde erstellt");
break;
}
}
public void switchClock() { public JLabel getClock2() {
whiteToMove = !whiteToMove;
} return clock2;
}
public JLabel getClock1() { }
return clock1;
}
public JLabel getClock2() {
return clock2;
}
}

View File

@ -0,0 +1,12 @@
package de.mannheim.th.chess.utl;
import de.mannheim.th.chess.model.Database;
/**
* Liest ein schon vordefinierten Spielstand ein.
*/
public class GameReader{
private Database database = new Database();
}

View File

@ -1,64 +0,0 @@
package de.mannheim.th.chess.utl;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import com.github.bhlangonijr.chesslib.move.MoveList;
public class OpeningRecognizer {
private static class Opening {
String name;
String moves;
Opening(String name, String moves) {
this.name = name;
this.moves = moves;
}
}
private static List<Opening> openingList = new ArrayList<>();
public static void loadOpenings() throws IOException {
BufferedReader openingReader = new BufferedReader(new FileReader("src/main/resources/openings.pgn"));
StringBuilder openingName = new StringBuilder();
String moves = null;
String line;
while ((line = openingReader.readLine()) != null) {
if ((line.startsWith("[Site") && openingName.toString().equals("")) || line.equals("") ) {
continue;
}
if (line.startsWith("[Site")) {
openingList.add(new Opening(openingName.toString(), moves));
moves = null;
openingName.delete(0, openingName.length());
continue;
}
if (line.startsWith("[White")) {
openingName.append(line.split("\"")[1].trim());
continue;
}
if (line.startsWith("[Black")) {
openingName.append(":").append(line.split("\"")[1].trim());
continue;
}
moves = line;
}
openingReader.close();
}
public static String compareOpening(MoveList moves, String openingBefore) {
for (Opening o: openingList) {
if (o.moves.equals(moves.toSanWithMoveNumbers().trim())) {
return o.name;
}
}
return openingBefore;
}
}

File diff suppressed because it is too large Load Diff

View File

@ -1,32 +0,0 @@
package de.mannheim.th.chess.utl;
import static org.junit.jupiter.api.Assertions.*;
import java.io.IOException;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import com.github.bhlangonijr.chesslib.Square;
import com.github.bhlangonijr.chesslib.move.Move;
import com.github.bhlangonijr.chesslib.move.MoveList;
class OpeningRecognizerTest {
@BeforeAll
static void prepareOpenings() throws IOException {
OpeningRecognizer.loadOpenings();
}
@Test
void test() {
Move m = new Move(Square.E2, Square.E4);
MoveList moves = new MoveList();
moves.add(m);
assertEquals(OpeningRecognizer.compareOpening(moves, "Unknown"), "King's pawn Opening");
}
}