From fb71c40735bfc9885a4438be4e407108c823cff6 Mon Sep 17 00:00:00 2001 From: dick Date: Fri, 3 May 2024 16:27:56 +0200 Subject: [PATCH] codeFinal+docs+clean --- out/AutomatiqueActionListener.class | Bin 1657 -> 0 bytes out/CaseMouseListener.class | Bin 3438 -> 0 bytes out/FenetreChoix.class | Bin 1359 -> 0 bytes out/FenetreModif$1.class | Bin 1376 -> 0 bytes out/FenetreModif.class | Bin 1103 -> 0 bytes out/FenetrePrincipale.class | Bin 1143 -> 0 bytes out/GenerateurSudoku.class | Bin 720 -> 0 bytes out/GrilleExisteActionListener.class | Bin 1443 -> 0 bytes out/GrillePainter.class | Bin 1296 -> 0 bytes out/GrilleSudokuDessin.class | Bin 1304 -> 0 bytes out/GrilleVideActionListener.class | Bin 631 -> 0 bytes out/Grilles.class | Bin 1236 -> 0 bytes out/Lecteur.class | Bin 1132 -> 0 bytes out/MainCreation.class | Bin 1381 -> 0 bytes out/MainJeu.class | Bin 502 -> 0 bytes out/ManuelActionListener.class | Bin 822 -> 0 bytes out/OuvertureFichier.class | Bin 1181 -> 0 bytes out/Register.class | Bin 1071 -> 0 bytes out/Reinitialiser.class | Bin 720 -> 0 bytes out/ReinitialiserActionListener.class | Bin 552 -> 0 bytes out/Resolveur.class | Bin 855 -> 0 bytes out/SaisieGrille.class | Bin 2084 -> 0 bytes out/SudokuGenerator.class | Bin 2861 -> 0 bytes src/AutomatiqueActionListener.java | 34 +++++++++-- src/CaseMouseListener.java | 43 ++++++++++++-- src/FenetreChoix.java | 30 +++++++++- src/FenetreModif.java | 58 ++++++++++-------- src/FenetrePrincipale.java | 32 +++++++++- src/GenerateurSudoku.java | 20 ------- src/GrilleExisteActionListener.java | 58 +++++++++++++----- src/GrillePainter.java | 29 +++++++++ src/GrilleVideActionListener.java | 42 +++++++++---- src/Grilles.java | 65 ++++++++++++++++++++ src/Lecteur.java | 82 ++++++++++++++------------ src/MainCreation.java | 55 ++++++----------- src/MainJeu.java | 17 +++++- src/ManuelActionListener.java | 33 +++++++++-- src/Register.java | 70 +++++++++++++--------- src/Reinitialiser.java | 25 +++++++- src/ReinitialiserActionListener.java | 26 ++++++-- src/Resolveur.java | 23 +++++++- src/SaisieGrille.java | 36 +++++++++-- 42 files changed, 569 insertions(+), 209 deletions(-) delete mode 100644 out/AutomatiqueActionListener.class delete mode 100644 out/CaseMouseListener.class delete mode 100644 out/FenetreChoix.class delete mode 100644 out/FenetreModif$1.class delete mode 100644 out/FenetreModif.class delete mode 100644 out/FenetrePrincipale.class delete mode 100644 out/GenerateurSudoku.class delete mode 100644 out/GrilleExisteActionListener.class delete mode 100644 out/GrillePainter.class delete mode 100644 out/GrilleSudokuDessin.class delete mode 100644 out/GrilleVideActionListener.class delete mode 100644 out/Grilles.class delete mode 100644 out/Lecteur.class delete mode 100644 out/MainCreation.class delete mode 100644 out/MainJeu.class delete mode 100644 out/ManuelActionListener.class delete mode 100644 out/OuvertureFichier.class delete mode 100644 out/Register.class delete mode 100644 out/Reinitialiser.class delete mode 100644 out/ReinitialiserActionListener.class delete mode 100644 out/Resolveur.class delete mode 100644 out/SaisieGrille.class delete mode 100644 out/SudokuGenerator.class delete mode 100644 src/GenerateurSudoku.java create mode 100644 src/Grilles.java diff --git a/out/AutomatiqueActionListener.class b/out/AutomatiqueActionListener.class deleted file mode 100644 index 71d5119b729bcc506c9fc5acfd87870f3d61cd46..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1657 zcmaJ?ZC4XV7`+38NtOj9@={b_QM3snv9^WQs1>3?5QGwn75X-8hOn~PNq2TZ{z>}_ zTKv|Y7CH8ue&JjHQ+xXCCY}?-_CqE!lbPo}_da)?{PoZ4KLO0*I|D6f^ z=VDLfT;Wx6%UjQ-9Wb=taXcru$IzO|uBVVhio-C`0h3{HCJa8lA(7o3j89c_Z~SQ(<;$Y zA+hX>6U;d(x8gfqPzro0s`(^F7_QYLT6G|+a&qXM9Qr4R(h_^pwsdIQCqL^+1EaXi zamBjDl{_7f=+vUG!M(Ze4|BshNx#Z5>#WLd-guZhYUSM5{P(31Z}4#ToUyb zTBBjg#56u3NU^=`*gH}AcxEGtv7V*~w@u`6hhd;9c4a|%wg{d&!4A!IAiO|FY!Ah93h3aVODp7erz z6G+{lBw7*=7%tD#5v`pqS6XFhQGM!?Sgx=tu_Y!siVQ<>U810Jj{@f2w(US2_ARSs z*BROhs!X|dFFKxl5>~gQza|Kcc0_Fb73ps)zbeZNBTczC!#s>2DPwYLDG>JVlBmTo zIG#|ENpE^KB^CO%EILu-;s1PJlMxN_^Q=;V4t!BtlEIED>m*7HA2b{ri{OT*jcQ5H zVpf$NiKC^hyt35RXm>llFtCoN9A8Goe#S5s3l-bb@%GfN%++05uYZv^EB}Duhh`r) z4%TydB)qaK_1L1K_gQPMT*K~7wLEok?Vu*#aeTAs{F~Z0Z8bs^gzJ`^K;{|Dd5=0m z!4+Cd&G8k()ia#ll`6+KB>n#%rM_6_MXx?dJ(S@geOjWnNDn4jCoo6jBU+8qx`n=t z@mFBu*MA59g;osnGyw>KSJj*(o4VMz4Y)AtYci8 zojAt$kGM(G=|q2GRQBR#b(;TyThCtMquZ&$RNKT6K4$&=H9iH7arY;rSh_%y2)`x9 zpF$_iyTPdkcOV^gSqz{L!_;T5(Ch{^q$ym$U0ftCmngR(e2x(;(k=S$_#2Nomf8}; bVmXevLcf9(VOXQjDmLPC44e2G-(v7z-k7&u diff --git a/out/CaseMouseListener.class b/out/CaseMouseListener.class deleted file mode 100644 index cfb871672e4dec42c595f96e59fc28070da080c2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3438 zcma)8TW}j!8UBtg-j%$*M6sNRIL^AcRI-EBxUE~{G;OWewSwG)$hc7gl(lp$Z@k)7 zcUO)RE-etCjl#iLK6@62~)yD%?HgotKNE4{-_o3U&x9rPU=vFDcGx!hMz-M&01z zkc5Kw30>i(DC`Fm>=rM2?r8gvglvxjb+hawujrO3WcMi8i+v1z4tMi<#pDHU@RCbX zlXLQ)%%$dq-T?*o3cY^P%UXsIw`xX^!mxx91qbnd!t4cZXl5l{I8QmNQlM6yqK@Z1 ziEgD&*t+Q!T$^iEN?RY&3homi`zU}mAVOhG!Tmy^pA@!05TmL;s9+oqG3=;n%RFnD zCCz_V)-vT6qR1=U5lcGqryYSQW zsDj7vIB|wR`US`luXN3zT!xdWGiP!VvYYecA&@b}5XqS(Zo8Up%6Nj#o7W7z%xwud z0xlq}rk!&HH+^i5ue#GZH_B1W2$JVFxjepbmP#n&NrppHCZ+g-YG~>TfvDSR&7ucw zOFo%Y=f<^W!EapSYDUHha@H`bo2qG57i=!!B&Br|hT}ECk`vSiQG5t<3O6+B+(x!U?`5rO%`&M0CR#G+<86IIybxu{FOoJ!{v-(yG4ba_RzyIj+3htu{wYVWo1f`Sst zG!rP(qHftGeR0vI!gmnqa;ejT#ES|lf*+AP{19(-1!u*Kl5Ae1>Qm`xw4BOvwdA`{ zO|IJ9sZmwATGJfW;EqbkaBZPY>vCN!)XUa#eN>(2bulY0kgY|N$yTX`TAfJHbT%r= zWh$^xqhLk3X1U{N72d2@>i?`)YF+~6X3s{xo~&0FxIJyzRn47REpd+_GAL^!{!CMK z(@#zdP9lTNJ(xb#MrEupJlZ5KMdvfuA>&4S(7XRl<5eQ;ywCYVYSLOT^or(My3JF> z@e3Qmu{Pl+H-z_-(2Ihmz2RAYdPDd?oA5b?!Mg*G($(}?1)sx3D!1-TRcr2f?-n>M z;|mO#yr?Fxuc|ehSM?h|p|WoozeCkmTY_>ZZO=1|&C|6e=tB8fArc6(RIReUs8fnt zhJa?P5~EJb}B%35WjZckn}xnI^fZ9z;ir7AAYtf7~dIgx#^g)A)> zt9Qvw2uEE7S1T>gYBkSZ!Z&EVw)SwN)g^rMzXXj|mhdgQNPUauAlR6H6AaM;O|%l9 z)&;u$w!3;%(39rUq-D7dHB4=myGvHtk?{({fKYE6fohT+R9UL01DB$B72lKaeQ~k; zfMMST*NMs2GEe*P{kvvbE4h|U<$SsIerPEA$IfVGnVNTB-lAr$Z87p%rrRdNx$`x? zg?eiyo3pRoMOHJ6g6?w4mXf2J+s+!A<8Vj96^8w7F>M7^!fRCQyQ|Wq^W(x0eL)52 zLT2=&Zzx&?XdT82^!yU-hG{S4(c!nihDUx5=?zc&%k=CA6CceVxkKrr$s&5yp z(7v0Tjf||LYxqq_>)38QLYtk<&5?mift~?>x6A(-T)M*kx%(2kxx4N4pT(Qq>lhNh z1MArTGbDYbQUB-A+jsz2$HV^iNJBW*kdCggSHtgMvKWjVEfhns=|U#-3(OSX!m&)4 z1Ro^9EC~|fLZ*WyI%3De0hS0QLcy`?D2z*SDRdbNiSRm}%E$@%I?jwogzLsJjZ@;0 zb!e~PfWPGpVG~0EjbQKX6TfUC!Rdi-(>3GYVacK>Im)^llMh=cg;t}Zz;t4q( zX#g!;jIgV>|Jobz;nqbQ=L*GeLJp18U_XTz>1-#RK3qZ^uc04rlE!ba3%|zz-o+sPggy8NRMw3lwiA2VAnqm4 z``KO`U@0WoAq=yJFv1?gL6)cAlNe<$;z4#9E!=aPS~JvCr1lC^3x1nU4d6TYF8#`s V!!`PU8JB4nrPUAdBfO5pe*i|_q^SS^ diff --git a/out/FenetreChoix.class b/out/FenetreChoix.class deleted file mode 100644 index f204a258292499f3a01fac01b2f928ddc9b49025..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1359 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 kMHvYT>jSe|A=hRkR5Px# diff --git a/out/GrilleExisteActionListener.class b/out/GrilleExisteActionListener.class deleted file mode 100644 index f9e211433378630ce2ed257c2e6af67d6537720d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1443 zcmZ`(*-{fh6g`~;IvEENBgmo{+%Q4HxPlV*0E&i1qiDpJA?ZMCGLz~|1b@Z9uu6j^ zrEk9Y0e+5pdlIVHtf}eg+jEz5?$W>heER|50bUyjAjlCi(Sc5e*jxL(ZB=Y%&01W2 zD~cXN=Pl_-?+!ySnOcq@j0lHe;s{KJ!G}s#Dq?0+);)2*=t8&FagHc>}<>sui ztAe2?r#)|4^$khBAN!{n1Ko&n#7rF3!Q%&27-R2YK{NA%C(HJ=s7$vp|ldy24! zaf)z|hJii|>$II_NG5%Ht;DtTGAjpS`yjW} zGO1;b3k;@aXGzy*6Gn<5+#qt}B}pl`h%t_|iE&ta8GNAHREg!9@RpQY6UzI*Fmed^ z)IsnDMsQj4y~5CYn2AsBnu+U}U^qtPvJIt#<4sFNjpQl{b+m2Q#_f~2vA^(3wj(MA zCK1%x%9yx?+YH_Hb$4U2CY)($SKKv*zP2xW!?Ut(wdOh$E0dbjMt4oz!+nM*5zPxK zy(daK)s&57o7xTp16fRS%$S(PLu$92R&G%Ha&6X7x_9@XrY6*toWo;|Cnj>3r+Um% z(|bzHyCqpB`sH1sEZTZ9Xq1w^DaRtikY7LzUc4vZ*8b^f)7$BW_Qa%?8A4gNM5v-U z>4=3!bycY6_NwLC_CvQJHz_w3@kdAsKO;CM+xeJC>D zgoZlrHdImfECo#bfBeU_6P%{&A^?U3dIS2(pi4)~9ay6EDM_Ow2k2{zZh?(n`~v=o zB!*|Sb|Xk@6d}YAp(}zRkLPW>-{9mMkfWc$o9K!~Vv(PS2j;iYQ`o}sg>Cc|;sc@Y zI8g}3hw@uUOoh?|p(f63W26vIeg#FmG}VzF=xE~VHYUmH=2T~TptFgo3Es;;BARaE z&e&Hxp!bo674TtApo{j$2|ynK>!)WBV>p2;7^1E_MSYaOB8Ksj=)b`klyDa7IFA=( el>qxoLYTmF&?Lt>ddLsQ2*)HN1%_9Cpu#_atY-uO diff --git a/out/GrillePainter.class b/out/GrillePainter.class deleted file mode 100644 index 577e5588b16c06696c96be3c606b987139c6f25c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1296 zcmZux&rcIU6#j&w$3E{$0R#;eD(jSm`Q4`L_ zqk0n#deuWQni%8JgBSl9qXd1kZMP-3X?Nbd_sx6Xd~bHXAAb4*U<5NRRKdX^DUji0 zaIb4yTA!&USNmp`*Y!k}!8u?gjqD(UL-o&dR5N%jkhY!en@DS$Yepgy8g+rgrQie< zhMHA98_%Xw8#-ZCf6Rs#oMDbShDO^vqGgOkAtVhw1ze~_gW%&~kkoPiyvW_Cz=tNv zohj#TRF9<=;FCDT(W2lqS{anMW@HR~B5jx^(WxhDbDFSA9@^SHoJy^_|pV@8sya5YMgf4&AP{2T!V-3T(&*;|gJ z%v72|9*GS{CMj=uA66vnLNEF_E-AQ-5JQ8#up~H@BO!`uycIeW)(aVWaaF-Jo7pTi zQ|#rsf*ZJ5Xi`Z7S@kb2k_urAaNJffh&xA)0yW1-uF}4?G&85qJY?{x(PCe%vr+(9 zw1*WsRuKl5kfXG)xyY~*ECk{hW2i0AxUU(>tWK&(k<^N4mC$lJ_h?y9&uPn|d37s# zCPU72iFa4U#!JeCW0f5b`{$`ZJgX%(rnF5f4@ZoW+lm$r9`TK*a_NLVZiq^rBb0gt z7#$d;Z$&&+pw_`j?{S*7(a30&1N&g_$zYhEw+I6c)Zi|nWD}Gi1yB7x+17wkD!XBXR!e%UA6nRl@i_<)Of^aL!gT}G4?|2(eH(C?E%KDoEw>2tn<8t^$k z;#LtaK(e`1rYvT84DHCo;ibjonUJc=l4=@WvSmwC@kKS0XewO;A-YcDP>`khW4Q4I z9=ssz8#Lk_T?gOLgdc?dNyqvZ`48#FkkE>Il&urhhiKv89Fy!17JfrM0A~kq(`^5+6g@AJqF7Z@C#e(S#4Uk-_^UB>A$+8yB#v#|I%y|vGt=n;R9kJ;IFga& zhGAHC$DSEr!@#0zTCjo6lny)iNlf`TPmWUqGaBpNd(S=h+^hTi`(Hml1+b1y10zs$ zs3tUw3QXOz?pq({+WU@sCwJ+p<=Rbw(F>021gio{GPM)I7$Q0h6Gvb&q3k=&rd{ha zyxq=*-EKQB6YhjgCfvMP(J^tro3r+V+=jDfyKTpF4U8iy%T5Yt$x0=)V~~2<#4*GK zqHR04>f5(%-?tkz=M!6CHd&SG{>`!?(?&3B;w8)pOtdV=4GP{~%X4iv5SSTCD*IOJ zu2XL_N5{Ot^da3KlHbsg5IA-iShw0vy%zZ1uC1%U(~g?^BrPdM}`a)1KM+piRU;X&hyNNqr4oJul@spSQ=p4(Tp)v&!&>!5ZnoQR=&ReCa7 zV~7=sRUJLhISdoMFd4GjfowEHRk~u`iKOpUWEcrg1Pq3A=F4_Du$zJ*RZ-lw6}BXi zcRSG)j(&okoa`7#Vt`}N#E{Z3`1>ydcV&3thr+-x(i|BRS>!1EE+C|Or=Ld1-~YbVTNo!Vq_DD(;{>XP;?e^ yA9?GPrCxJMJ*hvVPunZqfZrjp^netdkuOY|$^mIYWC)Z+3OTYP1e&L~hJ`nZK8wNt diff --git a/out/Grilles.class b/out/Grilles.class deleted file mode 100644 index 18560e43d5af3588aea4ebdaa03b333d458df199..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1236 zcmY*YL2nyH6#mBR-SKWW$tGdjI?Xn2+EOQO=qq*y8LO zdtDVc^x{9j5ph8r2wXtzA(bd92gHRVe}OXxj#z>4jgyqbmS^6ZdGCAQ``-Ase}8-i zU;(dLNI;WF+R$MLIQMGzYxzbk+{jng?)mjtz_=EKL0l5hvQsM(DH^M*WeH2*L_a!+ z@{2*kFNe)eyd1au+NK2)wn7{baI=;FF?k(?8}kZh=ur9_wYYX9eGtPceMI2oemaXB ziXei8LA+qY#c=`2qU+_5WXZ9tZcf@rtA6x)BWn8+rvye1$d;=&AJqM397LfB52qz2 zY-DieNcYR1v}1phfKi9A?p_Zhafc1;cR8QJS%I+%RqC|-%m+dJ!@zH4g3V^sZU<`( z-@1d`dZlDWVNw^~7?;kS8qBU<+bhAKhm-|lR#`K@b`1(`1=%Q zRDU>wm-y<`M*|7N;Ch9g$6avOr=LJPq9O1yS9J~8d{eJrfHp(LLnM*n=?{+ilT~p{ z$NUvCv80s_%wqB>%)10SR@9$j@NQav0;gzbv(lB0`87szu1p)-7_D}t*xLP5*(bIz zP?V1`J~FwDbIQ?`lcS@}>aMQxUUyQnhHHF@e9qNpN}gjiOSF{ZtvgnudePMjuHjXg z>22du*Vx_K{aq_{byoTL5&O<#33o8Y@4I*pQ#?^khB(D_h-x@|z9U>m8R6m_jx!^T zIeH7+-^4icCy3zTZJZ{?BvCSWpQ>))EIww&r+f|%aRFVvyU#I=FOb7mJpTrl@GWD$ zC*mxt6=Ch7fRx0m5_1w#@F!tP3{vqP+*=Z3f5Tjmm@;>e5Ig+S_i(uf24No8_J)Da zIL9RMW)8%!XxGP;Se{0KxDVyV3!YZ(YSiGbZi4F{xwq7S_j;e~kFr3_D;TC4X%2dV h`+52~TqWzdKHpI!|G_cEbBDhkhI^Dt;CdgZ^dHe({oeop diff --git a/out/Lecteur.class b/out/Lecteur.class deleted file mode 100644 index 8e08d2c9d7e4a5e942438a4b516eb6c81fea33d4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1132 zcmY*Z%Wl&^6g`vJp4hmpOKbX|rGfHDp`<(mq|iz{iX!y^3PM7a5N>L~klK;!AP_60 zF8Bb%h6NIviWQGV5f1?pV#9Cn6;z0FCbST|xSl(6&OK-DjQ#D`yN>`)W86XtX$j4S z4nx4X<=yc{s$O_wWM=M`Ur7XvlR+3HV*=^i&}E4X2eY#!2}_`>fexaPiJSTJF$iY)@|xyfeKsH)M{L_O;z-hb3qv@7anf$o3QCIl;3Xho+D7h41*1?Nj4 zjnZGqL^paQdTne)-+$XF-&;)l1)`!lvF=|}7vdmXw>@fM8wMn@HnwAjK*xshCX9ey zQw#wuSNh{*r;S~zcY387E&39BnwX`Tb9XC#EeWD9gCT+5N%piJ``PP3y$Co_1A*A}pszB$zb5K&FJpQ4} z0xjjltK6RQY7K%!QNV7tBymz8HCqy}%27S8_=-%-x^!M)+2}*Of$B+tErh{%gjqk| zf^U8A8;DmN2pnZp%PN{E;26h*ibv3p;p}I}{9sKvrel7EOiiZ?+IyH+$lp}d-=p

{W@bk^@ZA z1>MzEg$qumV7SH;j19YbzM#39W7P^86P3H#ykk{o_PhEa*KjqZ;%d~`w=uC~tSzs7 zq0c3qsxMx#1-mhgi;V4<#Z}}vqjnvmkI`g%)XlfK+Q$3s5Z8eN=)?(r3THSjp^N-p zR_I0?8<#Ea_5c6? diff --git a/out/MainCreation.class b/out/MainCreation.class deleted file mode 100644 index 94b2805e65682ca4b58576edc42529709b0452ac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1381 zcmZuxOg z`|}T9Ibk4`Yd1o>5;oM&p$P+)j`Ib>sZ8lGQYG*R=|;AyEk-PyK$2m?7r|}u6AzuB z;3!|LzZ4$VfDEzBYR`7m!bzNBFvzwd_XI;cvr2ac#wkQM0N)AnE6QsKuf$)eFfcKO zK^E_xTr8 z^QCfy8<4Mo=}%cJ@w#vlxX5tsVJI9&*jt{Y$+vwKZgUxkJ-eks-(E6t9+n=ywvf@x zj8XJ^%9DG_4Y;%H$St=?aSY5bj2}`hdH_F)^=Y^4)%fyk@BAsGS2+7c{B!nAF2H3)itodf|-*!_4P7>6Kr@ z91@klO{!p7dBL`>&@GL##E|_gLZ5zmN+q5XSSGy|hz#Lrgo1_JxWix)V^!(Pxdmu|rm2R}eTHRvTHCFzQC*sKe0gZJLnBs)?_ z=6N4IAAc_*qM|}?Qxv5pBH0gmNehQW_K5m{{sus$zz~fav^zsHqd7j)275;fhQ~DO zYrw)Vs(3MaY@ uEv{jl8s!94dXkkXEOhNpx#fZBh$FjYDL diff --git a/out/MainJeu.class b/out/MainJeu.class deleted file mode 100644 index a6c5becd69695a2d371febd01710e13bb85d165d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 502 zcmZuuO-}+b5Pg+}g>@C=%TILG3uppogYh5<2ZJ98hQxR(P@sg}C3P|SlQ`-D5>32t z^G6w{Xktw0VLH>kd2jmq`Stbz;2eh*mJl*w*a#!Skm&PAUK(((Te@!cMJr&4oJvmy zXAGfyp%FtAF%y=JW!V4V_2-8`xP;q!5nJVfk#65AEo)oBqP0UxzI3?Ww5Kl z6C_;e`SQs^1|c0bZEWe6MtP?rTRovn>=2=z<3fxWjEdhD4Dp)u#MQ`c3U$ky13EEW zf-q$B_lp!6thzr^Em4&kZ2$5V_4wGwHrcG#5|}ocVvedD?Tq&D(G={35^{&4zShtf x_TW&ip(j*pip(p_>#i|IjWxc;(Ow>rDq1XgNqJ0{cflh^8vKLzakvwXY z8clrR%^zhv15HfPhdrA!Gv~XUbAJ8){u976Jkk+DSVP1>6fuT{6F%T(m)jllb@N16 zK11xWw59)qA)GHX5{M(AK{t?u!LWS5?Lc&&TE2Abs`Pwe3ztE+jvaYcad}VBo2tS* zGrdzusIMlcWgYWKX;?6@sA$vwK4H*W((5~((6NMN4H*L~SS5-3iiG5=-`Zm)z$NR-tHM2fGY$-fm0lSoK-UzayWjw8XGE zVdba3DF(v!&Do)>PFZILQD`tko;xk-TB<5-Q44xa;lANb)yEW{4E9jCZO8427Q@zs z^jVr0ijqvw?CVb8TB0Hqz}o-zqojmV$Ktel414s2)HcyRsyqsl;vLG0l!xfA7tg_p zJ71xFqKx4##d(A&CJ=#6F-fQQaQ~vNMt2dq-7bECHp1LDqz^vhO8VLe*&oQgJx9K_ j7v3GA@E30#F{(&GqkT*wtu_uD$dJkvLVZAYAw2v8JpRM@ diff --git a/out/OuvertureFichier.class b/out/OuvertureFichier.class deleted file mode 100644 index 039a049cf7a9ef6538bfb8cf0823d99ec3cc6948..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1181 zcmZuxOHUI~6#i~IGq;@%ba)ID1;uv@6a=v@JD0w90A%aE+#oth9(bf6??|Y%ge$R*~h}n3Y$Y? zs6X~iS$R>hs|caiO%!IRi%wSq24nLof~a%7^$ZQC-b(0^zfpsMCWe4biKeZBU}%iS zDokF{X~(t-xj_{Xv~Zl!a2Bn9byWdSS9wv$IV)aQNfqaCo}*pE1zcpPJr!Zb^e}5y zfkBQYlQF_Za9P6@TqTmsifNCMMp85x8+ScX4KZ{u@C`Fx7O7!ikM#$>?}Ibl+S4t3l8g96QlQa3^y5P7;;+>Mst=Pq9=2Bj$ z=*KM$w{eG|#>{5Z+2%R5UFNAi6F%}29Mcj#>v#=^Nc7tR684;17(*y;Rl%wz z?;f1N7@ajL+2fxvOI{4eeFm-i_%NvHV%g46I+xP;H+{DYrs3YD)9yY#kYZ5iJxX6~ zv@%-dj$N>iv|)5J;JE=m9m{b{RG@5u!UE)brw8@mH*nwdK7tGT2rW=-%`WsAe?sco zLBqoAcRVsAJ-CGle?m6o_zs%&;2zqx5RV)34lX4WL($vcBVs6fxTfoS=uGfVL+UeR zgQqrSwte_>Q=<1LBJACUFhG7fcqpgLQy28ZTc#tXcpHHcSu zO_TC@-Atj*ZIP@BAp>ZoT^Cdg)1{n*hH2E|3BoYRmP0*pH4>Xb98JX1h&Oce-lCbX zKpLS#B9J+zI5;OJlJAg$loJa_gpslL7vuxT1nWNp{bs8C{a|F}2Vi3y0}@d@AZj0y Fe*i=P`P~2j diff --git a/out/Register.class b/out/Register.class deleted file mode 100644 index 3d22e400735ec3b4d8e4b8bbe8eafd8f13820db9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1071 zcmY*YTTc@~7(LV5Y?lQJbdjQkf}jPI3Tn|7t3kxna52&{gI24ASMv-Z!=FEy%^4yx|7FZJfj_HcLMH&Oi{Qtdf4dsUs9>A~BQsJW(Xg>fDiIN}=m(0|5t;a%MoRWfUP#H*ipc3EJvyfRDcrf?EwwPx4NVnwL9h#`()4VQ4a>HH=N240hd6^qU|GTR89ax|@SBdigI z__1^u^rG#~*`Bp_VnV?fvCkbHZ`oGDb!>0*`zHlgn>K{yh_YFy3v#5gl!j|kRxQ=}%7!Diqo?;Hm1S2~DSn35f@_ps zFBr83hT}Ga*6e^IOTkhx#~lXWYMy8dw&#?DWFh>qj&X^?04C^h%FhSVix9QfX%?rR zQ6C)L1KXhi!wqWXwrs<=i8PI=lug4=bKpZH{8e4>=ltowKKKd&!34g?tKdtDB9QBUrd{S4&b9x}6uE*EXfh~n?AO4Dk^nkmI4x;kswm2>Qh=q2c zZ=*HCKclxZv5P@D3ChVRO=N#%7vnqRqaQ^G^gx9T2T59y(qGb}1r+iq|DYCX+Ym)N zRYx%bovd^tOEt4JeuNm7(Tk__grC#?3(BL21hMv^ObDCq*rDuP4B|b8u!Uhv5&Hy` rLt0WeZgFHdrWxbl92%we2Vr)A_yIZ}a`gO0c!nbxrVMig^x^J5cQfYr diff --git a/out/Reinitialiser.class b/out/Reinitialiser.class deleted file mode 100644 index 7a9179dec567b838b441bf7760a69a5c4512f44a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 720 zcmZuu%Wl&^6g^|7aqT)!((+0vg#xyzhy?5cNPqxE3J(#KO;;0lh^9@(kuxdEo-bj; z8i@j8kq_Vx_!WeJJ5Gd1g+{v9bMNsvXYT#>>+1}_14JGy*bZ_&R*+{XAMhjI7;x2Z zJntQdSTp4BNG0_>20IA5E>__>@O-SnXDGZBrYZSAjzvn?ekun8LD;>$mcbT%lu#z% zh$|)dq{HP{Qoq=qe?7_YO%GL^a!~WJjtvI?-zGz)FZ3MPnu`&^N)VEShch_q;GB>1 zs4uziOvhRb8C;&Gd>SXCDMJ*rPd=~N`cJ79c8#G6KDNwEoK%dsRNBEd!)C_7-{^)o z5=uAj$66+;ElEw83Dg3zwfwlS%aD7R?33$KTPpEvGVF=;74Mlrm3T(*LZq*gbSU;2 zwiYf=YCJM}O+!}bXdWLv<)a0M*GVR6EFMckSY2Al4PzJEvx=pzheFlrJAH#`uk5TwQC59b}RpcnHQgrEfC=wmR66*(2EgNR0Q@xh7dlDI?2eo!n)e;3N)dhAJC7A z?wDXgFL(CNz30q1XTQGRKLMN}Z$LvpN6^FyLJaXPA935^ZpXfBc16o)2pvmT`X>y5 zLa`pkD#AJp6KgOTvJXNHC3oaNc&9C2_T8!+_`($)Av>OQ96`uN<60r3CSr&)m;){c zQe4f)(Q55aU(u0dh%7N1NFc2wt}~iA`)V#Q03dz3`sF%qtC|4O}3-<4urN0wpt-<5@%;Ca7IUSd`0irZnYDZEGCRPKygf9SQurBqFR zN%wLh2kHgvQxF;$wyA0=M*0z&%4K#kWs;^l)E&}&fX;m3$fk-90D-jG@FL}yzGl8~gwQ-t0ll!n|7 Dx~X+S diff --git a/out/Resolveur.class b/out/Resolveur.class deleted file mode 100644 index c039556521507a5b197e270f1a093fa5c92aa6a0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 855 zcmY*YOHUI~7(KUh?@XtZQjx2WJ`5U_j*)5?l|`u!B9ZuLB1#Nwn9>O;)V7uuV`5zK zCtzi8!G?`1i3_$S?%BF>)j@6}rCJ-*(w|e@cm0+1$9_A^9cYe1j6iI@)$6PTvvt#z_%q6+;ec^&8X-r(f-vN0&oIl- z3wq^!g80ZlV3^h{o7gpD(z8`$Az26BMM{xrS+nF+7G$>_-BoxrT<$?rR;XCDAQ@e z%jJT0v|9cRbg1k1Et~d8{*`GqJm);eyMYnh#5oF*Mv=5`u`)$zinP;|rHonH3hv+q u?xN2BVV&_S)?VX5D8(fV^kIo%(lxw|KjCLAL?2Nx%FO5>xP>{R^FIM0%-gDmbKJRD72^7zYqj1;qt|$wDDDA7+q4 z7GA^a0@0eR&s61-tX5@d&i$Mj?oSp~-8-Y4Znzz`@CJ^sP`XW27T0Rdf+|!`UQ5lJ z7-Y$LrzS5|)@rio*6Pxe)i4H-RQIQ7O%_`_)C`)j@D`3T7pGL(;VRJIl8d}8y?S;B zzz+~W*23F3#*VByu2;`jZmm{4Vg-6z+$XEf>WaHq^L>uv9TO)k4C7sa&c?iEl(Vcd zOi9*iE>qv0mvilJic@v$Oe1i4E>5GM}lnTMM#!xzX~@xw^CX*(GPSsdq2SdL!R$ zLa1@47>3@oU3L^Fw<{udcbw14Wm1JBc!A8za(PY7b{|Jwe3i#~($BA#*8Hm+rW+&e z;?~RKUGX6rwzG@ecFJx^R`VrMX%JDyWoVrY6@6W>1ncRfJ) zSNazmxY{j#<8Kpv8%U(}4fOML;3}_qa|7u|enRIcPa#4XVG%C8oH5=aS*CUjmy>795~8~hIn#ucYJ3%{uuE&;y-wiNNW$w_Eb&~THF=d*$zEP z=%rmd8*T6GD4|oBreuNQEHv^O_#vTxg-{|I`UXMmp*F1BI>!KO!?1hjC{?blVk4V1dnniS?*7;*fExS z1vB`F`y1RXU>?iV?&4#7fvfl$*YJS*?|AkIH+>clBGMtAA|MWtx7+J8bP2)Js5nAK r2Nk1r_5aXlCNfR7bfhzz7|Nu7LhdC6BJ4C!qKiZrOLUp>3;6Iqq05s0 diff --git a/out/SudokuGenerator.class b/out/SudokuGenerator.class deleted file mode 100644 index c8d4474175e728edfc83e2428f09136e4e6f7a9d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2861 zcmb7`&vO&!8OOgX?e4ph*C5--Sl9|mL%=e`DkgCf8%Toz$JiiZIR-&eSfrJ-AZs-% zDbA^r1NUA!(}9^zr{v(7P7d@?;|ZZXk#;)m^pcqzGRfr9>E95BmVV!NWn-93W;(X^ zeYNlN=iSxc{`=XV0Gz<}I3kD&=r#b=thRGA{z}ttxQ+I7c1}7C*w}@nhMiTnU2yB9amz9|F-NnZ zo9E}`ooRvH8U|G)-a65#RNTNVFS<_I4Fpme`Zw34d3ZmLAq>lXk7(%YVr<6CF2^y5 z7v$<*4FgYCL)YnW{Y4u;!AlyffQc5o2FZ49k|_-f?SPU@$MG`u3mmX9itIBYhXxe6 z?l!9Jni6@=!a)sZ<{BS5b+4SM5I9rugB7Peo;hE4otB$vDK#=qxVY-IYnhTC1XL(f z=#>2%olG^5uAx^PuV7ptXXB?hOv#_AR=(Nx{Kk1l!uQGQoON3*r|NDNDEos23f14% zCrXhccvavv8_UBXE;|#)&+xXu2^%vw$+D=LDu@}HIqVN+k==5xv*HF`Y1yfFxGjBj zMmE$DoVGEGcQo{PEs4No$zhHXBYVlh84Y8bs&A8VJhR|CW!5oMb}LS&-d5sL(1m9Z zmTG~&>RhXne;(&-Z+-rw>&7Gz~W{!_TXIp)JG*(RVI#i zv1H>tsn5JEa>-+%7X6!37%^QPdFkT8sW_cS}NUiF=X;mu4p zG?a~8`MHfN-IYbR$}Z@7>ob0tvh9=|O(n0n!IIn;8&~$ZRPJ=(uY@PDSJ9kxn#x3g zR`&LzCcr};xqOL$1-}!N+|X^;bIma>eefcoB780Z0_+Buyk6zEG)Il2F?J8yA2`wA z@G6%99WmK(oL}X_m&z5|Mk4kAq8LrYK93ip(R@+o$Kc0I#PUVKiDl)B36qnA{Fbmp zzEIRdbFL_JljdAg)?&*#AswxRv^RbrJPnnD3~DAAq8s0&J(EiuiLk{Z6VQtJH*vxQ zQQC{A@wu$*9hji9Y#fEB*BS>cGm z#)xs{--%cv_7Jhi{C)Hk@1b|$AZ>RX8@Y{t99&2Lx%(I_-p5e!m3!E859ujAI%y$6e&ea+rB@c);-?V}8xk`z`0+VFLfcYbY`MMeKNjS78do z1bQ@qvY;HmV~h#B{1_4KF%D^uAijt32u5mFVEze-pLO6((0AVY9+49Q?>?d?arr0@ z4?QzQRI`jlj}FU`X1;KF-<^&3HhAuCj1yt<(5mtKiAJjkEgp?C(`4SdQ!iIzC%g<$Ss+W z6MgAs^tr72RSTbFkW=WzY5vZcWrf}$!5j(Zsro4@eNIsfK>rVfK!sZEA&MT-@S*5Xv>K(k1o-~tYT22qBgJX`%AutomatiqueActionListener est un écouteur d'événements utilisé pour gérer l'action + * lorsqu'on clique sur le bouton "Automatique" dans la fenêtre de choix. + * Elle permet de choisir un fichier contenant une grille de Sudoku, de la résoudre automatiquement + * et d'afficher le résultat dans une nouvelle fenêtre. + * + * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton. + * + * @author Dick Adrien + * @version 3.0 + */ public class AutomatiqueActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe AutomatiqueActionListener. + * + * @param choixFrame La fenêtre de choix du Sudoku. + */ public AutomatiqueActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton + * "Automatique" est cliqué. + * + * @param e L'événement associé à l'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix du Sudoku. choixFrame.dispose(); - int[][] grille = new int[9][9]; // Création d'une grille vide + // Crée une grille vide de Sudoku. + int[][] grille = new int[9][9]; - // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille. JFileChooser fileChooser = new JFileChooser(); int returnValue = fileChooser.showOpenDialog(null); + // Vérifie si l'utilisateur a sélectionné un fichier. if (returnValue == JFileChooser.APPROVE_OPTION) { File selectedFile = fileChooser.getSelectedFile(); - // Lecture de la grille à partir du fichier sélectionné + // Lit la grille à partir du fichier sélectionné. Lecteur.lecture(selectedFile, grille); - // Résolution du Sudoku + // Résout le Sudoku. long startTime = System.nanoTime(); if (Resolveur.resoudreSudoku(grille)) { long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1000000; + // Affiche la grille résolue dans une nouvelle fenêtre. FenetrePrincipale fenetrePrincipale = new FenetrePrincipale(); fenetrePrincipale.afficher(true, grille); JOptionPane.showMessageDialog(null, "Grille résolue avec succès en " + duration + " millisecondes !"); diff --git a/src/CaseMouseListener.java b/src/CaseMouseListener.java index fc4a43a..53d4217 100644 --- a/src/CaseMouseListener.java +++ b/src/CaseMouseListener.java @@ -1,22 +1,51 @@ import javax.swing.*; import java.awt.event.*; +/** + * La classe CaseMouseListener est un écouteur d'événements de souris utilisé pour gérer les actions + * lorsque l'utilisateur clique sur une case de la grille de Sudoku. + * Elle permet à l'utilisateur de sélectionner une case, d'y entrer un chiffre ou des valeurs incertaines. + * + * Elle étend MouseAdapter pour gérer les événements de souris de manière simplifiée. + * + * Elle utilise des boîtes de dialogue JOptionPane pour permettre à l'utilisateur d'entrer des chiffres ou des valeurs incertaines. + * + * @author Dick Adrien + * @version 8.0 + */ public class CaseMouseListener extends MouseAdapter { private SaisieGrille panel; + /** + * Constructeur de la classe CaseMouseListener. + * + * @param panel Le panneau de saisie de la grille de Sudoku associé à cet écouteur. + */ public CaseMouseListener(SaisieGrille panel) { this.panel = panel; } + /** + * Méthode appelée lorsque l'utilisateur clique sur une case de la grille de Sudoku. + * + * @param e L'événement de souris associé au clic. + */ @Override public void mouseClicked(MouseEvent e) { + // Convertit les coordonnées du clic en indices de ligne et de colonne dans la grille. int x = e.getX() / panel.getTailleCellule(); int y = e.getY() / panel.getTailleCellule(); + + // Vérifie si les coordonnées se trouvent dans la grille. if (x >= 0 && x < panel.getTailleGrille() * panel.getTailleRegion() && y >= 0 && y < panel.getTailleGrille() * panel.getTailleRegion()) { + // Enregistre la ligne et la colonne sélectionnées. panel.setLigneSelectionnee(y); panel.setColonneSelectionnee(x); System.out.println("Case sélectionnée : (" + panel.getLigneSelectionnee() + ", " + panel.getColonneSelectionnee() + ")"); + + // Vérifie si la case sélectionnée peut être modifiée. if (panel.getGrilleInitiale()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] == 0) { + // Affiche une boîte de dialogue pour permettre à l'utilisateur d'entrer un chiffre ou des valeurs incertaines. String[] options = {"Incertain", "Valider"}; JTextField textField = new JTextField(); Object[] message = { @@ -25,12 +54,16 @@ public class CaseMouseListener extends MouseAdapter { }; int option = JOptionPane.showOptionDialog(null, message, "Entrez un nombre", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]); if (option == 1) { + // L'utilisateur a choisi de valider un chiffre. String valeurStr = textField.getText(); try { int valeur = Integer.parseInt(valeurStr); + // Vérifie si le chiffre est valide pour cette case. if (panel.validerChiffre(panel.getLigneSelectionnee(), panel.getColonneSelectionnee(), valeur)) { + // Met à jour la grille et la redessine si le chiffre est valide. panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeur; panel.repaint(); + // Vérifie si la grille est complète après la mise à jour. if (panel.grilleComplete()) { panel.afficherBravo(); } @@ -41,7 +74,7 @@ public class CaseMouseListener extends MouseAdapter { JOptionPane.showMessageDialog(null, "Saisie invalide. Veuillez entrer un nombre."); } } else if (option == 0) { - // Le joueur a choisi "Incertain" + // L'utilisateur a choisi "Incertain". JTextField[] incertainFields = new JTextField[4]; for (int i = 0; i < 4; i++) { incertainFields[i] = new JTextField(); @@ -55,9 +88,9 @@ public class CaseMouseListener extends MouseAdapter { }; int incertainOption = JOptionPane.showOptionDialog(null, incertainMessage, "Entrez les valeurs incertaines", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, null, null); if (incertainOption == JOptionPane.OK_OPTION) { - // Vérifier que les valeurs obligatoires sont remplies + // Vérifie que les valeurs obligatoires sont remplies. if (!incertainFields[0].getText().isEmpty() && !incertainFields[1].getText().isEmpty()) { - // Vérifier que les valeurs incertaines sont valides + // Vérifie que les valeurs incertaines sont valides. boolean valeursValides = true; for (int i = 0; i < 4; i++) { if (!incertainFields[i].getText().isEmpty()) { @@ -69,7 +102,7 @@ public class CaseMouseListener extends MouseAdapter { } } if (valeursValides) { - // Récupérer les valeurs incertaines saisies par le joueur + // Récupère les valeurs incertaines saisies par l'utilisateur. int valeursIncertaines = 0; for (int i = 0; i < 4; i++) { if (!incertainFields[i].getText().isEmpty()) { @@ -77,7 +110,7 @@ public class CaseMouseListener extends MouseAdapter { valeursIncertaines |= (valeur << (i * 4)); } } - // Mettre à jour la grille avec les valeurs incertaines + // Met à jour la grille avec les valeurs incertaines et la redessine. panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeursIncertaines; panel.repaint(); } else { diff --git a/src/FenetreChoix.java b/src/FenetreChoix.java index d34c45c..c358812 100644 --- a/src/FenetreChoix.java +++ b/src/FenetreChoix.java @@ -1,30 +1,58 @@ import javax.swing.*; import java.awt.*; - +/** + * La classe FenetreChoix est utilisée pour afficher la fenêtre de choix de mode de résolution du Sudoku. + * Elle crée une fenêtre avec deux boutons, l'un pour le mode automatique et l'autre pour le mode manuel. + * Lorsque l'utilisateur choisit l'un des modes, la fenêtre se ferme. + * + * @author Dick Adrien + * @version 2.0 + */ public class FenetreChoix { + /** + * Affiche la fenêtre de choix. + */ public void afficher() { + // Crée une nouvelle fenêtre avec un titre. JFrame choixFrame = new JFrame("Choix de résolution du Sudoku"); + + // Définit l'opération de fermeture par défaut de la fenêtre. choixFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + // Définit la taille de la fenêtre. choixFrame.setSize(400, 200); + + // Définit le gestionnaire de disposition de la fenêtre. choixFrame.setLayout(new BorderLayout()); + + // Centre la fenêtre sur l'écran. choixFrame.setLocationRelativeTo(null); + // Crée un label pour afficher un message d'instruction. JLabel label = new JLabel("Choisissez le mode de résolution du Sudoku :"); label.setHorizontalAlignment(JLabel.CENTER); + // Crée deux boutons pour les modes automatique et manuel. JButton automatiqueButton = new JButton("Automatique"); JButton manuelButton = new JButton("Manuel"); + // Crée un panel pour contenir les boutons et définit son gestionnaire de disposition. JPanel boutonsPanel = new JPanel(); boutonsPanel.setLayout(new FlowLayout()); + + // Ajoute les boutons au panel. boutonsPanel.add(automatiqueButton); boutonsPanel.add(manuelButton); + // Ajoute le label et le panel de boutons à la fenêtre. choixFrame.add(label, BorderLayout.NORTH); choixFrame.add(boutonsPanel, BorderLayout.CENTER); + + // Rend la fenêtre visible. choixFrame.setVisible(true); + // Associe un écouteur d'événements aux boutons pour gérer les actions. automatiqueButton.addActionListener(new AutomatiqueActionListener(choixFrame)); manuelButton.addActionListener(new ManuelActionListener(choixFrame)); } diff --git a/src/FenetreModif.java b/src/FenetreModif.java index 7918950..a198128 100644 --- a/src/FenetreModif.java +++ b/src/FenetreModif.java @@ -2,45 +2,53 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe FenetreModif est utilisée pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier. + * Elle comporte une méthode statique fenetreModification qui prend en paramètre une grille Sudoku, puis affiche une fenêtre avec la grille et un bouton d'enregistrement. + * + * @author Raban Hugo + * @version 3.0 + */ public class FenetreModif{ + /** + * Méthode statique pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier. + * + * @param grille La grille Sudoku à modifier. + */ public static void fenetreModification(int[][] grille) { - JFrame frame = new JFrame("Sudoku"); - frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - SaisieGrille saisieGrille = new SaisieGrille(grille); // Utilisation de la classe SaisieGrille pour permettre la saisie des valeurs - JButton register = new JButton("Enregistrer"); + JFrame frame = new JFrame("Sudoku"); // Crée une nouvelle fenêtre avec le titre "Sudoku" + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Définit l'action par défaut lorsque la fenêtre est fermée + SaisieGrille saisieGrille = new SaisieGrille(grille); // Crée une nouvelle instance de SaisieGrille avec la grille Sudoku fournie + JButton register = new JButton("Enregistrer"); // Crée un nouveau bouton "Enregistrer" + + // Ajoute un écouteur d'événements au bouton "Enregistrer" register.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e){ - JFileChooser fileChooser = new JFileChooser(); + JFileChooser fileChooser = new JFileChooser(); // Crée un sélecteur de fichiers - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); - fileChooser.setFileFilter(filter); + FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); // Définit un filtre pour les fichiers avec l'extension .gri + fileChooser.setFileFilter(filter); // Applique le filtre au sélecteur de fichiers - File workingDirectory = new File(System.getProperty("user.dir")); - fileChooser.setCurrentDirectory(workingDirectory); + File workingDirectory = new File(System.getProperty("user.dir")); // Récupère le répertoire de travail de l'application + fileChooser.setCurrentDirectory(workingDirectory); // Définit le répertoire de départ du sélecteur de fichiers JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { - Register.sauvegarde(fileChooser.getSelectedFile(), grille); + int valeur_de_retour = fileChooser.showOpenDialog(panneau); // Affiche le sélecteur de fichiers et attend la sélection d'un fichier + if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { // Si un fichier est sélectionné + Register.sauvegarde(fileChooser.getSelectedFile(), grille); // Enregistre la grille dans le fichier sélectionné en utilisant la méthode sauvegarde de la classe Register } } }); - frame.add(register, BorderLayout.SOUTH); // Ajouter le bouton "Enregistrer" + frame.add(register, BorderLayout.SOUTH); // Ajoute le bouton "Enregistrer" en bas de la fenêtre + frame.add(saisieGrille, BorderLayout.CENTER); // Ajoute la grille à la fenêtre - frame.add(saisieGrille, BorderLayout.CENTER); // Ajouter la grille à la fenêtre + frame.pack(); // Ajuste la taille de la fenêtre pour qu'elle s'adapte à son contenu + frame.setLocationRelativeTo(null); // Centre la fenêtre sur l'écran + frame.setVisible(true); // Rend la fenêtre visible - frame.pack(); - frame.setLocationRelativeTo(null); // Centrer la fenêtre sur l'écran - frame.setVisible(true); - - System.out.println("La fenêtre de création a été affichée."); + System.out.println("La fenêtre de création a été affichée."); // Affiche un message dans la console pour indiquer que la fenêtre a été affichée } -} \ No newline at end of file +} diff --git a/src/FenetrePrincipale.java b/src/FenetrePrincipale.java index 3a3f703..ecc0cb5 100644 --- a/src/FenetrePrincipale.java +++ b/src/FenetrePrincipale.java @@ -1,25 +1,53 @@ - import javax.swing.*; import java.awt.*; - +/** + * La classe FenetrePrincipale est utilisée pour afficher la fenêtre principale du jeu Sudoku. + * Elle affiche une grille de Sudoku dans une fenêtre Swing. + * + * Elle prend en compte le mode de jeu (automatique ou manuel) pour personnaliser l'affichage. + * Si le mode est manuel, un bouton de réinitialisation est également affiché. + * + * @author Dick Adrien + * @version 2.0 + */ public class FenetrePrincipale { + /** + * Affiche la fenêtre principale du Sudoku. + * + * @param modeAutomatique Indique si le mode de jeu est automatique ou manuel. + * @param grille La grille de Sudoku à afficher. + */ public void afficher(boolean modeAutomatique, int[][] grille) { + // Crée une nouvelle fenêtre avec un titre. JFrame frame = new JFrame("Sudoku"); + + // Définit l'opération de fermeture par défaut de la fenêtre. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + // Crée un composant pour la saisie de la grille de Sudoku. SaisieGrille saisieGrille = new SaisieGrille(grille); + // Si le mode n'est pas automatique, ajoute un bouton de réinitialisation. if (!modeAutomatique) { JButton reinitialiserButton = new JButton("Réinitialiser"); reinitialiserButton.addActionListener(new ReinitialiserActionListener(grille, saisieGrille)); frame.add(reinitialiserButton, BorderLayout.SOUTH); } + // Ajoute le composant de saisie de la grille à la fenêtre. frame.add(saisieGrille, BorderLayout.CENTER); + + // Ajuste la taille de la fenêtre en fonction de son contenu. frame.pack(); + + // Centre la fenêtre sur l'écran. frame.setLocationRelativeTo(null); + + // Rend la fenêtre visible. frame.setVisible(true); + // Affiche un message dans la console pour indiquer que la fenêtre Sudoku a été affichée. System.out.println("La fenêtre Sudoku a été affichée."); } } diff --git a/src/GenerateurSudoku.java b/src/GenerateurSudoku.java deleted file mode 100644 index 0106136..0000000 --- a/src/GenerateurSudoku.java +++ /dev/null @@ -1,20 +0,0 @@ -import javax.swing.*; - -public class GenerateurSudoku { - public static int[][] genererGrille() { - // grille par défaut - int[][] grille = { - {0, 0, 0, 0, 9, 5, 0, 0, 4}, - {5, 3, 0, 4, 0, 8, 7, 0, 2}, - {0, 0, 0, 7, 0, 0, 6, 0, 3}, - {9, 0, 0, 0, 3, 4, 0, 8, 0}, - {0, 4, 0, 0, 1, 0, 0, 7, 0}, - {0, 2, 0, 5, 7, 0, 0, 0, 6}, - {4, 0, 9, 0, 0, 2, 0, 0, 0}, - {6, 0, 7, 9, 0, 3, 0, 2, 1}, - {2, 0, 0, 6, 5, 0, 0, 0, 0} - }; - - return grille; - } -} diff --git a/src/GrilleExisteActionListener.java b/src/GrilleExisteActionListener.java index 90c7491..9f09e43 100644 --- a/src/GrilleExisteActionListener.java +++ b/src/GrilleExisteActionListener.java @@ -1,38 +1,64 @@ import javax.swing.*; -import java.awt.*; +import javax.swing.filechooser.FileNameExtensionFilter; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; -public class GrilleExisteActionListener implements ActionListener{ +/** + * La classe GrilleExisteActionListener est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille existante. + * + * Lorsque l'utilisateur clique sur le bouton pour choisir une grille existante, cet écouteur est déclenché. + * + * Il ferme la fenêtre de choix actuelle, ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille existant, puis charge la grille à partir de ce fichier. + * + * Si l'utilisateur sélectionne un fichier valide, la grille est chargée à partir de ce fichier et une nouvelle fenêtre de modification est affichée avec cette grille. + * + * @author Raban Hugo + * @version 4.0 + */ +public class GrilleExisteActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe GrilleExisteActionListener. + * + * @param choixFrame La fenêtre de choix actuelle. + */ public GrilleExisteActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton). + * + * @param e L'événement d'action associé à cette action. + */ @Override - public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix actuelle choixFrame.dispose(); - int [][] grille = new int [9][9]; - JFileChooser fileChooser = new JFileChooser(); - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); + // Crée une nouvelle grille vide + int[][] grille = new int[9][9]; + + // Ouvre le sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + JFileChooser fileChooser = new JFileChooser(); + FileNameExtensionFilter filter = new FileNameExtensionFilter("Fichier grille", "gri"); fileChooser.setFileFilter(filter); + // Définit le répertoire de travail actuel comme répertoire initial du sélecteur de fichiers File workingDirectory = new File(System.getProperty("user.dir")); fileChooser.setCurrentDirectory(workingDirectory); - JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { + + // Affiche le sélecteur de fichiers dans un panneau + JPanel panel = new JPanel(); + int returnValue = fileChooser.showOpenDialog(panel); + + // Si l'utilisateur a sélectionné un fichier valide + if (returnValue == JFileChooser.APPROVE_OPTION) { + // Charge la grille à partir du fichier sélectionné Lecteur.lecture(fileChooser.getSelectedFile(), grille); + // Affiche une nouvelle fenêtre de modification avec la grille chargée FenetreModif.fenetreModification(grille); } } -} \ No newline at end of file +} diff --git a/src/GrillePainter.java b/src/GrillePainter.java index f60250f..653e6a7 100644 --- a/src/GrillePainter.java +++ b/src/GrillePainter.java @@ -1,11 +1,31 @@ import java.awt.*; +/** + * La classe GrillePainter est utilisée pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie. + * + * Elle fournit une méthode statique dessinerGrille qui prend en charge le dessin de la grille et des valeurs de la grille. + * + * Elle utilise les informations fournies par le panneau de saisie (SaisieGrille) pour dessiner correctement la grille. + * + * Elle utilise la classe Graphics2D pour dessiner des formes et des textes. + * + * @author Dick Adrien + * @version 4.0 + */ public class GrillePainter { + + /** + * Méthode statique pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie. + * + * @param g Le contexte graphique dans lequel dessiner. + * @param panel Le panneau de saisie de la grille de Sudoku. + */ public static void dessinerGrille(Graphics g, SaisieGrille panel) { Graphics2D g2d = (Graphics2D) g; Stroke ancienStroke = g2d.getStroke(); g2d.setStroke(new BasicStroke(4)); + // Dessine les lignes de la grille for (int i = 0; i <= panel.getTailleGrille() * panel.getTailleRegion(); i++) { if (i % panel.getTailleRegion() == 0) { g2d.drawLine(0, i * panel.getTailleCellule(), panel.getTailleGrille() * panel.getTailleRegion() * panel.getTailleCellule(), i * panel.getTailleCellule()); @@ -15,6 +35,7 @@ public class GrillePainter { g2d.setStroke(ancienStroke); + // Dessine les valeurs de la grille for (int i = 0; i < panel.getTailleGrille() * panel.getTailleRegion(); i++) { for (int j = 0; j < panel.getTailleGrille() * panel.getTailleRegion(); j++) { g.setColor(Color.BLACK); @@ -22,9 +43,11 @@ public class GrillePainter { int valeur = panel.getGrille()[i][j]; if (valeur != 0) { + // Dessine la valeur dans la case if (valeur < 10) { g.drawString(String.valueOf(valeur), j * panel.getTailleCellule() + panel.getTailleCellule() / 2, i * panel.getTailleCellule() + panel.getTailleCellule() / 2); } else { + // Si la valeur est incertaine, la décompose et la dessine dans les sous-cases int[] valeurs = decomposerValeurs(valeur); for (int k = 0; k < valeurs.length; k++) { int xOffset = (k % 2) * panel.getTailleCellule() / 2; @@ -37,6 +60,12 @@ public class GrillePainter { } } + /** + * Méthode privée pour décomposer une valeur incertaine en ses sous-valeurs. + * + * @param valeursIncertaines La valeur incertaine à décomposer. + * @return Un tableau d'entiers contenant les sous-valeurs. + */ private static int[] decomposerValeurs(int valeursIncertaines) { int[] valeurs = new int[4]; for (int i = 0; i < 4; i++) { diff --git a/src/GrilleVideActionListener.java b/src/GrilleVideActionListener.java index 35aed73..55ca395 100644 --- a/src/GrilleVideActionListener.java +++ b/src/GrilleVideActionListener.java @@ -1,28 +1,44 @@ import javax.swing.*; -import java.awt.*; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; -public class GrilleVideActionListener implements ActionListener{ +/** + * La classe GrilleVideActionListener est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille vide. + * + * Lorsque l'utilisateur clique sur le bouton pour choisir une grille vide, cet écouteur est déclenché. + * + * Il crée une grille vide, ferme la fenêtre de choix actuelle, puis affiche une nouvelle fenêtre de modification avec cette grille vide. + * + * @author Raban Hugo + * @version 2.0 + */ +public class GrilleVideActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe GrilleVideActionListener. + * + * @param choixFrame La fenêtre de choix actuelle. + */ public GrilleVideActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton). + * + * @param e L'événement d'action associé à cette action. + */ @Override - public void actionPerformed(ActionEvent e) { - int [][] grille = new int [9][9]; - choixFrame.dispose(); + // Crée une nouvelle grille vide + int[][] grille = new int[9][9]; Grilles.grilleVide(grille); + + // Ferme la fenêtre de choix actuelle + choixFrame.dispose(); + + // Affiche une nouvelle fenêtre de modification avec la grille vide FenetreModif.fenetreModification(grille); } - -} \ No newline at end of file +} diff --git a/src/Grilles.java b/src/Grilles.java new file mode 100644 index 0000000..d7d28e0 --- /dev/null +++ b/src/Grilles.java @@ -0,0 +1,65 @@ +import javax.swing.*; +import java.io.*; + +/** + * La classe Grilles contient des méthodes pour manipuler les grilles Sudoku. + * + * Elle comporte deux méthodes statiques : + * - grilleExiste pour lire une grille à partir d'un fichier existant et stocker ses valeurs dans une grille. + * - grilleVide pour initialiser une grille avec des valeurs vides (0). + * + * @author Raban Hugo + * @version 2.0 + */ +public class Grilles { + /** + * Méthode statique pour lire les données d'un fichier et les stocker dans une grille. + * + * @param name Le nom du fichier à lire. + */ + public static void grilleExiste(String name) { + int valeur[] = new int[9]; // Tableau pour stocker les valeurs lues temporairement + int valeurEnFin[][] = new int[9][9]; // Tableau pour stocker les valeurs de la grille + + int valeurActuelle = 0; + + try { + FileInputStream fichier = new FileInputStream(name); // Crée un flux pour lire le fichier + DataInputStream flux = new DataInputStream(fichier); // Crée un flux de données pour lire les données à partir du flux de fichier + + try { + // Lecture des données du fichier + for (int i = 0; i < 9; i++) { + valeur[i] = flux.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire + } + flux.close(); // Fermeture du flux de données + } catch (IOException e) { + System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture + } + } catch (FileNotFoundException e) { + System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé + } + + // Transformation des valeurs lues en tableau 2D pour la grille + for (int i = 0; i < 9; i++) { + for (int j = 8; j >= 0; j--) { + valeurActuelle = valeur[i] % 10; // Extrait le chiffre des unités de la valeur + valeur[i] = (valeur[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur + valeurEnFin[i][j] = valeurActuelle; // Stocke la valeur dans la grille + } + } + } + + /** + * Méthode statique pour initialiser une grille avec des valeurs vides (0). + * + * @param g La grille à initialiser. + */ + public static void grilleVide(int[][] g) { + for (int i = 0; i < 9; i++) { + for (int j = 0; j < 9; j++) { + g[i][j] = 0; // Initialise chaque cellule de la grille avec la valeur 0 + } + } + } +} diff --git a/src/Lecteur.java b/src/Lecteur.java index 619a279..919f033 100644 --- a/src/Lecteur.java +++ b/src/Lecteur.java @@ -1,45 +1,49 @@ -import javax.swing.*; -import java.awt.*; import java.io.*; -import javax.swing.filechooser.FileNameExtensionFilter; -public class Lecteur{ - public static void lecture(File name, int [][] g) { - - int valeur[] = new int[9]; - int valeur_en_fin[][]= new int[9][9]; +/** + * La classe Lecteur est utilisée pour lire les données d'un fichier de grille. + * + * Elle comporte une méthode statique lecture qui prend en entrée un fichier et une grille, puis lit les données du fichier pour les stocker dans la grille. + * + * Le fichier doit contenir une grille Sudoku sous forme de chiffres, où chaque ligne représente une ligne de la grille et chaque chiffre représente une valeur dans la grille. + * + * @author Raban Hugo + * @version 5.0 + */ +public class Lecteur { + /** + * Méthode statique pour lire les données d'un fichier et les stocker dans une grille. + * + * @param fichier Le fichier à lire. + * @param grille La grille dans laquelle stocker les données lues. + */ + public static void lecture(File fichier, int[][] grille) { + int[] valeurs = new int[9]; // Tableau pour stocker les valeurs lues temporairement - int valeur_actuelle=0; + try { + FileInputStream fileInputStream = new FileInputStream(fichier); // Crée un flux pour lire le fichier + DataInputStream dataInputStream = new DataInputStream(fileInputStream); // Crée un flux de données pour lire les données à partir du flux de fichier - try{ - FileInputStream fichier = new FileInputStream(name); - DataInputStream flux = new DataInputStream(fichier); - - try{ - for(int i=0; i<9; i++){ - valeur[i]=flux.readInt(); - System.out.print(valeur[i]); + try { + // Lecture des données du fichier + for (int i = 0; i < 9; i++) { + valeurs[i] = dataInputStream.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire + } + dataInputStream.close(); // Fermeture du flux de données + } catch (IOException e) { + System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture + } + } catch (FileNotFoundException e) { + System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé + } + + // Transformation des valeurs lues en tableau 2D pour la grille + for (int i = 0; i < 9; i++) { + for (int j = 8; j >= 0; j--) { + int valeurActuelle = valeurs[i] % 10; // Extrait le chiffre des unités de la valeur + valeurs[i] = (valeurs[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur + grille[i][j] = valeurActuelle; // Stocke la valeur dans la grille + } } - flux.close(); - }catch(IOException e){ - System.out.println("Lecture fichier impossible"); - } - }catch(FileNotFoundException e){ - System.out.println("Fichier non trouvé"); } - - for(int i=0; i<9; i++){ - for(int j=8; j>=0; j--){ - valeur_actuelle=valeur[i]; - - valeur_actuelle=valeur_actuelle%10; - valeur[i]=(valeur[i]-valeur_actuelle)/10; - - valeur_en_fin[i][j]=valeur_actuelle; - System.out.print(valeur_actuelle); - g[i][j] = valeur_actuelle; - } - valeur_actuelle=0; - } - } -} \ No newline at end of file +} diff --git a/src/MainCreation.java b/src/MainCreation.java index 7867bb3..9ec5691 100644 --- a/src/MainCreation.java +++ b/src/MainCreation.java @@ -1,24 +1,31 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; -import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe MainCreation est utilisée pour démarrer l'application de création de grille de Sudoku. + * + * Elle crée une fenêtre de sélection pour choisir entre une grille vide ou une grille existante. + * + * L'utilisateur peut sélectionner l'une des deux options en cliquant sur les boutons correspondants. + * + * Les actions des boutons sont gérées par des écouteurs d'événements spécifiques. + * + * Elle utilise les classes GrilleVideActionListener et GrilleExisteActionListener pour gérer les actions des boutons. + * + * @author Raban Hugo + * @version 3.0 + */ public class MainCreation { public static void main(String[] args) { - //Création de la fenetre de selection + choix du dossier + // Création de la fenetre de selection + choix du dossier JFrame selF = new JFrame("Choix de résolution du Sudoku"); selF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); selF.setSize(400, 200); selF.setLayout(new BorderLayout()); selF.setLocationRelativeTo(null); - JLabel sel = new JLabel("Quelle grilles souhaitez vous ?"); - //Création des boutons + JLabel sel = new JLabel("Quelle grille souhaitez-vous ?"); + // Création des boutons sel.setHorizontalAlignment(JLabel.CENTER); JButton grilleVide = new JButton("Grille vide"); JButton grilleExiste = new JButton("Grille Existante"); @@ -31,34 +38,8 @@ public class MainCreation { selF.add(sel, BorderLayout.NORTH); selF.add(boutonsSelect, BorderLayout.CENTER); selF.setVisible(true); - //Action des bouton + // Action des boutons grilleVide.addActionListener(new GrilleVideActionListener(selF)); grilleExiste.addActionListener(new GrilleExisteActionListener(selF)); - /*grilleVide.addActionListener(new ActionListener() { - public void actionPerformed(ActionEvent e) { - selF.dispose(); - Grilles.grilleVide(grille); - FenetreModif.fenetreModification(grille); - } - });*/ - /* grilleExiste.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - selF.dispose(); - JFileChooser fileChooser = new JFileChooser(); - - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); - fileChooser.setFileFilter(filter); - - File workingDirectory = new File(System.getProperty("user.dir")); - fileChooser.setCurrentDirectory(workingDirectory); - JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { - Lecteur.lecture(fileChooser.getSelectedFile(), grille); - FenetreModif.fenetreModification(grille); - } - } - });*/ } } diff --git a/src/MainJeu.java b/src/MainJeu.java index 8641b8e..cd59eea 100644 --- a/src/MainJeu.java +++ b/src/MainJeu.java @@ -1,9 +1,24 @@ - +/** + * La classe MainJeu est utilisée pour démarrer le programme du jeu. + * Elle crée une instance de la classe FenetreChoix et affiche la fenêtre de choix du jeu. + * + * @author Dick Adrien + * @version 2.0 + */ public class MainJeu { + /** + * La méthode principale qui lance le programme. + * + * @param args les arguments de la ligne de commande (non utilisés dans cet exemple) + */ public static void main(String[] args) { + // Affiche un message indiquant que le programme principal a démarré. System.out.println("Le programme Main a démarré."); + // Crée une instance de la classe FenetreChoix pour afficher la fenêtre de choix du jeu. FenetreChoix fenetreChoix = new FenetreChoix(); + + // Appelle la méthode pour afficher la fenêtre de choix du jeu. fenetreChoix.afficher(); } } diff --git a/src/ManuelActionListener.java b/src/ManuelActionListener.java index 6342f73..ca9a798 100644 --- a/src/ManuelActionListener.java +++ b/src/ManuelActionListener.java @@ -2,30 +2,55 @@ import javax.swing.*; import java.awt.event.*; import java.io.File; +/** + * La classe ManuelActionListener est un écouteur d'événements utilisé pour gérer l'action + * lorsqu'on clique sur le bouton "Manuel" dans la fenêtre de choix. + * Elle permet de choisir un fichier contenant une grille de Sudoku et d'afficher la grille dans une nouvelle fenêtre + * pour que l'utilisateur puisse la résoudre manuellement. + * + * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton. + * + * @author Dick Adrien + * @version 2.0 + */ public class ManuelActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe ManuelActionListener. + * + * @param choixFrame La fenêtre de choix du Sudoku. + */ public ManuelActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton + * "Manuel" est cliqué. + * + * @param e L'événement associé à l'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix du Sudoku. choixFrame.dispose(); - int[][] grille = new int[9][9]; // Création d'une grille vide + // Crée une grille vide de Sudoku. + int[][] grille = new int[9][9]; - // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille. JFileChooser fileChooser = new JFileChooser(); int returnValue = fileChooser.showOpenDialog(null); + // Vérifie si l'utilisateur a sélectionné un fichier. if (returnValue == JFileChooser.APPROVE_OPTION) { File selectedFile = fileChooser.getSelectedFile(); - // Lecture de la grille à partir du fichier sélectionné + // Lit la grille à partir du fichier sélectionné. Lecteur.lecture(selectedFile, grille); - // Affichage de la grille dans la fenêtre principale en mode manuel + // Affiche la grille dans la fenêtre principale en mode manuel. FenetrePrincipale fenetrePrincipale = new FenetrePrincipale(); fenetrePrincipale.afficher(false, grille); } diff --git a/src/Register.java b/src/Register.java index 8bb978e..d665fcc 100644 --- a/src/Register.java +++ b/src/Register.java @@ -3,36 +3,48 @@ import java.awt.*; import java.io.*; import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe Register est utilisée pour enregistrer une grille Sudoku dans un fichier. + * Elle comporte une méthode statique sauvegarde qui prend en paramètre un fichier et une grille Sudoku, puis enregistre la grille dans le fichier. + * + * @author Raban Hugo + * @version 3.0 + */ public class Register{ - public static void sauvegarde(File name, int [][] g){ - int val[] = new int[9]; + /** + * Méthode statique pour enregistrer une grille Sudoku dans un fichier. + * + * @param name Le fichier dans lequel enregistrer la grille. + * @param g La grille Sudoku à enregistrer. + */ + public static void sauvegarde(File name, int [][] g){ + int val[] = new int[9]; // Tableau pour stocker temporairement les valeurs à écrire dans le fichier - int actuVal=0; - int v=0; + int actuVal=0; + int v=0; - try{ - FileOutputStream fichier = new FileOutputStream(name); - DataOutputStream flux = new DataOutputStream(fichier); + try{ + FileOutputStream fichier = new FileOutputStream(name); // Crée un flux de sortie vers le fichier spécifié + DataOutputStream flux = new DataOutputStream(fichier); // Utilise un flux de données pour écrire dans le fichier - try{ - - - for(int i=0; i<9; i++){ - for(int j=0; j<9; j++){ - actuVal = g[i][j]; - v = (v*10) - actuVal; - } - flux.writeInt(-v); - v=0; - actuVal=0; - } - flux.close(); - }catch(IOException e){ - System.out.println("Lecture fichier imposible"); - } - }catch(FileNotFoundException e){ - System.out.println("Fichier non trouvé"); - } - System.out.print("Fichier enregistrer"); - } -} \ No newline at end of file + try{ + // Parcourt la grille et écrit chaque valeur dans le fichier + for(int i=0; i<9; i++){ + for(int j=0; j<9; j++){ + actuVal = g[i][j]; + v = (v*10) - actuVal; + } + flux.writeInt(-v); // Écrit la valeur dans le fichier (avec un signe négatif pour distinguer les valeurs positives) + v=0; // Réinitialise la valeur temporaire + actuVal=0; + } + flux.close(); // Ferme le flux de sortie + }catch(IOException e){ + System.out.println("Lecture fichier imposible"); // Affiche un message d'erreur en cas de problème lors de l'écriture dans le fichier + } + }catch(FileNotFoundException e){ + System.out.println("Fichier non trouvé"); // Affiche un message d'erreur si le fichier spécifié n'est pas trouvé + } + System.out.print("Fichier enregistré"); // Affiche un message de confirmation dans la console une fois que l'enregistrement est terminé + } +} diff --git a/src/Reinitialiser.java b/src/Reinitialiser.java index a5c8bc3..1cb49e7 100644 --- a/src/Reinitialiser.java +++ b/src/Reinitialiser.java @@ -1,22 +1,41 @@ import javax.swing.*; import java.awt.event.*; +/** + * La classe Reinitialiser est un écouteur d'événements utilisé pour réinitialiser la grille Sudoku. + * Elle implémente l'interface ActionListener. + * + * @author Dick Adrien + * @version 1.0 + */ public class Reinitialiser implements ActionListener { - private int[][] grille; - private SaisieGrille panneauSaisie; + private int[][] grille; // La grille Sudoku + private SaisieGrille panneauSaisie; // Le panneau de saisie de la grille + /** + * Constructeur de la classe Reinitialiser. + * + * @param grille La grille Sudoku à réinitialiser. + * @param panneauSaisie Le panneau de saisie associé à la grille. + */ public Reinitialiser(int[][] grille, SaisieGrille panneauSaisie) { this.grille = grille; this.panneauSaisie = panneauSaisie; } + /** + * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué. + * Cette méthode réinitialise la grille en copiant la grille initiale et redessine le panneau de saisie. + * + * @param e L'événement d'action. + */ @Override public void actionPerformed(ActionEvent e) { // Réinitialiser la grille en copiant la grille initiale for (int i = 0; i < grille.length; i++) { System.arraycopy(panneauSaisie.getGrilleInitiale()[i], 0, grille[i], 0, grille[i].length); } - // Redessiner le panneau + // Redessiner le panneau de saisie panneauSaisie.repaint(); } } diff --git a/src/ReinitialiserActionListener.java b/src/ReinitialiserActionListener.java index 75818ab..cb5a546 100644 --- a/src/ReinitialiserActionListener.java +++ b/src/ReinitialiserActionListener.java @@ -1,19 +1,37 @@ - import javax.swing.*; import java.awt.event.*; - +/** + * La classe ReinitialiserActionListener est un écouteur d'événements utilisé pour gérer les actions associées à la réinitialisation de la grille Sudoku. + * Elle implémente l'interface ActionListener. + * + * @author Dick Adrien + * @version 1.0 + */ public class ReinitialiserActionListener implements ActionListener { - private int[][] grille; - private SaisieGrille saisieGrille; + private int[][] grille; // La grille Sudoku + private SaisieGrille saisieGrille; // Le panneau de saisie de la grille + /** + * Constructeur de la classe ReinitialiserActionListener. + * + * @param grille La grille Sudoku à réinitialiser. + * @param saisieGrille Le panneau de saisie associé à la grille. + */ public ReinitialiserActionListener(int[][] grille, SaisieGrille saisieGrille) { this.grille = grille; this.saisieGrille = saisieGrille; } + /** + * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué. + * Cette méthode crée une instance de la classe Reinitialiser et appelle sa méthode actionPerformed. + * + * @param e L'événement d'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Créer une instance de Reinitialiser et appeler sa méthode actionPerformed Reinitialiser reinitialiser = new Reinitialiser(grille, saisieGrille); reinitialiser.actionPerformed(e); } diff --git a/src/Resolveur.java b/src/Resolveur.java index 44fd1e6..e0cd49d 100644 --- a/src/Resolveur.java +++ b/src/Resolveur.java @@ -1,4 +1,17 @@ +/** + * La classe Resolveur est utilisée pour résoudre une grille Sudoku. + * Elle comporte une méthode statique resoudreSudoku qui prend en paramètre une grille Sudoku à résoudre. + * + * @author Dick Adrien + * @version 1.0 + */ public class Resolveur { + /** + * Méthode statique pour résoudre une grille Sudoku. + * + * @param grille La grille Sudoku à résoudre. + * @return true si la grille est résolue avec succès, false sinon. + */ public static boolean resoudreSudoku(int[][] grille) { int row = -1; int col = -1; @@ -41,7 +54,15 @@ public class Resolveur { return false; } - // Vérifie si un nombre peut être placé dans une cellule spécifique + /** + * Vérifie si un nombre peut être placé dans une cellule spécifique de la grille. + * + * @param grille La grille Sudoku. + * @param row L'indice de ligne de la cellule. + * @param col L'indice de colonne de la cellule. + * @param num Le nombre à vérifier. + * @return true si le nombre peut être placé dans la cellule, false sinon. + */ private static boolean estCoupValide(int[][] grille, int row, int col, int num) { // Vérifie la ligne for (int x = 0; x < 9; x++) { diff --git a/src/SaisieGrille.java b/src/SaisieGrille.java index 0174b9c..03aa1d3 100644 --- a/src/SaisieGrille.java +++ b/src/SaisieGrille.java @@ -2,6 +2,18 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; +/** + * La classe SaisieGrille est un composant graphique utilisé pour afficher et manipuler une grille de Sudoku. + * Elle permet à l'utilisateur de sélectionner des cellules et d'y entrer des chiffres. + * Elle fournit également des méthodes pour valider les chiffres entrés et vérifier si la grille est complète. + * + * Elle étend JPanel pour être utilisée comme composant graphique dans une fenêtre Swing. + * + * Elle utilise un gestionnaire d'événements de souris pour gérer la sélection des cellules. + * + * @author Dick Adrien + * @version 8.0 + */ public class SaisieGrille extends JPanel { private static final int TAILLE_GRILLE = 3; private static final int TAILLE_REGION = 3; @@ -11,6 +23,11 @@ public class SaisieGrille extends JPanel { private int ligneSelectionnee = -1; private int colonneSelectionnee = -1; + /** + * Constructeur de la classe SaisieGrille. + * + * @param grille La grille de Sudoku à afficher et à manipuler. + */ public SaisieGrille(int[][] grille) { this.grille = grille; this.grilleInitiale = new int[grille.length][grille[0].length]; @@ -22,9 +39,12 @@ public class SaisieGrille extends JPanel { setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE)); setFocusable(true); + // Ajoute un écouteur d'événements de souris pour gérer la sélection des cellules. addMouseListener(new CaseMouseListener(this)); } + // Méthodes d'accès aux attributs + public int[][] getGrilleInitiale() { return grilleInitiale; } @@ -61,27 +81,29 @@ public class SaisieGrille extends JPanel { return grille; } + // Méthodes de validation et de vérification de la grille + public boolean validerChiffre(int ligne, int colonne, int chiffre) { - // Vérifier si le chiffre est entre 1 et 9 + // Vérifie si le chiffre est entre 1 et 9 if (chiffre < 1 || chiffre > 9) { return false; } - // Vérifier la ligne + // Vérifie la ligne for (int j = 0; j < grille.length; j++) { if (grille[ligne][j] == chiffre && j != colonne) { return false; } } - // Vérifier la colonne + // Vérifie la colonne for (int i = 0; i < grille.length; i++) { if (grille[i][colonne] == chiffre && i != ligne) { return false; } } - // Vérifier la région + // Vérifie la région int regionX = colonne / TAILLE_REGION; int regionY = ligne / TAILLE_REGION; for (int i = regionY * TAILLE_REGION; i < (regionY + 1) * TAILLE_REGION; i++) { @@ -92,7 +114,7 @@ public class SaisieGrille extends JPanel { } } - // Vérifier les valeurs incertaines dans la cellule + // Vérifie les valeurs incertaines dans la cellule int valeursIncertaines = grille[ligne][colonne]; for (int i = 0; i < 4; i++) { int valeur = (valeursIncertaines >> (i * 4)) & 0xF; @@ -115,12 +137,16 @@ public class SaisieGrille extends JPanel { return true; } + // Méthode de dessin de la grille + @Override protected void paintComponent(Graphics g) { super.paintComponent(g); GrillePainter.dessinerGrille(g, this); } + // Méthode pour afficher un message de réussite + public void afficherBravo() { JOptionPane.showMessageDialog(this, "Bravo ! La grille est complétée avec succès."); }