def apply_peddler_effect(self, player: Player) -> None:
"""Apply the effect of a peddler (neutral or player) building."""
"""
Buy 1 cube (any resource but gold) from the stock with 1 denier.
"""
# Remark: Hard-coded! We don't use the tags <cost><n_deniers>-1 and <gain><CHOICES>... in <game_elements><buildings><player_buildings><player_building><secondary_effect>.
money_resource_cost, qty_cost = Money.money, -1 # type: MoneyResource, int
if player.current_money_resources[money_resource_cost] + \
qty_cost < 0: # Has the player enough money or resource?
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have enough money or resource as ' +
str(qty_cost) + ' ' + money_resource_cost.name + '(s) required.')
else:
resource_gain_choices, qty_gain = [resource for resource in Resource.resources.values()
if not resource.is_wild()], \
+1 # type: List[Resource], int
resource_gain = player.choose_buy_resource(money_resource_cost, qty_cost, resource_gain_choices,
qty_gain) # type: Resource
if resource_gain is None:
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' and had chosen to don\'t apply the effect.')
else:
print(indent(4) + player.name() + ' wants to consume ' + str(qty_cost) + ' ' +
money_resource_cost.name + '(s) to obtain ' + str(qty_gain) + ' ' + resource_gain.name + '(s).')
player.current_money_resources[money_resource_cost] += qty_cost
player.current_money_resources[resource_gain] += qty_gain
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' once the effect applied.')
def choose_buy_resource_multi(self, costs, resource_gain_choices,
qty_gain: int): # -> List[Resource]
# Remark: we only consider the case that costs is a List[Tuple[Money,int]] without resource and of length 2 or more.
possibilities = list(
Building.ABBREV_NO_USE_EFFECT) # type: List[str[1..qty_gain]]
abbrev_resource_name_resource = {
resource.get_name_abbreviation(): resource
for resource in resource_gain_choices
} # type: Dict[str[1], Resource] # E.g. {'F': food, ...}.
possibilities.extend([
''.join(resource_gain.get_name_abbreviation()
for resource_gain in list(resource_gain_choice))
for n_parts in range(1, qty_gain + 1)
for resource_gain_choice in itertools.
combinations_with_replacement(resource_gain_choices, n_parts)
])
print(
indent(4) + self.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) + '.')
response = input(
indent(4) + 'Do you want to consume either ' + ' or '.join(
str(qty_cost) + ' ' + money_resource_cost.name + '(s) for ' +
str(1 + i_costs) + ' resource(s)'
for i_costs, (money_resource_cost,
qty_cost) in enumerate(costs)) + ' ' +
Building.TXT_NO_USE_EFFECT + '? [' + '/'.join(possibilities) +
'] ') # type: str
response = self.check_response_in_possibilities(
response, possibilities, 5)
choose_buy_resource_multi = list()
if response != Building.ABBREV_NO_USE_EFFECT:
for abbrev_resource_name in response:
choose_buy_resource_multi.append(
abbrev_resource_name_resource[abbrev_resource_name])
return choose_buy_resource_multi
def print_buildings_by_location(self, n_indent: int) -> None:
"""Display the player buildings of the player that is the location of the buildings in the deck: in the pile, the hand and the discard (but neither along the road nor replaced) ."""
print(
indent(n_indent) + self.name() + ', location of your buildings: ')
for location in Location:
player_building_names_by_location = sorted([
player_building.name for player_building in
self.get_player_buildings_by_location(location)
]) # type: List[PlayerBuilding]
if player_building_names_by_location:
print(
indent(n_indent + 1) + location.name.lower() + ': ' +
TXT_SEPARATOR.join(player_building_names_by_location) +
'.')
def apply_primary_effect(self, player: Player) -> None:
"""Apply the (default) primary effect of a player building."""
print(
indent(3) + 'Primary effect of the player building ' +
self.txt_name_owner(True) + ' for a worker of the player ' +
player.name() + ': ' + self.primary_effect.text)
pass # Nothing to do!
def apply_no_cost_only_gain_effect(self, money_resources_gain, player: Player = None) -> None:
"""Apply the effect of a building for (the worker of) the player. This effect doesn't require any cost and give some gain; so, we don't ask it hte player want it and give him."""
if player is None:
player = self.color_player.player
money_resource, qty = money_resources_gain # type: Tuple[MoneyResource, int]
player.current_money_resources[money_resource] += qty
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) + '.')
def choose_n_batches_to_castle(self, n_max_batches_to_castle: int) -> int:
response = input(
indent(3) +
'How many batches do you want to offer to the castle? [0..' +
str(n_max_batches_to_castle) + '] ') # type: str
return self.check_response_in_interval(response, 0,
n_max_batches_to_castle, 4)
def apply_primary_effect(self, player: Player) -> None:
"""Apply the effect of a peddler neutral building."""
"""
Buy 1 cube (any resource but gold) from the stock with 1 denier.
"""
# Remark: Hard-coded! We don't use the tags <cost><n_deniers>-1 and <gain><CHOICES>... in <game_elements><buildings><neutral_buildings><neutral_building>.
print(indent(3) + 'Effect of the neutral building ' + self.name +
' for a worker of the player ' + player.name() + ': ' + self.primary_effect.text)
self.apply_peddler_effect(player)
def apply_secondary_effect(self) -> None:
"""Apply the secondary effect of this small production player building."""
super().apply_secondary_effect()
if self.current_n_cubes_into_area == 0:
print(
indent(4) +
'There is no cube left in this small production player building, the owner gets nothing.'
)
else:
self.current_n_cubes_into_area -= 1
print(
indent(4) + 'There is now ' +
str(self.current_n_cubes_into_area) +
' cube(s) into the area of this small production player building.'
)
self.apply_no_cost_only_gain_effect(
self.secondary_effect.money_resources_gain,
self.color_player.player)
def apply_secondary_effect(self) -> None:
"""Apply the secondary effect of a bank player building."""
"""
Buy 1 gold from the stock with 2 deniers.
"""
# Remark: Hard-coded! We don't use the tags <cost><n_deniers>-2 and <gain><n_gold_cubes>+1 in <game_elements><buildings><player_buildings><player_building><secondary_effect>.
super().apply_secondary_effect()
money_resource_cost, qty_cost = Money.money, -2 # type: Money, int
player = self.color_player.player # type: Player
if player.current_money_resources[money_resource_cost] + \
qty_cost < 0: # Has the player enough money or resource?
print(
indent(4) + player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have enough money or resource as '
+ str(qty_cost) + ' ' + money_resource_cost.name +
'(s) required.')
else:
resource_gain_choices, qty_gain = [
Resource.get_wild_resource()
], +1 # type: List[Resource], int
resource_gain = player.choose_buy_resource(
money_resource_cost, qty_cost, resource_gain_choices,
qty_gain) # type: Resource
if resource_gain is None:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and had chosen to don\'t apply the effect.')
else:
print(
indent(4) + player.name() + ' wants to consume ' +
str(qty_cost) + ' ' + money_resource_cost.name +
'(s) to obtain ' + str(qty_gain) + ' ' +
resource_gain.name + '(s).')
player.current_money_resources[money_resource_cost] += qty_cost
player.current_money_resources[resource_gain] += qty_gain
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' once the effect applied.')
def choose_n_provost_movement(self, n_min_provost_movements_player: int,
n_max_provost_movements_player: int) -> int:
response = input(
indent(3) + 'How long do you want to move the Provost? [' +
str(n_min_provost_movements_player) + '..' +
str(n_max_provost_movements_player) + '] ') # type: str
return self.check_response_in_interval(response,
n_min_provost_movements_player,
n_max_provost_movements_player,
4)
def apply_secondary_effect(self) -> None:
"""Apply the secondary effect of a gold mine player building."""
"""
Exchange 1 cube from your personal stock with 1 gold cube from the stock.
"""
# Remark: Hard-coded! We don't use the tags <cost><CHOICES>... and <gain><n_gold_cubes>+1... in <game_elements><buildings><player_buildings><player_building><secondary_effect>.
super().apply_secondary_effect()
money_resource_cost, qty_cost = None, -1 # type: Resource, int # None for any resource but we eliminate wild (to avoid the case to exchange 1 wild with 1 wild!).
money_resource_gain, qty_gain = Resource.get_wild_resource(
), +1 # type: Resource, int
player = self.color_player.player # type: Player
money_resource_cost_choices = [
money_resource
for money_resource, qty in player.current_money_resources.items()
if money_resource != Money.money and not money_resource.is_wild()
and qty + qty_cost >= 0
] # type: List[Resource] # All suffisant available resources excepted wild.
if not money_resource_cost_choices:
print(
indent(4) + player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have resource (wild is not considered) as '
+ str(qty_cost) + ' required.')
else:
# The player can have or not the choice of the resource.
if len(money_resource_cost_choices) == 1:
money_resource_cost = money_resource_cost_choices[0]
print(
indent(4) + player.name() + 'can only exchange resource ' +
money_resource_cost.name + ', and it is done.')
else:
money_resource_cost = player.choose_exchange_resource(
False, qty_cost, money_resource_cost_choices,
money_resource_gain, qty_gain)
# We apply the exchange.
player.current_money_resources[money_resource_cost] += qty_cost
player.current_money_resources[money_resource_gain] += qty_gain
print(
indent(4) + player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) + '.')
def apply_primary_effect(self, player: Player) -> None:
"""Apply the primary effect of a market player building."""
"""
Exchange 1 cube from your personal stock with 4 deniers.
"""
# Remark: Hard-coded! We don't use the tags <cost><CHOICES>... and <gain><n_deniers>+4... in <game_elements><buildings><player_buildings><player_building><primary_effect>.
super().apply_primary_effect(player)
money_resource_cost, qty_cost = None, -1 # type: Resource, int # None for any resource (including wild).
money_resource_gain, qty_gain = Money.money, +4 # type: Money, int
money_resource_cost_choices = [
money_resource
for money_resource, qty in player.current_money_resources.items()
if money_resource != Money.money and qty + qty_cost >= 0
] # type: List[Resource] # All suffisant available resources.
if not money_resource_cost_choices:
print(
indent(4) + player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have resource as '
+ str(qty_cost) + ' required.')
else:
# The player do not have to use the effect; otherwie, the exchange is applied.
money_resource_cost = player.choose_exchange_resource(
True, qty_cost, money_resource_cost_choices,
money_resource_gain, qty_gain)
# We apply the exchange if the player wants to do it.
if money_resource_cost is None:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and didn\'t use the effect.')
else:
player.current_money_resources[money_resource_cost] += qty_cost
player.current_money_resources[money_resource_gain] += qty_gain
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) + '.')
def apply_effect_multi(self, player: Player, all_costs, resource_gain_choices, single_qty_gain: int) -> None:
"""Apply an effect with several choices (e.g. primary effects of bank and peddler player buildings)."""
# :param all_costs: # type: List[Tuple[Money, int]] # Must be ordered!
# :param resource_gain_choices: # type: List[Resource]
costs = [(money_resource_cost, qty_cost) for (money_resource_cost, qty_cost) in all_costs
if player.current_money_resources[money_resource_cost] + qty_cost >= 0]
if not costs: # Has the player enough money or resource?
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have enough money or resource as ' +
'either ' + ' or '.join(str(qty_cost) + ' ' + money_resource_cost.name + '(s)'
for (money_resource_cost, qty_cost) in all_costs) + ' required.')
elif len(costs) == 1:
print(indent(4) + 'There exists only one choice according to money and resources you have.')
money_resource_cost, qty_cost = costs[0]
resource_gain = player.choose_buy_resource(money_resource_cost, qty_cost, resource_gain_choices,
single_qty_gain) # type: Resource
if resource_gain is None:
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' and had chosen to don\'t apply the effect.')
else:
print(indent(4) + player.name() + ' wants to consume ' +
str(qty_cost) + ' ' + money_resource_cost.name + '(s) to obtain ' +
str(single_qty_gain) + ' ' + resource_gain.name + '(s).')
player.current_money_resources[money_resource_cost] += qty_cost
player.current_money_resources[resource_gain] += single_qty_gain
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' once the effect applied.')
else:
resources_gain = player.choose_buy_resource_multi(costs, resource_gain_choices,
len(costs) * single_qty_gain)
if not resources_gain:
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' and had chosen to don\'t apply the effect.')
else:
money_resource_cost, qty_cost = costs[len(resources_gain) - 1] # costs must be ordered!
print(indent(4) + player.name() + ' wants to consume ' +
str(qty_cost) + ' ' + money_resource_cost.name + '(s).')
player.current_money_resources[money_resource_cost] += qty_cost
for resource_gain, qty_gain in collections.Counter(resources_gain).items(): # To group by resource.
print(indent(4) + player.name() + ' wants to obtain ' +
str(single_qty_gain * qty_gain) + ' ' + resource_gain.name + '(s).')
player.current_money_resources[resource_gain] += single_qty_gain * qty_gain
print(indent(4) + player.txt_name_money_resources_workers_PPs_deck(True, True, False, False, False) +
' once the effect applied.')
def check_response_in_interval(self, response: str, n_min: int, n_max: int,
n_indent: int) -> int:
"""Check that a (string) response is in an interval (of numeric values)."""
is_response_ok = False # type: bool
while not is_response_ok:
try:
response_ok = int(response) # type: int
is_response_ok = n_min <= response_ok <= n_max # Is in the interval?
except ValueError:
is_response_ok = False # Not a numeric.
if not is_response_ok:
response = input(indent(n_indent) + 'Please: ')
return response_ok
def choose_buy_castle_multi(self, costs,
castle_gain_choices): # -> List[Castle]
n_min_castle_gain = 0 # type: int
n_max_castle_gain = len(castle_gain_choices) # type: int
response = input(
indent(4) + 'How many tokens of parts of the castle among [' +
', '.join(castle.name for castle in castle_gain_choices) +
'] do you want to buy with: ' + ' or '.join(
str(qty_cost) + ' ' + money_resource_cost.name + '(s)'
for (money_resource_cost, qty_cost) in costs) + '? [' +
str(n_min_castle_gain) + '..' + str(n_max_castle_gain) +
'] ') # type: str
return castle_gain_choices[:self.check_response_in_interval(
response, n_min_castle_gain, n_max_castle_gain, 5)]
def choose_buy_resource(self, money_resource_cost: MoneyResource,
qty_cost: int, resource_gain_choices,
qty_gain: int) -> Resource:
possibilities = list(
Building.ABBREV_NO_USE_EFFECT) # type: List[str[1]]
abbrev_resource_name_resource = {
} # type: Dict[str[1], Resource] # E.g. {'F': food, ...}.
for resource in resource_gain_choices:
abbrev_resource_name = resource.get_name_abbreviation()
abbrev_resource_name_resource[abbrev_resource_name] = resource
possibilities.append(abbrev_resource_name)
print(
indent(4) + self.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) + '.')
response = input(
indent(4) + 'Do you want to consume ' + str(qty_cost) + ' ' +
money_resource_cost.name + '(s) to obtain ' + str(qty_gain) +
' resource ' + Building.TXT_NO_USE_EFFECT + '? [' +
'/'.join(possibilities) + '] ') # type: str
response = self.check_response_in_possibilities(
response, possibilities, 5)
return None if response == Building.ABBREV_NO_USE_EFFECT else abbrev_resource_name_resource[
response]
def choose_action(self, possible_actions):
self.print_buildings_by_location(3)
n_possible_actions = len(
possible_actions
) # type: int # >= 1 because it must contain the passing action.
if n_possible_actions == 1:
print(
indent(3) +
'You don\'t have any choice and you have to do the action: ' +
possible_actions[0][1])
return possible_actions[0]
else:
print(indent(3) + 'Here are all the possible action(s):')
for i_possible_actions, possible_action in enumerate(
possible_actions):
print(
indent(4) + str(i_possible_actions) + ': ' +
possible_action[1])
response = input(
indent(3) + 'Which action do you choose? [0..' +
str(n_possible_actions - 1) + '] ') # type: str
return possible_actions[self.check_response_in_interval(
response, 0, n_possible_actions - 1, 4)]
def choose_exchange_resource(self, can_no_use_effect: bool, qty_cost: int,
resource_cost_choices,
money_resource_gain: MoneyResource,
qty_gain: int) -> Resource:
abbrev_resource_name_resources = Resource.get_name_abbreviation_resources(
resource_cost_choices)
possibilities = list() # type: List[str[1]]
if can_no_use_effect:
possibilities.append(Building.ABBREV_NO_USE_EFFECT)
possibilities += list(abbrev_resource_name_resources.keys())
print(
indent(4) + self.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) + '.')
response = input(
indent(4) + 'Do you want to exchange ' + str(qty_cost) +
' of some resource with ' + str(qty_gain) + ' ' +
money_resource_gain.name +
(' or not use the effect ' +
Building.TXT_NO_USE_EFFECT if can_no_use_effect else '') + '? [' +
'/'.join(possibilities) + '] ') # type: str
response = self.check_response_in_possibilities(
response, possibilities, 5)
return None if response == Building.ABBREV_NO_USE_EFFECT else abbrev_resource_name_resources[
response]
def choose_construct_residence(
self, resource_costs,
i_road_buildings_on_road): # -> Optional[Tuple[int, Building]]
n_min_i_building = 0 # type: int
n_max_i_building = len(i_road_buildings_on_road) # type: int
response = input(
indent(4) + 'Which of your ' + str(n_max_i_building) +
' building(s) [' + ', '.join(
building_on_road.name
for (i_road, building_on_road) in i_road_buildings_on_road) +
'] do you want to choose (or ' + str(n_min_i_building) +
' if you don\'t want to use the effect)? [' +
str(n_min_i_building) + '..' + str(n_max_i_building) +
'] ') # type: str
response = self.check_response_in_interval(response, n_min_i_building,
n_max_i_building,
5) # type: int
return None if response == n_min_i_building else i_road_buildings_on_road[
response - 1]
def apply_effect_buy_castle_multi(self, player: Player, all_costs) -> None:
"""Apply the primary or secondary effect of a church player building that is buy Castle tokens with deniers."""
remaining_n_castle_tokens = Building.game_element.game.get_remaining_n_castle_tokens(
) # type: int
if remaining_n_castle_tokens == 0:
print(
indent(4) +
'The effect can\'t be applied because there are not tokens anymore in the castle.'
)
else:
# Display the tokens in the castle.
print(
indent(4) + 'The tokens in the castle are: ' +
TXT_SEPARATOR.join(
str(castle.current_n_castle_tokens) + ' of ' +
str(castle.n_prestige_pts) + ' prestige point(s) (' +
castle.name + ')'
for castle in Building.game_element.castle
if castle.current_n_castle_tokens > 0) + '.')
# Prepare costs and gains.
castle_gain_choices = [
castle for castle in Building.game_element.castle
for _counter in range(castle.current_n_castle_tokens)
] # type: List[Castle]
single_qty_gain = +1 # type: int # Unused. # Must be equals to one!
costs = [(money_resource_cost, qty_cost)
for (money_resource_cost, qty_cost) in all_costs
if player.current_money_resources[money_resource_cost] +
qty_cost >= 0]
n_choices = min(len(costs), len(castle_gain_choices)) # type: int
costs = costs[:n_choices]
castle_gain_choices = castle_gain_choices[:n_choices]
# Has the player enough money or resource?
if n_choices == 0:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, False, False, True, False) +
' and can\'t apply the effect because he/she doesn\'t have enough money or resource as '
+ 'either ' + ' or '.join(
str(qty_cost) + ' ' + money_resource_cost.name + '(s)'
for (money_resource_cost, qty_cost) in all_costs) +
' required.')
else:
castles_gain = player.choose_buy_castle_multi(
costs, castle_gain_choices)
if not castles_gain:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, False, False, True, False) +
' and had chosen to don\'t apply the effect.')
else:
n_castles_gain = len(castles_gain) # type: int
money_resource_cost, qty_cost = costs[
n_castles_gain -
1] # type: List[MoneyResource], int # costs must be ordered!
print(
indent(4) + player.name() + ' wants to consume ' +
str(qty_cost) + ' ' + money_resource_cost.name +
'(s).')
player.current_money_resources[
money_resource_cost] += qty_cost
for castle_gain, qty_gain in collections.Counter(
castles_gain).items(): # To group by castle part.
print(
indent(4) + player.name() + ' wants to obtain ' +
str(qty_gain) + ' ' + castle_gain.name +
'(s) each giving ' +
str(castle_gain.n_prestige_pts) +
' prestige point(s).')
player.current_n_prestige_pts += castle_gain.n_prestige_pts * qty_gain
castle_gain.current_n_castle_tokens -= qty_gain
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, False, False, True, False) +
' once the effect applied.')
def income_effect(self, income_phase: Phase = None) -> None:
"""Give some money to the player owing this hotel prestige building on the road."""
n_deniers = income_phase.n_deniers_if_hotel # type: int
print(indent(2) + self.color_player.player.name() + ' obtains ' + str(n_deniers) + ' ' + Money.money.name +
'(s) for a(n) ' + self.name + ' building along the road.')
self.color_player.player.current_money_resources[Money.money] += n_deniers
def apply_primary_effect(self, player: Player) -> None:
"""Apply the primary effect of a lawyer player building."""
"""
Construct a residential building by paying 1 food cube and turning over one of your cards along the road (except a Lawyer).
"""
# Remark: Hard-coded! We don't use the tags <cost><n_food_cubes>-1 and <gain><n_residence_to_construct>+1 AND algorithm... in <game_elements><buildings><player_buildings><player_building><primary_effect>.
super().apply_primary_effect(player)
print(
indent(4) + 'The road consists in: ' +
self.game_element.game.txt_road(False) + '.')
resource_cost, qty_cost = Resource.get_resource(
'food'), -1 # type: Resource, int
if player.current_money_resources[resource_cost] + \
player.current_money_resources[Resource.get_wild_resource()] + qty_cost < 0:
print(
indent(4) + player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and can\'t apply the effect because he/she doesn\'t have enough resource as '
+ str(qty_cost) + ' ' + resource_cost.name +
'(s) required (even by considering wild resource).')
else:
i_road_buildings_on_road = [
(i_road, building_worker[0])
for (i_road,
building_worker) in enumerate(self.game_element.game.road)
if building_worker[0].get_building_type() == BuildingType.
PLAYER and building_worker[0].color_player.player == player
and building_worker[0].can_be_a_residential_building
] # type: List[Tuple[PlayerBuilding]]
if not i_road_buildings_on_road:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and can\'t apply the effect because he/she has no building to be constructed as a residential building along the road.'
)
else:
resource_costs = None # type: List[Tuple[Resource, int]]
qty_current_resource_cost = player.current_money_resources[
resource_cost]
if qty_current_resource_cost == 0:
resource_costs = [(Resource.get_wild_resource(), qty_cost)]
elif qty_current_resource_cost >= abs(qty_cost):
resource_costs = [(resource_cost, qty_cost)]
else:
resource_costs = [(resource_cost,
-qty_current_resource_cost),
(Resource.get_wild_resource(),
qty_cost + qty_current_resource_cost)]
i_road_building_to_construct_as_residence = player.choose_construct_residence(
resource_costs, i_road_buildings_on_road)
if i_road_building_to_construct_as_residence is None:
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' and had chosen to don\'t apply the effect.')
else:
i_road = i_road_building_to_construct_as_residence[
0] # type: int
building_to_construct_as_residence = i_road_building_to_construct_as_residence[
1] # type: PlayerBuilding
print(
indent(4) + player.name() + ' wants to consume ' +
' and '.join(
str(qty_cost) + ' ' + resource_cost.name + '(s)'
for (resource_cost, qty_cost) in resource_costs) +
' to construct his/her ' +
i_road_building_to_construct_as_residence[1].name +
' building (the ' + ordinal_number(i_road + 1) +
' building along the road) as a residential building.')
for (resource_cost, qty_cost) in resource_costs:
player.current_money_resources[
resource_cost] += qty_cost
if self.game_element.game.road[i_road][1] is not None:
# Remark: building_to_construct_as_residence is equals to self.game_element.game.road[i_road][0].
self.game_element.game.road[i_road].append(
building_to_construct_as_residence)
self.game_element.game.road[i_road][
0] = player.get_residence_building()
player.deck[
building_to_construct_as_residence] = Location.REPLACED
print(
indent(4) + 'The road consists in: ' +
self.game_element.game.txt_road(False) + '.')
print(
indent(4) +
player.txt_name_money_resources_workers_PPs_deck(
True, True, False, False, False) +
' once the effect applied.')
def check_response_in_possibilities(self, response: str, possibilities,
n_indent: int) -> str:
"""Check that a (string) response is in a list of (str[1..2]) possibilities."""
while len(response) == 0 or response.upper() not in possibilities:
response = input(indent(n_indent) + 'Please: ')
return response.upper()
def apply_secondary_effect(self) -> None:
"""Apply the (default) secondary effect of a player building."""
print(
indent(3) + 'Secondary effect of the player building ' +
self.txt_name_owner(True) + ': ' + self.secondary_effect.text)
pass # Nothing to do!
def apply_primary_effect(self, player: Player) -> None:
"""Apply the (default that is for park, forest, quarry and trading post) effect of a neutral building."""
print(indent(3) + 'Effect of the neutral building ' + self.name +
' for a worker of the player ' + player.name() + ': ' + self.primary_effect.text)
self.apply_no_cost_only_gain_effect(self.primary_effect.money_resources_gain, player)
