API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 23rd, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.77 KB | None | 0 0
raw download clone embed print report
  1. import Util from '../util';
  2. import CardsGame from './cardsgame';
  3. import Deck from './deck';
  4. import GameTable from './gametable';
  5. import CurrentTurn from './currentturn';
  6. import cards from '../../assets/cartes';
  7. /**
  8. * Représente les règles du jeu Bâtisseurs: Moyen-Age
  9. */
  10. export default class BatisseursMoyAge extends CardsGame {
  11. /**
  12. * Constructeur
  13. * @param {Object[]} Tableau des cartes du jeu
  14. * @class
  15. */
  16. constructor(cards) {
  17. super("BATISSEURS_MOY-AGE","Bâtisseurs Moyen-Âge", cards, 3);
  18. this.actionNames = ["getWorker", "getBuilding", "getGold", "putWorker", "buyAction"];
  19. }
  20.  
  21. //PAS UTILISEE
  22. /**
  23. * Liste des matériaux possibles
  24. * @returns {[string,string,string,string]}
  25. */
  26. static getMaterials() {
  27. "use strict";
  28. return ["pierre", "tuile", "savoir", "bois"];
  29. }
  30.  
  31. //PAS UTILISEE
  32. /**
  33. * Vérifie que le salaire d'un ouvrier correspond à sa qualification
  34. * @param {number} salary Salaire d'un ouvrier
  35. * @param {string} level Niveau de l'ouvrier (apprenti, manoeuvre, compagnon, maître
  36. * @returns {boolean} true si salaire est correct pour le niveau de l'ouvrier, false sinon
  37. */
  38. validateSalaryByLevel(salary, level) {
  39. return true;
  40. }
  41.  
  42. //PAS UTILISEE
  43. /**
  44. * Vérifie qu'une carte requiert un nombre positif d'au moins un matériau valide
  45. * @param {Object} card Carte du jeu
  46. * @returns {boolean} true si matériau requis, false sinon
  47. */
  48. needsMaterials(card) {
  49. let hasMaterial = false;
  50. BatisseursMoyAge.getMaterials().map(function (material) {
  51. if (card.hasOwnProperty(material) && parseInt(card[material]) > 0) {
  52. hasMaterial = true;
  53. }
  54. });
  55. return hasMaterial;
  56. }
  57.  
  58. /**
  59. * Vérifie qu'une carte de famille "ouvrier" est valide; sinon retourne un message d'erreur explicite
  60. * @param {Object} card Carte du jeu
  61. * @returns {Object} retourne {error: boolean, message: string}, si erreur détectée : error = true, message contient une explication de l'erreur
  62. */
  63. validateBatisseursMAOuvrier(card) {
  64. let result = {error: false, message: ""};
  65.  
  66. let isValid = true;
  67. let messages = "";
  68. if (card.famille === "ouvrier") {
  69. let niveau = card.niveau;
  70. if (!(niveau === "apprenti" || niveau === "manoeuvre" || niveau === "compagnon" || niveau === "maître")) {
  71. messages += ("niveau invalide, id de la carte:" + card.id + "\n");
  72. isValid = false;
  73. }
  74. else { // L'attribut niveau est Ok
  75. let salaire = card.salaire;
  76. if (niveau === "apprenti") {
  77. if (salaire !== 2) { isValid = false; messages += ("salaire invalide, id de la carte" + card.id + "\n");}
  78. }
  79. else if (niveau === "manœuvre") {
  80. if (salaire !== 3) { isValid = false; messages += ("salaire invalide, id de la carte" + card.id + "\n");}
  81. }
  82. else if (niveau === "compagnon") {
  83. if (salaire !== 4) { isValid = false; messages += ("salaire invalide, id de la carte" + card.id + "\n");}
  84. }
  85. else if (niveau === "maître") {
  86. if (salaire !== 5) { isValid = false; messages += ("salaire invalide, id de la carte" + card.id + "\n");}
  87. }
  88. else { // Le salaire a bien été vérif
  89. let valeurSalaire = 0;
  90. if (card.hasOwnProperty("pierre") && card.pierre > 0 && card.pierre < 4) {valeurSalaire += card.pierre;}
  91. if (card.hasOwnProperty("bois") && card.bois > 0 && card.bois < 4) {valeurSalaire += card.bois;}
  92. if (card.hasOwnProperty("savoir") && card.savoir > 0 && card.savoir < 4) {valeurSalaire += card.savoir;}
  93. if (card.hasOwnProperty("tuile") && card.tuile > 0 && card.tuile < 4) {valeurSalaire += card.tuile;}
  94. if (valeurSalaire !== salaire) { isValid = false; messages += ("valeur du salaire incorrecte, id de la carte:" + card.id + "\n");}
  95. }
  96. }
  97. }
  98. result[0] = isValid;
  99. result[1] = messages;
  100.  
  101. return result;
  102. }
  103.  
  104. /**
  105. * Vérifie qu'une carte de famille "bâtiment" est valide; sinon retourne un message d'erreur explicite
  106. * @param {Object} card Carte du jeu
  107. * @returns {Object} retourne {error: boolean, message: string}, si erreur détectée : error = true, message contient une explication de l'erreur
  108. */
  109. validateBatisseursMABatiment(card) {
  110. let result = {error: false, message: ""};
  111.  
  112. let isValid = true;
  113. let messages = "";
  114. if (card.famille === "bâtiment") {
  115. if (card.label.length === 0 || !card.label) {isValid = false; messages += ("label vide, id de la carte:" + card.id + "\n");}
  116. if (card.gains <= 0) { isValid = false; messages += ("gains inférieurs à 1, id de la carte:" + card.id + "\n");}
  117. if (card.pv < 0) { isValid = false; messages += ("pv inférieurs à 0, id de la carte:" + card.id + "\n");}
  118.  
  119. if (card.hasOwnProperty("pierre") && (!(card.pierre > 0 && card.pierre < 6))) {
  120. isValid = false; messages += ("valeur propriete pierre incorrecte, id de la carte:" + card.id + "\n");
  121. }
  122. if (card.hasOwnProperty("bois") && (!(card.bois > 0 && card.bois < 6))) {
  123. isValid = false; messages += ("valeur propriete bois incorrecte, id de la carte:" + card.id + "\n");
  124. }
  125. if (card.hasOwnProperty("savoir") && (!(card.savoir > 0 && card.savoir < 6))) {
  126. isValid = false; messages += ("valeur propriete savoir incorrecte, id de la carte:" + card.id + "\n");
  127. }
  128. if (card.hasOwnProperty("tuile") && (!(card.tuile > 0 && card.tuile < 6))) {
  129. isValid = false; messages += ("valeur propriete tuile incorrecte, id de la carte:" + card.id + "\n");
  130. }
  131. }
  132. result[0] = isValid;
  133. result[1] = messages;
  134.  
  135. return result;
  136. }
  137.  
  138. /**
  139. * Vérifie qu'une carte de famille "machine" est valide; sinon retourne un message d'erreur explicite
  140. * @param {Object} card Carte du jeu
  141. * @returns {Object} retourne {error: boolean, message: string}, si erreur détectée : error = true, message contient une explication de l'erreur
  142. */
  143. validateBatisseursMAMachine(card) {
  144. let result = {error: false, message: ""};
  145.  
  146. let isValid = true;
  147. let messages = "";
  148. if (card.famille === "machine") {
  149. if (card.label.length === 0 || !card.label) {isValid = false; messages += ("label vide, id de la carte:" + card.id + "\n");}
  150. if (!(card.pv === 1 || card.pv === 2)) { isValid = false; messages += ("pv non égal à 1 ou 2, id de la carte:" + card.id + "\n");}
  151. if((card.production === 2 && card.pv !== 1) || (card.production === 3 && card.pv !== 2)){
  152. isValid = false;
  153. messages += ("valeur de matière ne correpond pas avec pv, id de la carte:" + card.id + "\n");
  154. }
  155. if (card.hasOwnProperty("pierre") && (!(card.pierre > 0 && card.pierre < 3))) {
  156. isValid = false; messages += ("valeur propriete pierre incorrecte, id de la carte:" + card.id + "\n");
  157. }
  158. if (card.hasOwnProperty("bois") && (!(card.bois > 0 && card.bois < 3))) {
  159. isValid = false; messages += ("valeur propriete bois incorrecte, id de la carte:" + card.id + "\n");
  160. }
  161. if (card.hasOwnProperty("savoir") && (!(card.savoir > 0 && card.savoir < 3))) {
  162. isValid = false; messages += ("valeur propriete savoir incorrecte, id de la carte:" + card.id + "\n");
  163. }
  164. if (card.hasOwnProperty("tuile") && (!(card.tuile > 0 && card.tuile < 3))) {
  165. isValid = false; messages += ("valeur propriete tuile incorrecte, id de la carte:" + card.id + "\n");
  166. }
  167. }
  168. result[0] = isValid;
  169. result[1] = messages;
  170.  
  171. return result;
  172. }
  173.  
  174. /**
  175. * Appelle les différentes fonctions de validation d'une carte en fonction de sa famille
  176. * @param {Object} card Carte du jeu
  177. * @returns {Object} retourne {error: boolean, message: string}, si erreur détectée : error = true, message contient une explication de l'erreur
  178. */
  179. validationBatisseursMA(card) {
  180. if(card.famille === "ouvrier"){
  181. return this.validateBatisseursMAOuvrier(card);
  182. }else if(card.famille === "bâtiment"){
  183. return this.validateBatisseursMABatiment(card);
  184. }else {
  185. return this.validateBatisseursMAMachine(card);
  186. }
  187. /*let result = {error: false, message: ""};
  188.  
  189. // Les 3 fonctions de validation DU BATISSEUR
  190. let resultOuvrier = this.validateBatisseursMAOuvrier(card);
  191. let resultBatiment = this.validateBatisseursMABatiment(card);
  192. let resultMachine = this.validateBatisseursMAMachine(card);
  193.  
  194. // Calcul du resultat des vérifications
  195. result[0] = resultOuvrier[0] && resultBatiment[0] && resultMachine[0];
  196. result[1] = resultOuvrier[1] + resultBatiment[1] + resultMachine[1];
  197.  
  198. return result;*/
  199. }
  200.  
  201. /**
  202. * Appel à la validation générale d'un jeu de cartes, en lui passant la fonction spécifique de validation du jeu
  203. * @returns {string} chaine de caractères listant toutes les erreurs détectées dans les cartes du jeu séparées par un saut de ligne
  204. */
  205. validate() {
  206. // Appel de la fonction de validation générale de la "classe mere" CardsGame
  207. // La fonction de validation relative au batisseur sera appelé par la suite.
  208. return super.validate(this.validationBatisseursMA);
  209. }
  210.  
  211. //PAS UTILISEE
  212. /**
  213. * Calcule le nombre d'actions requises pour affecter un ou plusieurs ouvriers sur un même bâtiment durant le même tour par le joueur courant
  214. * @param {number} nbr Nombre d'ouvriers à affecter
  215. * @returns {number} Nombre d'actions requises
  216. */
  217. getNbrActionsForWorkersOnSameBuildingAndSameTurn(nbr){
  218. let result = 1;
  219. return result;
  220. }
  221.  
  222. //PAS UTILISEE
  223. /**
  224. * Calcule le nombre d'écus à recevoir pour une ou plusieurs actions vendues
  225. * @param {number} nbr Nombre d'actions vendues
  226. * @returns {number} Nombre d'écus à recevoir
  227. */
  228. getNbrEcusForNbrActions(nbr){
  229. return 0;
  230. }
  231.  
  232. /**
  233. * Effectue la mise en place du jeu Bâtisseurs: Moyen-Age
  234. * @param {Game} game Partie en cours
  235. */
  236. initialize(game) {
  237. this.generateHashCode(game);
  238.  
  239. //Initialiser le premier tour
  240. game.currentTurn = new CurrentTurn(3);
  241.  
  242. this.initWorkerDeck(game);
  243. this.initBuildingDeck(game);
  244. this.initGold(game);
  245. }
  246.  
  247. /**
  248. * Ajoute 10 écus à chaque joueur
  249. * @param {Game} game Partie en cours
  250. */
  251. initGold(game) {
  252. game.players.forEach((player) => {
  253. player.inventory.push({ecus: 10});
  254. });
  255. }
  256.  
  257. /**
  258. * Créer un deck avec tous les ouvriers
  259. * @param {Game} game Partie en cours
  260. */
  261. initWorkerDeck(game){
  262. let workerDeck = new Deck(cards);
  263. workerDeck.cards = workerDeck.getCards({famille:"ouvrier"});
  264. workerDeck.shuffle();
  265. game.decks[1] = workerDeck;
  266.  
  267. game.decks[1].cards.forEach((card) => {
  268. this.validationBatisseursMA(card);
  269. });
  270. }
  271.  
  272. /**
  273. * Créer un deck avec tous les batiments
  274. * @param {Game} game Partie en cours
  275. */
  276. initBuildingDeck(game){
  277. let buildingDeck = new Deck(cards);
  278. buildingDeck.cards = buildingDeck.getCards({famille:"bâtiment"}).concat(buildingDeck.getCards({famille:"machine"}));
  279. buildingDeck.shuffle();
  280. game.decks[0] = buildingDeck;
  281.  
  282. game.decks[0].cards.forEach((card) => {
  283. this.validationBatisseursMA(card);
  284. });
  285. }
  286.  
  287. /**
  288. * Génere un hashcode
  289. */
  290. generateHashCode(game) {
  291. let randomString = Util.randomString(20);
  292. let label = game.cardsGame.label;
  293. let timeStamp = new Date().getTime();
  294. let hashcode = Util.hashCode(randomString + label + timeStamp);
  295. game.hashCode = hashcode;
  296. }
  297.  
  298. //PAS UTILISEE, on appel les méthodes de vérif DIRECT dans l'execute (voir ci-dessous) correspondant
  299. /**
  300. * Vérifie si l'action est autorisée pour le joueur en cours
  301. * @param {Game} game Partie en cours
  302. * @param {string} actionName Nom de l'action à vérifier
  303. * @param {Object} args Paramètres facultatifs de l'action à effectuer
  304. * @returns {boolean} true si action autorisée, false sinon
  305. */
  306. isValidAction(game, actionName, args) {
  307. if (this.actionNames.indexOf(actionName) < -1) { return false;} // L'action n'existe pas
  308. if (actionName === "getWorker") { return this.verifGetWorker(game, args);}
  309. else if (actionName === "getBuilding") { return this.verifGetBuilding(game, args);}
  310. else if (actionName === "getGold") { return this.verifGetGold(game, args);}
  311. else if (actionName === "putWorker") { return this.verifPutWorker(game, args);}
  312. else if (actionName === "buyAction") { return this.verifBuyAction(game, args);}
  313. return false;
  314. }
  315.  
  316. verifGetWorker(game, args) {
  317. let bool = game.decks[1].cards.some((value) => {
  318. return value.id === args.workerId;
  319. });
  320.  
  321. if(bool === false || game.currentTurn.nbrActions === 0){
  322. bool = false;
  323. }else{
  324. bool = true;
  325. }
  326. return bool;
  327. }
  328.  
  329. verifGetBuilding(game, args) {
  330. let bool = game.decks[0].cards.some((value) => {
  331. return value.id === args.buildingId;
  332. });
  333.  
  334. if(bool === false || game.currentTurn.nbrActions === 0){
  335. return false;
  336. }else{
  337. return true;
  338. }
  339. }
  340.  
  341. verifGetGold(game, args) {
  342. return game.currentTurn.nbrActions >= args.amount;
  343. }
  344.  
  345. verifPutWorker(game, args) {
  346. return game.currentTurn.nbrActions >= 1;
  347. }
  348.  
  349. verifBuyAction(game, args) {
  350. let player = game.players[game.currentPlayer-1];
  351. let nbreGold = player.inventory.find(item => item.ecus !== undefined).ecus;
  352. if (nbreGold >= 5) {
  353. return true;
  354. } else { return false;}
  355. }
  356.  
  357. /**
  358. * Effectue une action pour le joueur en cours
  359. * @param {Game} game Partie en cours
  360. * @param {string} actionName Nom de l'action à vérifier
  361. * @param {Object} args Paramètres facultatifs de l'action à effectuer
  362. * @returns {boolean} true si action autorisée, false sinon
  363. */
  364. doAction(game, actionName, args) {
  365. // Action valide ??
  366. // Si action valide, execution de la fonction correspondante
  367. if (actionName === "getWorker") {this.executeGetWorker(game, args);}
  368. if (actionName === "getBuilding") {this.executeGetBuilding(game, args);}
  369. if (actionName === "getGold") {this.executeGetGold(game, args);}
  370. if (actionName === "putWorker") {this.executePutWorker(game, args);}
  371. if (actionName === "buyAction") {this.executeBuyAction(game, args);}
  372. this.afterAction(game, actionName, args);
  373. }
  374.  
  375. executeGetWorker(game, args) {
  376. if (this.verifGetWorker(game, args)) {
  377. let workerObj = game.decks[1].getCardById(args.workerId);
  378. game.decks[1].removeCard(args.workerId);
  379. game.players[game.currentPlayer-1].gameTable.addSet(workerObj, true);
  380. game.currentTurn.pushAction("getWorker", args); //ajoute dans l'action dans l'historique des actions
  381. }
  382. }
  383.  
  384. executeGetBuilding(game, args) {
  385. if (this.verifGetBuilding(game, args)) {
  386. let buildingObj = game.decks[0].getCardById(args.buildingId);
  387. game.decks[0].removeCard(args.buildingId);
  388. game.players[game.currentPlayer - 1].gameTable.addSet(buildingObj, true);
  389. game.currentTurn.pushAction("getBuilding", args);
  390. }
  391. }
  392.  
  393. executeGetGold(game, args) {
  394. if (this.verifGetGold(game, args)) {
  395. // args.amount [Amount] : Le nombre d'action depensé pour l'action
  396.  
  397. // Combien de gold a ajouter :
  398. let amountToAdd = 0;
  399. if (args.amount === 1) {
  400. amountToAdd = 1;
  401. }
  402. else if (args.amount === 2) {
  403. amountToAdd = 3;
  404. }
  405. else {
  406. amountToAdd = 6;
  407. }
  408.  
  409. // Joueur courant
  410. let player = game.players[game.currentPlayer - 1];
  411.  
  412. // Son nombre de gold
  413. let currentGoldAmount = player.inventory.find(item => item.ecus !== undefined).ecus;
  414.  
  415. // Ajout du nombre de gold
  416. player.inventory.find(item => item.ecus !== undefined).ecus = currentGoldAmount + amountToAdd;
  417.  
  418. // Enlever le nombre d'action correspondant
  419. game.currentTurn.nbrActions = game.currentTurn.nbrActions - args.amount;
  420. game.currentTurn.pushAction("getGold", args);
  421. }
  422. }
  423.  
  424. executePutWorker(game, args) {
  425. if (this.verifPutWorker(game, args)) {
  426. let countWorkerOnSameBuilding = 0;
  427. let player = game.players[game.currentPlayer - 1];
  428. let workerCard = player.gameTable.getCardById(args.workerId);
  429. let completedWorkerCard = game.cardsGame.getCardById(workerCard.id);
  430.  
  431. // Si il a la propriete salaire ( ex: machine ne l'a pas )
  432. if (completedWorkerCard.hasOwnProperty("salaire")) {
  433. player.inventory.find(item => item.ecus !== undefined).ecus -= game.cardsGame.getCardById(completedWorkerCard.id).salaire;
  434. }
  435. player.gameTable.removeSet(workerCard.id);
  436.  
  437. player.gameTable.addCardToSet(args.buildingId, workerCard); //ajoute une carte ouvrière au même set que l'identifiant du batiment
  438.  
  439. this.checkBuildindFinished(game, args.buildingId);
  440.  
  441. game.currentTurn.actions.forEach(function (action) { //je parcours toutes les actions du tour actuel du joueur courant
  442. if (action.args.buildingId === args.buildingId) {
  443. countWorkerOnSameBuilding++; //incrémente s'il y a le batiment donné en paramètre
  444. }
  445. });
  446.  
  447. if (countWorkerOnSameBuilding === 0) { //le cas où on a pas encore affecté d'ouvriers sur le batiment ce tour ci
  448. game.currentTurn.nbrActions -= 1;
  449. } else if (countWorkerOnSameBuilding === 1) { //le cas où on a déjà affecté un ouvrier sur le batiment ce tour ci
  450. game.currentTurn.nbrActions -= 2;
  451. } else if (countWorkerOnSameBuilding === 2) { //le cas où on a déjà affecté deux ouvriers sur le batiment ce tour ci
  452. game.currentTurn.nbrActions -= 3;
  453. }
  454. game.currentTurn.pushAction("putWorker", args);
  455. }
  456. }
  457.  
  458. executeBuyAction(game, args) {
  459. if (this.verifBuyAction(game, args)) {
  460. let player = game.players[game.currentPlayer - 1];
  461. game.currentTurn.addNbrActions(1);
  462. player.inventory.find(item => item.ecus !== undefined).ecus -= 5;
  463. game.currentTurn.pushAction("buyAction", args);
  464. }
  465. }
  466.  
  467. /**
  468. * Vérifie toutes les ressources nécessaires pour terminer le chantier sont disponibles et dans ce cas transforme le chantier en bâtiment
  469. * @param {Game} game Partie en cours
  470. * @param {string} buildingId Identifiant d'un chantier sur lequel un ouvrier vient d'être affecté
  471. */
  472. checkBuildindFinished(game, buildingId){
  473. let id = buildingId;
  474. // Tout a 0 par default
  475. let bois = 0, pierre = 0, savoir = 0, tuile = 0;
  476. let player = game.players[game.currentPlayer - 1];
  477.  
  478. var buildingCard = game.cardsGame.getCardById(buildingId);
  479.  
  480. // Attribution des composants requis
  481. if (buildingCard.bois != null) {bois = buildingCard.bois;} //laisser != car vérifie juste la valeur, pas le type!
  482. if (buildingCard.pierre != null) {pierre = buildingCard.pierre;}
  483. if (buildingCard.savoir != null) {savoir = buildingCard.savoir;}
  484. if (buildingCard.tuile != null) {tuile = buildingCard.tuile;}
  485.  
  486. // Pour chaque carte du tas qui n'est pas un batiment,
  487. // On soustrait les atributs selons les specs des ouvriers
  488. let heap = game.players[game.currentPlayer-1].gameTable.getHeap(id);
  489. heap.forEach((card) => {
  490. if (card.id !== buildingCard.id && card.famille === "ouvrier" || card.famille === "machine") {
  491. let completeCard = game.cardsGame.getCardById(card.id);
  492. if (card.famille === "machine") {
  493. if (completeCard.production.hasOwnProperty("pierre")) {pierre -= completeCard.production.pierre;}
  494. if (completeCard.production.hasOwnProperty("bois")) {bois -= completeCard.production.bois;}
  495. if (completeCard.production.hasOwnProperty("savoir")) {savoir -= completeCard.production.savoir;}
  496. if (completeCard.production.hasOwnProperty("tuile")) {tuile -= completeCard.production.tuile;}
  497. }
  498. else { // Cas où c'est un ouvrier
  499. if (completeCard.hasOwnProperty("bois")) {
  500. bois -= completeCard.bois;
  501. }
  502. if (completeCard.hasOwnProperty("pierre")) {
  503. pierre -= completeCard.pierre;
  504. }
  505. if (completeCard.hasOwnProperty("savoir")) {
  506. savoir -= completeCard.savoir;
  507. }
  508. if (completeCard.hasOwnProperty("tuile")) {
  509. tuile -= completeCard.tuile;
  510. }
  511. }
  512. }
  513. });
  514.  
  515. // Si le batiment est terminé ( assez de ressources dans le set du gametable )
  516. if (bois <= 0 && tuile <= 0 && savoir <= 0 && pierre <= 0) { // Le batiment est fini
  517. // payer le joueur de la valeur du batiment
  518. var currentPlayer = game.players[game.currentPlayer-1];
  519. let currentGoldAmount = currentPlayer.inventory.find(item => item.ecus !== undefined).ecus;
  520. if (buildingCard.hasOwnProperty("gains")) {
  521. currentPlayer.inventory.find(item => item.ecus !== undefined).ecus = currentGoldAmount + buildingCard.gains;
  522. }
  523. // enlever le set en question
  524. currentPlayer.gameTable.removeSet(buildingId);
  525.  
  526. heap.forEach((card) => {
  527. if (card.famille === "ouvrier") {
  528. currentPlayer.gameTable.addSet(card, true);
  529. }
  530. else { // batiment/machine
  531. let completeCard = game.cardsGame.getCardById(card.id);
  532. if (card.id === buildingCard.id) {
  533. currentPlayer.score = currentPlayer.score + completeCard.pv;
  534. }
  535. currentPlayer.gameTable.addSet(card, false); // face caché car fini
  536. }
  537. });
  538. }
  539. }
  540.  
  541. /**
  542. * Effectue les opérations nécessaires après qu'une action ai été effectuée dont la vérification si la partie est terminée
  543. * @param {Game} game Partie en cours
  544. * @param {string} actionName Nom de l'action à vérifier
  545. * @param {Object} args Paramètres facultatifs de l'action à effectuer
  546. * @returns {boolean} true si action autorisée, false sinon
  547. */
  548. afterAction(game, actionName, args) {
  549. this.checkIsFinished(game); // La game est finie si oui=> TODO mettre fin a la game
  550. }
  551.  
  552. /**
  553. * Vérifie les conditions de fin de partie sont respectées
  554. * @param {Game} game Partie en cours
  555. * @returns {boolean} true si jeu doit être terminé, false sinon
  556. */
  557. checkIsFinished(game) {
  558. if (game.players.some(player => player.score > 16) && game.currentPlayer === game.players.length) {
  559. game.isFinished = true;
  560. return true;
  561. }
  562. }
  563.  
  564. /**
  565. * Classement des joueurs triés selon leur score final
  566. * @param {Game} game Partie en cours
  567. * @returns {Object[]} Tableau d'objets {user: User, pv: number, ecus: number, score: number} où score = pv + (1pv par tranche de 10 écus)
  568. */
  569. getRanking(game) {
  570. let result = [];
  571.  
  572. let sortedTab = game.players.sort(function (a, b) {
  573. return this.sortScore(a,b);
  574. });
  575.  
  576. sortedTab.forEach((player) => {
  577. let nbPvPerTenEcus = Math.round(player.inventory.find(item => item.ecus !== undefined).ecus / 10);
  578. result.push({user:player.user, pv:player.score, ecus:player.inventory.find(item => item.ecus !== undefined).ecus, score:player.score + nbPvPerTenEcus});
  579. });
  580. return result;
  581. }
  582.  
  583. /**
  584. * Compare deux joueurs selon leur score final
  585. * @param {Player} playerA Joueur A
  586. * @param {Player} playerB Joueur B
  587. * @returns {number} 1 si score final de A > B, 0 si scores finaux égaux, -1 si score final de B > A
  588. */
  589. sortScore(playerA, playerB) {
  590. let a = playerA.score;
  591. let b = playerB.score;
  592. let result = 0;
  593. if(a === b){
  594. a = playerA.pv;
  595. b = playerB.pv;
  596. if (a === b) {
  597. a = playerA.ecus;
  598. b = playerB.ecus;
  599. }
  600. }
  601. return a - b;
  602. }
  603. }
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!