API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2018
192
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 38.00 KB | None | 0 0
raw download clone embed print report
  1. import java.util.InputMismatchException;
  2. import java.util.Scanner;
  3.  
  4. public class Kingdomino {
  5. // FONCTION POUR LE DEBUG
  6. private static boolean debug = false;
  7.  
  8. // les terrains sur la partie gauche de chaque domino ; p=prairie, m=marais,
  9. // c=champ,f=forêt, e=eau, M=mine.
  10. static String domino_terrain_g[] = { "p", "c", "c", "e", "f", "c", "e", "f", "c", "f", "m", "e", "f", "c", "c", "M",
  11. "e", "c", "m", "f", "c", "c", "m", "c", "f", "c", "f", "e", "p", "f", "e", "e", "f", "c", "f", "f", "e",
  12. "f", "f", "f", "c", "M", "e", "p", "e", "e", "f", "c" };
  13. // les terrains sur la partie droite de chaque domino, les lettres ont la
  14. // même
  15. // signification que ci-dessus.
  16. static String domino_terrain_d[] = { "m", "p", "m", "f", "f", "f", "e", "c", "p", "e", "m", "c", "c", "c", "c", "e",
  17. "M", "M", "e", "m", "e", "m", "M", "m", "c", "p", "p", "e", "p", "f", "f", "f", "p", "e", "c", "f", "c",
  18. "c", "p", "c", "m", "c", "p", "p", "p", "f", "f", "m" };
  19. // le nombre de couronnes sur la partie gauche de chaque domino
  20. static int domino_couronne_g[] = { 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0,
  21. 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0 };
  22. // le nombre de couronnes sur la partie droite de chaque domino
  23. static int domino_couronne_d[] = { 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 2, 1, 0, 0, 0,
  24. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 0, 2, 0, 0, 2 };
  25.  
  26. // indique si le domino est déjà joué (true) ou pas (false).
  27. static boolean domino_joue[] = new boolean[48];
  28.  
  29. // tableau contenant les terrains de chaque joueur ; indice 1= numéro de
  30. // ligne,
  31. // indice 2= numéro de colonne, indice 3= numéro du joueur.
  32. static String platjeu_terrain[][][] = new String[13][13][2];
  33. // tableau contenant le nombre de couronne de chaque joueur ; indice 1=
  34. // numéro
  35. // de ligne, indice 2= numéro de colonne, indice 3= numéro du joueur.
  36. static int platjeu_couronne[][][] = new int[13][13][2];
  37.  
  38. // Initialise le plateau de jeu et definit tous les dominos comme étant non
  39. // joués.
  40. public static void initialisation() {
  41. for (int i = 0; i < 48; i++) {
  42. domino_joue[i] = false;
  43. }
  44. for (int joueur = 0; joueur < 2; joueur++) {
  45. for (int ligne = 0; ligne < 13; ligne++) {
  46. for (int colonne = 0; colonne < 13; colonne++) {
  47. platjeu_terrain[ligne][colonne][joueur] = " ";
  48. platjeu_couronne[ligne][colonne][joueur] = 0;
  49. }
  50. }
  51. }
  52. platjeu_terrain[6][6][0] = "C";
  53. platjeu_terrain[6][6][1] = "C";
  54. }
  55.  
  56. // Choisit un domino au hasard, valeur retournée = numéro du domino ou -1 si
  57. // tous les dominos sont joués.
  58. public static int choix_domino() {
  59. int domino;
  60. boolean dominos_tous_joues = true;
  61.  
  62. for (int i = 0; i < 48; i++) {
  63. if (domino_joue[i] != true) {
  64. dominos_tous_joues = false;
  65. }
  66. }
  67. if (!dominos_tous_joues) {
  68. do {
  69. domino = (int) (Math.random() * 48);
  70. } while (domino_joue[domino] == true);
  71. domino_joue[domino] = true;
  72. return domino;
  73. } else {
  74. return -1;
  75. }
  76.  
  77. }
  78.  
  79. // Indique si la case à la ligne "l" et la colonne "c" colle bien le
  80. // château.
  81. public static boolean case_colle_chateau(int l, int c) {
  82. return ((l == 5) && (c == 6)) || ((l == 6) && (c == 7)) || ((l == 7) && (c == 6)) || ((l == 6) && (c == 5));
  83. }
  84.  
  85. // indique si la case à la ligne "ligne" et à la colonne "colonne" est bien
  86. // dans
  87. // le plateau de jeu.
  88. public static boolean case_dans_tableau(int ligne, int colonne) {
  89. return (((ligne <= 12) && (ligne >= 0)) && ((colonne <= 12) && (colonne >= 0)));
  90. }
  91.  
  92. // Indique si la case à la ligne "ligne" et à la colonne "colonne" du joueur
  93. // "joueur" est vide ou non
  94. public static boolean case_vide(int ligne, int colonne, int joueur) {
  95. return (platjeu_terrain[ligne][colonne][joueur].contentEquals(" "));
  96. }
  97.  
  98. // Indique si la case à la ligne "ligne" et à la colonne "colonne" du joueur
  99. // "joueur" colle un terrain de meme nature que le terrain "terrain".
  100. public static boolean case_colle_terrain(String terrain, int ligne, int colonne, int joueur) {
  101. String terrain_dessus, terrain_dessous, terrain_droite, terrain_gauche;
  102. if (ligne > 1) {
  103. terrain_dessus = platjeu_terrain[ligne - 1][colonne][joueur];
  104. } else {
  105. terrain_dessus = " ";
  106. }
  107.  
  108. if (ligne < 12) {
  109. terrain_dessous = platjeu_terrain[ligne + 1][colonne][joueur];
  110. } else {
  111. terrain_dessous = " ";
  112. }
  113.  
  114. if (colonne > 1) {
  115. terrain_gauche = platjeu_terrain[ligne][colonne - 1][joueur];
  116. } else {
  117. terrain_gauche = " ";
  118. }
  119. if (colonne < 12) {
  120. terrain_droite = platjeu_terrain[ligne][colonne + 1][joueur];
  121. } else {
  122. terrain_droite = " ";
  123. }
  124. return ((terrain == terrain_dessus) || (terrain == terrain_dessous) || (terrain == terrain_gauche)
  125. || (terrain == terrain_droite));
  126. }
  127.  
  128. // Indique si on a le droit de mettre le domino "domino" à la ligne "ligne"
  129. // et à
  130. // la colonne "colonne" pour le joueur "joueur" ; valeur retournée= true si
  131. // positionnement autorisé.
  132. public static boolean positionnement_autorise(int domino, int ligne1, int colonne1, String orientation,
  133. int joueur) {
  134. boolean P;
  135. boolean colle_chateau;
  136. boolean dans_tableau;
  137. boolean colle_terrain;
  138. boolean positionnement_sur_cases_vides;
  139. int ligne2 = ligne1;
  140. int colonne2 = colonne1;
  141.  
  142. boolean erreur = false;
  143.  
  144. switch (orientation) {
  145. case "d":
  146. ligne2 = ligne1;
  147. colonne2 = colonne1 + 1;
  148. break;
  149. case "g":
  150. ligne2 = ligne1;
  151. colonne2 = colonne1 - 1;
  152. break;
  153. case "h":
  154. ligne2 = ligne1 - 1;
  155. colonne2 = colonne1;
  156. break;
  157. case "b":
  158. ligne2 = ligne1 + 1;
  159. colonne2 = colonne1;
  160. break;
  161. default:
  162. erreur = true;
  163. }
  164.  
  165. dans_tableau = case_dans_tableau(ligne1, colonne1) && case_dans_tableau(ligne2, colonne2);
  166.  
  167. if (dans_tableau && !erreur) {
  168. colle_chateau = case_colle_chateau(ligne1, colonne1) || case_colle_chateau(ligne2, colonne2);
  169. positionnement_sur_cases_vides = case_vide(ligne1, colonne1, joueur) && case_vide(ligne2, colonne2, joueur);
  170. colle_terrain = case_colle_terrain(domino_terrain_g[domino], ligne1, colonne1, joueur)
  171. || case_colle_terrain(domino_terrain_d[domino], ligne2, colonne2, joueur);
  172. P = ((colle_chateau || colle_terrain) && positionnement_sur_cases_vides && taille_7x7(ligne1,colonne1,ligne2,colonne2,joueur));
  173. } else {
  174. P = false;
  175. }
  176. return P;
  177. }
  178.  
  179.  
  180. // calcul le nombre de lignes du début vierges
  181.  
  182. public static int lignes_debut(int joueur) {
  183. int nombre_lignes_vierges_début = 0;
  184. for (int i = 0; i < 13; i++) {
  185. int k = 0;
  186. for (int j = 0; j < 13; j++) {
  187. if (case_vide(i, j, joueur) == true) {
  188. k++;
  189. }
  190. }
  191. if (k == 13) {
  192. nombre_lignes_vierges_début++;
  193. } else {
  194. break;
  195. }
  196. }
  197. return nombre_lignes_vierges_début;
  198. }
  199.  
  200. // calcul le nombre de lignes de la fin vierge
  201. public static int lignes_fin(int joueur) {
  202. int nombre_lignes_vierges_fin = 0;
  203. for (int i = 12; i >= 0; i--) {
  204. int k = 0;
  205. for (int j = 0; j < 13; j++) {
  206. if (case_vide(i, j, joueur) == true) {
  207. k++;
  208. }
  209. }
  210. if (k == 13) {
  211. nombre_lignes_vierges_fin++;
  212. } else {
  213. break;
  214. }
  215. }
  216. return nombre_lignes_vierges_fin;
  217. }
  218.  
  219. // calcul le nombre de colonnes du début vierges
  220. public static int colonnes_debut(int joueur) {
  221. int nombre_colonnes_vierges_début = 0;
  222. for (int i = 0; i < 13; i++) {
  223. int k = 0;
  224. for (int j = 0; j < 13; j++) {
  225. if (case_vide(j, i, joueur) == true) {
  226. k++;
  227. }
  228. }
  229. if (k == 13) {
  230. nombre_colonnes_vierges_début++;
  231. } else {
  232. break;
  233. }
  234. }
  235. return nombre_colonnes_vierges_début;
  236. }
  237.  
  238. // calcul le nombre de colonnes de la fin vierges
  239. public static int colonnes_fin(int joueur) {
  240. int nombre_colonnes_vierges_début = 0;
  241. for (int i = 12; i >= 0; i--) {
  242. int k = 0;
  243. for (int j = 0; j < 13; j++) {
  244. if (case_vide(j, i, joueur) == true) {
  245. k++;
  246. }
  247. }
  248. if (k == 13) {
  249. nombre_colonnes_vierges_début++;
  250. } else {
  251. break;
  252. }
  253. }
  254. return nombre_colonnes_vierges_début;
  255. }
  256.  
  257. public static boolean empireDuMilieu (int joueur) {
  258. boolean leBoolean;
  259.  
  260. int nombre_lignes_vierges_début=0;
  261. int nombre_lignes_vierges_fin=0;
  262. int nombre_colonnes_vierges_début=0;
  263. int nombre_colonnes_vierges_fin=0;
  264.  
  265. nombre_lignes_vierges_début=lignes_debut(joueur);
  266. nombre_lignes_vierges_fin=lignes_fin(joueur);
  267. nombre_colonnes_vierges_début=colonnes_debut(joueur);
  268. nombre_colonnes_vierges_fin=colonnes_fin(joueur);
  269.  
  270. if (nombre_lignes_vierges_début==nombre_lignes_vierges_fin) {
  271. if (nombre_colonnes_vierges_début==nombre_colonnes_vierges_fin) {
  272. leBoolean=true;
  273. }
  274. else leBoolean=false;
  275. }
  276. else {
  277. leBoolean=false;
  278. }
  279. return leBoolean;
  280. }
  281.  
  282. /*
  283. //Tableau de 7 par 7
  284. public static boolean taille_7x7_origine(int joueur) {
  285. boolean leBoolean;
  286. leBoolean=true;
  287. //Plateau de 7 par 7.
  288. int nombre_lignes_vierges_début=0;
  289. int nombre_lignes_vierges_fin=0;
  290. int nombre_colonnes_vierges_début=0;
  291. int nombre_colonnes_vierges_fin=0;
  292.  
  293. nombre_lignes_vierges_début=lignes_début(joueur);
  294. nombre_lignes_vierges_fin=lignes_fin(joueur);
  295. nombre_colonnes_vierges_début=colonnes_début(joueur);
  296. nombre_colonnes_vierges_fin=colonnes_fin(joueur);
  297.  
  298. if ((nombre_lignes_vierges_début + nombre_lignes_vierges_fin) < 6) {
  299. leBoolean=false;
  300. }
  301. if ((nombre_colonnes_vierges_début + nombre_colonnes_vierges_fin) < 6) {
  302. leBoolean=false;
  303. }
  304.  
  305. return leBoolean;
  306. }
  307. */
  308.  
  309. // Règle du tableau de 7 par 7
  310. public static boolean taille_7x7(int ligne1, int colonne1, int ligne2, int colonne2, int joueur) {
  311. int ligne_min, ligne_max, colonne_min, colonne_max; // initialisation du nombre de lignes et de colonnes que prennent l'ensemble des dominos placés dans le plateau de jeu
  312. int ligne, colonne;// initialisation d'une ligne et d'une colonne quelconque à partir d'ici, le joueur n'a pas encore placé le domino
  313. ligne_min = ligne1;
  314. colonne_min = colonne1;
  315. ligne_max = ligne1;
  316. colonne_max = colonne1;// affectation d'une valeur a ligne min et ligne max qui evoluera par la suite
  317.  
  318. if (ligne2 < ligne_min) {
  319. ligne_min = ligne2;
  320. }
  321. if (ligne2 > ligne_max) {
  322. ligne_max = ligne2;
  323. }
  324.  
  325. if (colonne2 < ligne_min) {
  326. colonne_min = colonne2;
  327. }
  328. if (colonne2 > ligne_max) {
  329. colonne_max = colonne2;
  330. } // l'ordinateur va calculer la ligne min et la ligne max à l'aide de ligne2 et colonne2 si on place le domino a une position quelconque
  331.  
  332. // à partir de maintenant, le joueur a placé son domino
  333. for (ligne = 0; ligne < 13; ligne++) {
  334. for (colonne = 0; colonne < 13; colonne++) {
  335. if (!case_vide(ligne, colonne, joueur)) {// après avoir parcouru le tableau, les cases qui nous interressent pour calculer ligne min, lignes max,
  336. // colonne min et colonne max sont les cases non vides
  337. if (ligne < ligne_min) {
  338. ligne_min = ligne;// la ligne min devient la ligne si cette ligne est plus petite que la ligne min déjà calculée
  339. }
  340. if (ligne > ligne_max) {
  341. ligne_max = ligne;// la ligne max devient la ligne si cette ligne est plus grande que la ligne max déjà calculée
  342. }
  343. if (colonne < colonne_min) {
  344. colonne_min = colonne;// la colonne min devient la colonne si cette colonne est plus petite que la colonne min déjà calculée
  345. }
  346. if (colonne > colonne_max) {
  347. colonne_max = colonne;// la colonne max devient la colonne si cette colonne est plus grande que la colonne déjà calculée
  348. }
  349. }
  350. }
  351. }
  352. return (((ligne_max - ligne_min) < 7) && ((colonne_max - colonne_min) < 7));// si la différence entre la ligne(resp colonne) la plus grande et la ligne(resp colonne)
  353. // la plus petite est inferieure à 7, alors elle est contenue dans un tableau de 7x7
  354. }
  355.  
  356. // Affiche les deux dominos d'indice "domino1" et "domino2".
  357. public static void affiche_deux_dominos(int domino1, int domino2) {
  358. System.out.println(" ------- ------- ");
  359. System.out.print("1 : |");
  360. if (domino_couronne_g[domino1] != 0) {
  361. System.out.print(domino_couronne_g[domino1]);
  362. } else {
  363. System.out.print(" ");
  364. }
  365. System.out.print(domino_terrain_g[domino1]);
  366. System.out.print("|");
  367. System.out.print(domino_terrain_d[domino1]);
  368. if (domino_couronne_d[domino1] != 0) {
  369. System.out.print(domino_couronne_d[domino1]);
  370. } else {
  371. System.out.print(" ");
  372. }
  373. System.out.print("| 2 : |");
  374. if (domino_couronne_g[domino2] != 0) {
  375. System.out.print(domino_couronne_g[domino2]);
  376. } else {
  377. System.out.print(" ");
  378. }
  379. System.out.print(domino_terrain_g[domino2]);
  380. System.out.print("|");
  381. System.out.print(domino_terrain_d[domino2]);
  382. if (domino_couronne_d[domino2] != 0) {
  383. System.out.print(domino_couronne_d[domino2]);
  384. } else {
  385. System.out.print(" ");
  386. }
  387. System.out.println("|");
  388. System.out.println(" ------- ------- ");
  389. }
  390.  
  391. // Affiche un domino d'indice "domino".
  392. public static void affiche_un_domino(int domino) {
  393. System.out.println(" ------- ");
  394. System.out.print("domino restant : |");
  395. if (domino_couronne_g[domino] != 0) {
  396. System.out.print(domino_couronne_g[domino]);
  397. } else {
  398. System.out.print(" ");
  399. }
  400. System.out.print(domino_terrain_g[domino]);
  401. System.out.print("|");
  402. System.out.print(domino_terrain_d[domino]);
  403. if (domino_couronne_d[domino] != 0) {
  404. System.out.print(domino_couronne_d[domino]);
  405. } else {
  406. System.out.print(" ");
  407. }
  408. System.out.println("|");
  409. System.out.println(" ------- ");
  410.  
  411. }
  412.  
  413. // Demande au joueur "joueur" le numéro du domino qu'il veut jouer parmi les
  414. // deux qui lui sont présentés ; valeur retournée = 1 (choix du premier
  415. // domino)
  416. // ou 2 (choix du deuxième).
  417. public static int choix_domino_par_joueur(int joueur, String joueur1, String joueur2) {
  418. Scanner sc = new Scanner(System.in);
  419. int domino;
  420. if (joueur == 0) {
  421. System.out.println(joueur1 + ", c'est à toi. Choisis un domino : ");
  422. do {
  423. domino = 0;
  424. System.out.println("Tape 1 ou 2 :");
  425. try {
  426. domino = sc.nextInt();
  427. } catch (InputMismatchException ex) {
  428. sc.nextLine();
  429. }
  430. } while ((domino != 1) && (domino != 2));
  431. } else {
  432. System.out.println(joueur2 + ", c'est à toi. Choisis un domino : ");
  433. do {
  434. domino = 0;
  435. System.out.println("Tape 1 ou 2 :");
  436. try {
  437. domino = sc.nextInt();
  438. } catch (InputMismatchException ex) {
  439. sc.nextLine();
  440. }
  441. } while ((domino != 1) && (domino != 2));
  442. }
  443. // sc.close();
  444. return domino;
  445. }
  446.  
  447. public static int choix_domino_Intelligence_artificielle(int joueur, String joueur_solo,
  448. String intelligence_artificielle) {
  449. Scanner sc = new Scanner(System.in);
  450. int domino = 0;
  451. if (joueur == 0) {
  452. System.out.println(joueur_solo + ", c'est à toi. Choisis un domino : ");
  453. do {
  454. domino = 0;
  455. System.out.println("Tape 1 ou 2 :");
  456. try {
  457. domino = sc.nextInt();
  458. } catch (InputMismatchException ex) {
  459. sc.nextLine();
  460. }
  461. } while ((domino != 1) && (domino != 2));
  462. } else {
  463. domino = (int) (Math.random() * 2) + 1;
  464. if (domino == 2) {
  465. System.out.println("le domino choisi par l'ordinateur est le " + domino + "ème");
  466. }
  467. if (domino == 1) {
  468. System.out.println("le domino choisi par l'ordinateur est le " + domino + "er");
  469. }
  470. }
  471. return domino;
  472. }
  473.  
  474. public static int choix_domino_IA_difficile(int joueur, String joueur_solo,
  475. String intelligence_artificielle) {
  476. Scanner sc = new Scanner(System.in);
  477. int domino = 0;
  478. if (joueur == 0) {
  479. System.out.println(joueur_solo + ", c'est à toi. Choisis un domino : ");
  480. do {
  481. domino = 0;
  482. System.out.println("Tape 1 ou 2 :");
  483. try {
  484. domino = sc.nextInt();
  485. } catch (InputMismatchException ex) {
  486. sc.nextLine();
  487. }
  488. } while ((domino != 1) && (domino != 2));
  489. } else {
  490. String orientation = " ";
  491. int k = 0;
  492. for (int dom = 0; dom < 2; dom++) {
  493. for (int ligne = 0; ligne < 13; ligne++) {
  494. for (int colonne = 0; colonne < 13; colonne++) {
  495. switch (orientation) {
  496. case "d":
  497. if (calcul_scores(joueur)<k){// méthode qui calcule le score du joueur sans prendre en compte dom, ligne,colonne, switch ;)
  498. k=calcul_scores(joueur);
  499. }
  500. case "g":
  501. if (calcul_scores(joueur)<k){
  502. k=calcul_scores(joueur);
  503. }
  504. case "h":
  505. if (calcul_scores(joueur)<k){
  506. k=calcul_scores(joueur);
  507. }
  508. case "b":
  509. if (calcul_scores(joueur)<k){
  510. k=calcul_scores(joueur);
  511. }
  512. }
  513. }
  514. }
  515. }
  516. int domino_choix;
  517. int i1;
  518. int j1;
  519. String orient;
  520. String orientation1 = " ";
  521. for (int choix_domino=0;choix_domino<2;choix_domino++){
  522. for (int i=0;i<13;i++) {
  523. for (int j=0;j<13;j++){
  524. switch (orientation1) {
  525. case "d":
  526. if (calcul_scores(joueur)==k){
  527. domino_choix=choix_domino;
  528. i1=i;
  529. j1=j;
  530. orient="d";
  531. }
  532. case "g":
  533. if (calcul_scores(joueur)==k){
  534. domino_choix=choix_domino;
  535. i1=i;
  536. j1=j;
  537. orient="g";
  538. }
  539. case "h":
  540. if (calcul_scores(joueur)==k){
  541. domino_choix=choix_domino;
  542. i1=i;
  543. j1=j;
  544. orient="h";
  545. }
  546. case "b":
  547. if (calcul_scores(joueur)==k){
  548. domino_choix=choix_domino;
  549. i1=i;
  550. j1=j;
  551. orient="b";
  552. }
  553. }
  554.  
  555.  
  556. }
  557. }
  558. }
  559. choix_ligne_par_intelligence_artificielle();
  560. choix_colonne_par_intelligence_artificielle();
  561. choix_orientation_par_intelligence_artificielle();
  562. }
  563. if (domino == 2) {
  564. System.out.println("le domino choisi par l'ordinateur est le " + domino + "ème");
  565. }
  566. if (domino == 1) {
  567. System.out.println("le domino choisi par l'ordinateur est le " + domino + "er");
  568. }
  569. return domino;
  570. }
  571. // Demande au joueur d'entrer le numéro de ligne dans laquelle il veut
  572. // placer
  573. // son domino ; valeur retournée = numéro de ligne;
  574. public static int choix_ligne() {
  575. Scanner sc = new Scanner(System.in);
  576. int ligne;
  577. do {
  578. System.out.print("numéro de ligne : ");
  579. ligne = 0;
  580. try {
  581. ligne = sc.nextInt();
  582. } catch (InputMismatchException ex) {
  583. sc.nextLine();
  584. }
  585. } while ((ligne < 1) && (ligne > 13));
  586. // sc.close();
  587. return ligne - 1;
  588. }
  589.  
  590. // Demande au joueur d'entrer le numéro de colonne dans laquelle il veut
  591. // placer
  592. // son domino ; valeur retournée = numéro de colonne;
  593. public static int choix_colonne() {
  594. Scanner sc = new Scanner(System.in);
  595. int colonne;
  596. do {
  597. System.out.print("numéro de colonne : ");
  598. colonne = 0;
  599. try {
  600. colonne = sc.nextInt();
  601. } catch (InputMismatchException ex) {
  602. sc.nextLine();
  603. }
  604. } while ((colonne < 1) && (colonne > 13));
  605. // sc.close();
  606. return colonne - 1;
  607. }
  608.  
  609. // Demande au joueur d'entrer l'orientation dans laquelle il veut placer son
  610. // domino ; valeur retournée : "g"=gauche, "d"=droite, "h"=haut, "b"=bas.
  611. public static String choix_orientation() {
  612. Scanner sc = new Scanner(System.in);
  613. String orientation;
  614. do {
  615. System.out.print("Orientation (g=gauche=+180°, d=droite=0°, h=haut=+90°, b=bas=-90°) : ");
  616. orientation = "a";
  617. try {
  618. orientation = sc.nextLine();
  619. } catch (InputMismatchException ex) {
  620. sc.nextLine();
  621. }
  622. } while ((!orientation.equals("g")) && (!orientation.equals("d")) && (!orientation.equals("h"))
  623. && (!orientation.equals("b")));
  624. // sc.close();
  625. return orientation;
  626. }
  627.  
  628. // Demande au joueur "joueur" de placer le demino "domino" dans le plateau
  629. // de
  630. // jeu.
  631. public static void positionner_domino(int domino, int joueur) {
  632. int ligne;
  633. int colonne;
  634. String orientation;
  635. do {
  636. System.out.println("Où veux-tu le placer ? ");
  637. ligne = choix_ligne();
  638. colonne = choix_colonne();
  639. orientation = choix_orientation();
  640. } while (!positionnement_autorise(domino, ligne, colonne, orientation, joueur));
  641. platjeu_terrain[ligne][colonne][joueur] = domino_terrain_g[domino];
  642. platjeu_couronne[ligne][colonne][joueur] = domino_couronne_g[domino];
  643. if (orientation.equals("d")) {
  644. platjeu_terrain[ligne][colonne + 1][joueur] = domino_terrain_d[domino];
  645. platjeu_couronne[ligne][colonne + 1][joueur] = domino_couronne_d[domino];
  646. }
  647. if (orientation.equals("g")) {
  648. platjeu_terrain[ligne][colonne - 1][joueur] = domino_terrain_d[domino];
  649. platjeu_couronne[ligne][colonne - 1][joueur] = domino_couronne_d[domino];
  650. }
  651. if (orientation.equals("h")) {
  652. platjeu_terrain[ligne - 1][colonne][joueur] = domino_terrain_d[domino];
  653. platjeu_couronne[ligne - 1][colonne][joueur] = domino_couronne_d[domino];
  654. }
  655. if (orientation.equals("b")) {
  656. platjeu_terrain[ligne + 1][colonne][joueur] = domino_terrain_d[domino];
  657. platjeu_couronne[ligne + 1][colonne][joueur] = domino_couronne_d[domino];
  658. }
  659. }
  660.  
  661. public static int choix_ligne_par_intelligence_artificielle() {
  662. int ligne;
  663. ligne = (int) (Math.random() * 14);
  664. return ligne - 1;
  665. }
  666.  
  667. public static int choix_colonne_par_intelligence_artificielle() {
  668. int colonne;
  669. colonne = (int) (Math.random() * 14);
  670. return colonne - 1;
  671. }
  672.  
  673. public static String choix_orientation_par_intelligence_artificielle() {
  674. String orientation[] = { "d", "g", "h", "b" };
  675. return orientation[(int) (Math.random() * 4)];
  676. }
  677.  
  678. public static void positionnement_par_intelligence_artificielle(int domino) {
  679. int ligne;
  680. int colonne;
  681. String orientation;
  682. do {
  683. ligne = choix_ligne_par_intelligence_artificielle();
  684. colonne = choix_colonne_par_intelligence_artificielle();
  685. orientation = choix_orientation_par_intelligence_artificielle();
  686. } while (!positionnement_autorise(domino, ligne, colonne, orientation, 1));
  687. platjeu_terrain[ligne][colonne][1] = domino_terrain_g[domino];
  688. platjeu_couronne[ligne][colonne][1] = domino_couronne_g[domino];
  689. if (orientation.equals("d")) {
  690. platjeu_terrain[ligne][colonne + 1][1] = domino_terrain_d[domino];
  691. platjeu_couronne[ligne][colonne + 1][1] = domino_couronne_d[domino];
  692. }
  693. if (orientation.equals("g")) {
  694. platjeu_terrain[ligne][colonne - 1][1] = domino_terrain_d[domino];
  695. platjeu_couronne[ligne][colonne - 1][1] = domino_couronne_d[domino];
  696. }
  697. if (orientation.equals("h")) {
  698. platjeu_terrain[ligne - 1][colonne][1] = domino_terrain_d[domino];
  699. platjeu_couronne[ligne - 1][colonne][1] = domino_couronne_d[domino];
  700. }
  701. if (orientation.equals("b")) {
  702. platjeu_terrain[ligne + 1][colonne][1] = domino_terrain_d[domino];
  703. platjeu_couronne[ligne + 1][colonne][1] = domino_couronne_d[domino];
  704. }
  705. }
  706.  
  707. // Affiche le plateau de jeu
  708. public static void affiche_tableau() {
  709. String espace_suppl = " ";
  710. System.out.println(" Joueur 1 : "+ calcul_scores(0)+" Joueur 2 : "+calcul_scores(1));
  711. System.out.println(" 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 ");
  712. System.out.println(" ════════════════════════════════════════ ════════════════════════════════════════");
  713.  
  714. for (int ligne = 0; ligne <= 12; ligne++) {
  715. if (ligne >= 9) {
  716. espace_suppl = "";
  717. }
  718. System.out.print(espace_suppl+(ligne+1)+" ");
  719. for (int colonne = 0; colonne <= 12; colonne++) {
  720. System.out.print("▌" + platjeu_terrain[ligne][colonne][0]);
  721. if (platjeu_couronne[ligne][colonne][0] == 0) {
  722. System.out.print(" ");
  723. } else {
  724. System.out.print(platjeu_couronne[ligne][colonne][0]);
  725. }
  726. }
  727. System.out.print("▌");
  728. System.out.print(" "+espace_suppl+(ligne +1)+" ");
  729. for (int colonne = 0; colonne <= 12; colonne++) {
  730. System.out.print("▌" + platjeu_terrain[ligne][colonne][1]);
  731. if (platjeu_couronne[ligne][colonne][1] == 0) {
  732. System.out.print(" ");
  733. } else {
  734. System.out.print(platjeu_couronne[ligne][colonne][1]);
  735. }
  736. }
  737. System.out.println("▌");
  738. System.out.println(" ════════════════════════════════════════ ════════════════════════════════════════");
  739. }
  740. }
  741.  
  742. // Définit si le domino est jouable ou non
  743. public static boolean domino_jouable(int domino, int joueur) {
  744. boolean jouable = false;
  745. for (int ligne = 0; ligne < 13; ligne++) {
  746. for (int colonne = 0; colonne < 13; colonne++) {
  747. jouable = jouable || positionnement_autorise(domino, ligne, colonne, "d", joueur);
  748. jouable = jouable || positionnement_autorise(domino, ligne, colonne, "g", joueur);
  749. jouable = jouable || positionnement_autorise(domino, ligne, colonne, "h", joueur);
  750. jouable = jouable || positionnement_autorise(domino, ligne, colonne, "b", joueur);
  751. }
  752. }
  753. return jouable;
  754. }
  755.  
  756. // affectation du numéro d'ensemble au terrain
  757. public static void numero_terrain(String terrain, int ligne, int colonne, int numero_ensemble_terrain[][],
  758. int num_terrain, int joueur) {
  759. if ((platjeu_terrain[ligne][colonne][joueur].equals(terrain))
  760. && (numero_ensemble_terrain[ligne][colonne] == 0)) {
  761. numero_ensemble_terrain[ligne][colonne] = num_terrain;
  762. if (ligne > 1) {
  763. numero_terrain(terrain, ligne - 1, colonne, numero_ensemble_terrain, num_terrain, joueur);
  764. }
  765.  
  766. if (ligne < 12) {
  767. numero_terrain(terrain, ligne + 1, colonne, numero_ensemble_terrain, num_terrain, joueur);
  768. }
  769.  
  770. if (colonne > 1) {
  771. numero_terrain(terrain, ligne, colonne - 1, numero_ensemble_terrain, num_terrain, joueur);
  772. }
  773. if (colonne < 12) {
  774. numero_terrain(terrain, ligne, colonne + 1, numero_ensemble_terrain, num_terrain, joueur);
  775. }
  776.  
  777. }
  778. }
  779.  
  780. // Calcul des scores
  781. public static int calcul_scores(int joueur) {
  782. int score = 0;
  783. int num_terrain = 1;
  784. int numero_ensemble_terrain[][] = new int[13][13];
  785. for (int ligne = 0; ligne < 13; ligne++) {
  786. for (int colonne = 0; colonne < 13; colonne++) {
  787. numero_ensemble_terrain[ligne][colonne] = 0;
  788. }
  789. }
  790. for (int ligne = 0; ligne < 13; ligne++) {
  791. for (int colonne = 0; colonne < 13; colonne++) {
  792. if (!platjeu_terrain[ligne][colonne][joueur].equals(" ")
  793. && (numero_ensemble_terrain[ligne][colonne] == 0)) {
  794. numero_terrain(platjeu_terrain[ligne][colonne][joueur], ligne, colonne, numero_ensemble_terrain,
  795. num_terrain, joueur);
  796. num_terrain++;
  797. }
  798. }
  799. }
  800. int nbe_terrains_ds_ensemble[] = new int[num_terrain - 1];
  801. for (int i = 0; i < (num_terrain - 1); i++) {
  802. nbe_terrains_ds_ensemble[i] = 0;
  803. }
  804. for (int ligne = 0; ligne < 13; ligne++) {
  805. for (int colonne = 0; colonne < 13; colonne++) {
  806. if (numero_ensemble_terrain[ligne][colonne] != 0) {
  807. nbe_terrains_ds_ensemble[numero_ensemble_terrain[ligne][colonne] - 1]++;
  808. }
  809. }
  810. }
  811.  
  812. int nbe_couronnes_ds_ensemble[] = new int[num_terrain - 1];
  813. for (int ligne = 0; ligne < 13; ligne++) {
  814. for (int colonne = 0; colonne < 13; colonne++) {
  815. if ((numero_ensemble_terrain[ligne][colonne] != 0) && (platjeu_couronne[ligne][colonne][joueur] != 0)) {
  816. nbe_couronnes_ds_ensemble[numero_ensemble_terrain[ligne][colonne]
  817. - 1] += platjeu_couronne[ligne][colonne][joueur];
  818. }
  819. }
  820. }
  821. for (int i = 0; i < (num_terrain - 1); i++) {
  822. score += nbe_terrains_ds_ensemble[i] * nbe_couronnes_ds_ensemble[i];
  823. }
  824. return score;
  825. }
  826.  
  827. // Calcul de la taille du domaine le plus
  828. public static int taille_domaine_le_plus_etendu(int joueur) {
  829. int taille = 0;
  830. int num_terrain = 1;
  831. int numero_ensemble_terrain[][] = new int[13][13];
  832. for (int ligne = 0; ligne < 13; ligne++) {
  833. for (int colonne = 0; colonne < 13; colonne++) {
  834. numero_ensemble_terrain[ligne][colonne] = 0;
  835. }
  836. }
  837. for (int ligne = 0; ligne < 13; ligne++) {
  838. for (int colonne = 0; colonne < 13; colonne++) {
  839. if (!platjeu_terrain[ligne][colonne][joueur].equals(" ")
  840. && (numero_ensemble_terrain[ligne][colonne] == 0)) {
  841. numero_terrain(platjeu_terrain[ligne][colonne][joueur], ligne, colonne, numero_ensemble_terrain,
  842. num_terrain, joueur);
  843. num_terrain++;
  844. }
  845. }
  846. }
  847. int nbe_terrains_ds_ensemble[] = new int[num_terrain - 1];
  848. for (int i = 0; i < (num_terrain - 1); i++) {
  849. nbe_terrains_ds_ensemble[i] = 0;
  850. }
  851. for (int ligne = 0; ligne < 13; ligne++) {
  852. for (int colonne = 0; colonne < 13; colonne++) {
  853. if (numero_ensemble_terrain[ligne][colonne] != 0) {
  854. nbe_terrains_ds_ensemble[numero_ensemble_terrain[ligne][colonne] - 1]++;
  855. }
  856. }
  857. }
  858. for (int i = 0; i < (num_terrain - 1); i++) {
  859. if (nbe_terrains_ds_ensemble[i] > taille) {
  860. taille = nbe_terrains_ds_ensemble[i];
  861. }
  862. }
  863. return taille;
  864. }
  865.  
  866. // Calcul du plus grand nombre de couronnes
  867. public static int nbe_de_couronnes(int joueur) {
  868. int couronnes = 0;
  869. for (int ligne = 0; ligne < 13; ligne++) {
  870. for (int colonne = 0; colonne < 13; colonne++) {
  871. couronnes += platjeu_couronne[ligne][colonne][joueur];
  872. }
  873. }
  874. return couronnes;
  875. }
  876.  
  877.  
  878. public static void main(String[] args) {
  879. Scanner sc = new Scanner(System.in);
  880. int style_partie;
  881. int domino1;
  882. int domino2;
  883. int domino_choisi;
  884. String joueur1 = new String(), joueur2 = new String(), joueur_solo = new String(),
  885. intelligence_artificielle = "ordinateur";
  886. int ordinateur = 0;
  887. System.out.println("Quel type de partie voulez-vous jouer ? ");
  888. System.out.println("1 : partie contre ordinateur facile : ");
  889. System.out.println("2 : partie contre ordinateur difficile : ");
  890. System.out.println("3 : partie 2 joueurs: ");
  891. style_partie = sc.nextInt();
  892.  
  893. if (style_partie==2){
  894.  
  895. }
  896. if (style_partie == 3) {
  897.  
  898. initialisation();
  899. do {
  900. // afficher le jeu
  901. affiche_tableau();
  902.  
  903. // choisir le premier joueur aléatoirement
  904. int joueur = (int) (Math.random() * 2);
  905.  
  906. // génerer deux dominos aléatoirement
  907. domino1 = choix_domino();
  908. domino2 = choix_domino();
  909.  
  910. if ((domino1 != -1) && (domino2 != -1)) {
  911.  
  912. // afficher les deux dominos
  913. affiche_deux_dominos(domino1, domino2);
  914.  
  915. // demander au joueur choisi de choisir un domino parmi les
  916. // deux
  917. domino_choisi = choix_domino_par_joueur(joueur, joueur1, joueur2);
  918.  
  919. // demander aux deux joueurs où placer les dominos tout en
  920. // respectant les règles
  921. if (joueur == 1) {
  922. if (domino_jouable(domino1, joueur)) {
  923. positionner_domino(domino1, joueur);
  924. affiche_tableau();
  925. } else {
  926. System.out.println("Domino défaussé mon pote... désolé");
  927. }
  928. System.out.println(joueur1 + " c'est à toi. ");
  929. if (domino_jouable(domino2, 1 - joueur)) {
  930. affiche_un_domino(domino2);
  931. positionner_domino(domino2, 1 - joueur);
  932. } else {
  933. System.out.println("Domino défaussé mon pote... désolé");
  934. }
  935. } else {
  936. if (domino_jouable(domino2, joueur)) {
  937. positionner_domino(domino2, joueur);
  938. affiche_tableau();
  939. } else {
  940. System.out.println("Domino défaussé mon pote... désolé");
  941. }
  942.  
  943. System.out.println(joueur2 + " c'est à toi. ");
  944. if (domino_jouable(domino1, 1 - joueur)) {
  945. affiche_un_domino(domino1);
  946. positionner_domino(domino1, 1 - joueur);
  947. } else {
  948. System.out.println("Domino défaussé mon pote... désolé");
  949. }
  950. }
  951. }
  952.  
  953. } while ((domino1 != -1) && (domino2 != -1));
  954.  
  955. //Empire Du Milieu
  956. int score_final_0=calcul_scores(0);
  957. int score_final_1=calcul_scores(1);
  958. if (empireDuMilieu(0)==true) {
  959. score_final_0=score_final_0+10;
  960. }
  961. if (empireDuMilieu(1)==true) {
  962. score_final_1=score_final_1+10;
  963. }
  964.  
  965.  
  966. if (score_final_0==score_final_1) {
  967. if (taille_domaine_le_plus_etendu(0)==taille_domaine_le_plus_etendu(1)) {
  968. if (nbe_de_couronnes(0)==nbe_de_couronnes(1)) {
  969. System.out.println("Egalité !! ");
  970. }
  971. if (nbe_de_couronnes(0)>nbe_de_couronnes(1)) {
  972. System.out.println("Vainqueur : joueur 1");
  973. }
  974. if (nbe_de_couronnes(0)<nbe_de_couronnes(1)) {
  975. System.out.println("Vainqueur : joueur 2");
  976. }
  977. }
  978. if (taille_domaine_le_plus_etendu(0)>taille_domaine_le_plus_etendu(1)) {
  979. System.out.println("Vainqueur : joueur 1");
  980. }
  981. if (taille_domaine_le_plus_etendu(0)<taille_domaine_le_plus_etendu(1)) {
  982. System.out.println("Vainqueur : joueur 2");
  983. }
  984. }
  985. if (score_final_0>score_final_1) {
  986. System.out.println("Vainqueur : joueur 1");
  987. }
  988.  
  989. if (score_final_0<score_final_1) {
  990. System.out.println("Vainqueur : joueur 2");
  991. }
  992. System.out.println("~FIN DE LA PARTIE~");
  993. }
  994.  
  995.  
  996. if (style_partie == 1) {
  997. initialisation();
  998.  
  999. do {
  1000. // afficher le jeu
  1001. affiche_tableau();
  1002.  
  1003. // choisir le premier joueur aléatoirement
  1004. int joueur = (int) (Math.random() * 2);
  1005. ordinateur = joueur;
  1006. // génerer deux dominos aléatoirement
  1007. domino1 = choix_domino();
  1008. domino2 = choix_domino();
  1009.  
  1010. if ((domino1 != -1) && (domino2 != -1)) {
  1011. // afficher les deux dominos
  1012. affiche_deux_dominos(domino1, domino2);
  1013.  
  1014. // choix du domino par le joueur ou l'ordinateur
  1015. domino_choisi = choix_domino_Intelligence_artificielle(joueur, joueur_solo,
  1016. intelligence_artificielle);
  1017.  
  1018. // demander aux deux joueurs où placer les dominos tout en
  1019. // respectant les règles
  1020. if (joueur == 1) {
  1021. if (domino_choisi == 1) {
  1022. if (domino_jouable(domino1, joueur)) {
  1023. // do {
  1024. positionnement_par_intelligence_artificielle(domino1);
  1025. // } while
  1026. // (positionnement_autorise(domino1,choix_ligne_par_intelligence_artificielle(),choix_colonne_par_intelligence_artificielle(),choix_orientation_par_intelligence_artificielle(),joueur)==false);
  1027. affiche_tableau();
  1028. } else {
  1029. System.out.println("Domino défaussé pour l'ordinateur !");
  1030. }
  1031. System.out.println(joueur_solo + " c'est à toi. ");
  1032. if (domino_jouable(domino2, 1 - joueur)) {
  1033. affiche_un_domino(domino2);
  1034. positionner_domino(domino2, 1 - joueur);
  1035. } else {
  1036. System.out.println("Domino défaussé mon pote... désolé");
  1037. }
  1038. }
  1039. if (domino_choisi == 2) {
  1040. if (domino_jouable(domino2, joueur)) {
  1041. positionnement_par_intelligence_artificielle(domino2);
  1042. affiche_tableau();
  1043. } else {
  1044. System.out.println("Domino défaussé pour l'ordinateur !");
  1045. }
  1046. System.out.println(joueur_solo + " c'est à toi. ");
  1047. if (domino_jouable(domino1, 1 - joueur)) {
  1048. affiche_un_domino(domino1);
  1049. positionner_domino(domino1, 1 - joueur);
  1050. } else {
  1051. System.out.println("Domino défaussé mon pote... désolé");
  1052. }
  1053. }
  1054. } else {
  1055. if (domino_choisi == 1) {
  1056. if (domino_jouable(domino1, joueur)) {
  1057. positionner_domino(domino1, joueur);
  1058. affiche_tableau();
  1059. } else {
  1060. System.out.println("Domino défaussé mon pote... désolé");
  1061. }
  1062.  
  1063. if (domino_jouable(domino2, 1 - joueur)) {
  1064. affiche_un_domino(domino2);
  1065. positionnement_par_intelligence_artificielle(domino2);
  1066. affiche_tableau();
  1067. } else {
  1068. System.out.println("Domino défaussé pour l'ordinateur !");
  1069. }
  1070. }
  1071. if (domino_choisi == 2) {
  1072. if (domino_jouable(domino2, joueur)) {
  1073. positionner_domino(domino2, joueur);
  1074. affiche_tableau();
  1075. } else {
  1076. System.out.println("Domino défaussé mon pote... désolé");
  1077. }
  1078.  
  1079. if (domino_jouable(domino1, 1 - joueur)) {
  1080. affiche_un_domino(domino1);
  1081. // do {
  1082. positionnement_par_intelligence_artificielle(domino1);
  1083. // } while
  1084. // (positionnement_autorise(domino1,choix_ligne_par_intelligence_artificielle(),choix_colonne_par_intelligence_artificielle(),choix_orientation_par_intelligence_artificielle(),1-joueur)==false);
  1085. affiche_tableau();
  1086. } else {
  1087. System.out.println("Domino défaussé pour l'ordinateur !");
  1088. }
  1089. }
  1090. }
  1091. }
  1092. } while ((domino1 != -1) && (domino2 != -1));
  1093.  
  1094. //Empire Du Milieu
  1095. int score_final_0=calcul_scores(0);
  1096. int score_final_1=calcul_scores(1);
  1097. if (empireDuMilieu(0)==true) {
  1098. score_final_0=score_final_0+10;
  1099. }
  1100.  
  1101. if (empireDuMilieu(1)==true) {
  1102. score_final_1=score_final_1+10;
  1103. }
  1104.  
  1105. if (score_final_0 == score_final_1) {
  1106. if (taille_domaine_le_plus_etendu(0) == taille_domaine_le_plus_etendu(1)) {
  1107. if (nbe_de_couronnes(0) == nbe_de_couronnes(1)) {
  1108. System.out.println("Egalité !! ");
  1109. }
  1110. if (nbe_de_couronnes(0) > nbe_de_couronnes(1)) {
  1111. System.out.println("Vainqueur : " + joueur1);
  1112. }
  1113. if (nbe_de_couronnes(0) < nbe_de_couronnes(1)) {
  1114. System.out.println("Vainqueur : " + intelligence_artificielle);
  1115. }
  1116. }
  1117. if (taille_domaine_le_plus_etendu(0) > taille_domaine_le_plus_etendu(1)) {
  1118. System.out.println("Vainqueur : " + joueur1);
  1119. }
  1120. if (taille_domaine_le_plus_etendu(0) < taille_domaine_le_plus_etendu(1)) {
  1121. System.out.println("Vainqueur : " + intelligence_artificielle);
  1122. }
  1123. }
  1124. if (score_final_0 > score_final_1) {
  1125. System.out.println("Vainqueur : " + joueur1);
  1126. }
  1127. if (score_final_0 < score_final_1) {
  1128. System.out.println("Vainqueur : " + intelligence_artificielle);
  1129. }
  1130.  
  1131. System.out.println("~FIN DE LA PARTIE~");
  1132. }
  1133. }
  1134. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!