Exemple #1
0
 /**
  * Moves the robber to the specified HexLocation, and retrieves the players that own municipals
  * next to that hex, excluding those that don't have resources to steal and the player that moved
  * the robber
  *
  * @pre canDoMoveRobberToHex != null
  * @param hex
  * @throws Exception
  * @return array of Players that are adjacent to the new Robber Hex, that have resources to steal.
  */
 public Player[] moveRobberToHex(int UserId, HexLocation hexLocation) throws Exception {
   if (canDoMoveRobberToHex(UserId, hexLocation) == false) {
     throw new Exception("Cannot move Robber to that Hex");
   }
   board.moveRobberToHex(hexLocation);
   Hex hex = board.getHex(hexLocation);
   Vertex[] adjacentVertices = hex.getAdjacentVertices();
   ArrayList<Integer> adjacentPlayerIDs = new ArrayList<Integer>();
   ArrayList<Player> adjacentPlayers = new ArrayList<Player>();
   for (Vertex vertex : adjacentVertices) {
     // If the vertex has a municipal, that municipal is not owned by the player moving the robber
     // and the Player is not already in the list, and the Player has resources to be stolen
     if (vertex.getMunicipal() != null) {
       int municipalID = vertex.getMunicipal().getPlayer().getPlayerIndex();
       Player player = vertex.getMunicipal().getPlayer();
       if (vertex.hasMunicipal()
           && UserId != municipalID
           && !adjacentPlayerIDs.contains(municipalID)
           && player.getResourceCardHandSize() > 0) {
         adjacentPlayerIDs.add(municipalID);
         adjacentPlayers.add(player);
       }
     }
   }
   // Convert the found players into an array to return
   Player[] players = new Player[adjacentPlayers.size()];
   return adjacentPlayers.toArray(players);
 }
Exemple #2
0
  public void addPlayer(int userID, CatanColor playerColor) {

    System.out.println("Game.addPlayer");
    if (players == null) players = new Player[numberofPlayers];

    int playerCount = 0;
    while (players[playerCount] != null) {
      playerCount++;
      if (playerCount == 4) {
        break;
      }
    }

    System.out.println("Player count == " + playerCount);

    if (playerCount < 4) {
      System.out.println("Adding new player.");
      Player p = new Player(playerCount, bank);
      p.setPlayerId(userID);
      p.setPlayerColor(playerColor);
      players[playerCount] = p;
    }

    if (playerCount == 4) {
      System.out.println("Beginning game.");
      status = "FirstRound";
    }
  }
Exemple #3
0
 /**
  * This method stands to show if the player CAN use one of his/her un-used dev Cards of the type
  * you ask it about.
  *
  * @param devCardType
  * @return
  */
 public boolean canDoPlayerUseDevelopmentCard(int userID, DevCardType devCardType) {
   // We need to be able to measure how long a player has owned a card.
   if (currentPlayer.getPlayerId() == userID) {
     return currentPlayer.canDoPlayDevelopmentCard(turnNumber, devCardType);
   }
   return false;
 }
Exemple #4
0
 /**
  * Will return the number of the specified resource that the player currently has
  *
  * @pre None
  * @param resourceType
  * @return the number of the specified resource that the player currently has
  */
 public int getNumberResourcesOfType(int UserId, ResourceType resourceType) {
   Player player = getPlayerByID(UserId);
   if (player != null) {
     return player.getNumberResourcesOfType(resourceType);
   }
   return 0;
 }
Exemple #5
0
 public int getNumberOfSoldiersPlayed(int userID) {
   Player player = getPlayerByID(userID);
   if (player == null) {
     return -1;
   }
   return player.getNumberOfSoldiersPlayed();
 }
Exemple #6
0
 /**
  * This method will cycle through the array of players and will rotate them through the
  * currentPlayer so the turns can proceed. This will be helpful when the index of the player array
  * is [3] and we need to bring it back to [0] showing that that person is next.
  *
  * @pre the players array is not null
  * @post the next player is set.
  */
 public void incrementPlayer() {
   // If we are done with the first two rounds of the Game (for setup
   for (int i = 0; i < numberofPlayers; i++) {
     if (currentPlayer.getPlayerIndex() == players[i].getPlayerIndex()) {
       // players[i] = currentPlayer; // This should probably be omitted
       // If we are no longer in the setup phase
       if (turnNumber > 1) {
         if (i == numberofPlayers - 1) {
           setCurrentPlayer(players[0]);
           currentPlayer.setHasDiscarded(false);
           turnNumber++;
           versionNumber++;
           status = "Rolling";
           return;
         } else {
           setCurrentPlayer(players[i + 1]);
           currentPlayer.setHasDiscarded(false);
           versionNumber++;
           status = "Rolling";
           return;
         }
       }
       // We must still be in the setup phase
       else {
         // We are still in the first round
         if (turnNumber == 0) {
           // If we are on the last person in the round, he/she gets to go again
           if (i == numberofPlayers - 1) {
             // setCurrentPlayer(players[numberofPlayers - 1]); // Could probably omit this line
             turnNumber++;
             versionNumber++;
             status = "SecondRound";
             return;
           } else {
             setCurrentPlayer(players[i + 1]);
             versionNumber++;
             return;
           }
         }
         // We are still in the second round
         else if (turnNumber == 1) {
           if (i == 0) {
             setCurrentPlayer(players[0]);
             // inSetUpPhase = false;
             turnNumber++;
             versionNumber++;
             status = "Rolling";
             return;
           } else {
             setCurrentPlayer(players[i - 1]);
             versionNumber++;
             return;
           }
         }
       }
     }
   }
 }
Exemple #7
0
 /**
  * The players all collect resources on the specified rollValue, from the given Bank
  *
  * @param rollValue
  * @throws Exception
  */
 private void playersCollectResources(int rollValue) throws Exception {
   if (players == null) {
     throw new Exception("The players Array is null, cannot have players collect Resources");
   }
   for (Player player : players) {
     player.collectResources(rollValue, bank);
     versionNumber++;
   }
 }
Exemple #8
0
  /**
   * This method does the actual trade by interacting with the bank and the Current Player to
   * ascertain the port type and what if they can trade or not.
   *
   * @pre the resource types it receives are valid, and that tradeIn is what the player performing
   *     the trade already has
   * @throws Exception
   */
  public void doMaritimeTrade(ResourceType tradeIn, ResourceType receive) throws Exception {

    if (canDoPlayerDoMaritimeTrade(tradeIn, receive)) {

      ResourceCard[] tradingCards = currentPlayer.prepareBankTrade(tradeIn);

      bank.playerTurnInResources(tradingCards);

      currentPlayer.getResourceCardHand().addCard(bank.playerTakeResource(receive));

    } else throw new Exception("Cannot do Maritime Trade");
  }
Exemple #9
0
 /**
  * Checks whether the Specified User can Steal from the Specified Victim
  *
  * @pre None
  * @param UserId
  * @param victimId
  * @return whether the Specified User can Steal from the Specified Victim
  */
 public boolean canDoStealPlayerResource(int UserId, int victimId) {
   // Check if the user is the current player
   if (UserId != currentPlayer.getPlayerId()) {
     return false;
   }
   if (UserId == victimId) {
     return false;
   }
   Player victim = getPlayerByID(victimId);
   if (victim == null || victim.getResourceCardHandSize() <= 0) {
     return false;
   }
   return true;
 }
  @Test
  public void testgoodInput() {
    FinishTurnInput input = new FinishTurnInput(0);
    Player testPlayer = model.getPlayer(new PlayerID(0));
    try {
      // (int soldier, int monument, int monopoly, int yearOfPlenty, int roadBuild)
      testPlayer.getPlayerBank().setDC(new DevelopmentHand(0, 0, 0, 0, 0));
      testPlayer.getPlayerBank().addNewDC(new DevelopmentHand(1, 1, 1, 1, 1));
    } catch (BankException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    FinishTurnCommand command = new FinishTurnCommand();
    command.setGameModel(model);
    try {
      model = (GameModel) command.execute(new ObjectMapper().writeValueAsString(input));
    } catch (JsonProcessingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    assertEquals(testPlayer.getPlayerBank().getMonopoly().getQuantity(), 1);
    assertEquals(testPlayer.getPlayerBank().getMonument().getQuantity(), 1);
    assertEquals(testPlayer.getPlayerBank().getRoadBuild().getQuantity(), 1);
    assertEquals(testPlayer.getPlayerBank().getSoldier().getQuantity(), 1);
    assertEquals(testPlayer.getPlayerBank().getYearOfPlenty().getQuantity(), 1);
    assertEquals(testPlayer.getPlayerBank().getNewMonopoly().getQuantity(), 0);
    assertEquals(testPlayer.getPlayerBank().getNewMonument().getQuantity(), 0);
    assertEquals(testPlayer.getPlayerBank().getNewRoadBuild().getQuantity(), 0);
    assertEquals(testPlayer.getPlayerBank().getNewSoldier().getQuantity(), 0);
    assertEquals(testPlayer.getPlayerBank().getNewYearOfPlenty().getQuantity(), 0);

    assertEquals(testPlayer.getPlayerFacade().canBeRobbed(), true);
  }
Exemple #11
0
  /**
   * This method Uses a development card and marks it as played
   *
   * @param devCardType is valid and you own that card
   * @return whether or not you just won the game
   * @throws Exception
   */
  public boolean useMonumentCard(int userID, DevCardType devCardType) throws Exception {
    if (currentPlayer.getPlayerId() == userID) {

      if (currentPlayer.canDoPlayDevelopmentCard(turnNumber, devCardType)) {
        // Marks the card as played
        currentPlayer.playDevelopmentCard(turnNumber, devCardType);
        currentPlayer.setHasPlayedDevCardThisTurn(true);

        // Now do what monuments do:
        currentPlayer.incrementVictoryPoints();
        setVersionNumber(versionNumber++);
        return doWeHaveAWinner();
      } else throw new Exception("Cannot Play Monument card!");
    } else throw new Exception("Cannot Play Monument card, you are not the current Player!");
  }
Exemple #12
0
 /**
  * The Specified Player will discard the specified number of Resource Cards back to the bank from
  * his hand
  *
  * @pre canDoDiscardNumberOfResourceType != false
  * @param UserId
  * @param numberToDiscard
  * @param resourceType
  * @throws Exception
  * @post The Specified Player will have discarded the specified number of Resource Cards back to
  *     the bank from his hand
  */
 public void discardNumberOfResourceType(
     int UserId, int numberToDiscard, ResourceType resourceType) throws Exception {
   getPlayerByID(UserId).discardResourcesOfType(resourceType, numberToDiscard);
   getPlayerByID(UserId).setHasDiscarded(true);
   status = "Robbing";
   System.out.println("Status: " + status);
   // If there is any player that has more than 7 cards and has not yet discarded this turn
   // must discard, so we set the game status to "Discarding"
   for (Player player : players) {
     if (player.getResourceCardHandSize() > 7 && player.isHasDiscarded() == false) {
       status = "Discarding";
       System.out.println("Status: " + status);
     }
   }
 }
Exemple #13
0
 /**
  * Retrieves whether the Robber can be moved to the specified hexLocation
  *
  * @pre board != null
  * @param hex
  * @return whether the Robber can be moved to the specified hexLocation
  */
 public boolean canDoMoveRobberToHex(int UserId, HexLocation hexLocation) {
   // Check if the user is the current player
   if (UserId != currentPlayer.getPlayerId()) {
     return false;
   }
   return board.canDoMoveRobberToHex(hexLocation);
 }
Exemple #14
0
 /**
  * The art of placing a settlement on the vertex.
  *
  * @pre the Can do is true
  * @param vertexLocation
  * @throws Exception
  * @post a settlement is placed on a vertex
  */
 public void placeSettlementOnVertex(int UserId, VertexLocation vertexLocation) throws Exception {
   if (canDoPlaceSettlementOnVertex(UserId, vertexLocation) == false) {
     throw new Exception(
         "Cannot build Settlement on this vertex, this should not have been allowed to get this far.");
   }
   // If we are in the first two rounds of the game
   if (turnNumber < 2) {
     board.placeInitialSettlementOnVertex(currentPlayer, vertexLocation);
     versionNumber++;
     // Here we collect the resources for the second placed settlement in setup round
     if (turnNumber == 1) {
       Hex[] adjacentHexes = board.getVertex(vertexLocation).getAdjacentHexes();
       for (Hex hex : adjacentHexes) {
         if (hex != null) {
           ResourceType hexResourceType = hex.getHexResourceType();
           ResourceCard card = bank.playerTakeResource(hexResourceType);
           currentPlayer.getResourceCardHand().addCard(card);
         }
       }
     }
   } else {
     board.placeSettlementOnVertex(currentPlayer, vertexLocation);
     versionNumber++;
   }
 }
Exemple #15
0
 /**
  * Can we place a settlement on that vertex?
  *
  * @pre the vertex location is not null
  * @param vertexLocation
  * @post it tells you whether or not you can build a Settlement on that vertex
  */
 public boolean canDoPlaceSettlementOnVertex(int UserId, VertexLocation vertexLocation) {
   // Check if the user is the current player
   if (UserId != currentPlayer.getPlayerId()) {
     return false;
   }
   return board.canDoPlaceSettlementOnVertex(currentPlayer, vertexLocation);
 }
Exemple #16
0
 /**
  * This card is special because it is the only development card that references the bank, so
  * additional checks need to be made, and so for security reasons it gets its own method to do so.
  */
 public boolean canDoPlayerUseYearOfPlenty(ResourceType[] resourceType, int userID) {
   // This is important because the bank not have the cards they need.
   if (currentPlayer.getPlayerId() == userID) {
     if (resourceType.length == 1) {
       if (!canDoPlayerTake2OfResource(resourceType[0])) {
         return false;
       }
     } else {
       for (int i = 0; i < resourceType.length; i++) {
         if (!bank.canDoPlayerTakeResource(resourceType[i])) return false;
       }
     }
     return currentPlayer.canDoPlayDevelopmentCard(turnNumber, DevCardType.YEAR_OF_PLENTY);
   }
   return false;
 }
Exemple #17
0
 /**
  * Asks the player if he or she can build a settlement and tells the client that.
  *
  * @return
  */
 public boolean canDoPlayerBuildSettlement(int UserId) {
   if (!isPlayersTurn(UserId)) {
     return false;
   }
   if (turnNumber == 0) {
     if (currentPlayer.getNumberUnplayedSettlements() != 5) {
       return false;
     }
     return true;
   } else if (turnNumber == 1) {
     if (currentPlayer.getNumberUnplayedSettlements() != 4) {
       return false;
     }
     return true;
   }
   return currentPlayer.canDoBuySettlement();
 }
Exemple #18
0
 /**
  * The Specified User will Steal a Random ResourceCard from the specified Victim
  *
  * @pre canDoStealPlayerResource != false
  * @param UserId
  * @param victimId
  * @throws Exception
  * @post the Victim will have one less Resource Card, which the User will now have in possession
  */
 public void stealPlayerResource(int UserId, int victimId) throws Exception {
   if (canDoStealPlayerResource(UserId, victimId) == false) {
     throw new Exception("canDoStealPlayerResource == false");
   }
   currentPlayer.stealPlayerResource(getPlayerByID(victimId));
   status = "Playing";
   versionNumber++;
 }
Exemple #19
0
 public void setLargestArmy(Player largestArmy) {
   // Take the largest army away from the other player if he has it
   if (this.largestArmy != null) {
     this.largestArmy.setHasLargestArmy(false);
   }
   // Give to new player
   this.largestArmy = largestArmy;
   largestArmy.setHasLargestArmy(true);
 }
Exemple #20
0
 /**
  * This method polls the player to see if the player can build a road and then returns the result
  * to that which called it (most likely the client)
  *
  * @return a true or false to if the player can build a road there.
  */
 public boolean canDoPlayerBuildRoad(int UserId) {
   if (!isPlayersTurn(UserId)) {
     return false;
   }
   if (turnNumber == 0) {
     if (currentPlayer.getNumberUnplayedRoads() != 15) {
       return false;
     }
     return true;
   } else if (turnNumber == 1) {
     if (currentPlayer.getNumberUnplayedRoads() != 14) {
       return false;
     }
     return true;
   } else {
     return currentPlayer.canDoBuyRoad();
   }
 }
Exemple #21
0
 public void setLongestRoad(Player longestRoad) {
   // Take the longest road away from the other player if he has it
   if (this.longestRoad != null) {
     this.longestRoad.setHasLongestRoad(false);
   }
   // Give to new player
   this.longestRoad = longestRoad;
   longestRoad.setHasLongestRoad(true);
 }
Exemple #22
0
 public void setRollDice(int UserId, int rollValue) throws Exception {
   if (canDoRollDice(UserId) == false) {
     throw new Exception("canDoRollDice == false");
   }
   if (rollValue == 7) {
     status = "Robbing";
     // If there is any player that has more than 7 cards and has not yet discarded this turn
     // must discard, so we set the game status to "Discarding"
     for (Player player : players) {
       if (player.getResourceCardHandSize() > 7 && player.isHasDiscarded() == false) {
         status = "Discarding";
       }
     }
   } else {
     status = "Playing";
     playersCollectResources(rollValue);
   }
   versionNumber++;
 }
Exemple #23
0
 public void placeRoadOnEdge(int userId, EdgeLocation edgeLocation, boolean usingRoadBuilder)
     throws Exception {
   if (canDoPlaceRoadOnEdge(userId, edgeLocation) == false) {
     throw new Exception("Specified Player cannot place a road on the given edgeLocation");
   }
   // If we are in the setup phase, the rules for placing a road are slightly different
   if (usingRoadBuilder == true) {
     if (currentPlayer.getPlayerId() == userId
         && currentPlayer.canDoPlayDevelopmentCard(turnNumber, DevCardType.ROAD_BUILD)
         && currentPlayer.getNumberUnplayedRoads() >= 2) {
       board.placeRoadBuildRoadOnEdge(getCurrentPlayer(), edgeLocation);
       versionNumber++;
     } else {
       throw new Exception("Unable to play Road Builder!");
     }
   } else {
     board.placeRoadOnEdge(getCurrentPlayer(), edgeLocation);
     versionNumber++;
   }
 }
Exemple #24
0
 /**
  * TODO - Verify Completion
  *
  * <p>Checks to see if the given Player can place a road on the specified edge
  *
  * @pre None
  * @param UserId
  * @param edgeLocation
  * @return whether the Specified player can place a road on the specified edge
  */
 public boolean canDoPlaceRoadOnEdge(int UserId, EdgeLocation edgeLocation) {
   // Check if the user is the current player
   if (UserId != currentPlayer.getPlayerId()) {
     System.out.println("Game1: false");
     return false;
   }
   // If we are in the setup phase, the rules for placing a road are slightly different
   if (turnNumber == 0) {
     if (currentPlayer.getNumberUnplayedRoads() != 15) {
       return false;
     }
     return board.canDoPlaceInitialRoadOnEdge(getCurrentPlayer(), edgeLocation);
   } else if (turnNumber == 1) {
     if (currentPlayer.getNumberUnplayedRoads() != 14) {
       return false;
     }
     return board.canDoPlaceInitialRoadOnEdge(getCurrentPlayer(), edgeLocation);
   } else {
     return board.canDoPlaceRoadOnEdge(getCurrentPlayer(), edgeLocation);
   }
 }
Exemple #25
0
 /**
  * Does the player have cards to trade?
  *
  * @pre valid resource type
  * @param resourceType
  * @return yes you can trade or no you can't.
  */
 public boolean canTradeResourcesToBank(ResourceType resourceType) {
   // Does the Player have cards to trade?
   // Does the Player have a port?
   // Does the Player have enough cards to trade?
   int size = currentPlayer.getResourceCardHand().getNumberResourcesOfType(resourceType);
   int rate = getTradeRate(resourceType);
   if (size >= rate) {
     return true;
   } else {
     return false;
   }
 }
Exemple #26
0
 public int getIndexOfPlayer(Player player) {
   if (player == null) {
     return -1;
   }
   int index = -1;
   for (int i = 0; i < players.length; i++) {
     if (player.getPlayerId() == players[i].getPlayerId()) {
       index = i;
     }
   }
   return index;
 }
  @Test
  @Ignore
  public void testBuyDevCard() throws InvalidTypeException, Exception {
    final int guy = game.getCurrentTurn();
    game.setPhase(TurnTracker.Phase.DISCARDING);

    final ResourceCard one = game.getResourceCard(ResourceType.WHEAT);
    final ResourceCard two = game.getResourceCard(ResourceType.ORE);
    final ResourceCard three = game.getResourceCard(ResourceType.SHEEP);

    game.giveResource(one, guy);
    game.giveResource(two, guy);
    game.giveResource(three, guy);

    Player p = game.getPlayerManager().getPlayerByID(guy);
    final int sizeold = p.quantityOfDevCards();

    game.buyDevelopmentCard(guy);
    p = game.getPlayerManager().getPlayerByID(guy);
    final int sizenew = p.quantityOfDevCards();

    assertTrue(sizenew == sizeold + 1);
  }
Exemple #28
0
 /**
  * This method returns a 3, 4, or 2 depending on the port type you have, if any.
  *
  * @pre valid resource type
  * @return
  */
 public int getTradeRate(ResourceType resourceType) {
   return currentPlayer.getTradeRate(resourceType);
 }
Exemple #29
0
  public boolean useSoldierCard(int userID, PlaySoldier_Params params) {
    // Do they have more than three soldiers? Do they have the most soldiers? If so, award them the
    // Largest Army award (assuming they don't already have it) and take it from the previous title
    // holder
    // Must move robber to a different hex

    if (currentPlayer.getPlayerId() == userID) {

      if (currentPlayer.canDoPlayDevelopmentCard(turnNumber, DevCardType.SOLDIER)) {
        if (canDoStealPlayerResource(userID, params.getVictimIndex())) {

          try {
            moveRobberToHex(userID, params.getLocation());
            stealPlayerResource(userID, params.getVictimIndex());
            currentPlayer.playDevelopmentCard(turnNumber, DevCardType.SOLDIER);
            currentPlayer.setHasPlayedDevCardThisTurn(true);
          } catch (Exception e) {
            System.out.println(
                "Something went wrong when trying to move the robber or steal resources");
            e.printStackTrace();
          }

          boolean firstTime = true;

          // Initial selection of LargestArmy recipient.
          if (currentPlayer.getNumberOfSoldiersPlayed() == 3) {
            for (int i = 0; i < players.length; i++) {
              if (players[i].getPlayerId() != currentPlayer.getPlayerId()
                  && players[i].getNumberOfSoldiersPlayed() >= 3) {
                firstTime = false;
              }
            }
            if (firstTime) {
              indexOfLargestArmy = currentPlayer.getPlayerIndex();
              largestArmy = currentPlayer;
              currentPlayer.incrementVictoryPoints();
              currentPlayer.incrementVictoryPoints();
            }
          }
          int test = 0;
          // Check for competition
          if (currentPlayer.getNumberOfSoldiersPlayed() >= 3 && !firstTime) {
            if (currentPlayer.getNumberOfSoldiersPlayed() > largestArmy.getNumberOfSoldiersPlayed()
                && currentPlayer.getPlayerId() != largestArmy.getPlayerId()) {
              // indexOfLargestArmy = currentPlayer.getPlayerId();

              for (int i = 0; i < players.length; i++) {
                if (largestArmy.getPlayerId() == players[i].getPlayerId()) {
                  players[i].decrementVictoryPoints();
                  players[i].decrementVictoryPoints();
                }
              }

              largestArmy = currentPlayer;
              currentPlayer.incrementVictoryPoints();
              currentPlayer.incrementVictoryPoints();
            }
          }
          // Did the Largest Army award win the game?!
          setVersionNumber(versionNumber++);
          return doWeHaveAWinner();
        }
      }
    }
    return doWeHaveAWinner();
  }
Exemple #30
0
  /**
   * TODO Javadoc and Implement
   *
   * @param devCardType
   * @param resourceType
   * @return
   * @throws Exception
   */
  public boolean useDevelopmentCard(
      int userID, DevCardType devCardType, ResourceType[] resourceType) throws Exception {

    if (currentPlayer.getPlayerId() == userID) {

      if (currentPlayer.canDoPlayDevelopmentCard(turnNumber, devCardType)) {
        switch (devCardType) {
          case MONOPOLY:
            if (resourceType == null || resourceType.length > 1) {
              throw new Exception("Trying to use monopoly on more than one resource!");
            }
            // Declare a Resource the player wants, and then extract it from all players who have
            // it.
            for (int i = 0; i < players.length; i++) {
              if (players[i] != currentPlayer) {
                // If not the current player, ask the player for an Array list of it's resource card
                // of that type
                currentPlayer
                    .conformToMonopoly(resourceType[0])
                    .addAll(players[i].conformToMonopoly(resourceType[0]));
                players[i].conformToMonopoly(resourceType[0]).clear();
              }
            }
            currentPlayer.playDevelopmentCard(turnNumber, DevCardType.MONOPOLY);
            currentPlayer.setHasPlayedDevCardThisTurn(true);
            setVersionNumber(versionNumber++);
            return doWeHaveAWinner();
          case YEAR_OF_PLENTY:
            if (canDoPlayerUseYearOfPlenty(resourceType, userID)) {
              // Add two resources of the types specified to the currentPlayers hand
              if (resourceType.length == 1) {
                ResourceCard resource = bank.playerTakeResource(resourceType[0]);
                // some sneaky idea that realizes conformToMonopoly returns the arraylist of that
                // players cards of a specified type.
                currentPlayer.conformToMonopoly(resourceType[0]).add(resource);
                ;
                // repeat
                resource = bank.playerTakeResource(resource.getResourceType());
                currentPlayer.conformToMonopoly(resourceType[0]).add(resource);
              } else if (resourceType.length == 2) {
                for (int g = 0; g < resourceType.length; g++) {
                  ResourceCard resource = bank.playerTakeResource(resourceType[g]);
                  // some sneaky idea that realizes conformToMonopoly returns the arraylist of that
                  // players cards of a specified type.
                  currentPlayer.conformToMonopoly(resourceType[g]).add(resource);
                }
              }
              currentPlayer.playDevelopmentCard(turnNumber, DevCardType.YEAR_OF_PLENTY);
              currentPlayer.setHasPlayedDevCardThisTurn(true);
              setVersionNumber(versionNumber++);
              return doWeHaveAWinner();
            } else {
              throw new Exception("The bank has not what you seek.");
            }
          default:
            throw new Exception("Wrong declaration for a development card of this type.");
        }
      }
    } else {
      throw new Exception("You cannot use a development Card");
    }

    return doWeHaveAWinner();
  }