示例#1
0
 public static void Merge(Hotel mergerHotel, List<Hotel> mergingHotels)
 {
     foreach (var hotel in mergingHotels)
     {
         DividePrizes(hotel);
         DecideStocks(hotel, mergerHotel);
     }
 }
示例#2
0
 public StockDecision(Player player, Hotel mergingHotel, Hotel mergerHotel, int keeping, int exchanging, int selling)
 {
     Player = player;
     MergingHotel = mergingHotel;
     MergerHotel = mergerHotel;
     TotalStocks = player.StockBank.NameStocksDictionary[mergingHotel.Name].Quantity;
     Keeping = keeping;
     Exchanging = exchanging;
     Selling = selling;
     Debug.Assert(this.Correct());
 }
示例#3
0
 public static void Initialize()
 {
     HotelsList = new List<Hotel>();
     HotelNameHotelDictionary = new Dictionary<string, Hotel>();
     foreach (string hotelName in Hotel.HOTEL_NAMES)
     {
         var hotel = new Hotel(hotelName);
         HotelsList.Add(hotel);
         HotelNameHotelDictionary.Add(hotelName, hotel);
     }
     StockBank = new StockBank();
     StockBank.Fill();
 }
示例#4
0
 public void PlayerPutsCard(Player player, TileCard card, TileCardEffect effect, Hotel involvedHotel)
 {
     Log(string.Format("{0}: {1} puts {2}", nameof(PlayerPutsCard), player, card));
 }
 public StockDecision GetStockDecision(Player player, Hotel mergingHotel, Hotel mergerHotel)
 {
     return new StockDecision(player, mergingHotel, mergerHotel, player.StockBank.NameStocksDictionary[mergingHotel.Name].Quantity, 0, 0);
 }
示例#6
0
 /// <summary>
 /// Gets the current size of a hotel on board.
 /// </summary>
 /// <param name="hotel">The hotel to be checked.</param>
 /// <returns>The size of the selected hotel.</returns>
 public static int GetHotelSize(Hotel hotel)
 {
     // Maybe need to add hotel-group dictionary to the board.
     TileGroup group = Board.TileGroups.FirstOrDefault(tg => tg.Hotel == hotel);
     return group != null ? group.Size : 0;
 }
示例#7
0
 /// <summary>
 /// Setup a new hotel on board.
 /// </summary>
 /// <param name="card">The card who caused the setup.</param>
 /// <param name="involvedHotel">The hotel chosen to be setup.</param>
 private static void SetUp(TileCard card, Hotel involvedHotel)
 {
     card.Tile.Occupied = true;
     var group = new TileGroup(card.Tile) { Hotel = involvedHotel };
     SwallowGroups(card, group);
 }
示例#8
0
 /// <summary>
 /// Merge hotels to one big hotel on board.
 /// </summary>
 /// <param name="card">The tile card which caused the merge.</param>
 /// <param name="involvedHotel">The hotel which swallowes all his neighbor hotels.</param>
 private static void Merge(TileCard card, Hotel involvedHotel)
 {
     card.Tile.Occupied = true;
     TileGroup group = Board.TileGroups.FirstOrDefault(tg => tg.Hotel == involvedHotel);
     group.AddTiles(card.Tile);
     SwallowGroups(card, group);
 }
示例#9
0
 /// <summary>
 /// Enlarge a hotel on board.
 /// </summary>
 /// <param name="card">The tile card whose effect is enlarge.</param>
 /// <param name="involvedHotel"></param>
 private static void EnlageHotel(TileCard card, Hotel involvedHotel)
 {
     // Maybe need to add hotel-group dictionary to the board.
     card.Tile.Occupied = true;
     TileGroup group = Board.TileGroups.FirstOrDefault(tg => tg.Hotel == involvedHotel);
     group.AddTiles(card.Tile);
     SwallowGroups(card, group);
 }
示例#10
0
 /// <summary>
 /// Putting a tile card on board, by removing the card from the player's bank, 
 /// and calling the BoardManager to handle the effect the card has on the board.  
 /// </summary>
 /// <param name="player">The player who puts the tile card.</param>
 /// <param name="card">The tile card being put.</param>
 /// <param name="effect">Which effect the tile card has on the board.</param>
 /// <param name="involvedHotel">The main hotel that is being affected by putting the tile card:
 /// In case of enlarging an hotel, the involved hotel is the hotel being enlarged. In case of setting up a new hotel, the involved hotel
 /// is the hotel the player decided to setup. In case of a merge effect, the involved hotel is the main hotel that swallows all his neighbor hotels.</param>
 private static void PutCardOnBoard(Player player, TileCard card, TileCardEffect effect, Hotel involvedHotel)
 {
     player.TileCardBank.Remove(card);
     Output.PlayerPutsCard(player, card, effect, involvedHotel);
     BoardManager.HandleEffect(card, effect, involvedHotel);
 }
示例#11
0
 private static void DecideStocks(Hotel mergingHotel, Hotel mergerHotel)
 {
     Player decider = GameManager.CurrentPlayer;
     StockDecision decision;
     for (var i = 0; i < GameManager.NumberOfPlayers; i++)
     {
         decision = decider.DecideStocks(mergingHotel, mergerHotel);
         ProcessDecision(decision);
         decider = GameManager.GetNextPlayer(decider);
     }
 }
示例#12
0
 public static void BuyStocksFromPlayer(Player player, Hotel hotel, int quantity)
 {
     TakeStocksFromPlayer(player, hotel.Name, quantity);
     player.Cash += hotel.CurrentStockValue * quantity;
 }
示例#13
0
 private static void ExchangeStocks(Player player, Hotel mergingHotel, Hotel mergerHotel, int mergingHotelStocksExchangedNumber)
 {
     Debug.Assert(mergingHotelStocksExchangedNumber % 2 == 0);
     TakeStocksFromPlayer(player, mergingHotel.Name, mergingHotelStocksExchangedNumber);
     GiveStocksToPlayer(player, mergerHotel.Name, mergingHotelStocksExchangedNumber / 2);
 }
示例#14
0
        private static void DividePrizes(Hotel hotel)
        {
            int firstPrize = hotel.CurrentStockValue * 10;
            int secondPrize = firstPrize / 2;

            List<Player> firstPrizeReceivers = new List<Player>();
            List<Player> secondPrizeReceivers = new List<Player>();
            var stocksHolders = GameManager.Players.Where(p =>
                p.StockBank.NameStocksDictionary[hotel.Name].Quantity > 0).OrderByDescending(p =>
                p.StockBank.NameStocksDictionary[hotel.Name].Quantity).Select(p =>
                    new { Player = p, Quantity = p.StockBank.NameStocksDictionary[hotel.Name].Quantity }).ToList();
            foreach (var p in stocksHolders.Where(p => p.Quantity == stocksHolders.First().Quantity))
            {
                firstPrizeReceivers.Add(p.Player);
            }
            if (stocksHolders.Any(p => p.Quantity != stocksHolders.First().Quantity))
            {
                foreach (var pl in stocksHolders.Where(pl => pl.Quantity == stocksHolders.First(p =>
                    p.Quantity != stocksHolders.First().Quantity).Quantity))
                {
                    secondPrizeReceivers.Add(pl.Player);
                }
            }
            else
                secondPrizeReceivers.AddRange(firstPrizeReceivers);

            foreach (var p in firstPrizeReceivers)
                GivePrize(p, firstPrize, true);
            foreach (var p in secondPrizeReceivers)
                GivePrize(p, secondPrize, false);
        }
示例#15
0
 public void PlayerSetsUpHotel(Player player, Hotel setUpHotel)
 {
     Log(string.Format("{0}: {1} sets up {2}", nameof(PlayerSetsUpHotel), player, setUpHotel));
 }
示例#16
0
 /// <summary>
 /// Handles the effect of a newly put tile card on the board.
 /// This method happens after all the prerequisites for putting the new card are met. 
 /// </summary>
 /// <param name="card">The newly put tile card.</param>
 /// <param name="effect">The effect this tile card has on the board, which was calculated earlier.</param>
 /// <param name="involvedHotel">The main hotel that is being affected by putting the tile card:
 /// In case of enlarging an hotel, the involved hotel is the hotel being enlarged. In case of setting up a new hotel, the involved hotel
 /// is the hotel the player decided to setup. In case of a merge effect, the involved hotel is the main hotel that swallows all his neighbor hotels.</param>
 public static void HandleEffect(TileCard card, TileCardEffect effect, Hotel involvedHotel)
 {
     switch (effect)
     {
         case TileCardEffect.None:
             PutTile(card);
             break;
         case TileCardEffect.Enlarge:
             EnlageHotel(card, involvedHotel);
             break;
         case TileCardEffect.SetUp:
             SetUp(card, involvedHotel);
             break;
         case TileCardEffect.Merge:
             Merge(card, involvedHotel);
             break;
         default:
             Debug.Fail("Unknown effect");
             break;
     }
     Debug.Assert(card.Tile.Occupied == true, "Tile is not occupied as it should be.");
 }
示例#17
0
 public StockDecision DecideStocks(Hotel mergingHotel, Hotel mergerHotel)
 {
     var decision = (StockDecision)GameManager.Input.GetStockDecision(this, mergingHotel, mergerHotel);
     GameManager.Output.PlayerStockDecision(this, decision);
     return decision;
 }
示例#18
0
 /// <summary>
 /// Initialization of some static fields.
 /// </summary>
 public static void Initialize()
 {
     Neutral = new Hotel(HOTEL_NAME_NEUTRAL);
     HOTEL_NAMES = new List<string>{
     HOTEL_NAME_EUROPLAZA,
     HOTEL_NAME_CONTINENTAL,
     HOTEL_NAME_OLYMPIA,
     HOTEL_NAME_PARK,
     HOTEL_NAME_LASVEGAS,
     HOTEL_NAME_REVIERA,
     HOTEL_NAME_HOLIDAY  };
 }