private void PayForLunchAndSetMarkers(DayOfWeek day)
{
foreach (PlayerBase player in Players)
{
int cost = 0;
Place visitedPlace = PublicBoard.VisitedPlaces[player][day];
if (visitedPlace is RestaurantPlace)
{
RestaurantPlace restaurant = visitedPlace as RestaurantPlace;
if (PublicBoard.RestaurantHasModifierForThisDay <OneDollarIncrease>(restaurant.Identifier, day))
{
cost++;
}
if (PublicBoard.RestaurantHasModifierForThisDay <OneDollarDiscount>(restaurant.Identifier, day))
{
cost--;
}
cost += restaurant.Cost;
if (cost >= 4 && player.Character == Character.CEO)
{
cost--;
}
}
PublicBoard.AddCashToPlayer(-cost, player);
}
;
}
private void ScorePreferencesAndLoyalty()
{
foreach (PlayerBase player in this.Players)
{
PublicBoard.SetUndesiredRestaurantOfTheWeek(player, _preferenceCards[player].Undesired);
LoyaltyCard loyalty = _loyaltyCards[player];
int visitsToLoyalty = 0;
foreach (DayOfWeek day in Extensions.Weekdays)
{
if (PublicBoard.VisitedPlaces[player][day] is RestaurantPlace && (PublicBoard.VisitedPlaces[player][day] as RestaurantPlace).Identifier == loyalty.Restaurant)
{
visitsToLoyalty++;
}
if (PublicBoard.RestaurantWithMajority(day) == _preferenceCards[player].FirstPreference && PublicBoard.IsPlayerInMajority(day, player))
{
PublicBoard.AddVictoryPointsToPlayer(_preferenceCards[player].FirstPreferenceBonus, player, VictoryPointsSource.PreferenceCard);
}
if (PublicBoard.RestaurantWithMajority(day) == _preferenceCards[player].SecondPreference && PublicBoard.IsPlayerInMajority(day, player))
{
PublicBoard.AddVictoryPointsToPlayer(_preferenceCards[player].SecondPreferenceBonus, player, VictoryPointsSource.PreferenceCard);
}
if (PublicBoard.Restaurants[_preferenceCards[player].Undesired].Visitors[day].Contains(player))
{
ApplyPunishment(_preferenceCards[player].Punishment, player);
}
if (PublicBoard.IsPlayerAlone(day, player.Left))
{
ApplyPunishment(_preferenceCards[player].SideBan, player.Left);
}
if (PublicBoard.IsPlayerAlone(day, player.Right))
{
ApplyPunishment(_preferenceCards[player].SideBan, player.Right);
}
}
PublicBoard.AddVictoryPointsToPlayer(loyalty.VictoryPoints[visitsToLoyalty], player, VictoryPointsSource.LoyaltyCard);
switch (_loyaltyCards[player].Type)
{
case LoyaltyType.VIP:
LoyaltyCardVIP cardVIP = _loyaltyCards[player] as LoyaltyCardVIP;
if (visitsToLoyalty >= 2)
{
List <int> desserts = player.ChooseDessert(PublicBoard, DessertBuffet.TakeChoices(cardVIP.DessertOptions), cardVIP.DessertTakeCount);
List <DessertCard> chosenCards = this.DessertBuffet.RemoveDessertAtIndexes(desserts);
_dessertCards[player].AddRange(chosenCards);
}
break;
case LoyaltyType.GOLD:
LoyaltyCardGOLD cardGOLD = _loyaltyCards[player] as LoyaltyCardGOLD;
if (visitsToLoyalty >= 3)
{
PublicBoard.AddCashToPlayer(cardGOLD.ExtraCash, player);
}
break;
}
}
}
private void ScoreVPs(DayOfWeek day)
{
foreach (Restaurant restaurant in Extensions.Restaurants)
{
foreach (PlayerBase player in PublicBoard.Restaurants[restaurant].Visitors[day])
{
foreach (FoodType food in PublicBoard.FavoriteFood[player])
{
if (PublicBoard.Restaurants[restaurant].Menu.Contains(food))
{
PublicBoard.AddVictoryPointsToPlayer(1, player, VictoryPointsSource.Food);
}
}
}
}
Players.ActionForCharacter(Character.HR, player =>
{
if (PublicBoard.IsPlayerInMajority(day, player))
{
if (player.ShouldSwitchCashForVPAndTP(PublicBoard, -1, 1, 0))
{
PublicBoard.AddCashToPlayer(-1, player);
PublicBoard.AddVictoryPointsToPlayer(1, player, VictoryPointsSource.Character);
}
}
});
Players.ActionForCharacter(Character.Marketing, player =>
{
if (!PublicBoard.IsPlayerInMajority(day, player))
{
if (player.ShouldSwitchCashForVPAndTP(PublicBoard, -3, 2, 1))
{
PublicBoard.AddCashToPlayer(-3, player);
PublicBoard.AddVictoryPointsToPlayer(2, player, VictoryPointsSource.Character);
PublicBoard.AddTeamScore(1);
}
}
});
Players.ActionForCharacter(Character.Programmer, player =>
{
if (!PublicBoard.IsPlayerInMajority(day, player) && !PublicBoard.IsPlayerAlone(day, player))
{
PublicBoard.AddVictoryPointsToPlayer(3, player, VictoryPointsSource.Character);
}
});
Players.ActionForCharacter(Character.Environment, player =>
{
if (PublicBoard.VisitedPlaces[player][day].Menu.Contains(FoodType.Vegetarian))
{
PublicBoard.AddVictoryPointsToPlayer(2, player, VictoryPointsSource.Character);
}
});
}
private void ApplyPunishment(Punishment punishment, PlayerBase target)
{
switch (punishment.Type)
{
case PunishmentType.Cash:
if (PublicBoard.PlayerCash[target] < Math.Abs(punishment.Value))
{
PublicBoard.AddCashToPlayer(-PublicBoard.PlayerCash[target], target);
}
else
{
PublicBoard.AddCashToPlayer(punishment.Value, target);
}
break;
case PunishmentType.VictoryPoints:
PublicBoard.AddVictoryPointsToPlayer(punishment.Value, target, VictoryPointsSource.Punishment);
break;
}
}
private void ScorePlayerBonus()
{
foreach (PlayerBonusCard playerBonus in this.PublicBoard.CurrentPlayerBonuses)
{
foreach (PlayerBase player in this.Players)
{
if (playerBonus.HasCompletedForPlayer(player, PublicBoard))
{
this.PublicBoard.AddVictoryPointsToPlayer(playerBonus.Points, player, VictoryPointsSource.PlayerBonus);
if (player.Character == Character.WarehouseManager)
{
Restaurant restaurant = player.ChooseRestaurantToAdvanceTrack(PublicBoard);
if (this.PublicBoard.RestaurantTracks[restaurant].AdvancePlayer(player))
{
List <DessertCard> cards = new List <DessertCard>();
List <int> chosenCardIndex = player.ChooseDessert(this.PublicBoard, this.DessertBuffet.TakeChoices(this.PublicBoard.RestaurantTracks[restaurant].CardAmount), 1);
List <DessertCard> chosenCards = this.DessertBuffet.RemoveDessertAtIndexes(chosenCardIndex);
_dessertCards[player].AddRange(chosenCards);
}
}
if (player.Character == Character.Finance)
{
PublicBoard.AddCashToPlayer(4, player);
}
}
}
}
foreach (PlayerBase player in this.Players)
{
if (player.Character == Character.ForeignAffairs)
{
int count = PublicBoard.VisitedPlaces[player].Select(x => x.Value).Where(x => x is RestaurantPlace).Distinct().Count();
PublicBoard.AddVictoryPointsToPlayer(count.Fibonacci(), player, VictoryPointsSource.Character);
}
}
}
