You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

261 lines
7.6 KiB

  1. //Imports
  2. import Card from "./cards/Card.js";
  3. import ChooseColor from "./cards/special/ChooseColor.js";
  4. import Skip from "./cards/special/Skip.js";
  5. import PlusAmount from "./cards/special/PlusAmount.js";
  6. import Reverse from "./cards/special/Reverse.js";
  7. import Player from "./Player.js";
  8. import {CARD_COLORS, style} from "./uno.js";
  9. //Um generatePool zu exportieren, muss es in eine Klasse konvertiert werden
  10. export default class Game {
  11. //Erstellt ein Spiel mit SpielerAnzahl und Array mit Regeln, initialisiert dann das Spiel
  12. constructor(playerAmount, rules) {
  13. this._cardOnDeck = null; //Karte die auf dem Tisch liegt
  14. this._currentPlayer = -1; //Aktueller Spieler Index im Player Array
  15. this._direction = 1; //Spielrichtung
  16. this._players = []; //Array mit allen Spielern drin
  17. this._cardPool = []; //Pool aus Karten
  18. this._playerAmount = playerAmount; //Anzahl der Spieler
  19. this._rules = rules; //Array mit Regeln für das Spiel
  20. }
  21. //Richtet das Spiel ein
  22. initGame(){
  23. //CardPool wird generiert
  24. this._cardPool = this.generatePool();
  25. //Spieler werden erstellt
  26. this.createPlayers(this._playerAmount);
  27. }
  28. //Startet das Spiel
  29. start(){
  30. if(this._currentPlayer !== -1) return;
  31. //Wenn das Spiel noch nicht initialisiert wurde, initialisiere es
  32. if (this._cardPool.length === 0 || this._players.length === 0)
  33. this.initGame();
  34. let firstCardIndex = 0;
  35. let boolFirstSpecial = false;
  36. if (this._rules !== null){
  37. if('startCards' in this.rules)
  38. for (let i = 0; i < this.players.length; i++)
  39. this.players[i].drawCard(this.rules.startCards);
  40. if('firstPlaySpecial' in this.rules)
  41. boolFirstSpecial = this.rules.firstPlaySpecial;
  42. }
  43. if (!boolFirstSpecial){
  44. for (let i = 0; i < this.cardPool.length; i++){
  45. if (!(this.cardPool[i].name === 'R' || this.cardPool[i].name === 'S'
  46. || this.cardPool[i].name === 'CC' || this.cardPool[i].name === '+2'
  47. || this.cardPool[i].name === '+4')){
  48. firstCardIndex = i;
  49. break;
  50. }
  51. }
  52. }
  53. //Die Erste Karte wird auf den Tisch gelegt
  54. this._cardOnDeck = this._cardPool[firstCardIndex];
  55. this._cardPool.splice(firstCardIndex,1);
  56. //Karten Funktion der Karte auf dem Deck ausführen
  57. this.cardOnDeck.putSelf();
  58. }
  59. //
  60. gameLoop(){
  61. }
  62. //Gibt ein Array zurück mit allen Karten, die in einem Uno Spiel sind
  63. generatePool(){
  64. //Array wird erstellt, welches später zurückgegeben wird und alle Karten beinhaltet
  65. let pool = [];
  66. //Pool aus Karten generieren
  67. for (let k = 0; k < 2; k++) {
  68. //Special Karten werden hinzugefügt
  69. for (let j = 1; j < (CARD_COLORS.length); j++) {
  70. pool.push(new Reverse(CARD_COLORS[j], this)); // 8x Reverse
  71. pool.push(new PlusAmount(this, CARD_COLORS[j])); // 8x +2
  72. pool.push(new Skip(CARD_COLORS[j], this)); // 8x Skip
  73. if (k === 0) {
  74. pool.push(new ChooseColor(this)); // 4x ChooseColor
  75. pool.push(new PlusAmount(this)); // 4x +4
  76. }
  77. //Normale Karten werden hinzugefügt
  78. for (let i = 0; i <= 9; i++) {
  79. if (k === 1 && i === 0) continue;
  80. pool.push(new Card(i, CARD_COLORS[j], this)); // 76x (2x 4x 1-9 + 4x 0)
  81. }
  82. }
  83. }
  84. //Mischt das Array
  85. pool.sort(()=> Math.random() - 0.5);
  86. //Array mit Karten wird zurückgegeben
  87. return pool;
  88. }
  89. //Fügt die Spieler hinzu
  90. createPlayers(playerAmount){
  91. //Erstelle so viele Spieler, wie bei Erstellung des Spiels übergeben wurden
  92. for (let i = 0; i < playerAmount; i++){
  93. this._players.push(new Player("Player" + (i + 1), this));
  94. }
  95. }
  96. //Beendet den Zug des aktuellen Spielers und beginnt den Zug des nächsten Spielers
  97. nextTurn(){
  98. //Testet, ob Spiel Gewonnen
  99. for (let i = 0; i < this.players.length; i++){
  100. if(this.players[i].hand.length <= 0){
  101. //Breche den Loop ab
  102. return;
  103. }
  104. }
  105. //Wenn Zug nicht der Erste vom ganzen Spiel
  106. if(this.currentPlayer !== -1){
  107. //Aktuellen Spieler kann, darf nicht mehr Spielen
  108. this.players[this.currentPlayer].canPlay = false;
  109. this.players[this.currentPlayer].turn = false;
  110. }
  111. //nächster Spieler wird gesetzt
  112. this.currentPlayer = this.nextPlayer();
  113. this.players[this.currentPlayer].turn = true;
  114. //Aktualisiere das Deck des aktuellen Spielers, welche Karten er legen kann
  115. this.refreshCanPutCard();
  116. }
  117. //Testet alle Karten des aktuellen Spielers in seiner Hand, ob er sie legen kann
  118. refreshCanPutCard(){
  119. //Deck des aktuellen Spielers
  120. let currentPlayerCards = this.currentPlayerInstanz.hand;
  121. //Gehe alle Karten vom Deck durch
  122. for(let i = 0; i < currentPlayerCards.length; i++){
  123. //Wenn Farbe oder Zahl gleich oder eine Karte, die keine Farbe hat
  124. if(this._cardOnDeck.name.toString() === currentPlayerCards[i].name.toString() ||
  125. this.cardOnDeck.color === currentPlayerCards[i].color ||
  126. currentPlayerCards[i].color === CARD_COLORS[0] ||
  127. this.cardOnDeck.color === CARD_COLORS[0]) {
  128. //Aktualisiere den Wert der Karte, sodass sie gelegt werden kann
  129. this._players[this._currentPlayer].hand[i].canPut = true;
  130. //Der Spieler kann nun Karten legen
  131. this._players[this._currentPlayer].canPlay = true;
  132. } else {
  133. //Sonst setze den Wert der Karte so, dass sie nicht gelegt werden kann
  134. this._players[this._currentPlayer].hand[i].canPut = false;
  135. }
  136. }
  137. }
  138. //Errechne, wer der nächste Spieler ist
  139. nextPlayer(){
  140. if(this.currentPlayer === -1)
  141. return 0;
  142. //Anhand der Spielrichtung errechnen
  143. if(this._direction === 1)
  144. return (this._currentPlayer === this._players.length - 1) ? 0 : this._currentPlayer + 1; //bei normaler Richtung
  145. else
  146. return (this._currentPlayer === 0) ? this._players.length - 1 : this._currentPlayer - 1; //bei Invertierter Richtung
  147. }
  148. //Gib den Pool mit allen UnoKarten zurück
  149. get cardPool(){
  150. return this._cardPool;
  151. }
  152. //Gibt das Array mit allen Spielern des Spiels zurück
  153. get players(){
  154. return this._players;
  155. }
  156. //Gibt die aktuelle Karte auf dem Tisch zurück
  157. get cardOnDeck(){
  158. return this._cardOnDeck;
  159. }
  160. //Setzt die aktuelle Karte auf dem Tisch
  161. set cardOnDeck(card){
  162. this._cardOnDeck = card;
  163. }
  164. //Gibt den Index des aktuellen Spielers im players Array zurück
  165. get currentPlayer(){
  166. return this._currentPlayer;
  167. }
  168. //Gibt das Objekt des aktuellen Spielers zurück
  169. get currentPlayerInstanz(){
  170. return this._players[this.currentPlayer];
  171. }
  172. set currentPlayer(player){
  173. this._currentPlayer = player
  174. }
  175. //Gibt die aktuelle Ricktung zurück 1 = normal 2 = Invertiert
  176. get direction(){
  177. return this._direction;
  178. }
  179. set direction(direction){
  180. this._direction = direction;
  181. }
  182. get rules(){
  183. return this._rules;
  184. }
  185. }