From b68751ce2c224062197bf4c7371ca629e5e8ef9d Mon Sep 17 00:00:00 2001
From: Vincent <xefal77@gmail.com>
Date: Sun, 27 Oct 2024 23:07:11 +0100
Subject: [PATCH] Fix des scores
---
bin/controller/GameContext.class | Bin 1950 -> 2592 bytes
bin/controller/GameController.class | Bin 6231 -> 6231 bytes
bin/controller/ScoreGameContext.class | Bin 4674 -> 4380 bytes
bin/model/Pocket.class | Bin 1091 -> 1828 bytes
bin/model/Tile.class | Bin 977 -> 1064 bytes
bin/view/HexagonTile$1.class | Bin 754 -> 754 bytes
bin/view/HexagonTile.class | Bin 2843 -> 3061 bytes
src/main/java/controller/GameContext.java | 38 ++++-
src/main/java/controller/GameController.java | 71 +-------
.../java/controller/ScoreGameContext.java | 153 ++++++------------
src/main/java/model/Pocket.java | 111 +++++++------
src/main/java/model/Tile.java | 64 ++------
src/main/java/view/HexagonTile.java | 85 ++--------
13 files changed, 177 insertions(+), 345 deletions(-)
diff --git a/bin/controller/GameContext.class b/bin/controller/GameContext.class
index ff319ea1cbd9a674ec0e7051ddaf30cdc59ccaa3..f92151f10e124667dc391bbc6256ef652680b3dc 100644
GIT binary patch
literal 2592
zcmcgu$#WD{9RA*HJxfC-%LI`<AWXtC$PzRYLm+`LkPQ>Sut+*HO{SAccj)fP;;siT
zRB`d3;DLiy!BMMNj8s{i{R{jvyi1AS>z*)^#qwsV`ps|OfA8h@zkmG=zzKX6#~$=4
zI2T6%eKG7tPQm#&!aj0AL4O=k3`owPgoY9r#>E8Q$4CMvF)EKs3N9y*#F#v;D!3M-
z;B|T2h;&EkhktQ=h?|k_oR3Ai{a=zBF&;-ZG<i%Y$j7l0eF^lSpg>n}OCVm<7qm&s
z9MEP3>iVa&IW1FmjZ%h$tUzqUm^3xFZ0iC?S8_XjRGW7*!<J#X+5S00pU<50?Ts2G
zJ=;YK4YX*Kw26{FY&nK&Sf;bm(TMI+Y*&qOQq~xkrXtp@TaNAuBv-p8uhTFMw@V<H
zZoMoJ>ahw8xvt+Z^}+JYgl><@5Ck?%>TV@OFXj4lYmH|=>Eo+uYob{{)f8=?S|{6;
zKKy)luki728OLaGsFHNUvPQMy0&01-pt<_8OgNp($@CMpKC7`OeYQ~$*p&8CT*x@{
zhB=uzKdhO0DJ$hRjJR5Unpu0*Q81~XD9|MHC`@U2-E?c3*5aGVRQ=bMuHSIntO7&e
z*ni5csi*92e8ei-dHpO0haK+IX7nD*boB-IkQ_=ChmaAduMX%r%_%Z+6>nkh8U_oh
zq7`id8$FHJF-tpH6$fxo#S|Fuw2Bhi70jqGVX2tKZ51{+q>WWy^t0!T>Dr3|;mWU?
zGfmy@DQS+QJ1Si8C`+~E>NQX?hj|qXm{+i<;v;;l;uCzT;xlAad@j?fadpbJwMAJ>
z6<^>>f#y7`U|Xe<Zf9zWLO))3C5;^&nwZk_+>3^4#5q^DHP^B$#Ff2Yu8Ozl(ia!q
zwKdZzah5n0RWnRnAj&zg7g^F3EDw(wul+PH&!=Z~**_br6g6j%ee`zoDtFWLkfvq%
zniS-cbNDXkEOeB>Wvx_ZKw^PkjvvW>KRulR&E>R)oZB{Shtj>Rz0AYW-P2atEU*&_
zx53|sxUJ7=B}1+X$(7|`JX(S4k*dsVZ5*vvv5U9z9^RxuUfvur2<#&kK$;&X>ovZg
zILC=Rg)~kn&%?xqdCv>}rrVxDv^_^)>=}Yj5F!{R7<mGPV00`Pe1_N)#DAu&z}q~V
zsR?XB2wPEyZFm#g>3avcM{tzhr1fpYr1fyyV}yPp;HySF;=W3#$A}$A`#LJhYL&wk
zl@nBX2k-J+?IpfiMGAEwTM^yMLIoK|oB_qRY<-GEH6i)_fv-*sy_D|6d%lj?%S7c9
z_M=Q<397&nHV6zHSi(kud-$3_oxlqu2M;cxUP9515WxlsHg<$JhaRITd7;=Ikx;4$
z&A;G{CTyO*TWnW6W_b1<Hl>s*rwLoEyW{OjDk1}=`gnUJrTB1)^v&TE@#K-@k*C=9
z@YVeOr`XPKhs-A6wWk9c2@jwJgKYZ{%XJZ_`DS0jC~op}@Bz1a40mu1-{CsG#|=E-
z3;hGRUDP~`;7imgIQa^BL>25-&`nH1Qjut*U|(Oc9RZ(34S`ei;5A-6Kt$GAbUnvT
zj?u1x{mdaedmr}?$Z3*TXq;z?Q?-Pa0IpQ&h4tx@8X8|K@6iiu>AwBYdK}L~4d)@g
zt-Akz!dfShkRMhJN6xa}%`UDOP~;pMsOOW=ifLB6#Qx3THlKt$u<(e`3qA^eu(yB0
v6;YH$3+6;8FLl|`1OhMdNI}nE_@=T)y)=Kub8?pBApb?<jm<mZN+k9V4OT}h
delta 850
zcmZvbTTfF#6otRjmJU6gKn=!3!GNf!+=?P{#|mCRxyelw6f0IJa#ITU)*s+wUrbEA
zMBjXoL{0R;AK(x0kN9fDHEp5^dXibQ*WR;c@7Xiw)&3Wy*>AtTd<9zB@;O4naKR@)
zB0?3thCZL70=a0o<WtOL7rElB{wM=njdG2_C|wLW7&eSVi81D2+%OT*!bt~H;Y6|W
z=<~V3bT~1PCzXT~dBge3xarf)EeA7(S;Os}cd<a|j$tm>60FYFQSY&DDY=!5Z)VcV
z@&4q-;!twkQq9qS0^_NSrG^t8C3!`1I};yWORvgXN1NpowU)cI8IqQJG#lnE_eohE
zuwYpv?NRnOm-6Jk2P?alNLwDdU~DU$+K%_9o+KC6RwvTSQZBP%S!KnrW?AQv<uMzU
z4E2^x>T`pk>D<TAj~=zUN&|vwwu;B&m{@@08mjpZKPj$46${I!^9vhtp>TV)QN9DZ
z9XLpcLzGf3tdRDw*2HO&vO!VDJk3S59|*md;o+oiJCv@F_O#d;n*Sp)dnJtpNtUzH
zv~W(iH;unn)22nOICM*Ebn2jHUlsY~6`zRih!x6mj}Ll@&?iqj9R-b7qm#P#^VXf>
zGuF#>n%DUrbWkGykh(am-A9yVO!{#qnPN^)ZG#!I%<@$1neO{JNnYx{-!M<7luZPG
uQflbhm7~~DW#|?&#Ehe5p8B+_t_BJrDFXE5@qCQyGJKU7)2}cZj{F9s+i=GK
diff --git a/bin/controller/GameController.class b/bin/controller/GameController.class
index d34f2d17ac03327914b11f9329e4c35d34c72d0a..297bf98c509d895d4263f031b0924e358ae1ba37 100644
GIT binary patch
delta 461
zcmWNNYfBSQ0EVBL;03Ksw|U8oP{VukLbYuBFg2(&Q<xfR5Q1U|T9H-@%BWmQHxEV`
zSY#?)X5~at)I|yk^(|ySz)$`Q-!F%A;JnX!iMpb$pHHpsLSo4zfg%o3jGYoPDCHO@
zD8Qv#8E(q)Qb8S+G;xwvPSMV36S3AMSCPb7Y<M`1*QDF_{63PY<}fuJrB>8)qMn!X
z0##hZCrUjHbaR>8G%_UOOTEWw<|9{_rHx;ruh79dSBY?q4LVJ8O0TVpc<IvUA)D*u
z(`){x1WWpqzhC)p$oD1=ZsBBr90ryAj*{G!>pi&y<Z#~vQ$H6xkm8|o4@vP@-Jg)h
zu#yFp>6yGoL?0IOdDw41VDZ0_?Q5)zspdFGc%xC?YL0iDVL~<EbBRe>_#oLQSx@nZ
zX#r+<!597d%6Go8tn)V^Hko6aA134oIOatSYoY}Wyr@x^G|{s0INKbn#IeRfO^_v3
eE`RiE(}bLrF>Hl*on@9p{;KmoM%gjh>F#~5cVcJ&
delta 461
zcmWNNPe{{Y9L7IC4RkYYvu&+EE}{~}ip`d_Ob->9xgx@uU>cYaidu*AQV<rE5M}X}
zX{Qb|NjA$o)nN-3X;5G&tSnC&rKgk-k3E+cUU>d|zE9ep_P@U42>DsVR%`@VM=37$
zvXLO$*hevC>|sA44p6B#%t20bh<YkGOQlIV!nswf<rq$?Ddf2EIu|0f<Pu>sbxJ)$
ziPXEK4$??DO&sPNCurs(=ebG?-CUqo|0lHaoHmB&V3bbYaft+%Npgi0U8XL--FcmC
zZm@xy__#$8x6M?3&+hx;e<1!|^*+SSBRo82yAlKRafGMT&@b)*5j`_K>!Za{IR?f3
zLXMYgVwj!8L>A{1BVv6ej+naNj740TRwSX?Bo5x|%oGKD&?p}@)41lC;3%Is$!DGV
zMYc)0_$t6D?lLW`v}(U8>^pCnQNj<of66s$;_hqiIi=2PqF);Rw}$?si55+Tr@{S~
mESAV)nJxTd2P;yonz$#JVKFx630QW^j?K#9p5-z=Z|FbJEo)2w
diff --git a/bin/controller/ScoreGameContext.class b/bin/controller/ScoreGameContext.class
index d6755a36575b61e590f1545ad55d22df5416b544..d120ac08efd024c052e4adafd7f541a8290782ca 100644
GIT binary patch
literal 4380
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
Scn2lkiFe`M&itd!c;tT=NuMA9
literal 4674
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
EKeX+z?EnA(
diff --git a/bin/model/Pocket.class b/bin/model/Pocket.class
index 315513c23d7ad82c45972fc5e8d51dfea23c49c9..c8b39df5922f54618c70c4fe30db37fbd68f0750 100644
GIT binary patch
literal 1828
zcmZ`(-%}e^6#i}!vas2ZLV=QMYZ0sY0mRzYYN6N`ETE9mCKhRJ^%B;wuw*mIrnEl!
z=9{mMe?eb-&>4YZXB?k=@X5c&8Li*FSx8E0CUf@QdwzZAobTSh{`>8B0GF_7;v_!k
zLJ}V;aoNDQiAeKgB8DrNRN^Bgu9`Hs7QIS8^)qoDQ|f%$z{e&MxS=*PF<iu~5_1MV
zG4UzpV^~1mz)ce;uxQ|xf!hMHvfQ+%yozr>@&yLxOI+4G*R^Z8nU-c;AnrS^z39~)
z-|;GSfyDf}d?<4b9_I?SPm8XCQ?5wAQL_bxUer!Bw{pwREqYGHAD^Us%(rVb=~Rl3
ztMoWNzv->oZm!rmq)l|fsW|?mz*y>4(2np+-w}vRF`R<wRP20XbH%O|<%-J_L$0nC
zSqoF94#QH8mTCcE)n93JSD?FW`)x=C`cvs6fG`^k3(hyp7EYz-=vb0&so_fBE|fgg
zsg6y%R_3=S75FcDr49B|LFtv%s{2??rzY$El;?Ui9fzuT!I!0t1zFWq87K&t1+P&n
z**A1;v1XVtH6#neIB(%Kyl!C#Z!%YFbhEO)#_?G=h0_L#7Cyrr3rk9Tjxh_P7&EYJ
z;V$l3_yYG?fp%7-)PPj*2Nu4>R~95zER?X?ZlvdJz_#!;$_CafI9L}r_Rz7na<ld$
zS@tTb(-t=1vinUIG||&cCv#<`oV&TQZkNc>-WK>dGD!NWDe=}Jt6`HkWHprLfZP1X
z)0|%C{)kDFx*krmC~dbO{WS)tdRrV$YI-_7O&T)XHJ9*`K}1b^*6$J$?}LtNq~`cj
zbL(^tfDMorEo}RM$!udy*7N$(kr>1jspw7LzI{7pfq|p%B?~9Nf-aH_ibn1Ec*Im~
z&Cxbt`Ut#zRC8YL7iUnn$-Ngi*nV>~3rJT|E6Fzu2qUDp##KnM3IcEF^%?F-Kdw7@
zHjK9@&vJL29$|h@W_BSm*=>X}BijgPo*}Zli;itXf1#FuDF@I&+0U1809|~?x-rPC
zNowCgDu|b2o)E39%&&-M_h5vu)QVtg-4J3#B9KNV@EQ)hVu4p@2tOU9jnW9nQf4s{
zIGo~Fop#V6{PQ8x3smvy1g0vJGBs7~J#>keLSLaicVK^(^(p&!W(VeXeTY3p{QJXb
zW@z#*&QYo+W&`*M4PU3}KBDeLcI*~i-oyF8@dre8Pj5d%Vz~#;_y6DS;@Er>Z;!yj
z$R2tHe#9sj#|8dCU!Ka)4*Ey;Fc9LwiOZ2><WF=ZBiS7cK6(DP>Ul^{?KBLom(a&I
n<s6nV#ph%e_mIbZqIrM|)Fu%AS3N-q0~d4u&{5!h9pKXc^4yRK
literal 1091
zcmZ`%YflqF6g{(TS=ugd0b4}{eDtAIK}AwRVu%D2)Fy2-`fb>5%EGcs+O0-^ke~dZ
ziAd1IAK;HNo|)aISTUQuJ2Us(d(SyLzkYxJ31Ag#8CbZHMiw_s+{z#kZ3<ZwQBt9-
z!fh4qWQbZaQ895>AR9XEwsif*`y)qSYUeO$I$ovGKdcI*Lf3OT0%JS-@~y0NxvkWl
zkePJdZTT|nwply>cXmD6%6DO<7Px*`-5`Ew-SypYLtv(G&ZOc?f#fC$s8O!(JntUv
zI_-ws^>{Mca>6sT1f~ncb9xAv1lHXTEJ+lKPq~-PW`hE#t}w_+O|<O559vVXzo0j?
z;LvHe*kYo`yB637v_Lf&sfW@&cqWf}Ol|4eT~CHi-42v9nR?J|+s>9Ik&P;sl$92y
zaL>XBM%lUV?Y8Xf(O(N=7&ozOVFh^$_wm5OLlsu>$U+Wza*uvj)KXwv_wc0Os=V0U
zckEDmpeXj6voT%nL<Z3sWn^T_nYwC`numMF@V^oG*z*K(F;?G!&A{_G#0`AnG0$sd
z@iH2Gs7S9U0F<WJlQ6lS!Ue`@o~-eb8vIU|P9RF<V;H3$NW4Bl@))TvOz@U4P9mv5
zj5A1MmgN_jnblFXnd46In<{;U@tKRLY)BtoW28}x3cA3rf@TO!onlDf(*VB6{3TqD
z@dd2~uoS+03e&)=KCz5uzf9FD#LwYMT(uZiW#g)0<DW6>gkFUrr)X`)1$m{Q%=aTE
xbggEYj)xlBjZvBgJmJtS3frdX;EBkw)xsH_2KP$mx9Hs))LCPGkq86V{{YOC&shKf
diff --git a/bin/model/Tile.class b/bin/model/Tile.class
index 96b68529a6b1bac49f8359f6cb60fee74d08205f..0dc211d7645800a6e6231631dec7c606b221b12c 100644
GIT binary patch
delta 245
zcmW-bJ5K^p5QV?{Snn>n7z~?;K@kLGH_%|>BNkd~Wu&sh#6%m7Q20B@Eo|(yuraZ+
zproMlzi4ZmrTON}Imw*)c5h*K{`WNn4oC}x)FT`X$4)+*Ia)c|j$KFRqkE{5;_Yxe
zczPJzj7Gz|`?11w(kp+hCMxtl>MV({6o^=+!U{EFniTz|K8{MF*C<o=&-x->m#sp=
z234y5SDyrRaT@-}>;)}RZU1O8mHHQxo%c{|vL!6ZuYI&ASj|4Mwm-w!SFCv#OG^PP
SE#iGS4goqoRbtc@@%BGnwjtaA
delta 159
zcmZ3%agkl;)W2Q(7#JAL8PvHLI2hzP8Q2*V*clW-v=WF=1`#Uk465u5Y8!Pd7$;XV
z_A|0i=4SE|6=Psw5NF_IkYJDmLU{%$1{DVB$yrR+oGJ{w45|zw4C<5DF$MA(0(nLZ
zq723iG7P4Zd6?~4ZGj?olLMHISzUlE*U25sT8zGvH#2K-hcPfR$O7HN#2^O%d(jrn
diff --git a/bin/view/HexagonTile$1.class b/bin/view/HexagonTile$1.class
index f9a859f300f0c3522d6e587362345cf7eff88753..8b9e3b65b70757e72665cd7843e85dc971b37387 100644
GIT binary patch
delta 13
Ucmeyw`iXVJ5+=s%$xE4h0Vy&CH~;_u
delta 13
Vcmeyw`iXVJ5+=rZlb1620sty81#18R
diff --git a/bin/view/HexagonTile.class b/bin/view/HexagonTile.class
index b8009f4c590c6f27d28e61b66bb2d777837be24c..bf0bc95b838d1032f7ced67350f48fd204a85d85 100644
GIT binary patch
delta 1855
zcmY*a`&U#|6#nkqd*{wv4tO0I1mvNZf_FwVAD9S)X!*!jz6T#cfPx^SKw4&wmW5?6
zn_g;}+Jhceh%#f+YW0(?)&J2y&|0-xmeRNHOt@OJ?sv{Uckg|^`|W+sTrBuwYU0=X
zw|@e#1V7qXh~^*`V3)vdfjt6yEj(qzj~1IotH9IZ+Ge3$j1GZ)0{d;`pi^dDK@{VF
znB4+BVji^6Ycw_jHo}O@@*zS3hb{EkeBZBQe0*HrM>1j#*mwp<B-v5%eb&NrHY(6;
z<9QqxctPNVjjc!soD?`E8@(9BBD`edG+q|-6@fv4Gm`gJnZ0J=tcBMtym9Wg*o@q^
zc<(@8YyZHCcu%}fgR|~H>yg%Ztw#suc`M73by_ON>F=O}=a`I|Wy#+)S9>#A>f5Wm
zl|1e{(Aa>t6&}G-g<33AsKFA2I@D_jO=Mfyb+DtizboFW(13Fa?;xr0uEed!hU5&r
zF!3JVSNK3+Gqxyvi1P}Y@T9^8)GJ)XI)#s9?PE!tKasepwZE%v%RpbeyF*f6QuqXy
z6|UgChP(+c?_(6MO8N$TYT+}5&+&!AHf&cI!k3y4(~^gc{NxQiwDv27uknq-HGyvh
zzQgwl!vfcZ^N3Koftwaa6;hHkEi1PKeh_HDZG|z^C#M^K1_Pda)Hk`>Y?|cX-!ZUx
zRg(s@YEAQ;?KjStWm;kZy9zMi6Y)6niJaa@MZJ-Fa<ri__oKu{T03Dv=UC;Yp}CP!
z_}r3F=&m*jL%?*$;Ey@&PJ0?w3W4kN)v%mc28-x$$H@pHRE#`K;V&PB?9fUS(5(q8
zWSeBQRgjPnKP{k$xDt=a8(IrV)W>m>Y;L%^Y@R~!!9F4G0F;tv8M&8po9PUF9ILVk
zN;yhe)4d5}n3D{>%w98Tt;QN?32(FcS>Igoy#vb_f}vkyjL-X|OiU%#N;>#*8YS}+
zSVwH+lAEP!3sv*~Eb}}SqYRr%HLA&(O__<)%D9>kv97q0H0;RF$XU;5W%e|1$TfRv
z4D!*>Bj8jG!E_eXm~Ls<2%9P7)%v4F{uI^m2s>^x`@$K56CJ_i6hfZEl&D58uH?(g
z7{akoK^jw2DD++zC78gxg9^SXj>$ZQX`zx6q0*B^8f6n%MD~mp8(2&5{xDe~8;e=w
z8dh!z=CG+2@sQT?crIr{ZD1>HqddD<>lW5^KPx-H@*Jb;r>Nuw3V0doGons~c^|VZ
z<Y?M*?H*=p7B;HC8Re66Dsm<72FeoUwf=}JpFN$#A|+v?onPH<hK){noVu_{NMXil
zQyUt;^MG?PI}FTZGgp{*KsmOM=O(h-=G8O^-#^f`yQJ=uD<WH0b~qFRTgFfkOJioD
z*3fIru<7`(Vzsy1;4M6~)IV*obg<BW3$wc0mIg|)#%vmP*t~#AMMhzu&`zOp2<pFi
zl}9mMWTY^s$m`CGy4Adt<?sa&qt4B2?OljqH;?Qd)NjUKiq}GhF}k#IsokR=hH($d
z!dC4*>U3TI3xT`Rr*Z>jKjo5V13MzWz#4%&Jc39hg=n(Vu1w6ORn2GKurz^FF&Sr_
ziZteP>0v&u9G(ol*(3&ZvWvSAKsO8CLuv=9TQ9|oV<Qexy~9~itw4lq@^l`79bSr^
bBraEx#=ym#g_w2`ayfGXsNg@%F$DhwW4}I>
delta 1597
zcmZ9MX>(Ln5Qd*SbMM@ln?o2v1`<dJgiU4wLADS;Oh^=wO*WH}Edde;TY#_`&`|`U
zV2pUd1&~#Z3u;7|Sf<MI6PAAQH~7UWe}I-nNw9k|f?Buk+o${VIsJB@KIix07lx&N
z>i_mTpn@KcDXfSvnUxBw6jr;e@o;$76Qxd}UcHho&#AIjVV%Ny504Ex+87~DgQ|@R
zn^fKGvc;~dLiBu^)ZDDF)ni*TExKyE>N{L^dK9t3V>hh|dldG1EM}iVo5FtG@j!%f
z4tgBou&U21v@0BOIqHdgL6sL>QZ6sKynLoV>9<?A{JKEgI_4h>Y_MMOe+g_)RdC!e
zof(Fi%rZR6G>g3LjRzac8xQR-uWi}Yw7adPb+?iFoG_fE!|<vuspScap${Av?rYq$
ztz~oDv|7V!oHCqNSj5wY*XcAY<SD}&bQ#{{jNvV{`E*(S&%uI{3eFnN@wVX|I$hp1
zyvKRN5|$b+aM2%QPg?uF;S!e(R}`))T;sao1BDNj&_}v?Hy^uvV)#^}f2Nij3ZF|P
zavzYbY2DenPc!<$@FiXTS^JM+(Ix+#o@)_qYw{}tqx^GD)z`l|MOMXRIe7>Y&@#y=
zpoPmwsh!9OmTWp(uu`<;(l$YnWBqD3Kh=kmjBbf;=_QoL{YvZ>a|A~a5-h=Hw5%UP
zE~N}*tl&8Dn9IEEZp9)k@pR(12=qKy9?BTY1RrC*paz~U!~!A*#}l`)<H6em<Eb>^
zhe7is9CF}}(DsCKZie*ZRAqPgcQE_^!PKdm1zFdrB9+%5;bq^!wY#x{H^dOgq&L8C
z5i@JV<PgZIvLv=NPj>llVsvHdNIcO?B=J4o(s-I2XXkto#{V%~lo~WAR8}ZO%N>Xi
zjh7Y2?3j~ga5vGin?%zL$vEVdS>h#@p=#+PKbaTnWmuZwndt(}e}L5jqB34BvDZlc
zbqt}NLXu2ktsLk&VZK39+{iK-X<ox7F*ngbGh5}`&o<g=K{Lw7?q|G<XIa(OJtkN#
zPZ|j#?Ve5WsHCR}RtIM}F((?jMy2MV{0rxV5^>FJgz)w6M@H0-JnmTC_wPI;I?x>l
zgycbDa@R{ZEaVQzLA7V%M+p2y(7G#a642Y04caG7Wh7`rA4SPtiv7J_eri-@Xk<rm
zM?vTtN_K3n3>RgU(V}=U=RAW8?SgQDmu5^i=AUtChEi{#on~xdrWXcEIE5Sua6)?a
zr1WbCqvTmg$km_CDQU&iLZ*|IGFLAbem!TXnJ?}!?0XoO#a2J_g2CXQgzsus=vB{B
zzm(CTF7X5IO~&=yWPBpc1b;!!#MDI59+7`iPapAQv~&okqouth#8f8#IBnGddJ}{g
z@_5)>BrGq-3@!_`D^jPcQoL(&Ij^%yUJpIQ2yQqbY;uEgUzcUJSk5ydZQ)eTR2k*T
Rw&e_xQ8X;?^I~=p`5TK64h8@K
diff --git a/src/main/java/controller/GameContext.java b/src/main/java/controller/GameContext.java
index 722771d..4c0dafe 100644
--- a/src/main/java/controller/GameContext.java
+++ b/src/main/java/controller/GameContext.java
@@ -4,8 +4,10 @@ import view.HexagonTile;
import java.awt.Point;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.ArrayList;
import javax.swing.JPanel;
/**
@@ -46,7 +48,6 @@ public class GameContext {
return availablePositions;
}
-
/**
* Récupère l'offset actuel de la vue.
*
@@ -66,7 +67,6 @@ public class GameContext {
offset.translate(deltaX, deltaY);
}
-
/**
* Recalcule et applique la position de chaque tuile hexagonale en fonction de l'offset de vue.
* Actualise l'interface graphique en ajustant les positions des tuiles et en repeignant le panneau.
@@ -78,23 +78,45 @@ public class GameContext {
Point position = entry.getKey();
HexagonTile tile = entry.getValue();
- // Calcule la position avec l'offset
- int xOffset = position.x * (int) (50 * 3 / 2); // Ajuste la distance horizontale
- int yOffset = position.y * (int) (Math.sqrt(3) * 50); // Ajuste la distance verticale
+ int xOffset = position.x * (int) (50 * 3 / 2);
+ int yOffset = position.y * (int) (Math.sqrt(3) * 50);
- // Si la colonne est impaire, décale la tuile d'une demi-hauteur d'hexagone
if (position.x % 2 != 0) {
yOffset += (int) (Math.sqrt(3) * 50 / 2);
}
- // Applique l'offset de vue
xOffset += offset.x;
yOffset += offset.y;
- // Met à jour la position de l'hexagone
tile.setBounds(xOffset, yOffset, 50, 50);
}
gridPanel.revalidate();
gridPanel.repaint();
}
+
+ /**
+ * Retourne les positions adjacentes à une position donnée dans la grille hexagonale.
+ *
+ * @param position La position centrale pour laquelle obtenir les positions adjacentes.
+ * @return Une liste de positions adjacentes à la position spécifiée.
+ */
+ public List<Point> getAdjacentPositions(Point position) {
+ List<Point> adjacentPositions = new ArrayList<>();
+ if (position.x % 2 == 0) {
+ adjacentPositions.add(new Point(position.x + 1, position.y));
+ adjacentPositions.add(new Point(position.x - 1, position.y));
+ adjacentPositions.add(new Point(position.x, position.y + 1));
+ adjacentPositions.add(new Point(position.x, position.y - 1));
+ adjacentPositions.add(new Point(position.x + 1, position.y - 1));
+ adjacentPositions.add(new Point(position.x - 1, position.y - 1));
+ } else {
+ adjacentPositions.add(new Point(position.x + 1, position.y));
+ adjacentPositions.add(new Point(position.x - 1, position.y));
+ adjacentPositions.add(new Point(position.x, position.y + 1));
+ adjacentPositions.add(new Point(position.x, position.y - 1));
+ adjacentPositions.add(new Point(position.x + 1, position.y + 1));
+ adjacentPositions.add(new Point(position.x - 1, position.y + 1));
+ }
+ return adjacentPositions;
+ }
}
diff --git a/src/main/java/controller/GameController.java b/src/main/java/controller/GameController.java
index 2a9b385..785a690 100644
--- a/src/main/java/controller/GameController.java
+++ b/src/main/java/controller/GameController.java
@@ -11,11 +11,6 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
-/**
- * La classe GameController gère le flux de jeu et la logique principale, y compris le placement de tuiles,
- * la mise à jour de la grille et le calcul du score. Elle prend en charge l'initialisation du jeu,
- * la génération de tuiles et la gestion de la fin de la partie.
- */
public class GameController implements TilePlacer {
private Map<Point, HexagonTile> hexagonMap;
private Set<Point> availablePositions;
@@ -32,7 +27,6 @@ public class GameController implements TilePlacer {
private int seriesId;
private GameEndListener gameEndListener;
-
/**
* Constructeur de la classe GameController.
* Initialise les composants de la partie, y compris le contexte de jeu, la série de tuiles,
@@ -61,24 +55,12 @@ public class GameController implements TilePlacer {
updatePreview();
}
-
- /**
- * Charge une série de tuiles spécifiée par l'identifiant de série.
- *
- * @param idSeries l'identifiant de la série à charger
- */
public void loadSeries(int idSeries) {
currentTiles = dbManager.getTilesBySeries(idSeries);
tileIndex = 0;
System.out.println("Série " + idSeries + " chargée avec " + currentTiles.size() + " tuiles.");
}
-
- /**
- * Place une tuile à la position spécifiée dans la grille, si la position est disponible.
- *
- * @param position la position de la grille pour placer la tuile
- */
@Override
public void placeTile(Point position) {
if (availablePositions.contains(position)) {
@@ -88,7 +70,6 @@ public class GameController implements TilePlacer {
return;
}
- // Placer la tuile actuelle
hexTile.setTile(nextTile);
gridPanel.revalidate();
gridPanel.repaint();
@@ -103,40 +84,29 @@ public class GameController implements TilePlacer {
}
gameContext.repaintGrid(gridPanel);
+
+ // Calculer les scores et mettre à jour la visualisation des poches
scoreGameContext.calculateScore();
- // Incrémenter le nombre de tuiles placées et vérifier si la limite est atteinte
placedTileCount++;
if (placedTileCount > 48) {
- endGame(); // Terminer la partie si on a atteint la 50ᵉ tuile pile
- return; // Arrêter ici pour éviter de générer une tuile vide
+ endGame();
+ return;
}
- // Générer la prochaine tuile si la partie n'est pas terminée
generateNextTile();
}
}
- /**
- * Termine la partie, enregistre le score final et notifie le listener de fin de partie.
- */
private void endGame() {
int finalScore = scoreGameContext.getScore();
-
- // Enregistrer le score dans la base de données
new SendScore().insertscore(seriesId, finalScore);
- // Notifiez le listener de la fin de la partie
if (gameEndListener != null) {
gameEndListener.onGameEnd(finalScore);
}
}
- /**
- * Initialise le jeu en plaçant une tuile initiale au centre de la grille et en configurant la vue.
- *
- * @param cameraController le contrôleur de caméra pour gérer les déplacements de vue
- */
public void initializeGame(CameraController cameraController) {
generateNextTile();
Tile initialTile = getNextTile();
@@ -153,13 +123,6 @@ public class GameController implements TilePlacer {
generateNextTile();
}
- /**
- * Place la tuile initiale dans la grille et initialise les positions adjacentes comme disponibles.
- *
- * @param position la position centrale pour la tuile initiale
- * @param cameraController le contrôleur de caméra pour appliquer l'offset de vue
- * @param tile la tuile initiale à placer
- */
public void placeInitialTile(Point position, CameraController cameraController, Tile tile) {
if (tile == null) {
System.out.println("Erreur : tuile initiale non définie.");
@@ -177,15 +140,6 @@ public class GameController implements TilePlacer {
}
}
- /**
- * Ajoute une nouvelle tuile hexagonale à la grille à la position spécifiée.
- *
- * @param position la position de la tuile dans la grille
- * @param panel le panneau contenant la grille
- * @param hexSize la taille de l'hexagone
- * @param cameraController le contrôleur de caméra pour ajuster la position
- * @param tile la tuile à placer ou null pour un espace réservé
- */
public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController, Tile tile) {
if (position == null || panel == null) {
System.out.println("Erreur : position ou panel est null");
@@ -220,9 +174,6 @@ public class GameController implements TilePlacer {
panel.repaint();
}
- /**
- * Génère la prochaine tuile de la série et met à jour l'aperçu.
- */
public void generateNextTile() {
if (tileIndex < currentTiles.size()) {
nextTile = currentTiles.get(tileIndex++);
@@ -233,9 +184,6 @@ public class GameController implements TilePlacer {
}
}
- /**
- * Met à jour l'aperçu de la tuile suivante.
- */
private void updatePreview() {
if (nextTilePreview != null) {
if (nextTile != null) {
@@ -247,21 +195,10 @@ public class GameController implements TilePlacer {
}
}
- /**
- * Retourne la prochaine tuile à placer.
- *
- * @return la prochaine tuile ou null si aucune tuile n'est disponible
- */
public Tile getNextTile() {
return nextTile;
}
- /**
- * Retourne les positions adjacentes à une position donnée dans la grille.
- *
- * @param position la position centrale
- * @return un tableau de positions adjacentes
- */
private Point[] getAdjacentPositions(Point position) {
if (position.x % 2 == 0) {
return new Point[]{
diff --git a/src/main/java/controller/ScoreGameContext.java b/src/main/java/controller/ScoreGameContext.java
index 816f66e..b0ae9b7 100644
--- a/src/main/java/controller/ScoreGameContext.java
+++ b/src/main/java/controller/ScoreGameContext.java
@@ -7,47 +7,43 @@ import view.HexagonTile;
import javax.swing.*;
import java.awt.Point;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
/**
* La classe ScoreGameContext gère le calcul et l'affichage du score dans le jeu.
- * Elle crée des "Pockets" basées sur les tuiles placées et leurs types de terrain,
+ * Elle crée des "Pockets" basées sur les tuiles placées et leurs types de terrain,
* et calcule le score total en fonction de la taille de chaque Pocket.
*/
public class ScoreGameContext {
private GameContext gameContext;
private int score;
private JLabel scoreLabel;
- private Map<Point, Pocket> pocketMap; // Map des Pockets pour chaque tuile
- private Set<Pocket> pockets; // Ensemble de toutes les Pockets
+ private Map<Point, Pocket> pocketMap; // Map des Pockets pour chaque position de tuile
+ private Map<TerrainType, List<Pocket>> pocketsByTerrainType; // Ensemble de toutes les poches par type de terrain
/**
* Constructeur pour ScoreGameContext.
*
* @param gameContext le contexte du jeu qui contient l'état de la grille
- * @param scoreLabel le JLabel pour afficher le score
+ * @param scoreLabel le JLabel pour afficher le score
*/
public ScoreGameContext(GameContext gameContext, JLabel scoreLabel) {
this.gameContext = gameContext;
this.scoreLabel = scoreLabel;
this.pocketMap = new HashMap<>();
- this.pockets = new HashSet<>();
+ this.pocketsByTerrainType = new HashMap<>();
this.score = 0;
}
/**
- * Méthode principale pour recalculer le score en reconstruisant toutes les Pockets.
- * Elle parcourt les tuiles dans la grille et crée des Pockets par type de terrain.
+ * Méthode principale pour recalculer le score en reconstruisant toutes les poches.
+ * Elle parcourt les tuiles dans la grille et crée des poches par type de terrain.
*/
public void calculateScore() {
score = 0;
- pockets.clear();
- pocketMap.clear();
+ pocketsByTerrainType.clear();
- // Parcourt chaque tuile dans la grille pour créer des Pockets par type de terrain
+ // Parcourt chaque tuile dans la grille pour créer des poches par type de terrain
for (Map.Entry<Point, HexagonTile> entry : gameContext.getHexagonMap().entrySet()) {
Point position = entry.getKey();
HexagonTile hexTile = entry.getValue();
@@ -55,122 +51,69 @@ public class ScoreGameContext {
if (hexTile.isFilled()) {
Tile tile = hexTile.getTile();
- // Crée ou fusionne une Pocket pour chaque type de terrain de la tuile
- for (int segment = 0; segment < 6; segment++) {
- TerrainType terrainType = tile.getTerrainForSegment(segment);
- if (terrainType != null) {
- Pocket pocket = findOrCreatePocket(position, segment, terrainType);
- pocketMap.put(position, pocket);
- }
+ // Crée des poches pour chaque type de terrain de la tuile
+ addTileToPockets(tile.getTerrain(0), position); // Premier terrain
+ if (tile.hasTwoTerrains()) { // Deuxième terrain si disponible
+ addTileToPockets(tile.getTerrain(1), position);
}
}
}
- // Calcule le score total en additionnant le score de chaque Pocket
- System.out.println("Pockets and their sizes:");
- for (Pocket pocket : pockets) {
- System.out.println("Pocket with terrain " + pocket.getTerrainType() + " has size " + pocket.getSize());
- score += pocket.calculateScore();
+ // Calcule le score total en additionnant le score de chaque poche
+ System.out.println("Poches et leurs tailles:");
+ for (List<Pocket> pockets : pocketsByTerrainType.values()) {
+ for (Pocket pocket : pockets) {
+ int pocketSize = pocket.getSize();
+ score += pocket.calculateScore();
+ System.out.println("Poche de taille " + pocketSize + " ajoutant " + pocket.calculateScore() + " points au score.");
+ }
}
updateScoreDisplay();
}
/**
- * Recherche ou crée une Pocket pour un terrain spécifique dans une tuile.
+ * Ajoute une tuile à une poche de terrains en regroupant les tuiles adjacentes.
+ * Si des poches existent autour, fusionne ces poches.
*
- * @param position la position de la tuile
- * @param segment le segment de la tuile
- * @param terrainType le type de terrain de la tuile
- * @return la Pocket correspondante, soit une Pocket existante fusionnée, soit une nouvelle Pocket
+ * @param terrainType Le type de terrain de la tuile.
+ * @param position La position de la tuile.
*/
- private Pocket findOrCreatePocket(Point position, int segment, TerrainType terrainType) {
- Pocket newPocket = new Pocket(terrainType);
- newPocket.addTile(position);
+ private void addTileToPockets(TerrainType terrainType, Point position) {
+ List<Pocket> pockets = pocketsByTerrainType.computeIfAbsent(terrainType, k -> new ArrayList<>());
+ Pocket foundPocket = null;
+ List<Pocket> pocketsToMerge = new ArrayList<>();
- // Vérifie les voisins pour fusionner les Pockets si les segments se touchent
- for (int adjSegment = 0; adjSegment < 6; adjSegment++) {
- Point neighborPos = getAdjacentPositionForSegment(position, adjSegment);
- Pocket neighborPocket = pocketMap.get(neighborPos);
-
- if (neighborPocket != null && neighborPocket.getTerrainType() == terrainType) {
- // Vérifie si les segments de terrain se touchent avant de fusionner les Pockets
- if (areSegmentsConnected(position, neighborPos, segment, adjSegment, terrainType)) {
- System.out.println("Merging pocket at " + position + " with pocket at " + neighborPos + " for terrain " + terrainType);
- neighborPocket.merge(newPocket);
- pockets.remove(newPocket); // Supprime la Pocket fusionnée
- return neighborPocket; // Retourne la Pocket fusionnée
+ for (Pocket pocket : pockets) {
+ for (Point adj : gameContext.getAdjacentPositions(position)) {
+ if (pocket.containsTile(adj)) {
+ if (foundPocket == null) {
+ foundPocket = pocket;
+ foundPocket.addTile(position);
+ } else {
+ foundPocket.merge(pocket);
+ pocketsToMerge.add(pocket);
+ }
+ break;
}
}
}
- System.out.println("New pocket created at " + position + " for terrain " + terrainType);
- pockets.add(newPocket); // Ajoute la nouvelle Pocket si aucune fusion n'a eu lieu
- return newPocket;
- }
-
- /**
- * Vérifie si les segments de deux tuiles se touchent et partagent le même type de terrain.
- *
- * @param position1 la première position de tuile
- * @param position2 la seconde position de tuile
- * @param segment1 le segment de la première tuile
- * @param segment2 le segment de la seconde tuile
- * @param terrainType le type de terrain à vérifier
- * @return true si les segments sont connectés, false sinon
- */
- private boolean areSegmentsConnected(Point position1, Point position2, int segment1, int segment2, TerrainType terrainType) {
- Tile tile1 = gameContext.getHexagonMap().get(position1).getTile();
- Tile tile2 = gameContext.getHexagonMap().get(position2).getTile();
-
- if (tile1 == null || tile2 == null) return false;
-
- TerrainType terrainSegment1 = tile1.getTerrainForSegment(segment1);
- TerrainType terrainSegment2 = tile2.getTerrainForSegment(segment2);
-
- boolean connected = terrainSegment1 == terrainType && terrainSegment2 == terrainType;
- if (connected) {
- System.out.println("Segments connected between " + position1 + " and " + position2 + " for terrain " + terrainType);
+ if (foundPocket == null) {
+ Pocket newPocket = new Pocket(gameContext, terrainType);
+ newPocket.addTile(position);
+ pockets.add(newPocket);
+ pocketMap.put(position, newPocket);
}
- return connected;
- }
- /**
- * Obtient la position adjacente pour un segment spécifique (0 à 5).
- *
- * @param position la position de la tuile
- * @param segment le segment pour lequel on cherche la position adjacente
- * @return la position adjacente
- */
- private Point getAdjacentPositionForSegment(Point position, int segment) {
- if (position.x % 2 == 0) {
- switch (segment) {
- case 0: return new Point(position.x + 1, position.y);
- case 1: return new Point(position.x + 1, position.y - 1);
- case 2: return new Point(position.x, position.y - 1);
- case 3: return new Point(position.x - 1, position.y - 1);
- case 4: return new Point(position.x - 1, position.y);
- case 5: return new Point(position.x, position.y + 1);
- default: return position;
- }
- } else {
- switch (segment) {
- case 0: return new Point(position.x + 1, position.y);
- case 1: return new Point(position.x + 1, position.y + 1);
- case 2: return new Point(position.x, position.y + 1);
- case 3: return new Point(position.x - 1, position.y + 1);
- case 4: return new Point(position.x - 1, position.y);
- case 5: return new Point(position.x, position.y - 1);
- default: return position;
- }
- }
+ pockets.removeAll(pocketsToMerge);
}
/**
* Met à jour l'affichage du score dans GameView.
*/
private void updateScoreDisplay() {
- System.out.println("Updated Score: " + score); // Débogage du score
+ System.out.println("Score mis à jour : " + score);
scoreLabel.setText("Score: " + score);
}
diff --git a/src/main/java/model/Pocket.java b/src/main/java/model/Pocket.java
index 1eff0e8..e6425c3 100644
--- a/src/main/java/model/Pocket.java
+++ b/src/main/java/model/Pocket.java
@@ -1,82 +1,95 @@
-// src/main/java/model/Pocket.java
package model;
+import controller.GameContext;
+import view.HexagonTile;
+import java.awt.Color;
import java.awt.Point;
import java.util.HashSet;
import java.util.Set;
-/**
- * La classe <code>Pocket</code> représente un groupe de tuiles adjacentes
- * d'un même type de terrain dans le jeu.
- */
public class Pocket {
- private TerrainType terrainType; // Type de terrain de cette Pocket
- private Set<Point> tiles; // Ensemble des positions des tuiles de la Pocket
+ private GameContext gameContext;
+ private Set<Point> tilePositions; // Ensemble des positions des tuiles dans cette poche
+ private TerrainType terrainType; // Type de terrain de cette poche
/**
- * Constructeur de la classe <code>Pocket</code>.
+ * Constructeur de la classe Pocket.
*
- * @param terrainType Le type de terrain associé à cette Pocket.
+ * @param gameContext le contexte de jeu pour accéder aux tuiles
+ * @param terrainType le type de terrain de cette poche
*/
- public Pocket(TerrainType terrainType) {
+ public Pocket(GameContext gameContext, TerrainType terrainType) {
+ this.gameContext = gameContext;
this.terrainType = terrainType;
- this.tiles = new HashSet<>();
+ this.tilePositions = new HashSet<>();
}
/**
- * Récupère le type de terrain de cette Pocket.
+ * Ajoute une tuile à la poche.
*
- * @return Le type de terrain de cette Pocket.
+ * @param position la position de la tuile dans la grille
+ */
+ public void addTile(Point position) {
+ tilePositions.add(position);
+ }
+
+ /**
+ * Vérifie si la poche contient une tuile à la position donnée.
+ *
+ * @param position la position de la tuile à vérifier
+ * @return true si la tuile est dans la poche, false sinon
+ */
+ public boolean containsTile(Point position) {
+ return tilePositions.contains(position);
+ }
+
+ /**
+ * Récupère le type de terrain de cette poche.
+ *
+ * @return le type de terrain de la poche
*/
public TerrainType getTerrainType() {
return terrainType;
}
/**
- * Obtient la taille de cette Pocket, c'est-à-dire le nombre de tuiles.
+ * Calcule la taille de la poche en fonction du nombre de tuiles qu'elle contient.
*
- * @return La taille de la Pocket.
+ * @return la taille de la poche
*/
public int getSize() {
- return tiles.size();
+ return tilePositions.size();
}
/**
- * Ajoute une tuile à cette Pocket à une position donnée.
+ * Calcule le score de la poche en fonction de sa taille.
+ * La règle est que le score est la taille de la poche au carré.
*
- * @param position La position de la tuile à ajouter.
- */
- public void addTile(Point position) {
- tiles.add(position);
- }
-
- /**
- * Vérifie si une tuile à une position donnée est présente dans cette Pocket.
- *
- * @param position La position de la tuile à vérifier.
- * @return <code>true</code> si la tuile est présente, sinon <code>false</code>.
- */
- public boolean containsTile(Point position) {
- return tiles.contains(position);
- }
-
- /**
- * Fusionne cette Pocket avec une autre Pocket si elles partagent le même type de terrain.
- *
- * @param other La Pocket à fusionner.
- */
- public void merge(Pocket other) {
- if (this.terrainType == other.terrainType) {
- this.tiles.addAll(other.tiles);
- }
- }
-
- /**
- * Calcule le score de cette Pocket basé sur la taille au carré.
- *
- * @return Le score de la Pocket.
+ * @return le score de la poche
*/
public int calculateScore() {
- return getSize() * getSize(); // La taille au carré donne le score
+ return (int) Math.pow(getSize(), 2);
+ }
+
+ /**
+ * Fusionne cette poche avec une autre poche en ajoutant toutes ses tuiles.
+ *
+ * @param otherPocket la poche à fusionner avec celle-ci
+ */
+ public void merge(Pocket otherPocket) {
+ tilePositions.addAll(otherPocket.tilePositions);
+ }
+
+ /**
+ * Applique une couleur de contraste pour visualiser cette poche sur l'interface.
+ */
+ public void applyContrastColor() {
+ Color contrastColor = new Color(255, 255, 255, 128); // Couleur semi-transparente pour visualiser
+ for (Point position : tilePositions) {
+ HexagonTile tile = gameContext.getHexagonMap().get(position);
+ if (tile != null) {
+ tile.setContrastColor(contrastColor);
+ }
+ }
}
}
diff --git a/src/main/java/model/Tile.java b/src/main/java/model/Tile.java
index 703e0d6..ae554f5 100644
--- a/src/main/java/model/Tile.java
+++ b/src/main/java/model/Tile.java
@@ -1,50 +1,25 @@
-// src/main/java/model/Tile.java
package model;
-/**
- * La classe <code>Tile</code> représente une tuile dans le jeu, qui peut contenir un ou deux types de terrains.
- * Chaque tuile a un identifiant unique, un tableau de types de terrains, et gère sa rotation.
- */
public class Tile {
- private int id; // ID de la tuile
- private TerrainType[] terrains; // Tableau contenant deux types de terrains (ex. MER, FORET)
- private int segmentsForTerrain1; // Nombre de segments pour le premier terrain
- private int rotation; // Rotation de la tuile (en multiple de 60 degrés)
+ private int id;
+ private TerrainType[] terrains;
+ private int segmentsForTerrain1;
+ private int rotation;
- /**
- * Constructeur pour créer une nouvelle tuile avec deux types de terrains.
- *
- * @param id L'identifiant de la tuile.
- * @param terrain1 Le premier type de terrain.
- * @param terrain2 Le deuxième type de terrain.
- * @param segmentsForTerrain1 Le nombre de segments pour le premier terrain.
- */
public Tile(int id, TerrainType terrain1, TerrainType terrain2, int segmentsForTerrain1) {
this.id = id;
this.terrains = new TerrainType[]{terrain1, terrain2};
this.segmentsForTerrain1 = segmentsForTerrain1;
- this.rotation = 0; // Initialisation de la rotation à 0
+ this.rotation = 0;
}
- /**
- * Renvoie le terrain pour l'index donné (0 ou 1).
- *
- * @param index L'index du terrain à récupérer.
- * @return Le type de terrain à l'index spécifié, ou null si l'index est invalide.
- */
public TerrainType getTerrain(int index) {
if (index >= 0 && index < terrains.length) {
return terrains[index];
}
- return null; // Retourne null si l'index est invalide
+ return null;
}
- /**
- * Méthode pour obtenir le terrain associé à un segment spécifique (prend en compte la rotation).
- *
- * @param segmentIndex L'index du segment.
- * @return Le type de terrain associé au segment spécifié.
- */
public TerrainType getTerrainForSegment(int segmentIndex) {
int adjustedIndex = (segmentIndex - rotation + 6) % 6;
if (adjustedIndex < segmentsForTerrain1) {
@@ -54,35 +29,28 @@ public class Tile {
}
}
- /**
- * Fait tourner la tuile dans le sens horaire.
- */
public void rotateClockwise() {
rotation = (rotation + 1) % 6;
}
- /**
- * Fait tourner la tuile dans le sens antihoraire.
- */
public void rotateCounterClockwise() {
- rotation = (rotation + 5) % 6; // Tourner dans le sens inverse
+ rotation = (rotation + 5) % 6;
}
- /**
- * Renvoie la rotation actuelle de la tuile.
- *
- * @return La rotation de la tuile en multiples de 60 degrés.
- */
public int getRotation() {
return rotation;
}
- /**
- * Renvoie l'identifiant de la tuile.
- *
- * @return L'identifiant de la tuile.
- */
public int getId() {
return id;
}
+
+ /**
+ * Vérifie si la tuile a deux terrains différents.
+ *
+ * @return true si la tuile a deux terrains, sinon false.
+ */
+ public boolean hasTwoTerrains() {
+ return terrains[1] != null;
+ }
}
diff --git a/src/main/java/view/HexagonTile.java b/src/main/java/view/HexagonTile.java
index fd16f47..8c19415 100644
--- a/src/main/java/view/HexagonTile.java
+++ b/src/main/java/view/HexagonTile.java
@@ -7,78 +7,44 @@ import javax.swing.*;
import java.awt.*;
import java.awt.geom.Path2D;
-/**
- * La classe <code>HexagonTile</code> représente une tuile hexagonale dans le jeu.
- * Elle gère l'affichage d'une tuile avec ses segments de terrain et
- * indique si la tuile est un placeholder.
- */
public class HexagonTile extends JPanel {
- /** La tuile associée à cet hexagone. */
private Tile tile;
-
- /** La position de l'hexagone sur la grille. */
private Point position;
-
- /** Indicateur si l'hexagone est un placeholder. */
private boolean isPlaceholder;
+ private Color contrastColor; // Nouvelle couleur pour le contraste visuel des poches
- /**
- * Constructeur de la classe <code>HexagonTile</code>.
- *
- * @param position La position de l'hexagone sur la grille.
- * @param isPlaceholder Indique si cet hexagone est un placeholder.
- */
public HexagonTile(Point position, boolean isPlaceholder) {
this.position = position;
this.isPlaceholder = isPlaceholder;
this.tile = null;
+ this.contrastColor = null; // Par défaut, pas de contraste
setPreferredSize(new Dimension(100, 100));
}
- /**
- * Récupère la position de l'hexagone.
- *
- * @return La position de l'hexagone.
- */
public Point getPosition() {
return position;
}
- /**
- * Définit la tuile associée à cet hexagone.
- *
- * @param tile La tuile à associer.
- */
public void setTile(Tile tile) {
this.tile = tile;
- this.isPlaceholder = false; // Une fois la tuile posée, ce n'est plus un placeholder
+ this.isPlaceholder = false;
repaint();
}
- /**
- * Récupère la tuile associée à cet hexagone.
- *
- * @return La tuile associée.
- */
public Tile getTile() {
return tile;
}
- /**
- * Vérifie si l'hexagone est rempli avec une tuile.
- *
- * @return <code>true</code> si l'hexagone contient une tuile, sinon <code>false</code>.
- */
public boolean isFilled() {
return this.tile != null;
}
- /**
- * Méthode de peinture du composant.
- * Dessine l'hexagone et ses segments de terrain, ou un placeholder si aucun terrain n'est présent.
- *
- * @param g Le contexte graphique dans lequel dessiner.
- */
+ // Nouvelle méthode pour définir la couleur de contraste
+ public void setContrastColor(Color color) {
+ this.contrastColor = color;
+ repaint();
+ }
+
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
@@ -86,7 +52,7 @@ public class HexagonTile extends JPanel {
int centerX = getWidth() / 2;
int centerY = getHeight() / 2;
- int largeRadius = isPlaceholder ? 40 : 50; // Réduction de taille pour les placeholders
+ int largeRadius = isPlaceholder ? 40 : 50;
Shape largeHexagon = createHexagon(centerX, centerY, largeRadius);
g2d.setClip(largeHexagon);
@@ -102,33 +68,22 @@ public class HexagonTile extends JPanel {
g2d.setColor(Color.BLACK);
g2d.setStroke(new BasicStroke(3));
g2d.draw(largeHexagon);
+
+ // Appliquer la couleur contrastée si elle est définie
+ if (contrastColor != null) {
+ g2d.setColor(new Color(contrastColor.getRGB() & 0xFFFFFF | 0x66000000, true));
+ g2d.fill(largeHexagon);
+ }
}
- /**
- * Dessine les segments de terrain associés à la tuile.
- *
- * @param g2d Le contexte graphique dans lequel dessiner.
- * @param centerX La coordonnée X du centre de l'hexagone.
- * @param centerY La coordonnée Y du centre de l'hexagone.
- * @param radius Le rayon de l'hexagone.
- */
private void drawTerrainSegments(Graphics2D g2d, int centerX, int centerY, int radius) {
- // Parcourt les segments de 0 à 5 pour dessiner chaque segment en fonction du terrain associé
for (int i = 0; i < 6; i++) {
- TerrainType terrain = tile.getTerrainForSegment(i); // Récupère le terrain du segment, en prenant en compte la rotation
+ TerrainType terrain = tile.getTerrainForSegment(i);
g2d.setColor(getTerrainColor(terrain));
g2d.fillArc(centerX - radius, centerY - radius, 2 * radius, 2 * radius, 60 * i, 60);
}
}
- /**
- * Crée un hexagone à partir des coordonnées centrales et du rayon.
- *
- * @param centerX La coordonnée X du centre de l'hexagone.
- * @param centerY La coordonnée Y du centre de l'hexagone.
- * @param radius Le rayon de l'hexagone.
- * @return La forme hexagonale créée.
- */
private Shape createHexagon(int centerX, int centerY, int radius) {
Path2D hexagon = new Path2D.Double();
for (int i = 0; i < 6; i++) {
@@ -145,12 +100,6 @@ public class HexagonTile extends JPanel {
return hexagon;
}
- /**
- * Récupère la couleur associée à un type de terrain.
- *
- * @param terrain Le type de terrain à évaluer.
- * @return La couleur correspondant au type de terrain.
- */
private Color getTerrainColor(TerrainType terrain) {
if (terrain == null) {
return Color.WHITE;