From 2f1d9b4b9cc7015754555fb1d22c3ed8b476f293 Mon Sep 17 00:00:00 2001
From: utente <utente@172.30.118.244>
Date: Tue, 15 Apr 2025 09:45:38 +0200
Subject: [PATCH] Merge branch 'master' of
 https://gitarero.ecam.fr/marleen.peterson/OOP_3B4_Project.git

---
 default.board                             |   9 +
 pieces.png                                | Bin 0 -> 954 bytes
 src/Main.java                             |  22 ++
 src/backend/AutoPlayer.java               |  17 ++
 src/backend/Game.java                     | 110 +++++++++
 src/backend/Move.java                     |   5 +
 src/backend/Piece.java                    |  21 ++
 src/backend/PieceType.java                |  28 +++
 src/windowInterface/JPanelChessBoard.java | 196 ++++++++++++++++
 src/windowInterface/MyInterface.java      | 269 ++++++++++++++++++++++
 10 files changed, 677 insertions(+)
 create mode 100644 default.board
 create mode 100644 pieces.png
 create mode 100644 src/Main.java
 create mode 100644 src/backend/AutoPlayer.java
 create mode 100644 src/backend/Game.java
 create mode 100644 src/backend/Move.java
 create mode 100644 src/backend/Piece.java
 create mode 100644 src/backend/PieceType.java
 create mode 100644 src/windowInterface/JPanelChessBoard.java
 create mode 100644 src/windowInterface/MyInterface.java

diff --git a/default.board b/default.board
new file mode 100644
index 0000000..8d83268
--- /dev/null
+++ b/default.board
@@ -0,0 +1,9 @@
+BR,BN,BB,BQ,BK,BB,BN,BR
+BP,BP,BP,BP,BP,BP,BP,BP
+  ,  ,  ,  ,  ,  ,  ,  
+  ,  ,  ,  ,  ,  ,  ,  
+  ,  ,  ,  ,  ,  ,  ,  
+  ,  ,  ,  ,  ,  ,  ,  
+WP,WP,WP,WP,WP,WP,WP,WP
+WR,WN,WB,WQ,WK,WB,WN,WR
+W
diff --git a/pieces.png b/pieces.png
new file mode 100644
index 0000000000000000000000000000000000000000..01cc2f8e0723c40907fcafb30d2044adb1dbd2ff
GIT binary patch
literal 954
zcmV;r14aCaP)<h;3K|Lk000e1NJLTq003YB001Be1^@s6?ZACh00001b5ch_0Itp)
z=>Px&bV)=(RA_<KS=(;xFbKq}{Qobz4-M%Ub5FY6A{{Ab4a@)rJ1LPZQ~c}59ox43
zob$57=Oh;DYtMIMTI6uZ&^LFYF$VuO3ce@US8eauPv_b7!FY^`_+l+d<-#`&ULKh-
z28}TmVh%`0JlnzeR7gJa1}D4_;cfad{zBp}E)lLQK-6B=y8LY_0c<)B&gCPUIK<R8
zjKf3Kl|}3%KZu`*))BO|8CG7lC&8{f!NPW9b+8Eo5dJNLCHd$#z|kC~b)OJswzaO3
z0BvoMQ8*d2wmXgSvT;!`Q~H3R#i3P2^_AdYs4pB;o0kR3$@10++6voE3jo)$J0E^b
zj}VKq;BCpUbUMkej-aj#z9mGnQt7BLn8XOV@Dby`$P)$lRY@jvC}+@nhj~-n0(5p$
zbckhlvo+H_+f}`Ejyx&qRoJ>n93+CyBv1*&Oq{|ll?3Z58QD>Akp8lm*j5papY>-F
z_|!G7(E+F0t>l*zXgEm&ZX>9f!1N&qw-hUoZ8N-SbSxaZQZ4>gfJ_4KfM-5!RAwmJ
zMI2yF^HZ4sCXebFxEx$X2W8v9$LS)4Z@xqo@XOd44k-s<yOF3m_#pf0+~~&caVU%b
zN{Wh&lZ}0JY;W50I2qzO#A3m>yX8#}){C6-GEbrN>nHrb<OA(H96I)FhcRUMBOYLG
z&lNryT=VY%-nSrycuPFnbJsC`YPZcfr#$5Gc9!8P^tX?aSz#^_?n@eZ%GSF44HLlu
zXgW^>pkZqDvUnK2wjy?t@5Rq@NFzyDK7;PhNe%$nS?gU#<xXb*mT#GS^qYCRM|t-f
z^dQn(S4qIO#)p$uI2p9IJGJqmagmr=ea0|i+A?kVia2P3dGTys7APmnTf?>z?WPf0
z=Bh{9D_%50EY8Tmu^pC9C;6oj)D`T4XjaOO$^;XQ5ZQ&5aq|iC@qZ7<BvjtnPrH9n
z3AX^97&6~d9NVRvDt@t>s^`d)qG970lGuj~I+H*dh?h7i*(5ku$?%p{z4<&P9=274
zgXq}=KDD{39dO#*N`5DSnpAR7{v54I<q(8hiW-Qv8Qw8EB*(5)i(meOj7Kg59*w!`
z3`M($1Fva*iW9)(Q9T0>x!65KGqwpIS0_1l@pkYLe#J+}w~8l>Q`XTg{0sZ)wNvYW
cJN8}q0;pW6z5*s-O#lD@07*qoM6N<$g2Ji5hX4Qo

literal 0
HcmV?d00001

diff --git a/src/Main.java b/src/Main.java
new file mode 100644
index 0000000..870cae7
--- /dev/null
+++ b/src/Main.java
@@ -0,0 +1,22 @@
+import backend.Board;
+import backend.Move;
+import backend.Piece;
+import backend.PieceType;
+import windowInterface.MyInterface;
+
+
+public class Main {
+
+
+	public static void main(String[] args) {
+		// testing : 
+		Board testBoard = new Board(8, 8);
+		testBoard.populateBoard();
+		System.out.println(testBoard.toString());
+		
+		// launches graphical interface : 
+		MyInterface mjf = new MyInterface();
+		mjf.setVisible(true);
+	}
+
+}
diff --git a/src/backend/AutoPlayer.java b/src/backend/AutoPlayer.java
new file mode 100644
index 0000000..a988a22
--- /dev/null
+++ b/src/backend/AutoPlayer.java
@@ -0,0 +1,17 @@
+package backend;
+
+public class AutoPlayer {
+	
+	
+	/**
+	 * returns the best Move to try on provided board for active player
+	 * @param board
+	 * @return
+	 */
+	public Move computeBestMove(Board board) {
+		
+		return null;
+	}
+	
+	
+}
diff --git a/src/backend/Game.java b/src/backend/Game.java
new file mode 100644
index 0000000..4c64f70
--- /dev/null
+++ b/src/backend/Game.java
@@ -0,0 +1,110 @@
+package backend;
+
+import windowInterface.MyInterface;
+
+public class Game extends Thread {
+
+	private AutoPlayer aiPlayer;
+	private Board board;
+
+	private MyInterface mjf;
+	private int COL_NUM = 8;
+	private int LINE_NUM = 8;
+	private int loopDelay = 250;
+	boolean[] activationAIFlags;
+
+	public Game(MyInterface mjfParam) {
+		mjf = mjfParam;
+		board = new Board(COL_NUM, LINE_NUM);
+		loopDelay = 250;
+		LINE_NUM = 8;
+		COL_NUM = 8;
+		activationAIFlags = new boolean[2];
+		aiPlayer = new AutoPlayer();
+	}
+
+	public int getWidth() {
+		return board.getWidth();
+	}
+
+	public int getHeight() {
+		return board.getHeight();
+	}
+
+	public void run() {
+		while(true) {
+			aiPlayerTurn();
+			mjf.update(board.getTurnNumber(), board.isTurnWhite());
+			try {
+				Thread.sleep(loopDelay);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	private boolean isAITurn() {
+		return activationAIFlags[board.isTurnWhite()?1:0];
+	}
+
+	private void aiPlayerTurn() {
+		if(isAITurn()) {
+			board.playMove(aiPlayer.computeBestMove(new Board(board)));
+		}
+	}
+
+	public void clickCoords(int x, int y) {
+		int width = this.getWidth();
+		int height = this.getHeight();
+		if(0>x || 0>y || x>width || y>height) {
+			System.out.println("Click out of bounds");
+			return;
+		}
+		if(!isAITurn()) {
+			board.userTouch(x, y);
+		}
+		
+	}
+
+	public void setPiece(boolean isWhite, PieceType type, int x, int y) {
+		board.setPiece(isWhite, type, x, y);
+	}
+
+	public String[] getFileRepresentation() {
+		return board.toFileRep();
+	}
+
+	public void setLoopDelay(int delay) {
+		this.loopDelay = delay;
+	}
+
+	public void setDefaultSetup() {
+		board.cleanBoard();
+		board.populateBoard();
+	}
+
+	public void setBoard(String[] array) {
+		board = new Board(array);
+	}
+
+	public Iterable<Piece> getPieces() {
+		return board.getPieces();
+	}
+
+	public boolean isSelected(int x, int y) {
+		return board.isSelected(x, y);
+	}
+
+	public boolean isHighlighted(int x, int y) {
+		return board.isHighlighted(x, y);
+	}
+
+	public void undoLastMove() {
+		board.undoLastMove();
+	}
+
+	public void toggleAI(boolean isWhite) {
+		this.activationAIFlags[isWhite?1:0] = !this.activationAIFlags[isWhite?1:0];
+	}
+
+}
diff --git a/src/backend/Move.java b/src/backend/Move.java
new file mode 100644
index 0000000..5f64282
--- /dev/null
+++ b/src/backend/Move.java
@@ -0,0 +1,5 @@
+package backend;
+
+public class Move {
+	
+}
diff --git a/src/backend/Piece.java b/src/backend/Piece.java
new file mode 100644
index 0000000..ffa88bb
--- /dev/null
+++ b/src/backend/Piece.java
@@ -0,0 +1,21 @@
+package backend;
+
+public class Piece {
+
+	public int getX() {
+		return 0;
+	}
+
+	public int getY() {
+		return 0;
+	}
+	
+	public PieceType getType() {
+		return null;
+	}
+	
+	public boolean isWhite() {
+		return false;
+	}
+	
+}
diff --git a/src/backend/PieceType.java b/src/backend/PieceType.java
new file mode 100644
index 0000000..baceab1
--- /dev/null
+++ b/src/backend/PieceType.java
@@ -0,0 +1,28 @@
+package backend;
+
+public enum PieceType {
+	Pawn, Rook, Knight, Bishop, Queen, King;
+
+	public String getSummary() {
+		if(this == PieceType.Knight) {
+			return "N";
+		}
+		return this.name().substring(0, 1);
+	}
+	
+	public static PieceType fromSummary(char c) {
+		if(c=='P') {
+			return PieceType.Pawn;
+		}else if(c=='N') {
+			return PieceType.Knight;
+		}else if(c=='B') {
+			return PieceType.Bishop;
+		}else if(c=='R') {
+			return PieceType.Rook;
+		}else if(c=='K') {
+			return PieceType.King;
+		}
+		return PieceType.Queen;
+	}
+	
+}
diff --git a/src/windowInterface/JPanelChessBoard.java b/src/windowInterface/JPanelChessBoard.java
new file mode 100644
index 0000000..78a68de
--- /dev/null
+++ b/src/windowInterface/JPanelChessBoard.java
@@ -0,0 +1,196 @@
+package windowInterface;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+import javax.swing.JPanel;
+
+import backend.Game;
+import backend.Piece;
+import backend.PieceType;
+
+public class JPanelChessBoard extends JPanel {
+
+	private static final long serialVersionUID = 1L;
+	private Game myGame;
+	private MyInterface interfaceGlobal;
+	private BufferedImage spriteSheet;
+	private int PIECE_WIDTH = 16; //in spritesheet
+	private int PIECE_HEIGHT = 16; //in spritesheet
+	private int MARGIN = 6;
+	
+	private boolean pieceSelectorMode;
+	private boolean selectedPieceIsWhite;
+	private PieceType selectedPieceType;
+	private boolean pieceAdderMode;
+
+	public JPanelChessBoard(MyInterface itf) {
+		super();
+		myGame = null;
+		interfaceGlobal = itf;
+		selectedPieceIsWhite = true;
+		selectedPieceType = PieceType.Pawn;
+		pieceSelectorMode = false;
+		try {
+			spriteSheet = ImageIO.read(new File("pieces.png"));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		pieceSelectorMode = false;
+		pieceAdderMode = false;
+		addMouseListener(new MouseAdapter() { 
+			public void mousePressed(MouseEvent me) { 
+				// System.out.println(me);
+				if(pieceSelectorMode) {
+					int x = Math.round(me.getX()/cellWidth());
+					selectedPieceType = PieceType.values()[5-x];
+					selectedPieceIsWhite = (me.getY() > cellHeight());
+					pieceSelectorMode = false;
+				} else {
+					if(myGame == null) {
+						interfaceGlobal.instantiateSimu();
+					}
+					int x = (me.getX()*myGame.getWidth())/getWidth();
+					int y = (me.getY()*myGame.getHeight())/getHeight();
+					if(pieceAdderMode) {
+						//TODO
+						myGame.setPiece(selectedPieceIsWhite,selectedPieceType, x, y);
+						pieceAdderMode = false;
+					} else {
+						myGame.clickCoords(x,y);
+					}
+				}
+				repaint();
+			} 
+		}); 
+	}
+	
+
+	public void setGame(Game simu) {
+		myGame = simu;
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
+		this.setBackground(Color.black);
+		if(pieceSelectorMode) {
+			g.drawImage(
+					spriteSheet, 
+					0, 
+					0,
+					Math.round(5*cellWidth()),
+					Math.round(2*cellHeight()),
+					null
+					);
+			return;
+		}
+		if (myGame != null) {
+			// Draw Interface from state of simulator
+			float cellWidth = cellWidth();
+			float cellHeight = cellHeight();
+
+			g.setColor(Color.white);
+			for(int x=0; x<myGame.getWidth();x++) {
+				for (int y=0; y<myGame.getHeight(); y++) {
+					boolean isSelect = myGame.isSelected(x,y);
+					boolean isHighlight = myGame.isHighlighted(x,y);
+					if(isSelect) {
+						g.setColor(Color.blue);
+					}
+					if(isHighlight) {
+						g.setColor(Color.yellow);
+					}
+					if((x+y)%2==1 || isSelect || isHighlight) {
+						g.fillRect(
+								Math.round(x*cellWidth),
+								Math.round(y*cellHeight), 
+								Math.round(cellWidth),
+								Math.round(cellHeight)
+								);
+					}
+					if(isHighlight || isSelect) {
+						g.setColor(Color.white);
+					}
+					
+				}
+			}
+			
+			g.setColor(Color.gray);
+			for(int x=0; x<myGame.getWidth();x++) {
+				int graphX = Math.round(x*cellWidth);
+				g.drawLine(graphX, 0, graphX, this.getHeight());
+			}
+			for (int y=0; y<myGame.getHeight(); y++) {
+				int graphY = Math.round(y*cellHeight);
+				g.drawLine(0, graphY, this.getWidth(), graphY);
+			}
+			
+			for (Piece piece : myGame.getPieces()) {
+				drawPiece(g,piece);
+			}
+		}
+	}
+
+	private void drawPiece(Graphics g, Piece piece) {
+		g.drawImage(
+				getChessPieceImageFromType(piece.getType(), piece.isWhite()), 
+				MARGIN+(xCoordFromGame(piece.getX())), 
+				MARGIN+(yCoordFromGame(piece.getY())), 
+				null
+				);
+	}
+
+
+	private Image getChessPieceImageFromType(PieceType type, boolean isWhite) {
+		int x = spriteSheetPositionOfPieceType(type)*PIECE_WIDTH;
+		int y = PIECE_HEIGHT * (isWhite?1:0);
+		Image subImage = spriteSheet.getSubimage(x, y, PIECE_WIDTH, PIECE_HEIGHT);
+		return subImage.getScaledInstance(
+				Math.round(cellWidth())-2*MARGIN, 
+				Math.round(cellHeight())-2*MARGIN, 0
+				);
+	}
+	
+	private int spriteSheetPositionOfPieceType(PieceType type) {
+		return 5-type.ordinal();
+	}
+	
+	private float cellWidth() {
+		return (float) this.getWidth()/ (float)myGame.getWidth();
+	}
+	private float cellHeight() {
+		return (float)this.getHeight()/ (float)myGame.getHeight();
+	}
+	private int xCoordFromGame(int x) {
+		return Math.round(x*cellWidth());
+	}
+	private int yCoordFromGame(int y) {
+		return Math.round(y*cellHeight());
+	}
+
+	public void togglePieceSelector() {
+		pieceSelectorMode = ! pieceSelectorMode;
+	}
+
+	public void toggleAdderMode() {
+		pieceAdderMode = ! pieceAdderMode;
+	}
+
+	public boolean isPieceSelectorMode() {
+		return pieceSelectorMode;
+	}
+
+
+	public boolean isPieceAdderMode() {
+		return pieceAdderMode;
+	}
+
+}
diff --git a/src/windowInterface/MyInterface.java b/src/windowInterface/MyInterface.java
new file mode 100644
index 0000000..b7e2549
--- /dev/null
+++ b/src/windowInterface/MyInterface.java
@@ -0,0 +1,269 @@
+package windowInterface;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.SwingConstants;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import backend.Game;
+
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.awt.event.ActionEvent;
+import javax.swing.JList;
+import javax.swing.AbstractListModel;
+import javax.swing.JToggleButton;
+import javax.swing.JRadioButton;
+import javax.swing.JCheckBox;
+
+public class MyInterface extends JFrame {
+
+	private static final long serialVersionUID = -6840815447618468846L;
+	private JPanel contentPane;
+	private JLabel turnLabel;
+	private JLabel borderLabel;
+	private JLabel speedLabel;
+	private JPanelChessBoard panelDraw;
+	private Game game;
+	private JLabel actionLabel;
+	private JCheckBox chckbxBlackAI;
+	private JCheckBox chckbxWhiteAI;
+
+	/**
+	 * Create the frame.
+	 */
+	public MyInterface() {
+		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		setBounds(10, 10, 650, 650);
+		contentPane = new JPanel();
+		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+		contentPane.setLayout(new BorderLayout(0, 0));
+		setContentPane(contentPane);
+
+		JPanel panelTop = new JPanel();
+		contentPane.add(panelTop, BorderLayout.NORTH);
+		JPanel panelRight = new JPanel();
+		contentPane.add(panelRight, BorderLayout.EAST);
+		panelRight.setLayout(new GridLayout(4,1));
+		
+
+		actionLabel = new JLabel("Waiting For Start");
+		panelTop.add(actionLabel);
+
+		JButton btnGo = new JButton("Start/Restart");
+		btnGo.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicButtonStart();
+			}
+		});
+		panelTop.add(btnGo);
+
+		turnLabel = new JLabel("Turn : X");
+		panelTop.add(turnLabel);
+		
+		JButton btnLoad = new JButton("Load File");
+		btnLoad.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicLoadFileButton();
+			}
+		});
+		panelRight.add(btnLoad);
+
+		JButton btnSave = new JButton("Save To File");
+		btnSave.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicSaveToFileButton();
+			}
+		});
+		panelRight.add(btnSave);
+
+		JButton btnAdder = new JButton("Add Piece");
+		btnAdder.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clickButtonAdder();
+			}
+		});
+		panelRight.add(btnAdder);
+		
+		JButton btnPieceSelector = new JButton("Piece Select");
+		btnPieceSelector.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clickButtonSelector();
+			}
+		});
+		panelRight.add(btnPieceSelector);
+
+		JButton btnUndo = new JButton("Undo");
+		btnUndo.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicUndoButton();
+			}
+
+		});
+		panelTop.add(btnUndo);
+		
+		chckbxWhiteAI = new JCheckBox("WhiteAI");
+		chckbxWhiteAI.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicAIToggle(true);
+			}
+
+		});
+		panelTop.add(chckbxWhiteAI);
+		
+		chckbxBlackAI = new JCheckBox("BlackAI");
+		chckbxBlackAI.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent arg0) {
+				clicAIToggle(false);
+			}
+
+		});
+		panelTop.add(chckbxBlackAI);
+
+		panelDraw = new JPanelChessBoard(this);
+		contentPane.add(panelDraw, BorderLayout.CENTER);
+	}
+
+	public void setStepBanner(String s) {
+		turnLabel.setText(s);
+	}
+
+	public void setBorderBanner(String s) {
+		borderLabel.setText(s);
+	}
+
+	public JPanelChessBoard getPanelDessin() {
+		return panelDraw;
+	}
+	
+	public void instantiateSimu() {
+		if(game==null) {
+			game = new Game(this);
+			panelDraw.setGame(game);
+			game.start();
+		}
+	}
+
+	public void clicButtonStart() {
+		this.instantiateSimu();
+		game.setDefaultSetup();
+	}
+	
+	public void clickButtonAdder() {
+		panelDraw.toggleAdderMode();
+	}
+	public void clickButtonSelector() {
+		panelDraw.togglePieceSelector();
+	}
+
+	private void clicUndoButton() {
+		if(game == null) {
+			System.out.println("error : can't undo while no game present");
+		} else {
+			game.undoLastMove();
+		}
+
+	}
+	public void clicAIToggle(boolean isWhite) {
+		if(game == null) {
+			System.out.println("error : can't activate AI while no game present");
+			if(isWhite) {
+				chckbxWhiteAI.setSelected(false);
+			}else {
+				chckbxBlackAI.setSelected(false);
+			}
+		} else {
+			game.toggleAI(isWhite);
+		}
+	}
+	
+	public void clicLoadFileButton() {
+		Game loadedSim = new Game(this);
+		String fileName=SelectFile();
+		LinkedList<String> lines = new LinkedList<String>();
+		if (fileName.length()>0) {
+			try {
+				BufferedReader fileContent = new BufferedReader(new FileReader(fileName));
+				String line = fileContent.readLine();
+				int colorID = 0;
+				while (line != null) {
+					lines.add(line);
+					line = fileContent.readLine();
+				}
+				loadedSim.setBoard(Arrays.stream(lines.toArray()).map(Object::toString).toArray(String[]::new));
+				fileContent.close();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+			game = loadedSim;
+			panelDraw.setGame(game);
+			this.repaint();
+		}
+	}
+
+	public void clicSaveToFileButton() {
+		String fileName=SelectFile();
+		if (fileName.length()>0) {
+			String[] content = game.getFileRepresentation();
+			writeFile(fileName, content);
+		}
+	}
+	
+	public String SelectFile() {
+		String s;
+		JFileChooser chooser = new JFileChooser();
+		chooser.setCurrentDirectory(new java.io.File("."));
+		chooser.setDialogTitle("Choose a file");
+		chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
+		chooser.setAcceptAllFileFilterUsed(true);
+		if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
+			s=chooser.getSelectedFile().toString();
+		} else {
+			System.out.println("No Selection ");
+			s="";
+		}
+		return s;
+	} 
+	
+	public void writeFile(String fileName, String[] content) {
+		FileWriter csvWriter;
+		try {
+			csvWriter = new FileWriter(fileName);
+			for (String row : content) {
+			    csvWriter.append(row);
+			    csvWriter.append("\n");
+			}
+			csvWriter.flush();
+			csvWriter.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void update(int turnCount, boolean turnIsWhite) {
+		turnLabel.setText("Turn : "+turnCount+", "+ (turnIsWhite?"White":"Black"));
+		actionLabel.setText(panelDraw.isPieceAdderMode()?"Adding Piece":
+			(panelDraw.isPieceSelectorMode()?"Selecting Piece to Add":
+				"Playing"));
+		this.repaint();
+	}
+	
+	public void eraseLabels() {
+		this.setStepBanner("Turn : X");
+	}
+
+}