From 91da7823ad0e6b30e8eb87b738a56519e4fbafb3 Mon Sep 17 00:00:00 2001
From: "basile.blanchard" <basile.blanchard@ecam.fr>
Date: Tue, 22 Apr 2025 15:49:04 +0200
Subject: [PATCH] final deposit

---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 .classpath                                    |  10 +
 .project                                      |  17 +
 .settings/org.eclipse.core.resources.prefs    |   2 +
 .settings/org.eclipse.jdt.core.prefs          |  11 +
 bin/.DS_Store                                 | Bin 0 -> 6148 bytes
 bin/Main.class                                | Bin 0 -> 808 bytes
 bin/backend/AutoPlayer.class                  | Bin 0 -> 417 bytes
 bin/backend/Board$Position.class              | Bin 0 -> 828 bytes
 bin/backend/Board.class                       | Bin 0 -> 10760 bytes
 bin/backend/ChessTimer$1.class                | Bin 0 -> 571 bytes
 .../ChessTimer$TimerUpdateListener.class      | Bin 0 -> 287 bytes
 bin/backend/ChessTimer.class                  | Bin 0 -> 2838 bytes
 bin/backend/Game$1.class                      | Bin 0 -> 974 bytes
 bin/backend/Game.class                        | Bin 0 -> 5241 bytes
 bin/backend/Move.class                        | Bin 0 -> 2650 bytes
 bin/backend/MoveHistory.class                 | Bin 0 -> 1027 bytes
 bin/backend/Piece.class                       | Bin 0 -> 913 bytes
 bin/backend/PieceType.class                   | Bin 0 -> 1572 bytes
 bin/windowInterface/JPanelChessBoard$1.class  | Bin 0 -> 1835 bytes
 bin/windowInterface/JPanelChessBoard.class    | Bin 0 -> 5339 bytes
 bin/windowInterface/MyInterface$1.class       | Bin 0 -> 730 bytes
 bin/windowInterface/MyInterface$10.class      | Bin 0 -> 744 bytes
 bin/windowInterface/MyInterface$2.class       | Bin 0 -> 742 bytes
 bin/windowInterface/MyInterface$3.class       | Bin 0 -> 737 bytes
 bin/windowInterface/MyInterface$4.class       | Bin 0 -> 740 bytes
 bin/windowInterface/MyInterface$5.class       | Bin 0 -> 742 bytes
 bin/windowInterface/MyInterface$6.class       | Bin 0 -> 738 bytes
 bin/windowInterface/MyInterface$7.class       | Bin 0 -> 741 bytes
 bin/windowInterface/MyInterface$8.class       | Bin 0 -> 736 bytes
 bin/windowInterface/MyInterface$9.class       | Bin 0 -> 742 bytes
 bin/windowInterface/MyInterface.class         | Bin 0 -> 11814 bytes
 default.board                                 |   9 +
 pieces.png                                    | Bin 0 -> 954 bytes
 src/.DS_Store                                 | Bin 0 -> 6148 bytes
 src/Main.java                                 |  19 +
 src/backend/AutoPlayer.java                   |  10 +
 src/backend/Board.java                        | 621 ++++++++++++++++++
 src/backend/ChessTimer.java                   | 166 +++++
 src/backend/Game.java                         | 220 +++++++
 src/backend/Move.java                         |  64 ++
 src/backend/MoveHistory.java                  |  55 ++
 src/backend/Piece.java                        |  36 +
 src/backend/PieceType.java                    |  26 +
 src/windowInterface/JPanelChessBoard.java     | 196 ++++++
 src/windowInterface/MyInterface.java          | 387 +++++++++++
 46 files changed, 1849 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 .classpath
 create mode 100644 .project
 create mode 100644 .settings/org.eclipse.core.resources.prefs
 create mode 100644 .settings/org.eclipse.jdt.core.prefs
 create mode 100644 bin/.DS_Store
 create mode 100644 bin/Main.class
 create mode 100644 bin/backend/AutoPlayer.class
 create mode 100644 bin/backend/Board$Position.class
 create mode 100644 bin/backend/Board.class
 create mode 100644 bin/backend/ChessTimer$1.class
 create mode 100644 bin/backend/ChessTimer$TimerUpdateListener.class
 create mode 100644 bin/backend/ChessTimer.class
 create mode 100644 bin/backend/Game$1.class
 create mode 100644 bin/backend/Game.class
 create mode 100644 bin/backend/Move.class
 create mode 100644 bin/backend/MoveHistory.class
 create mode 100644 bin/backend/Piece.class
 create mode 100644 bin/backend/PieceType.class
 create mode 100644 bin/windowInterface/JPanelChessBoard$1.class
 create mode 100644 bin/windowInterface/JPanelChessBoard.class
 create mode 100644 bin/windowInterface/MyInterface$1.class
 create mode 100644 bin/windowInterface/MyInterface$10.class
 create mode 100644 bin/windowInterface/MyInterface$2.class
 create mode 100644 bin/windowInterface/MyInterface$3.class
 create mode 100644 bin/windowInterface/MyInterface$4.class
 create mode 100644 bin/windowInterface/MyInterface$5.class
 create mode 100644 bin/windowInterface/MyInterface$6.class
 create mode 100644 bin/windowInterface/MyInterface$7.class
 create mode 100644 bin/windowInterface/MyInterface$8.class
 create mode 100644 bin/windowInterface/MyInterface$9.class
 create mode 100644 bin/windowInterface/MyInterface.class
 create mode 100644 default.board
 create mode 100644 pieces.png
 create mode 100644 src/.DS_Store
 create mode 100644 src/Main.java
 create mode 100644 src/backend/AutoPlayer.java
 create mode 100644 src/backend/Board.java
 create mode 100644 src/backend/ChessTimer.java
 create mode 100644 src/backend/Game.java
 create mode 100644 src/backend/Move.java
 create mode 100644 src/backend/MoveHistory.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/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..81d1c9ef34b0e751f25257965d140ef88ca2f662
GIT binary patch
literal 6148
zcmeHK!AiqG5Z!I6O(;SR3OxqA7OZV4h?fxS4;aydN=;1BV9ZLAnnNk%tUu(J_&v_-
zZpB)qH<3C6vu}2GCShK}?ha#&dy{CNF`F@Ff+E%|7`_o)M_rPd_S6A6J|lk&6A{Af
zHGEu(CdXf70Kc8VLKd?$EI)t0B+iRY=Z)8l`o?C%Y?w{+%D)q(Uj)S@_k!#KXQx6W
z;oJ_wvv^#N?Cm3w7D1ejGno)aV+grCkJCt$o|vRjE^~dgU|Oa%vRl(>chG4&z5Za<
zcBThiu=~BiY-X7|yL*Qxqx<9`70-%74u6}JEsb+{0Yg{w<Y#Fj(p&Igw83(gv75E2
zQC9P%#yJaw!~iis46I^6@1kaNRUoYs1H{0;V*vLD2NcoOSSgfS2Mn?W0K{vg6tJ<E
zz#K=TtFclDD<E8@0;*K5TMVw!!SCoeS7W76r8BOZ53b+Lb%(;`+u`|+3}@U`NFy;o
z3@kEWsHu(T|MAcL|6&r&hyh|?tr+0-p+EGXBz?9n6^Cc719}aLf^n6?j}$QEQ4Fzo
d6t_U7fZss_(A8Ke1P=&Z1SAbK5Cgx;z&nwsgpB|I

literal 0
HcmV?d00001

diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..463d5f9
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.project b/.project
new file mode 100644
index 0000000..14798d9
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Project_2</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..99f26c0
--- /dev/null
+++ b/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..9a7984b
--- /dev/null
+++ b/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=21
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=21
diff --git a/bin/.DS_Store b/bin/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..dbc1dc901c0e38412af0d87130e46c54667025a4
GIT binary patch
literal 6148
zcmeHK!AiqG5S_KrrWUaWg&qT53)Z$2#7l_v;MIs8RBB?PhQ@4ZQ*$VVob`wN62Hfp
z-7VNw5ig>42WH>w&Q8KS*x4NbV9qGm1E>IiiArd!<M4rypL9W1)QW+~#5Y1nAn>zc
z-;Wn|>jlk#X5hCmKxelIK6r2gJ$QG1xsRR~zaK}#v|fK@D+Ob9t!Ng_vU%m+^UO`X
zbTo9l!3E7uIgkCR?fGX>m~|^#hdfEWC<zB5APPd<a(Nyl0nZ#hN`j$?b)~~BnWb)}
zIvzLL^_taewI?-eyx%~()of2DC3Aac_u!=4iyspHBxz(=b%bmvoWe62b6GvQgCyq3
z9eOBg6EcXXS^-Dv7_AhuAHc0(B9t}k&vWoamUEm;+0(cj45-s%mX{-4ouy_#Gw=-t
zs6JSzgto$5q9`3Wh!y~mo)JROre1<#EQPkhTq1f<m<&afp-i<HOorpSrS{nhbBQt>
zm})+l`ZH4<3KM_F?^|L!Fk7M?H3OP~Sq2JnTA};@==1)6Hb~Dj1Db(<#Q-xpZpXot
z)ZMy}9No1R>NP3}?aL*K5FFHXEDXAetEfWIXOV$uE6gS03W|OR2paUD8Te5K-T=Od
BkwyRj

literal 0
HcmV?d00001

diff --git a/bin/Main.class b/bin/Main.class
new file mode 100644
index 0000000000000000000000000000000000000000..f5ea01de0f62bc5194228fdac83fed9e8986a800
GIT binary patch
literal 808
zcmaJ<ZEq4m5PlYp9(O$~l~R?qwxw$C+S>Eo4;T|QF(EnB1anF2rv<jS2zTUIZ0f(#
z50KczAK;HN&K|~w)c9p)cW3r_=9!tFzrOzf@B&XwWEhMFmyrpBq1fY}x!>ne*MHmU
ziMC=`cqSvMo-<@!FQnX8aYxw5!g7$q0>e@uBk^WDXo=)KZ}kPk)gW&3e#jH4?|&W*
z^-+!pEzn#w!WocfSam-H7o1I%$f#TMLKDjjg%)pr5>dy08S|uLqll8`Tw%z$^|}}8
zmsJPXbQOhRJRJAA5^1i58(1?@nG@7J8!0hxu#OE96OTz-dB!bc{~Zx4q8EHn)3}=s
zwy@2RSMjVUh85SlT&j&7+%|EGp_Iy)hjMTSyA0+~qxVT}*}V**)p`tTr!wlqr}apQ
z<b=0{-#Ghww&B9k=D@*S95UD=p+Y&5X}=BkIGqeny42y)KN`wlDKS!MZ}i0G8cV~-
z4tggH8^M1{pe(x?kCV1|E%lHsJ;y_>8QUNPS|=bwCt3=!Cf$7UjC^iyiu~6!Y?IYt
zP{JZvXO=*|KsO6lutYEV^A{K?sC$m$Q88c4Pie3ACn$fzb#gZ+sGh?;nqseUU`()o
xfnOm8z$VN^8l-~?VOHt1i{+GaYlchZ-AgN2$9+5?)++sbh)1c2#}vun$!}XztGNIG

literal 0
HcmV?d00001

diff --git a/bin/backend/AutoPlayer.class b/bin/backend/AutoPlayer.class
new file mode 100644
index 0000000000000000000000000000000000000000..c69dc033770d93a3c77b97a360fa6e4ea9d20e2d
GIT binary patch
literal 417
zcmZWlyH3ME5S(@FIGBI~M6`%5p}-wY5K@9fWgZeJ{n<Xj1;>Y+b0q!>DkKU%fR94#
z*&!)tW^Q+9_ICIC=kp7|7=0fOVLuV+vn;Y`Tp4|ri&t6ta0$JcSc)hY#bb1v%w%c^
z?Q>Nqb3teghEsxjsWTa%g{>|;v<YFX3VBn_6InipB$wPg)~U#+qEt3sC0+BR7KDEM
z|K|}mN%j1tGIAmp=2|bg$<bh~oM=&Iqv1NX0`_=`&D#O~S~fyLaIdQ}l~>A66K+;K
zwcFtsybIp~aQMYLF!~%t%*5=Se4z7Qmjgyy1{<~+yN!T(ha<u+LPl#oV|JJwdb5a)
Wvr{_{o9fDG6+P^+hp$!Z4}JkrhEgs7

literal 0
HcmV?d00001

diff --git a/bin/backend/Board$Position.class b/bin/backend/Board$Position.class
new file mode 100644
index 0000000000000000000000000000000000000000..cd4c57af2769161f8000af56eaae28b3fe781dab
GIT binary patch
literal 828
zcmZvZPj3=Y6vfYD1_tRsr_@#~VE-!vMwTpUOtguSgjSOp5?%R#mokVml^KkF4L?CQ
zx?*EuHF05Fx$rX?<9XB3;Ge~tx$n-s_x$deZ$CbL25=j$g_OW*PxhZGf6%-W$jM;m
zK@fV87x)%T0cRv%$mUr3$Ibh_k?KbR;w4X;=aoR_rssRnErE2c-FCYI=6*0xIT)~Q
zWRVvzYHs%e1Qu<ik<rnT4GS4&I-ai%r_Xw7@=*51N}$*Y`f}Wr6Hnihq!|spP@vTL
zKjj`F)bptvvu35%`5Sl7eXMCN+gL+cAbYH${jm&Lyj*kVs^cVQ89{HPLH?P;-jl=_
zf&5WK%MRp8!k8V(aHuzr_oX+vqhLDetGk|FD;N8ELyr`&+rF<Rv78DmT;;Go7NgFu
zAHeWXh0(nrjIcrD4F0neirPm;MeQQr2ESyXjm`1)h!whSvHlSY_3{}C^~xEXcTDM4
z-DdK+#%GyL6%<g#GBX?JZMcXP-Z&tZ5pkr2QWRLlr9|d+BGalj-Xd+z8eb{&0i_1d
z8>Ed{;|s(={XGiTc~0RlbQn6Py4sj=tTBhP$z8Tk!Zu-c=5SiSaau&JQoKs^D@06T
zoii3-S_SbP6^ow)ci2q$S}`w>ch)t;P|H8js^=zTSO&PUk{!qSM9CnBuG%IC=%^mM
Li))N(aentF2Jw&k

literal 0
HcmV?d00001

diff --git a/bin/backend/Board.class b/bin/backend/Board.class
new file mode 100644
index 0000000000000000000000000000000000000000..379f5628881695d6338ae4d04020ffa92583c55f
GIT binary patch
literal 10760
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

literal 0
HcmV?d00001

diff --git a/bin/backend/ChessTimer$1.class b/bin/backend/ChessTimer$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..19751247909cede6486f2d5c354aedeb7a17f193
GIT binary patch
literal 571
zcmZuu%T59@6g`E3fpHW>9=>J40x<zG#*N0r5RE3tM#8>8Bb8ysOgsLUiI2pEAK*tB
zZwUz|u;}f%x96Vw=+E!hH-IaYZNwPzeLffqf7ob^gi>8O5n-ii!(!NY;xD`rY3Vhl
z;VxHWhNK=zRXL`__G0Eay<bRQ>Pv=Fbs6EX$6&RBp-6*a#YF;12XU;ru(8GvuNp$8
zEq&36CVdfhdEXNZxppw%UXO>;__Ls8T45+IsZ(iEEAcS$9TZTqQ6!1Qc3o_mqE7TY
z<XV^^$$1E(a3F4^DVv!urEa!Ck!ye81xosl_d<_?p^H5ukx-h4n!&yEeG#@iu9TqG
zQXQf6ZJ;#DG;W;M&azoEGoctA8!3vX37wK}B2Mk-oy;fP*C{7MHc1?yjx1SsiXE&Y
zM;?6=)@BN4bQ@l(_6Fwz`FXxGRc=zXlYbhinTCZe%8FqdJ9JyLuU+gDa%Or2aX=@A
F!XKcAZ+ZX#

literal 0
HcmV?d00001

diff --git a/bin/backend/ChessTimer$TimerUpdateListener.class b/bin/backend/ChessTimer$TimerUpdateListener.class
new file mode 100644
index 0000000000000000000000000000000000000000..0cb8f196621aada4faa5c4d7a7ca9be15928a9a9
GIT binary patch
literal 287
zcmZvXO-{ow5QX0)P27Z(MsNj$!iJmyRa8(RSn#u8=O!a?2u>86inDdm18^vWoi13w
zW=8t-H1C_Q@9hr21#*FaaJrV&8|%7Uys|M5>Yay^aX$97w0xtCWzB=YgpfCKBg<Cm
zm-24iaAgTur+s=KCPc+*b@oJ<?eXPjuLiCOlj7Oq^uGHTDqgCV3G?5^bAQ+!yVkC1
z(Mn_32+Rmaf9(jz|M(H6w`}ZHXKYL$gziNkaMBTCczJ=TBOwyck>bGZ)FoXl4&wy#
Gk!L?|dPZdc

literal 0
HcmV?d00001

diff --git a/bin/backend/ChessTimer.class b/bin/backend/ChessTimer.class
new file mode 100644
index 0000000000000000000000000000000000000000..a590880eb7972d1db2e8c8bba4b21797c7fe7a62
GIT binary patch
literal 2838
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

literal 0
HcmV?d00001

diff --git a/bin/backend/Game$1.class b/bin/backend/Game$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..9057994065deb30c7eb81b5d5bb771e47e8e79da
GIT binary patch
literal 974
zcmaKrU31bv6o%jBD<xe%N)@ZL78EH^Euz(%I?gy)wG6ZuR-EZwfNfa}Nhb-SKg*d~
zXT0zS_@f-phCn|qnoM@jp51-UyXS2F{`>t0z#F{O5MoGnjouew^=t2qkto(RL>SUT
z<Ev3K4eO+K&>f1Nry<5rnyqXMgzFy4k#LHB`{}fAc%mg;PgufXh<O9)7M~KkHQS=#
zJ2dl3TGD&XuvES}Rp~H98g^gA!I0q4u%IK16h|CshHzOeNVTLT_Q#{Ha1M>GDHt*>
zyJwgk!;xwnI3p@N9pXxaVx7Ws+fst3dKseSX0y_XV+Hp#+@<NuYB_RPrO2b<F~eGG
zBCWnX*|R+192-4RYk!~HJ38(ouVI}bcf&G{0<sij>}ShQ9H~rA2GSF1)Rv~Hbh9RT
zyCzlTvNti6zWeP|I-*a>Dj!ukDsY*jf)c}`M~wM&Qo5fNc<x|F4EjfV?DWJtsZtkL
zCD~Girf|Df&$L}>owS8Fu=^_ORK9%q#$&6J@I8x4-Y^Z<6|RQoRFYW|FK!9LvVYv`
z_heyTxZVfb^^m8khv|!grPHeTbV0-P#i5gTk*sZm=mqrZ=1=hIFC>4^D1;?yW3&cX
zMTT1L+d7tUi$)B$kqrn3M30g$Q9T1c!=3fQIo2*9x{uEjpx}e@zJNpkqHTD9hdw-k
zB3VlABa{O8+dv)<;JI^bTxXZ)AR9hA>&N1AHb)hkM2g@s2@K&0wy2NL#jK%DR)&00
RJi~TO{T|cj1$7~;{0E>s%OU^(

literal 0
HcmV?d00001

diff --git a/bin/backend/Game.class b/bin/backend/Game.class
new file mode 100644
index 0000000000000000000000000000000000000000..162fa6ea1ce2bb6e61a455eb9798311bca18e97b
GIT binary patch
literal 5241
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
YIQtX-FX1mGW&Fn@_rLcz2>Gx1FS1$rQUCw|

literal 0
HcmV?d00001

diff --git a/bin/backend/Move.class b/bin/backend/Move.class
new file mode 100644
index 0000000000000000000000000000000000000000..c2730bdf0492f6f10b130c2a1810fdb6151ce3e2
GIT binary patch
literal 2650
zcma)8T~8ZV5IxuU3$p}cFpfhAga9!H;(U-c!6a?shC&KST2s<A{m5c(VT0{O_JYLU
z=u=<%-iJP<Qk_aX^tDodRMj)P3z%i83evr^bMKrvGk0d>zyCS>6Tl<rF@zMfO}(;X
zG^&L)Yu|_=tdM-G@9Tw{-q<QU-+XISY=y`VO{@Nuf?Dz9R|;LWMGaTVJ#}l}Y;3(S
zjf$brw|a!>D2fWb6@Ay<YZ_JWMs(3^nD#@3$=nM6eD{5y(;Euml2tVl=t94SUZm(Z
zH@(pfg+UDwL`53X5ObxA8se^WNkg|QUDl95kKDVWK|_zQG#kdVz51rnT-P^i<egfz
zDtc{0Z<_M$DZ}=**;2T0OiJ>^km6g0z2s(vT$q<51=A7b*}7!M6{xvD4Gm9n)SsI^
zMm)+=l9x)S6BTbAdkN=OBojv(al=E`jU$K~3a8wpay~Btk>oAEAKNP1P10jV$?T*8
zTx~Iq4-^tl>bv&A7~k4Rv4ZYtxQ_*eOkLkGN>-zy+b>Ofn^Mcx8#a?Rlq;<SfTj2f
z_Y!!3k78gA^q#5~4Ikr?LQGP4u*+9T`!gl#Vge;RiQyB4{!`|1s9_27q)UkMUcIh2
z4^jwWS?Kbep61Sm_kT12fv_&6F{E<NWK1DsTMVvjv%l8#U9X%HWoxflF_ugzxNfPX
z8)C{wd2CsB%WmqsYlgjTRa*&sf%O>53KJ*bW@F#lF$(UhxH(_aE4I}<km$Zt_^C5G
z@3srLtT(DPqcyQ=Svz~X#j}h%G^Y%me0LmrCGomL<<5y>XNo+Cl3uHoP1`8;Me%tY
z?1_+4aeU3xDK)1!e^wd|qgkryt(MV>;akpxGvNjW5X1NE<^R6Q7ICA+RhC>AYc|S4
z;Jly|l4;@WoE6T_N#X3A6VA>l!M%@`y|}=&k6*tycED8r4<z%$Z4Bfuw~@||w2{fD
z!);{q*+?71`E0a}k>4DgQLf{hNWdV%NOK|$5if%QTtt@tqqu}g3}cKpmdT3f<U7t?
zBw?!@N%)2wNf=8sQ!?F%DUz^`IFj%d8_r3OwMjd{xaP1932QECSu(O@^GY~#IYaph
z;YaCajFhjE@;FIf!w4oQO*)h{7uut&csk*^EpQjNk^Ju%_?1G4Q1S+%%yk$?j*TY+
zjnjVP=|JPDK;w+xI3H+yJ<vGoH=YSJ&S5$r=HYj~m}dix^MS@Ae&e}7;~C6)o)?&2
zDUYaAmM5j>ru(L2J>=dvF0ZIpUJ7%;IB7r5t#fdsIOVl(1mk4<IJeKik<u2NLNHF&
zk8|f79BB-}xrtj`rFBp8Gs9x{<IJCfBW)!(w}Wvy`o+!j-E(lHDFx>a=D7-=pV`9F
z#7pds;lB_~-F=tTrBmMgn2d8zR}b+au<9r?o-#{i5m*zO_gH+7$1}5s_!N+8>2lg@
z$Qc9oIY<^b6c(v_K%WmCUSqCD@BK${9Z&HY`OI@vtWpYL&B0OfQ|lSU5T4@&_d$Md
V@Z!sk^%Y+8Bth*r_zrK7{TCpK#C`w(

literal 0
HcmV?d00001

diff --git a/bin/backend/MoveHistory.class b/bin/backend/MoveHistory.class
new file mode 100644
index 0000000000000000000000000000000000000000..4170f591121e85ee9a2c5b639d8fa5b0ccd6a4a1
GIT binary patch
literal 1027
zcmZWn%Wl(95IvJPb>cdS(^qJDl=MZCLIOy1ld9sOA{Hq~1cG39<5;OnVn>cssh`3Z
zuwhXoXeE#kYd#7w*S1n8Z0_~UoH=Li8UOkF;}?J@c&H*lSnLS%qvdq#NA9Wh!XEjq
zccwxi7$@RX)ceBe)n9c^EYl}s28?O>+(0NagZkLF`}H8z;CjpMIl>=%7NIm--*3j1
z8V8J@+qWItKOiK_l{P_n=5{R&Nn~|opsC0c@-r$La>!;tSkRHe90QuRW4#;?I+piF
zbo#8k&~#1FZwt?sag<d2V|zqco*E*0E>EI)mg#z3=>b2jJcVjh+ER5*$93G`DTm|H
zF=3}1J}_obqw;@>@zOLxZkm%Y-?RLt82O>5QLan_q~wN<O>7ZVdvrJ$`e%VrA7o`m
z#~qY89=b!q5;xCotD&Mw(BqyHvcaZ~#4vJ2HHGum>AHlJ*|&rzsp~rKL1Rl=?$|S}
z=eG3JkW)r>)ua?kyn`hFM}&l21m7x038XpVKLHw_^PG9gDB|0wUP7<_MDG11jPEFX
z4bY2x<^rBP6d1^(fF;i9VGowE!V#f}YZJZ%s{mT{8w$G@SbcZJqy?2#R$mKPRzhUN
z!acZ&Tg*dP$L)ykbr1tZ$#;R$C#2{+{NDbJ$~j9VaW&=!lWg*M+p#f=k-%<%B{}<D
zY(@Ns5x+6vSCgNiC|@ST(mS9QBQ#=!DI{`_<;c7gKBc95e9M+}NLiaT;1RE4FGiQ1
L*m$425_s?rDowhh

literal 0
HcmV?d00001

diff --git a/bin/backend/Piece.class b/bin/backend/Piece.class
new file mode 100644
index 0000000000000000000000000000000000000000..65ae2a445bdf4dbd003c384f7b9689d3ccb63918
GIT binary patch
literal 913
zcmZuuO>fgc6r6ROgv9Pw+LR`3p=tR@EI}^ZKu8D)DN+PQQ~`Q(+*P|J*eG!kz43!M
zfJB7Efgiw+Ld@G(trGd*-M70l@6C+={`>t0z%#VVa1@q?Ve~=AC*4D%BVC58uzDVT
z4!ff;KJC65p6e)8P+$1<_+2Wv>E$P_u->0z9`W+ALfK5-o|%;I>R6%l#Kb0js?ccn
zdO7&x&Vc=%Cnvg!0#<$aSW_spJA(>1!AB7#sp>w;v+Aag8>q-#!$%dK!b;!7`sKyP
zp&lQF!x1Of`biXy2I1JqIlFYzGcytNoN7^gs#6iqDecbuYvzf1=*1=OofXF%<nUg>
zo9Of~nV8fhu|kn1#ZdK4axsqd3nOBxHrIy|DO!|WVD>H?amLCKUv{S}yVDc*5|KWZ
zxGwYb)#8C>@Cz%!_7t^XXNryB!4#W8-JN3Vhvhc8Hf_HOXH?nIBj3k5J2hBs^ZgMg
z3u*_u+@%sF%2uMqv6ZM1rA^70y%cWYcBZDwUGT-=CpN#ca0r`82G;Ble+I~gFa+%7
zkhi`qkn6eR7WQ+<wMB9xmwb>*-dH5>=92H=ZZ`QfO-df#b^6zlFWaXUgWRXn1KVnE
U2EU5gyNcPfzuaNtd)EH_{|**(hyVZp

literal 0
HcmV?d00001

diff --git a/bin/backend/PieceType.class b/bin/backend/PieceType.class
new file mode 100644
index 0000000000000000000000000000000000000000..c969af821837dbe5c10378d3f3c3510f4637eae4
GIT binary patch
literal 1572
zcmZ{kZBr9h7>4gdlHE;M5l&Mo;tNG7$%>{_#nwbbDYi&>(S^)p+Ao{9hLvQ4n?#4-
z(Ld70Iy&vt>F4%8b-d3ZXvU<&49}kHoaa8z+sQxw{qYXKJ(Nt02uxJG>VY3V$?XJw
z)!#ij^i9MC#-4dEyj<N2Yq_<s(-4U7crQbN&x!-*^W1#gY#s<08(~n}Z}a1R(AsYv
z3M3wNe4lRdjUcSigkHlJkj0PcZad-@HOyA0(eR=pfzh?Cz0J#|d&RvqS0Me<&?~J%
zwH|~)ds!fs$(E?S+I-?$NLZK@5QixUoUt*5vka%uJ9#@Zc=P%o8YJ0Ll6vQCBw$!D
zEnMUskz!xkFcq^bTqX+@`^tu;Skgk4tfJTz8%f1d7Os&!SL|yWDaA%DTqiqF?52%T
z80zbmjnfzxI9&`vf2-4|_|dLcsq6YRt6sh2MS)stm_iJBm2N>`a#)tf87$kdaZ0JL
z*cihpmaV-Xv{?O`-`>*ANoTTy`3t0Yz&+`Z@xrTje7a3$vcuYw!jE`pVqIXouhU1Z
zw%@R^fucatiz4r++B{^xo&I>YE6@CDJKx`x6SS_{Z0f7Gp9;+PyY<E>J7iW=X?ARE
z;t{Lc@3UI>TCMzGvi<q1;pcFs+-4`L`VRtC{;>~F<(kTl$+$r+^xB<>n{$17%DFHk
zqUHR`B3lsSGfb{bshI+3IY-)ZcC_WZXv-PVmUBT5sXC}F`v;7lRa3&X!I_)jF5f6u
z|LU{AFMmRmWjZF)^7A+N;uWSfI3Jhi<pm99G?-1uS$Ro=ISu9wIWIFBI2tUNazS3z
zAg95iB^Tv48r&E+{^C8cE~edbyo(vPoakcCEgM}pZrSW2=a#K5Zn&?o^c%w)!MFT>
zfhhxVhMmAH1HR7n_e^7tPvt4g^PN7aPV*V}68o7vK`xyu=icD9bM-auI8*W0xcgC8
zQWG3+gQXc|aVGeuv}Sb4C4c)=Ax}!F+91_qpqIdXtoClo(F*P*oZoThSAHA^ZD^R*
zg7)!&o}ggx!<_Ga>U?I1a}sNKKsnXCC1$9in(Sh!yb*KWl?$r8o3ZJ)_+jBwHSwWN
hNe=l|Ps3rjD*BWZ&RcB%4e|eeBY3RSbFr)K-h1ffDA)i1

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/JPanelChessBoard$1.class b/bin/windowInterface/JPanelChessBoard$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..717b32519963fb0e8d4e1032a747021d4859c9ff
GIT binary patch
literal 1835
zcmah~-%}e^6#i}!SlC{E^as%jRIF4J(54`*Z38GoexxRdg+fcUy6oPPEt}oU?gnJ0
zPd@k;)Q7%weB;>}h>Q=8Gd?)ui*Ne3=#18LHX&0>mCWq!x#ymH?)|=VzMEhE{{9C5
zQ>bW&37p@yUCZ0fyP@*$8>Y(KSTtPa<Vq?Crai;A21hg`1bQDBTSms%4l`;?xnZX0
zRRc9;85LS5&>EKPVDJ*9D;$?EOVQ)DYlo8p7gEQEr&k0LInPq<5I7;xf>s@IbVz9E
z6o{udpsQfJYN1+QSN^iG?kIs%1<y2`6~niA+;ArNm;!^x?m9R^$CPEpxaboT$`Ux2
zD!hn;8KxtfUTH@XFKc*7VBk0kB+lX$fs++mnQBQn$_zcfNDu|YnvOo4)6g$)_CL3i
zcohRg%Z3VXM-=3B+Wox5>lhShH<jb8+E!SK=4N%gfs}?f1v;aQj^S=(ibhzHNMlH#
z#rLW%0ZgQ3)0F5fT-5M39dF$*H<fE;7WtUVI~6670oAy5%W$fScuc0!cMC_NvdqM&
z#5)+HBtZmES<NH@r(dv!QD2dG_Yl?{26Rp0Is?)f(7duYN+IVSmzZGw&ipHPK3FZ;
zA$3U-?@7FmDLQC*XU-@StDVgqc^n-uC-DJhsB`SY&YyF<b;A+pKhhn=ou)jpI_8kq
zFi(njzRb^rN!;M(q~t+pxS?%?YRN8Fbri6mp-8=TNE;tW;v>f0M&*pk#@H7)_NK%V
z&$QD_9Y0UqWQ;2kt4u;?)I?L3rJ@evRd*!TaF_B0DvW5SR!XfkDQH$Ao6o0Lc)_O<
z_wX61%XDmWGv|4}Mb&Ld)#sBiB-R;@=BtW9d<n#u)!zTngMj#go;*D}0v$^s^-|HO
zG<2vhc~#$3vo<TW=lL7wB6lf~H{+U)7ufDbQH3SXV!@Y5T}SVXXNV^u61jQTResJf
zNVo)~Z9xU$ycdKRperO!m!IhF=6i&!7(E)=$lp%Z7>(JZ4-N0r>pRGAqnIvww^9sn
z3ElLTk*(t-PSJ=u8fWSm#5a^TLB8LI_Mq>f=P~lbHS~VP!x~<54{%|E?E?(A^;x6)
z7~v6xTyBJ1{rU;C#4Zx?ePnr#zCFA6lFdC#{)~>gHC@9jXKwgw_^`xg4U5hMr)&B@
zZupm-$-3{>W273h^-r|T9!C25Yq-rW+Va*ex*9?3{)FusK4&`OU^-?AJV@g@k=BdL
zbdy}c4C%Lst60P}>cH!;Fph_$)km1b6O!Zs{p<XQY5as7ex(e*k(QXwF(Qp9YtYG-
zNo%RWFbakHRFa3JgSzzyS!|FmjuNdILF-dW8rL8+^ii{ENIoTh(-9+w_!Awc|H3^X
h{=f;Uj!gkEJisP>6C@=EE?GKl$Q9<FM^6mNe*l5MxWWJc

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/JPanelChessBoard.class b/bin/windowInterface/JPanelChessBoard.class
new file mode 100644
index 0000000000000000000000000000000000000000..1090ea18b31d8a90911cef29e1b09c185b88af75
GIT binary patch
literal 5339
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
VJ}T|}BHzH3e~P`A<w{}0e*u!j!w>)f

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$1.class b/bin/windowInterface/MyInterface$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..9c35eb68751d0030ffc971a972d241ceaa77ade1
GIT binary patch
literal 730
zcmaJ<O;6iE5Ph4Zabn!YK!LPC`N|;#34_E9go+RdBtt8;%6;Q3W+P`;vKJzL7E%F;
z13!Qtg_w1tmIJb-S<j5#n|U+4&o7Tp01mL`pv15^lB%yqr^<-*f=41ayZPt0wjER$
z`~kn_LBdrW{OAotWE@n9m}mLO1mapK6C6ZFY8A@N2qjX6s=1U|Ym0zkL5p1i?nx!h
zKEram5V_uEs2u9PsDt672M0A5Wi&k0;WL!m7SIT#66aULo=AW5ULqK#LLKp>%TsCN
zak65?F)S4|Y;BXc2G7U(Nz2jcQ1pq@4&R;p$ZlbGz3ZZhuMWO2%ooh<Vcv?KFglJ&
zl^oiYF_ODbRGq>7rLWRR97{Wz|K_eXttiraq@qM;QpIP&Tx!zmohrJI!-Qv<ppk3m
zA~PpCGgziImdQSV`M%vIy^0c99WG@j$lIaVX57xk9lXv1KHcV+Njj^90b)$i>E*tQ
zX?&)LVFt6~3g78(E7UrF;N4^HKi|#slKKwv8nb_K;~K=k0v3r~!8hWUuta)6Q4<ZU
PkY_bo1@>DdE1~%cN<yb`

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$10.class b/bin/windowInterface/MyInterface$10.class
new file mode 100644
index 0000000000000000000000000000000000000000..bb3f51429c3ba40763d10666a1b8b216f439bdcd
GIT binary patch
literal 744
zcmaJ<+iKfD5It+FR-~%2nx?rlH@EeJ<3f}|-&_jDq{N`4g#<t3Z7px*4azP^o0xu9
zAW0##{eXT{>8vnmABqICni-DHoHMImzwdtn=%ekT#;`q;YNBUDWkmjkCn7rf`jEHZ
z?z?ap!gGGbql~LG`ZPWliE+_j*ebhxW+HJVl!^L@ky^#FFhYr(p<$-7Xzvp+u9(py
z;Crd0`M}WXR3djr49-ALga?Kv0bDHjsG}LcL&#9?SU@wDN*rHaj75IR$C+SQigm)X
z5znQq=S|0oqlr}m$v&xT^3vC5T93{z#Drm|6aUxxfn7sycjRLYFI=oMY*ZKzuz^j6
zAjxFXAD-$owPKylS!t8!DQ#}EY7m2eqA&AAe3bUf@Sls@v-(K-fl4x6NR=K5Gu0$L
z7%IA(LB@+hko|>YQJ6zr7_?}mb&5w|VQ4o?zetV3gHPSZl)a<ccKq&}TLj&2SiCMV
zPw8wB2Drx(ok5xVc!p)F7@lKg&d{GTc-<QW^*gNoCGbn??=<#DNwQMb-kikB*upl^
dIM^Z58p(Z0Z-*A$#4F0INGriUuPJI+`vZn=s{8-|

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$2.class b/bin/windowInterface/MyInterface$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..9a0206599ad4b01638b08799f4eb2a0ee930975b
GIT binary patch
literal 742
zcmah{O>fgc5Ph43I5CE}EtEhhDJ6$ANElVziV!F&B9dDURJm`QrP<0|SKduqeijlR
z5(j<&KML_SjerZm(yV7jZ{EC_-5)={eFyLgj{;N#HZQc96c<C|RQX<JDmnP@+wblM
zs0qX;@?0jlG{?!?@rlY@fV#kz&t4{$^~Z@iSH>lSDKRS5)+wV(fx4S&+kMI=>5?vc
z1U}bByB8$wEk*8(1Zsm~qM8u65g|Y$L=~+FO~eA#o(Hs2ZPelHbgarFInI^9YFcD6
zAIVbtc#*7maRQxX4ZFJ(7g;Brx|(ewu-!}lHTk~Z!rsm(L>u=4+!feZGIxXxFM4Hm
zHX;9z3(zt@(x((GXr2GG5eVNEvoce!wVyHm>)xJtfn3DC$@0STeh!qI7StXM4KHSp
zOKTNpZyYM?-W1khi~Fq7u0h1HUn^foh1NvK>~(t282e1vfBYFy|0`~OoMTpa)`<bm
zu*x%<`ytkFi;=)>tS=Z|^6wcM{ZEL#;Le}=aGo#O*UmZCuW$<vR^UE1SzW^e)>qJ>
VUNCB-g@^RKMz6qs+q4SWzW|I!tWW>|

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$3.class b/bin/windowInterface/MyInterface$3.class
new file mode 100644
index 0000000000000000000000000000000000000000..ed184d2a7e85709d2e98807ae7a6172e37ef62ad
GIT binary patch
literal 737
zcmaJ<O;6iE5Ph43I5DO+l#fuLP{<*q60QU{D#VAVKr*xvRqh*S35(3GWN(N#Aoxp_
zXpws859p7oI%}fBp|Yh}&y3!ic{97e|NQ&~U=M2!N(@Uwsd{>Ntc*y{c`U+{n}2?D
z(?NwHxa8M7Ot|WYpSzbLHV&#p%(HxGLUApW3HM?nwTfhBgc2!3)m+G|`GJ5@L5pny
zew0d@9fp-wA#%OLP&v>&Q3u0>2M0A5W%wTI2pGyO3-BYU#OdIwE7GsLn+S%fNXI<s
z@KoA(l&n~B49i6go0}xg=lNJ)XgNB)5<TLyqW?~QXt%Jv-f_{u8wc|Y3k7p~Sg@k~
zIFa%Gz!<I03{MSB$kRS8ZLz2cgL|e2X)HcTJ7MtR$~LSvs(Yy7L}ya<PlUP9B-=Yy
zbS(!7&oV)i*G@%dj&x?QLfb5pje!M$T`E0}5?LKCWyi_eqS$8K_WSSf+K+hkEyqmK
zStSf`izzz2+;{OB(-bkxV0Khtm;Sawt^EM+2j-snZl1rRzV~^J*(cnn1~IURC1O|b
amiQ$slU`8NfRA_NS&deK{Z`3JX#52ze5z#t

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$4.class b/bin/windowInterface/MyInterface$4.class
new file mode 100644
index 0000000000000000000000000000000000000000..b2b70725cb40f70e9691dc43e8b3a7218e2ec8fb
GIT binary patch
literal 740
zcmaJ<+iuf95IviuapJm72v9=rg*>D|!aU@y2=$_(R&raUR(anz({w9$SF$&a_yYuA
zgTzJRfe+xLP-jh4ctEx^>zUCxGiPS^*Y6)c0qo(qhmyeBROykK9&1bKrHm;&d4KPB
z`W`9*&1-op!$j(Fcs9JI*m|fkG0)1W4e6G&4fkTJjE+=hNmD9NwO1<ZykcNf&|-&y
zua#EzjlgEN5V<`Ns2rFP)giDDz(dVP8I1sSGzH3C2WUh})9K`9Na=+fCM3{`Oe~Xu
zOqGjg$%+#vuu;^o(`RuFnUD33mt)c!8ZoCE{de+1w}qYUfsZzpJv<dyDVRIJiWA+6
z6BS2Bj^3(-_9xaF%|ps`%zIlc>LcKvn@JjzBk~pfb89c1JXU_F<HTf2k59;68CD(~
zYrdI-L}nTB@U>IQ?2*YVHhH0CwmFDq)9sbtM~STtpR@Dq^*MGKzxU!Rg5Gy5e$Fuu
z_^dJp_<$ClLGJr_h({a=JjT+j!Y=<^g<9_mf^T^8m+$BKkKFfDUSsJGZdQXCSj8H%
cD_CcK2^*{z9JSHF7JE*kQ{cX5Y$des0OJR%eE<Le

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$5.class b/bin/windowInterface/MyInterface$5.class
new file mode 100644
index 0000000000000000000000000000000000000000..600ae77d24cf489b5afb60d0d6b9759f0da1846f
GIT binary patch
literal 742
zcmaJ<-%k@k5dOBUz4kn9`Dqmpgg%s#a6ZTr#()GP$$=)2zHhH%S#s<qciT4n7X<zi
z6Vb#6{{a6e<LuF>59ThJy_w1P&3rSvKYxAy0bm~+9!df$6Qu`ca-=P#pJYto@zo!{
zz2l)G(7cdi875K>!w>xnimit#6Z5Q`*pSAgZMYv>Wpt!6OPW%Fsy$a(`y~UTf)=|B
ze66&yZv@slg~-jGK;^&;s1AWg0X)=vl+g%KM^m8OaezjoG@Xnt`;?x^enJAXk%?u}
zlc{p?G+A-t1Xhb0ws%-uL*`?B<mH(3k_OD_ME{-q&~0INv*)9QXC9skEEUWhV9AM|
zj}sN2$}ydpcPgQ`BWsQ3F=aaB%`F#o67WyWD2>Sx`I7#*w{0howIAv@F`3fCW3uOl
zwFgI<@8%$pSw=j5?SwM>-eeYQywWn;1BhnRZI)k1iLDNwvk%#O#j(ry-K{$W-EVmO
zImgWKS!E1xjafc}-1jkud5#1YusE%-$A4F$*8PIuE1vx2`+5F```+d?7VmM>8qB~l
eR+wGEbLN+@%6h?33k|$r&uMfD+_%nFLhCp9ovdpB

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$6.class b/bin/windowInterface/MyInterface$6.class
new file mode 100644
index 0000000000000000000000000000000000000000..2306f9dd2cc2557ea318336739146e83e5d471ab
GIT binary patch
literal 738
zcmaJ<+fLg+5IviiI5BSH(iT!K4W)SqsZ{r&;st~n5U5CoR%(^^jlG1WW>>N|MEw&)
zzoJqvQXlvLJ_>c#M9_!ImS#OOI%nq0>|WpexdPC~OBWS}m5Ee|o*XD6vSS{L@bK%M
z-`Q~CFa)RkoQEk_qwvG<RK&(bjfh2-PfRGzg)(73Hd3od=0+%yG1Sb7%sX!g7?rfx
zB;b}*(rh!Vc1w}#0|sYTC!zs{2R>ZXJyg;3(LlgZ?OH%Hl1dzn&xRuV%!jF9n2U7G
z(*e(<ji*V+ieqS(HSBDVxF#>g`bf*s*_lX)(~bT+`JUav=K8=x3yUtEF)WqL?PJM`
z4&qeCUv|dEXw^>=yElhtBih<>Sr-QHlOAWW*q3(1;Ga8tZN-u9Jr$=qmuhq<%!wx5
z{(+)<*-d$#3mUzCBy#g!=LV~^&MMgqSP<B)((9;@HQ-Tpmb|wV+l<$H^%H*YHy(a3
zFpuc05eB%x9G!mQdw7f|6fr!-{ItS5`r8Wi-VgY{uyD`!iu@(@{Z`bNzr{^!5Ch9t
dA-03(#IK-DdO=YOO}rq_YP1UMw?<Y$>n|SGs`>x`

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$7.class b/bin/windowInterface/MyInterface$7.class
new file mode 100644
index 0000000000000000000000000000000000000000..38431834f49b81b1f39774000612004569999615
GIT binary patch
literal 741
zcmaJ<O>fgc5Ph4NI5CEpei3L(3*?Xnspe3rhayC&im2okq@vt6&X8_#cO`q%sQ;#d
zUx3tt#DO2ck3!6v2sj{Hn)S@+&CHv(`{U=g?*Ml3*hfuZb*l8pOb@iB{Jl&mKD_wj
zcej0b0@0~FmvJWbIDRucrPTUpaABF1QybGcX&djRRvDeB!jh(3pkYr`(S6Fmq+-Ml
z1D`3a>~n$jUL|s4AmHtp5w#$2D};|`fI8YCT8ISdJqKtfO4HHgY)JV#Im}34E-|Uh
z1~OMJo+Uj;PGGHSV0W9zwPm^1TNcOUXEfrPUh?0~_nitm8-oBH-1l)$V7X%N5X+AA
ze445B!^?@aMjung+8UP5llhp1Td5i(5FDFHp3*Djwv7I{woS*6sqgDFGlkOQL$W7^
zsfP!euVyckMM1oM^N0%j+7uS+tZ1F>21FD&Vflg7*jflUdy~B_j$J0`Ke<NO|BBn6
zOUxZU8;k)iF~?_E`T^##z>&ZrmS!DZ@ZWW4_OB3r!QH?0L7D%^b3c_mmVV=AJ-7lZ
fSmkOD54gUDHRcPBI%wk|dyb=H;J!y}HFSOfXH2Yk

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$8.class b/bin/windowInterface/MyInterface$8.class
new file mode 100644
index 0000000000000000000000000000000000000000..767e31c91d0eb4a53be35b3745088b08a53ea856
GIT binary patch
literal 736
zcmaJ<O;6iE5Ph4ZabgTHl#jH07IH{Zsph}|2~<H5Rguhx1kHWpEMbweE7=>O{v$+B
zm0FN`=nvpWRm{3k%b~KRS<j5#n|U+4kH3HZ0<ez_2L*=ZkyJfBI#Na?mpl@|@t41T
zW7|QA!N2A=JczmK2dCX@5g7+%B4$}WGJ&`e$^`q7ky?c^HA0Dmp=_>X+SnvunA2j1
zfV)yj^PXX?nTu?77)l4aC#qnW^x&Z4qKKM@Dtv}w(*kOtRN`bf=!)cmcVodY6Y7Y^
z9iB)VkCP=Uj$t*gVPl)b)p$1687)UA1JNT+GyL!5hjt4)t&WR2UORZju$VKqhea!T
zDvD+FnJ(bN&={>~K%VqzXG?iK7~FF`Od|17+5!D%H}=j-Bh`m0ighYg|5%tSO{%>k
zMYnPg^E4GSc;!T-=95kh)@YeUvKL^!Z+A*>qd-=LOW6tXwkWn4xBd19y!Hd8zGawc
zI?IFsZZSirm-#MUVwNI?In0kM?9ty=sI<SsyT`&mzMJLmsPEUT#{3`LxCSw>gk@rv
butNL-R!J`?s-uQC<XMeYf&JFW3aCE;S-`4y

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface$9.class b/bin/windowInterface/MyInterface$9.class
new file mode 100644
index 0000000000000000000000000000000000000000..5e786c4620ea08fb3550f5918eb872da166fcd12
GIT binary patch
literal 742
zcmaJ<O;6iE5Ph4N7#l+jZGrMl$swdt&7l`Wg%lyGMlw*TC<ksEXKNOjUCCaE`m<2^
zkb3A3;76g(S`l!lY-!drqnS5v-tObmpT7XQXt}5{td67_>QPS_k^kh0h>m_e`>kCU
z4nugsuX&Vll}0Cn3y~NX4Qed2d}JbVEtHA6iIG~xvM@r4oS|XPWzpK9!nk6@9u<C(
zN}7F!jdo?_cAvpH&_m&YVLE_|Ngs7I19%7->TO%ljHMFCSC<2kpYlN_80KP~@T|{s
zY2$IyvE&%ms|L1qiCmMHYkenibbcv@)YFdtyZND2VQ;(dV-ZU(-ZLy$>>XekD-1!B
z$)wvm)oE(EI_<M^OP;4B+)C9T2LFe?$`kQb+RpIRwSBVui29*QGF?cO9tm@<iF(je
zbTtPVFA721PaccHeA9)&1}R!6n*a+#D=a;b8kq;5vQy-Jrr2iu&c{0hod?X^lr^(-
zHmC-;!5p1I>HBztw-hnF!~7VbJ4Wz2w+NhjEW7~tCG>9^ds~9cm$5enu{2h(MlcT6
a3A9FZH|g(?&`o?G&yuth?6*Z$!{R?(tg4Uz

literal 0
HcmV?d00001

diff --git a/bin/windowInterface/MyInterface.class b/bin/windowInterface/MyInterface.class
new file mode 100644
index 0000000000000000000000000000000000000000..bd02fed74bef2b4893b61a34f52b444ee50580a5
GIT binary patch
literal 11814
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

literal 0
HcmV?d00001

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/.DS_Store b/src/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..dbc1dc901c0e38412af0d87130e46c54667025a4
GIT binary patch
literal 6148
zcmeHK!AiqG5S_KrrWUaWg&qT53)Z$2#7l_v;MIs8RBB?PhQ@4ZQ*$VVob`wN62Hfp
z-7VNw5ig>42WH>w&Q8KS*x4NbV9qGm1E>IiiArd!<M4rypL9W1)QW+~#5Y1nAn>zc
z-;Wn|>jlk#X5hCmKxelIK6r2gJ$QG1xsRR~zaK}#v|fK@D+Ob9t!Ng_vU%m+^UO`X
zbTo9l!3E7uIgkCR?fGX>m~|^#hdfEWC<zB5APPd<a(Nyl0nZ#hN`j$?b)~~BnWb)}
zIvzLL^_taewI?-eyx%~()of2DC3Aac_u!=4iyspHBxz(=b%bmvoWe62b6GvQgCyq3
z9eOBg6EcXXS^-Dv7_AhuAHc0(B9t}k&vWoamUEm;+0(cj45-s%mX{-4ouy_#Gw=-t
zs6JSzgto$5q9`3Wh!y~mo)JROre1<#EQPkhTq1f<m<&afp-i<HOorpSrS{nhbBQt>
zm})+l`ZH4<3KM_F?^|L!Fk7M?H3OP~Sq2JnTA};@==1)6Hb~Dj1Db(<#Q-xpZpXot
z)ZMy}9No1R>NP3}?aL*K5FFHXEDXAetEfWIXOV$uE6gS03W|OR2paUD8Te5K-T=Od
BkwyRj

literal 0
HcmV?d00001

diff --git a/src/Main.java b/src/Main.java
new file mode 100644
index 0000000..7732cc8
--- /dev/null
+++ b/src/Main.java
@@ -0,0 +1,19 @@
+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);
+    }
+
+}
\ No newline at end of file
diff --git a/src/backend/AutoPlayer.java b/src/backend/AutoPlayer.java
new file mode 100644
index 0000000..3e67f52
--- /dev/null
+++ b/src/backend/AutoPlayer.java
@@ -0,0 +1,10 @@
+package backend;
+
+public class AutoPlayer {
+    
+    public Move computeBestMove(Board board) {
+        // This will be implemented in Part 4
+        // For now, just return null or a placeholder move
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/backend/Board.java b/src/backend/Board.java
new file mode 100644
index 0000000..9b876b0
--- /dev/null
+++ b/src/backend/Board.java
@@ -0,0 +1,621 @@
+package backend;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Board {
+    private int width;
+    private int height;
+    private Piece[][] pieces; // 2D array to represent the chess board
+    private int turnNumber;
+    private boolean isWhiteTurn;
+    private int selectedX;
+    private int selectedY;
+    private boolean hasSelection;
+    private Set<Position> validMoves; // Set of valid positions for the selected piece
+    private MoveHistory moveHistory; // Added move history
+
+    /**
+     * Position class to store x,y coordinates and enable using them in HashSet
+     */
+    private static class Position {
+        private final int x;
+        private final int y;
+        
+        public Position(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+        
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) return true;
+            if (obj == null || getClass() != obj.getClass()) return false;
+            Position position = (Position) obj;
+            return x == position.x && y == position.y;
+        }
+        
+        @Override
+        public int hashCode() {
+            return 31 * x + y;
+        }
+    }
+
+    /**
+     * Constructor for creating a new chess board
+     * @param width Width of the board
+     * @param height Height of the board
+     */
+    public Board(int width, int height) {
+        this.width = width;
+        this.height = height;
+        this.pieces = new Piece[width][height];
+        this.turnNumber = 0;
+        this.isWhiteTurn = true; // White goes first in chess
+        this.hasSelection = false;
+        this.selectedX = -1;
+        this.selectedY = -1;
+        this.validMoves = new HashSet<>();
+        this.moveHistory = new MoveHistory(); // Initialize move history
+    }
+
+    /**
+     * @return Width of the chess board
+     */
+    public int getWidth() {
+        return width;
+    }
+
+    /**
+     * @return Height of the chess board
+     */
+    public int getHeight() {
+        return height;
+    }
+
+    /**
+     * @return Current turn number
+     */
+    public int getTurnNumber() {
+        return turnNumber;
+    }
+
+    /**
+     * @return True if it's white's turn, false if it's black's turn
+     */
+    public boolean isTurnWhite() {
+        return isWhiteTurn;
+    }
+    
+    /**
+     * Places a piece of specified type and color at the given position
+     * @param isWhite True for white piece, false for black piece
+     * @param type Type of piece (Pawn, Rook, etc.)
+     * @param x X-coordinate
+     * @param y Y-coordinate
+     */
+    public void setPiece(boolean isWhite, PieceType type, int x, int y) {
+        if (x >= 0 && x < width && y >= 0 && y < height) {
+            pieces[x][y] = new Piece(x, y, type, isWhite);
+        }
+    }
+
+    /**
+     * Sets up the board with the standard chess starting position
+     */
+    public void populateBoard() {
+        // Place pawns
+        for (int x = 0; x < width; x++) {
+            setPiece(true, PieceType.Pawn, x, 6); // White pawns
+            setPiece(false, PieceType.Pawn, x, 1); // Black pawns
+        }
+        
+        // Place Rooks
+        setPiece(true, PieceType.Rook, 0, 7);
+        setPiece(true, PieceType.Rook, 7, 7);
+        setPiece(false, PieceType.Rook, 0, 0);
+        setPiece(false, PieceType.Rook, 7, 0);
+        
+        // Place Knights
+        setPiece(true, PieceType.Knight, 1, 7);
+        setPiece(true, PieceType.Knight, 6, 7);
+        setPiece(false, PieceType.Knight, 1, 0);
+        setPiece(false, PieceType.Knight, 6, 0);
+        
+        // Place Bishops
+        setPiece(true, PieceType.Bishop, 2, 7);
+        setPiece(true, PieceType.Bishop, 5, 7);
+        setPiece(false, PieceType.Bishop, 2, 0);
+        setPiece(false, PieceType.Bishop, 5, 0);
+        
+        // Place Queens
+        setPiece(true, PieceType.Queen, 3, 7);
+        setPiece(false, PieceType.Queen, 3, 0);
+        
+        // Place Kings
+        setPiece(true, PieceType.King, 4, 7);
+        setPiece(false, PieceType.King, 4, 0);
+        
+        // Reset turn information
+        turnNumber = 0;
+        isWhiteTurn = true;
+        
+        // Clear selection and valid moves
+        clearSelection();
+        moveHistory.clear(); // Clear move history when starting a new game
+    }
+    
+    /**
+     * Removes all pieces from the board
+     */
+    public void cleanBoard() {
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                pieces[x][y] = null;
+            }
+        }
+        turnNumber = 0;
+        isWhiteTurn = true;
+        clearSelection();
+        moveHistory.clear(); // Clear move history when cleaning the board
+    }
+    
+    /**
+     * @return String representation of the board
+     */
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Turn: ").append(turnNumber).append(", ").append(isWhiteTurn ? "White" : "Black").append("\n");
+        
+        for (int y = 0; y < height; y++) {
+            sb.append(8 - y).append(" ");
+            for (int x = 0; x < width; x++) {
+                if (pieces[x][y] == null) {
+                    sb.append(((x + y) % 2 == 0) ? "." : " ");
+                } else {
+                    Piece p = pieces[x][y];
+                    char c = p.getType().getSummary().charAt(0);
+                    sb.append(p.isWhite() ? Character.toUpperCase(c) : Character.toLowerCase(c));
+                }
+                sb.append(" ");
+            }
+            sb.append("\n");
+        }
+        sb.append("  a b c d e f g h");
+        return sb.toString();
+    }
+    
+    /**
+     * @return List of all pieces currently on the board
+     */
+    public ArrayList<Piece> getPieces() {
+        ArrayList<Piece> piecesList = new ArrayList<>();
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                if (pieces[x][y] != null) {
+                    piecesList.add(pieces[x][y]);
+                }
+            }
+        }
+        return piecesList;
+    }
+
+    /**
+     * Handles user clicks on the board
+     * @param x X-coordinate
+     * @param y Y-coordinate
+     */
+    public void userTouch(int x, int y) {
+        if (x < 0 || x >= width || y < 0 || y >= height) {
+            return; // Out of bounds
+        }
+        
+        if (!hasSelection) {
+            // If no piece is selected yet, select the piece at the clicked position
+            if (pieces[x][y] != null && pieces[x][y].isWhite() == isWhiteTurn) {
+                // Select the piece and calculate valid moves
+                selectedX = x;
+                selectedY = y;
+                hasSelection = true;
+                calculateValidMoves();
+            }
+        } else {
+            // If a piece is already selected
+            if (selectedX == x && selectedY == y) {
+                // If the same position is clicked again, unselect it
+                clearSelection();
+            } else if (isHighlighted(x, y)) {
+                // Move the selected piece to the new position if it's a valid move
+                Piece selectedPiece = pieces[selectedX][selectedY];
+                Piece capturedPiece = pieces[x][y]; // Store captured piece (null if no capture)
+                
+                // Create a Move object to record this move
+                Move move = new Move(selectedX, selectedY, x, y, selectedPiece, capturedPiece);
+                
+                // Move the piece (captures any piece at destination)
+                pieces[x][y] = selectedPiece;
+                pieces[selectedX][selectedY] = null;
+                
+                // Update the piece's position
+                selectedPiece.setPosition(x, y);
+                
+                // Record the move in history
+                moveHistory.recordMove(move);
+                
+                // Update turn information
+                turnNumber++;
+                isWhiteTurn = !isWhiteTurn;
+                
+                // Reset selection and valid moves
+                clearSelection();
+            } else if (pieces[x][y] != null && pieces[x][y].isWhite() == isWhiteTurn) {
+                // If clicked on another piece of the same color, select it instead
+                selectedX = x;
+                selectedY = y;
+                hasSelection = true;
+                calculateValidMoves();
+            } else {
+                // Clicked on an invalid position, unselect
+                clearSelection();
+            }
+        }
+    }
+
+    /**
+     * Clears selection and valid moves
+     */
+    private void clearSelection() {
+        hasSelection = false;
+        selectedX = -1;
+        selectedY = -1;
+        validMoves.clear();
+    }
+
+    /**
+     * Calculates valid moves for the currently selected piece
+     */
+    private void calculateValidMoves() {
+        validMoves.clear();
+        
+        if (!hasSelection) return;
+        
+        Piece piece = pieces[selectedX][selectedY];
+        if (piece == null) return;
+        
+        switch (piece.getType()) {
+            case Pawn:
+                calculatePawnMoves(piece);
+                break;
+            case Rook:
+                calculateRookMoves(piece);
+                break;
+            case Knight:
+                calculateKnightMoves(piece);
+                break;
+            case Bishop:
+                calculateBishopMoves(piece);
+                break;
+            case Queen:
+                calculateQueenMoves(piece);
+                break;
+            case King:
+                calculateKingMoves(piece);
+                break;
+        }
+    }
+    
+    /**
+     * Calculate valid moves for a pawn
+     * @param piece The pawn piece
+     */
+    private void calculatePawnMoves(Piece piece) {
+        int x = piece.getX();
+        int y = piece.getY();
+        boolean isWhite = piece.isWhite();
+        
+        // Direction is -1 for white (moving up) and 1 for black (moving down)
+        int direction = isWhite ? -1 : 1;
+        int startingRow = isWhite ? 6 : 1;
+        
+        // Move forward one square
+        if (isInsideBoard(x, y + direction) && pieces[x][y + direction] == null) {
+            validMoves.add(new Position(x, y + direction));
+            
+            // Move forward two squares from starting position
+            if (y == startingRow && isInsideBoard(x, y + 2 * direction) && pieces[x][y + 2 * direction] == null) {
+                validMoves.add(new Position(x, y + 2 * direction));
+            }
+        }
+        
+        // Capture diagonally
+        for (int dx = -1; dx <= 1; dx += 2) {
+            int newX = x + dx;
+            int newY = y + direction;
+            
+            if (isInsideBoard(newX, newY) && pieces[newX][newY] != null && pieces[newX][newY].isWhite() != isWhite) {
+                validMoves.add(new Position(newX, newY));
+            }
+        }
+    }
+    
+    /**
+     * Calculate valid moves for a rook
+     * @param piece The rook piece
+     */
+    private void calculateRookMoves(Piece piece) {
+        int x = piece.getX();
+        int y = piece.getY();
+        boolean isWhite = piece.isWhite();
+        
+        // Four directions: horizontal and vertical
+        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+        
+        for (int[] dir : directions) {
+            int dx = dir[0];
+            int dy = dir[1];
+            
+            for (int step = 1; step < Math.max(width, height); step++) {
+                int newX = x + dx * step;
+                int newY = y + dy * step;
+                
+                if (!isInsideBoard(newX, newY)) break; // Out of bounds
+                
+                if (pieces[newX][newY] == null) {
+                    // Empty square, can move here
+                    validMoves.add(new Position(newX, newY));
+                } else {
+                    // Square has a piece
+                    if (pieces[newX][newY].isWhite() != isWhite) {
+                        // Can capture opponent's piece
+                        validMoves.add(new Position(newX, newY));
+                    }
+                    break; // Can't move past a piece
+                }
+            }
+        }
+    }
+    
+    /**
+     * Calculate valid moves for a knight
+     * @param piece The knight piece
+     */
+    private void calculateKnightMoves(Piece piece) {
+        int x = piece.getX();
+        int y = piece.getY();
+        boolean isWhite = piece.isWhite();
+        
+        // All possible knight moves
+        int[][] moves = {
+            {-2, -1}, {-2, 1}, {-1, -2}, {-1, 2},
+            {1, -2}, {1, 2}, {2, -1}, {2, 1}
+        };
+        
+        for (int[] move : moves) {
+            int newX = x + move[0];
+            int newY = y + move[1];
+            
+            if (isInsideBoard(newX, newY) && (pieces[newX][newY] == null || pieces[newX][newY].isWhite() != isWhite)) {
+                validMoves.add(new Position(newX, newY));
+            }
+        }
+    }
+    
+    /**
+     * Calculate valid moves for a bishop
+     * @param piece The bishop piece
+     */
+    private void calculateBishopMoves(Piece piece) {
+        int x = piece.getX();
+        int y = piece.getY();
+        boolean isWhite = piece.isWhite();
+        
+        // Four diagonal directions
+        int[][] directions = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
+        
+        for (int[] dir : directions) {
+            int dx = dir[0];
+            int dy = dir[1];
+            
+            for (int step = 1; step < Math.max(width, height); step++) {
+                int newX = x + dx * step;
+                int newY = y + dy * step;
+                
+                if (!isInsideBoard(newX, newY)) break; // Out of bounds
+                
+                if (pieces[newX][newY] == null) {
+                    // Empty square, can move here
+                    validMoves.add(new Position(newX, newY));
+                } else {
+                    // Square has a piece
+                    if (pieces[newX][newY].isWhite() != isWhite) {
+                        // Can capture opponent's piece
+                        validMoves.add(new Position(newX, newY));
+                    }
+                    break; // Can't move past a piece
+                }
+            }
+        }
+    }
+    
+    /**
+     * Calculate valid moves for a queen
+     * @param piece The queen piece
+     */
+    private void calculateQueenMoves(Piece piece) {
+        // Queen combines rook and bishop movement
+        calculateRookMoves(piece);
+        calculateBishopMoves(piece);
+    }
+    
+    /**
+     * Calculate valid moves for a king
+     * @param piece The king piece
+     */
+    private void calculateKingMoves(Piece piece) {
+        int x = piece.getX();
+        int y = piece.getY();
+        boolean isWhite = piece.isWhite();
+        
+        // All 8 directions around the king
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dy = -1; dy <= 1; dy++) {
+                if (dx == 0 && dy == 0) continue; // Skip the current position
+                
+                int newX = x + dx;
+                int newY = y + dy;
+                
+                if (isInsideBoard(newX, newY) && (pieces[newX][newY] == null || pieces[newX][newY].isWhite() != isWhite)) {
+                    validMoves.add(new Position(newX, newY));
+                }
+            }
+        }
+    }
+    
+    /**
+     * Check if coordinates are inside the board
+     * @param x X-coordinate
+     * @param y Y-coordinate
+     * @return True if inside board, false otherwise
+     */
+    private boolean isInsideBoard(int x, int y) {
+        return x >= 0 && x < width && y >= 0 && y < height;
+    }
+
+    /**
+     * Checks if a position is currently selected
+     * @param x X-coordinate
+     * @param y Y-coordinate
+     * @return True if the position is selected, false otherwise
+     */
+    public boolean isSelected(int x, int y) {
+        return hasSelection && selectedX == x && selectedY == y;
+    }
+
+    /**
+     * Checks if a position is highlighted as a valid move
+     * @param x X-coordinate
+     * @param y Y-coordinate
+     * @return True if the position is highlighted, false otherwise
+     */
+    public boolean isHighlighted(int x, int y) {
+        return validMoves.contains(new Position(x, y));
+    }
+    
+    /**
+     * Undoes the last move made
+     */
+    public void undoLastMove() {
+        if (!moveHistory.canUndo()) {
+            return; // No moves to undo
+        }
+        
+        // Get the last move
+        Move lastMove = moveHistory.getLastMove();
+        
+        // Get the moving piece (which is now at the destination)
+        Piece movingPiece = pieces[lastMove.getToX()][lastMove.getToY()];
+        
+        if (movingPiece == null) {
+            // Something went wrong, the piece isn't where it should be
+            return;
+        }
+        
+        // Move the piece back to its original position
+        pieces[lastMove.getFromX()][lastMove.getFromY()] = movingPiece;
+        movingPiece.setPosition(lastMove.getFromX(), lastMove.getFromY());
+        
+        // If a piece was captured, put it back
+        if (lastMove.getCapturedPiece() != null) {
+            Piece capturedPiece = lastMove.getCapturedPiece();
+            pieces[lastMove.getToX()][lastMove.getToY()] = capturedPiece;
+        } else {
+            // Otherwise, clear the destination square
+            pieces[lastMove.getToX()][lastMove.getToY()] = null;
+        }
+        
+        // Revert turn information
+        turnNumber--;
+        isWhiteTurn = !isWhiteTurn;
+        
+        // Clear any selection and highlighting
+        clearSelection();
+    }
+    
+    /**
+     * Constructor for loading a board from a file
+     * @param array Array of strings representing the board
+     */
+    public Board(String[] array) {
+        this(8, 8); // Default to standard 8x8 board
+        // The rest will be implemented in part 3
+    }
+    
+    /**
+     * Constructor for copying a board
+     * @param board Board to copy
+     */
+    public Board(Board board) {
+        this(board.getWidth(), board.getHeight());
+        
+        this.turnNumber = board.getTurnNumber();
+        this.isWhiteTurn = board.isTurnWhite();
+        
+        // Copy pieces
+        for (Piece piece : board.getPieces()) {
+            this.setPiece(piece.isWhite(), piece.getType(), piece.getX(), piece.getY());
+        }
+    }
+    
+    /**
+     * Placeholder for saving the board to a file
+     * @return Array of strings representing the board
+     */
+    public String[] toFileRep() {
+        // This will be implemented in part 3
+        return null;
+    }
+    
+    /**
+     * Plays a move on the board
+     * @param move Move to play
+     */
+    public void playMove(Move move) {
+        if (move == null) {
+            return;
+        }
+        
+        int fromX = move.getFromX();
+        int fromY = move.getFromY();
+        int toX = move.getToX();
+        int toY = move.getToY();
+        
+        // Make sure there's a piece at the starting position
+        if (pieces[fromX][fromY] == null) {
+            return;
+        }
+        
+        // Store the piece that might be captured
+        Piece capturedPiece = pieces[toX][toY];
+        
+        // Update the move object with the actual pieces
+        move = new Move(fromX, fromY, toX, toY, pieces[fromX][fromY], capturedPiece);
+        
+        // Make the move
+        pieces[toX][toY] = pieces[fromX][fromY];
+        pieces[fromX][fromY] = null;
+        
+        // Update the piece's position
+        pieces[toX][toY].setPosition(toX, toY);
+        
+        // Record the move
+        moveHistory.recordMove(move);
+        
+        // Update turn information
+        turnNumber++;
+        isWhiteTurn = !isWhiteTurn;
+        
+        // Clear any selection
+        clearSelection();
+    }
+}
\ No newline at end of file
diff --git a/src/backend/ChessTimer.java b/src/backend/ChessTimer.java
new file mode 100644
index 0000000..7aba328
--- /dev/null
+++ b/src/backend/ChessTimer.java
@@ -0,0 +1,166 @@
+package backend;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class ChessTimer {
+    private long whiteTimeMillis; // Time remaining for white player in milliseconds
+    private long blackTimeMillis; // Time remaining for black player in milliseconds
+    private long lastUpdateTime; // Time when the timer was last updated
+    private boolean isRunning; // Is the timer currently running?
+    private boolean isWhiteTurn; // Is it white's turn?
+    private Timer timer; // Java util timer to handle periodic updates
+    private TimerUpdateListener listener; // Listener to notify UI when time changes
+    
+    /**
+     * Interface for notifying time updates
+     */
+    public interface TimerUpdateListener {
+        void onTimeUpdate(long whiteTimeMillis, long blackTimeMillis);
+        void onTimeExpired(boolean isWhiteExpired); // Called when a player's time runs out
+    }
+    
+    /**
+     * Constructor with initial time in minutes
+     * @param initialTimeMinutes Initial time for both players in minutes
+     * @param listener Listener to receive time updates
+     */
+    public ChessTimer(int initialTimeMinutes, TimerUpdateListener listener) {
+        this.whiteTimeMillis = initialTimeMinutes * 60 * 1000;
+        this.blackTimeMillis = initialTimeMinutes * 60 * 1000;
+        this.isRunning = false;
+        this.isWhiteTurn = true; // White starts in chess
+        this.listener = listener;
+    }
+    
+    /**
+     * Start the timer
+     */
+    public void start() {
+        if (!isRunning) {
+            isRunning = true;
+            lastUpdateTime = System.currentTimeMillis();
+            
+            // Schedule periodic updates (every 100ms)
+            timer = new Timer(true);
+            timer.scheduleAtFixedRate(new TimerTask() {
+                @Override
+                public void run() {
+                    updateTime();
+                }
+            }, 0, 100);
+        }
+    }
+    
+    /**
+     * Stop the timer
+     */
+    public void stop() {
+        if (isRunning) {
+            isRunning = false;
+            updateTime(); // Update one last time
+            
+            if (timer != null) {
+                timer.cancel();
+                timer = null;
+            }
+        }
+    }
+    
+    /**
+     * Reset the timer to the initial values
+     * @param initialTimeMinutes New initial time in minutes
+     */
+    public void reset(int initialTimeMinutes) {
+        stop();
+        this.whiteTimeMillis = initialTimeMinutes * 60 * 1000;
+        this.blackTimeMillis = initialTimeMinutes * 60 * 1000;
+        this.isWhiteTurn = true;
+        notifyTimeUpdate();
+    }
+    
+    /**
+     * Switch the active player
+     * @param isWhiteTurn True if it's now white's turn
+     */
+    public void switchTurn(boolean isWhiteTurn) {
+        if (isRunning) {
+            updateTime(); // Update time for the player who just completed their move
+        }
+        this.isWhiteTurn = isWhiteTurn;
+        notifyTimeUpdate();
+    }
+    
+    /**
+     * Update the time based on elapsed time
+     */
+    private void updateTime() {
+        if (!isRunning) return;
+        
+        long currentTime = System.currentTimeMillis();
+        long elapsedTime = currentTime - lastUpdateTime;
+        lastUpdateTime = currentTime;
+        
+        // Deduct time from the active player
+        if (isWhiteTurn) {
+            whiteTimeMillis -= elapsedTime;
+            if (whiteTimeMillis <= 0) {
+                whiteTimeMillis = 0;
+                stop();
+                if (listener != null) {
+                    listener.onTimeExpired(true);
+                }
+            }
+        } else {
+            blackTimeMillis -= elapsedTime;
+            if (blackTimeMillis <= 0) {
+                blackTimeMillis = 0;
+                stop();
+                if (listener != null) {
+                    listener.onTimeExpired(false);
+                }
+            }
+        }
+        
+        notifyTimeUpdate();
+    }
+    
+    /**
+     * Notify the listener about time updates
+     */
+    private void notifyTimeUpdate() {
+        if (listener != null) {
+            listener.onTimeUpdate(whiteTimeMillis, blackTimeMillis);
+        }
+    }
+    
+    /**
+     * Get white player's remaining time in milliseconds
+     */
+    public long getWhiteTimeMillis() {
+        return whiteTimeMillis;
+    }
+    
+    /**
+     * Get black player's remaining time in milliseconds
+     */
+    public long getBlackTimeMillis() {
+        return blackTimeMillis;
+    }
+    
+    /**
+     * Format milliseconds as "mm:ss"
+     */
+    public static String formatTime(long timeMillis) {
+        int seconds = (int) (timeMillis / 1000) % 60;
+        int minutes = (int) (timeMillis / (60 * 1000));
+        return String.format("%02d:%02d", minutes, seconds);
+    }
+    
+    /**
+     * Check if the timer is currently running
+     */
+    public boolean isRunning() {
+        return isRunning;
+    }
+}
\ No newline at end of file
diff --git a/src/backend/Game.java b/src/backend/Game.java
new file mode 100644
index 0000000..ab05009
--- /dev/null
+++ b/src/backend/Game.java
@@ -0,0 +1,220 @@
+package backend;
+
+import windowInterface.MyInterface;
+
+public class Game extends Thread {
+
+    private AutoPlayer aiPlayer;
+    private Board board;
+    private ChessTimer chessTimer; // Add chess timer
+    private MyInterface mjf;
+    private int COL_NUM = 8;
+    private int LINE_NUM = 8;
+    private int loopDelay = 250;
+    boolean[] activationAIFlags;
+    private int initialTimeMinutes = 10; // Default to 10 minutes per player
+    private boolean timerEnabled = false; // Flag to enable/disable timer
+
+    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();
+        
+        // Initialize the timer with a listener
+        chessTimer = new ChessTimer(initialTimeMinutes, new ChessTimer.TimerUpdateListener() {
+            @Override
+            public void onTimeUpdate(long whiteTimeMillis, long blackTimeMillis) {
+                // Update UI with new time values
+                mjf.updateTimers(whiteTimeMillis, blackTimeMillis);
+            }
+            
+            @Override
+            public void onTimeExpired(boolean isWhiteExpired) {
+                // Handle time expiration - game over
+                mjf.timeExpired(isWhiteExpired);
+            }
+        });
+    }
+
+    public int getWidth() {
+        return board.getWidth();
+    }
+
+    public int getHeight() {
+        return board.getHeight();
+    }
+    
+    // Added getBoard method to access the board
+    public Board getBoard() {
+        return this.board;
+    }
+
+    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()) {
+            // Before AI makes a move
+            boolean currentTurn = board.isTurnWhite();
+            
+            board.playMove(aiPlayer.computeBestMove(new Board(board)));
+            
+            // After AI makes a move, switch the timer
+            if (timerEnabled && currentTurn != board.isTurnWhite()) {
+                chessTimer.switchTurn(board.isTurnWhite());
+            }
+        }
+    }
+
+    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()) {
+            // Before user makes a move
+            boolean currentTurn = board.isTurnWhite();
+            
+            board.userTouch(x, y);
+            
+            // After user makes a move, check if turn switched and update timer
+            if (timerEnabled && currentTurn != board.isTurnWhite()) {
+                chessTimer.switchTurn(board.isTurnWhite());
+            }
+        }
+    }
+
+    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();
+        
+        // Reset the timer when starting a new game
+        if (timerEnabled) {
+            chessTimer.reset(initialTimeMinutes);
+        }
+    }
+
+    public void setBoard(String[] array) {
+        board = new Board(array);
+        
+        // Reset the timer when loading a new board
+        if (timerEnabled) {
+            chessTimer.reset(initialTimeMinutes);
+        }
+    }
+
+    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() {
+        // Store current turn before undo
+        boolean currentTurn = board.isTurnWhite();
+        
+        board.undoLastMove();
+        
+        // After undo, check if turn switched and update timer
+        if (timerEnabled && currentTurn != board.isTurnWhite()) {
+            chessTimer.switchTurn(board.isTurnWhite());
+        }
+    }
+
+    public void toggleAI(boolean isWhite) {
+        this.activationAIFlags[isWhite?1:0] = !this.activationAIFlags[isWhite?1:0];
+    }
+    
+    // Timer-related methods
+    
+    /**
+     * Start the chess timer
+     */
+    public void startTimer() {
+        if (timerEnabled) {
+            chessTimer.start();
+        }
+    }
+    
+    /**
+     * Stop the chess timer
+     */
+    public void stopTimer() {
+        if (timerEnabled) {
+            chessTimer.stop();
+        }
+    }
+    
+    /**
+     * Enable or disable the timer feature
+     */
+    public void setTimerEnabled(boolean enabled) {
+        this.timerEnabled = enabled;
+        if (enabled) {
+            chessTimer.reset(initialTimeMinutes);
+        } else {
+            chessTimer.stop();
+        }
+    }
+    
+    /**
+     * Check if timer is enabled
+     */
+    public boolean isTimerEnabled() {
+        return timerEnabled;
+    }
+    
+    /**
+     * Set the initial time in minutes for both players
+     */
+    public void setInitialTime(int minutes) {
+        this.initialTimeMinutes = minutes;
+        if (timerEnabled) {
+            chessTimer.reset(minutes);
+        }
+    }
+    
+    /**
+     * Get the current chess timer
+     */
+    public ChessTimer getChessTimer() {
+        return chessTimer;
+    }
+}
\ No newline at end of file
diff --git a/src/backend/Move.java b/src/backend/Move.java
new file mode 100644
index 0000000..a44958f
--- /dev/null
+++ b/src/backend/Move.java
@@ -0,0 +1,64 @@
+package backend;
+
+public class Move {
+    private int fromX;
+    private int fromY;
+    private int toX;
+    private int toY;
+    private Piece movingPiece;
+    private Piece capturedPiece;
+    
+    /**
+     * Constructor for a move
+     * @param fromX Starting X-coordinate
+     * @param fromY Starting Y-coordinate
+     * @param toX Destination X-coordinate
+     * @param toY Destination Y-coordinate
+     * @param movingPiece The piece being moved
+     * @param capturedPiece The piece being captured (null if no capture)
+     */
+    public Move(int fromX, int fromY, int toX, int toY, Piece movingPiece, Piece capturedPiece) {
+        this.fromX = fromX;
+        this.fromY = fromY;
+        this.toX = toX;
+        this.toY = toY;
+        this.movingPiece = movingPiece;
+        this.capturedPiece = capturedPiece;
+    }
+    
+    // Basic constructor for now - can be expanded later
+    public Move() {
+        this.fromX = -1;
+        this.fromY = -1;
+        this.toX = -1;
+        this.toY = -1;
+        this.movingPiece = null;
+        this.capturedPiece = null;
+    }
+    
+    // Getters
+    public int getFromX() { return fromX; }
+    public int getFromY() { return fromY; }
+    public int getToX() { return toX; }
+    public int getToY() { return toY; }
+    public Piece getMovingPiece() { return movingPiece; }
+    public Piece getCapturedPiece() { return capturedPiece; }
+    
+    // Setters if needed
+    public void setFromX(int fromX) { this.fromX = fromX; }
+    public void setFromY(int fromY) { this.fromY = fromY; }
+    public void setToX(int toX) { this.toX = toX; }
+    public void setToY(int toY) { this.toY = toY; }
+    public void setMovingPiece(Piece movingPiece) { this.movingPiece = movingPiece; }
+    public void setCapturedPiece(Piece capturedPiece) { this.capturedPiece = capturedPiece; }
+    
+    @Override
+    public String toString() {
+        if (movingPiece == null) {
+            return "Empty move";
+        }
+        String from = (char)('a' + fromX) + "" + (8 - fromY);
+        String to = (char)('a' + toX) + "" + (8 - toY);
+        return movingPiece.getType().getSummary() + from + "-" + to;
+    }
+}
\ No newline at end of file
diff --git a/src/backend/MoveHistory.java b/src/backend/MoveHistory.java
new file mode 100644
index 0000000..c90b527
--- /dev/null
+++ b/src/backend/MoveHistory.java
@@ -0,0 +1,55 @@
+package backend;
+
+import java.util.Stack;
+
+/**
+ * Class to maintain a history of moves made during the game
+ * and enable undo functionality
+ */
+public class MoveHistory {
+    private Stack<Move> moveStack;
+    
+    /**
+     * Constructor for MoveHistory
+     */
+    public MoveHistory() {
+        moveStack = new Stack<>();
+    }
+    
+    /**
+     * Records a move in the history
+     * 
+     * @param move The move to record
+     */
+    public void recordMove(Move move) {
+        moveStack.push(move);
+    }
+    
+    /**
+     * Gets the last move made and removes it from history
+     * 
+     * @return The last move made, or null if no moves have been made
+     */
+    public Move getLastMove() {
+        if (moveStack.isEmpty()) {
+            return null;
+        }
+        return moveStack.pop();
+    }
+    
+    /**
+     * Checks if there are moves to undo
+     * 
+     * @return True if there are moves in the history, false otherwise
+     */
+    public boolean canUndo() {
+        return !moveStack.isEmpty();
+    }
+    
+    /**
+     * Clears the move history
+     */
+    public void clear() {
+        moveStack.clear();
+    }
+}
\ No newline at end of file
diff --git a/src/backend/Piece.java b/src/backend/Piece.java
new file mode 100644
index 0000000..ef34f35
--- /dev/null
+++ b/src/backend/Piece.java
@@ -0,0 +1,36 @@
+package backend;
+
+public class Piece {
+    private int x;
+    private int y;
+    private PieceType type;
+    private boolean isWhite;
+    
+    public Piece(int x, int y, PieceType type, boolean isWhite) {
+        this.x = x;
+        this.y = y;
+        this.type = type;
+        this.isWhite = isWhite;
+    }
+    
+    public PieceType getType() {
+        return type;
+    }
+    
+    public boolean isWhite() {
+        return isWhite;
+    }
+    
+    public int getX() {
+        return x;
+    }
+    
+    public int getY() {
+        return y;
+    }
+    
+    public void setPosition(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}
\ No newline at end of file
diff --git a/src/backend/PieceType.java b/src/backend/PieceType.java
new file mode 100644
index 0000000..382a02a
--- /dev/null
+++ b/src/backend/PieceType.java
@@ -0,0 +1,26 @@
+package backend;
+
+public enum PieceType {
+    Pawn("Pawn", "p"),
+    Rook("Rook", "r"),
+    Knight("Knight", "n"),
+    Bishop("Bishop", "b"),
+    Queen("Queen", "q"),
+    King("King", "k");
+    
+    private final String name;
+    private final String summary;
+    
+    PieceType(String name, String summary) {
+        this.name = name;
+        this.summary = summary;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public String getSummary() {
+        return summary;
+    }
+}
\ No newline at end of file
diff --git a/src/windowInterface/JPanelChessBoard.java b/src/windowInterface/JPanelChessBoard.java
new file mode 100644
index 0000000..ad260b1
--- /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..363c622
--- /dev/null
+++ b/src/windowInterface/MyInterface.java
@@ -0,0 +1,387 @@
+package windowInterface;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.FlowLayout;
+import java.awt.Font;
+
+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.ChessTimer;
+import backend.Game;
+
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JSpinner;
+import javax.swing.SpinnerNumberModel;
+
+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;
+    
+    // Timer-related components
+    private JLabel whiteTimerLabel;
+    private JLabel blackTimerLabel;
+    private JCheckBox chckbxEnableTimer;
+    private JSpinner timeSpinner;
+
+    /**
+     * 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(7, 1, 0, 5)); // Increased number of rows for timer controls
+        
+        // Timer panel at the bottom
+        JPanel timerPanel = new JPanel();
+        timerPanel.setLayout(new GridLayout(2, 2, 5, 5));
+        contentPane.add(timerPanel, BorderLayout.SOUTH);
+        
+        // White timer
+        JPanel whiteTimerPanel = new JPanel();
+        whiteTimerLabel = new JLabel("10:00");
+        whiteTimerLabel.setFont(new Font("Monospaced", Font.BOLD, 20));
+        whiteTimerLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        whiteTimerPanel.add(new JLabel("White: "));
+        whiteTimerPanel.add(whiteTimerLabel);
+        timerPanel.add(whiteTimerPanel);
+        
+        // Black timer
+        JPanel blackTimerPanel = new JPanel();
+        blackTimerLabel = new JLabel("10:00");
+        blackTimerLabel.setFont(new Font("Monospaced", Font.BOLD, 20));
+        blackTimerLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        blackTimerPanel.add(new JLabel("Black: "));
+        blackTimerPanel.add(blackTimerLabel);
+        timerPanel.add(blackTimerPanel);
+        
+        // Timer controls
+        JPanel timerControls = new JPanel();
+        timerControls.setLayout(new FlowLayout());
+        
+        chckbxEnableTimer = new JCheckBox("Enable Timer");
+        chckbxEnableTimer.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                toggleTimer();
+            }
+        });
+        timerControls.add(chckbxEnableTimer);
+        
+        timerControls.add(new JLabel("Minutes:"));
+        timeSpinner = new JSpinner(new SpinnerNumberModel(10, 1, 60, 1));
+        timeSpinner.addChangeListener(new ChangeListener() {
+            public void stateChanged(ChangeEvent e) {
+                updateInitialTime();
+            }
+        });
+        timerControls.add(timeSpinner);
+        
+        timerPanel.add(timerControls);
+
+        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();
+        
+        // Reset and start the timer if enabled
+        if (game.isTimerEnabled()) {
+            game.startTimer();
+        }
+    }
+    
+    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);
+        }
+    }
+    
+    /**
+     * Toggle timer on/off
+     */
+    private void toggleTimer() {
+        if (game == null) {
+            System.out.println("error : can't toggle timer while no game present");
+            chckbxEnableTimer.setSelected(false);
+        } else {
+            boolean isEnabled = chckbxEnableTimer.isSelected();
+            game.setTimerEnabled(isEnabled);
+            
+            if (isEnabled) {
+                game.startTimer();
+            } else {
+                game.stopTimer();
+                
+                // Reset the displayed time
+                updateTimers(
+                    ((Integer)timeSpinner.getValue()) * 60 * 1000, 
+                    ((Integer)timeSpinner.getValue()) * 60 * 1000
+                );
+            }
+        }
+    }
+    
+    /**
+     * Update initial time when spinner changes
+     */
+    private void updateInitialTime() {
+        if (game != null) {
+            int minutes = (Integer)timeSpinner.getValue();
+            game.setInitialTime(minutes);
+            
+            // Update timer labels
+            long timeMillis = minutes * 60 * 1000;
+            whiteTimerLabel.setText(ChessTimer.formatTime(timeMillis));
+            blackTimerLabel.setText(ChessTimer.formatTime(timeMillis));
+        }
+    }
+    
+    /**
+     * Update timer display
+     */
+    public void updateTimers(long whiteTimeMillis, long blackTimeMillis) {
+        whiteTimerLabel.setText(ChessTimer.formatTime(whiteTimeMillis));
+        blackTimerLabel.setText(ChessTimer.formatTime(blackTimeMillis));
+    }
+    
+    /**
+     * Handle time expiration
+     */
+    public void timeExpired(boolean isWhiteExpired) {
+        String message = (isWhiteExpired ? "White" : "Black") + " player's time has expired. " + 
+                        (!isWhiteExpired ? "White" : "Black") + " wins!";
+        JOptionPane.showMessageDialog(this, message, "Game Over", JOptionPane.INFORMATION_MESSAGE);
+    }
+    
+    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");
+    }
+}
\ No newline at end of file