def check_request_is_possible(self, character: "CharacterModel",
with_character: "CharacterModel",
input_: TakeFromModel) -> None:
self.check_is_possible(character, with_character)
if input_.take_resource_id is not None and input_.take_resource_quantity:
if not self._kernel.resource_lib.have_resource(
character_id=with_character.id,
resource_id=input_.take_resource_id,
quantity=input_.take_resource_quantity,
):
raise ImpossibleAction(
f"{with_character.name} n'en à pas assez")
if input_.take_stuff_id:
try:
stuff: StuffModel = self._kernel.stuff_lib.get_stuff(
input_.take_stuff_id)
except NoResultFound:
raise ImpossibleAction(f"objet inexistant")
carried_count = self._kernel.stuff_lib.have_stuff_count(
character_id=with_character.id, stuff_id=stuff.stuff_id)
if carried_count < (input_.take_stuff_quantity or 1):
raise ImpossibleAction(
f"{with_character.name} n'en à pas assez")
def check_request_is_possible(self, character: "CharacterModel",
with_character: "CharacterModel",
input_: AttackModel) -> None:
# lonely attack when exhausted is not possible
if input_.lonely is not None and input_.lonely and not character.is_attack_ready(
):
raise ImpossibleAction(
f"{character.name} n'est pas en mesure de mener cette attaque !"
)
# with_character must not been part of attacking affinity
if input_.as_affinity is not None and self._kernel.affinity_lib.character_is_in_affinity(
affinity_id=input_.as_affinity,
character_id=with_character.id):
raise ImpossibleAction(
f"Vous ne pouvez pas attaquer un membre d'une même affinités")
# It must have ready fighter to fight
if input_.as_affinity is not None and not self._kernel.affinity_lib.count_ready_fighter(
affinity_id=input_.as_affinity,
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
):
raise ImpossibleAction(
f"Personne n'est en état de se battre actuellement")
def check_is_possible(self, character: "CharacterModel", stuff: "StuffModel") -> None:
if not stuff.shield:
raise ImpossibleAction("Ce n'est pas un bouclier")
if not stuff.ready_for_use:
raise ImpossibleAction(f"{stuff.name} n'est pas utilisable")
if character.shield:
raise ImpossibleAction("Vous utilisez déjà un bouclier")
def check_is_possible(self, character: "CharacterModel", stuff: "StuffModel") -> None:
if not stuff.armor:
raise ImpossibleAction("Ce n'est pas une armure/protection")
if not stuff.ready_for_use:
raise ImpossibleAction(f"{stuff.name} n'est pas utilisable")
if character.armor:
raise ImpossibleAction("Vous utilisez déjà une armure/protection")
def check_request_is_possible(self, character: "CharacterModel",
input_: CheatsModel) -> None:
if not input_.cheat_id:
raise ImpossibleAction("Choix du cheat nécessaire")
if input_.cheat_id in self._get_available_cheats(character):
return
raise ImpossibleAction("Ce cheat ne vous est pas accessible")
def _check_attack_lonely(self, character: CharacterModel,
defense: DefendDescription, aff: str) -> None:
if not character.is_attack_ready():
raise ImpossibleAction("Vous n'etes pas en état de vous battre")
# by affinities, character can be in defense side. In that case, don't permit the fight
if character.id in [f.id for f in defense.all_fighters]:
raise ImpossibleAction(
"Vous ne pouvez pas mener cette attaque car parmis les defenseur se trouve "
f"des personnes avec lesquelles vous etes affiliés. Affinités en défense: {aff}"
)
def check_is_possible(self, character: "CharacterModel",
with_character: "CharacterModel") -> None:
# TODO BS: Check here is possible too with affinities (like chief
# can manipulate, firendship, etc)
if not with_character.vulnerable:
raise ImpossibleAction(
f"{with_character.name} est en capacité de se defendre")
else:
if not character.is_attack_ready():
raise ImpossibleAction(
f"{character.name} ne peut contraindre {with_character.name}"
)
def check_request_is_possible(
self,
character: "CharacterModel",
with_character: "CharacterModel",
input_: TeachKnowledgeModel,
) -> None:
self.check_is_possible(character, with_character)
if input_.knowledge_id not in character.knowledges:
raise ImpossibleAction(
f"{character.name} n'a pas cette connaisance")
if input_.ap is not None and character.action_points < input_.ap:
raise ImpossibleAction(
f"{character.name} n'a pas assez de points d'actions")
def check_is_possible(self, character: "CharacterModel",
resource_id: str) -> None:
if not self._kernel.resource_lib.have_resource(character.id,
resource_id):
raise ImpossibleAction("Vous ne possedez pas cette resource")
# TODO BS 2019-09-10: manage more than two resource mix
for carried_resource in self._kernel.resource_lib.get_carried_by(
character.id):
for resource_mix_description in self._kernel.game.config.get_resource_mixs_with(
[resource_id, carried_resource.id]):
return
raise ImpossibleAction("Aucune association possible")
def check_request_is_possible(self, character: "CharacterModel",
input_: LearnKnowledgeModel) -> None:
if input_.knowledge_id is not None:
if input_.knowledge_id in character.knowledges:
raise ImpossibleAction("Connaissance déjà acquise")
knowledge_description = self._kernel.game.config.knowledge[
input_.knowledge_id]
for required_knowledge_id in knowledge_description.requires:
if required_knowledge_id not in character.knowledges:
raise ImpossibleAction(
f"Cette connaissance ne peut pas encore etre abordé")
if input_.ap is not None:
if character.action_points < input_.ap:
raise ImpossibleAction("Pas assez de points d'actions")
def check_is_possible(self, character: "CharacterModel",
stuff: "StuffModel") -> None:
# TODO BS 2019-07-31: check is owned stuff
if stuff.stuff_id in self._description.properties["accept_stuff_ids"]:
return
raise ImpossibleAction(f"Vous ne pouvez pas le manger")
def check_request_is_possible(
self, character: "CharacterModel", stuff: "StuffModel", input_: ContinueStuffModel
) -> None:
self.check_is_possible(character, stuff)
if input_.ap:
if character.action_points < input_.ap:
raise ImpossibleAction(f"{character.name} ne possède passez de points d'actions")
def check_request_is_possible(self, character: "CharacterModel",
resource_id: str,
input_: input_model) -> None:
if not self._kernel.resource_lib.have_resource(
character.id, resource_id, quantity=input_.quantity):
raise ImpossibleAction(
"Vous ne possedez pas assez de cette resource")
def check_is_possible(self, character: "CharacterModel",
with_character: "CharacterModel") -> None:
# FIXME BS: en fait, toute les actions doivent tester si la cible est sur la meme zone ...
if (character.world_row_i != with_character.world_row_i
or character.world_col_i != with_character.world_col_i):
raise ImpossibleAction(
"Les personnages ne sont pas sur la meme zone")
def check_is_possible(self, character: "CharacterModel",
with_character: "CharacterModel") -> None:
if not (character.world_row_i == with_character.world_row_i
and character.world_col_i == with_character.world_col_i
and not self._kernel.character_lib.is_following(
character.id, with_character.id)):
raise ImpossibleAction(
f"{with_character.name} ne se trouve pas ici")
def check_is_possible(self, character: "CharacterModel",
resource_id: str) -> None:
accept_resources_ids = [
rd.id for rd in self._description.properties["accept_resources"]
]
if resource_id in accept_resources_ids:
return
raise ImpossibleAction("Non consommable")
def check_is_possible(self, character: "CharacterModel") -> None:
for resource in self._kernel.game.world_manager.get_resource_on_or_around(
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
zone_row_i=character.zone_row_i,
zone_col_i=character.zone_col_i,
):
return
raise ImpossibleAction("Il n'y a rien à collecter ici")
def check_is_possible(self, character: "CharacterModel", stuff: "StuffModel") -> None:
# Consider action ca be possible (displayed in interface) if at least one of required stuff
# is owned by character
carried = self._kernel.stuff_lib.get_carried_by(character.id)
carried_stuff_ids = [r.stuff_id for r in carried]
for require in self._description.properties["require"]:
if "stuff" in require and require["stuff"] in carried_stuff_ids:
return
raise ImpossibleAction("Aucune resource requise n'est possédé")
def check_is_possible(self, character: "CharacterModel",
stuff: "StuffModel") -> None:
# TODO BS 2019-07-31: check is owned stuff
accept_resources_ids = [
rd.id for rd in self._description.properties["accept_resources"]
]
if (stuff.filled_with_resource is not None
and stuff.filled_with_resource in accept_resources_ids):
return
raise ImpossibleAction(f"Il n'y a pas de quoi boire la dedans")
def check_request_is_possible(
self, character: "CharacterModel", input_: BeginStuffModel
) -> None:
self.check_is_possible(character)
check_common_is_possible(self._kernel, description=self._description, character=character)
cost = self.get_cost(character)
if character.action_points < cost:
raise ImpossibleAction(
f"{character.name} no possède pas assez de points d'actions "
f"({round(cost, 2)} nécessaires)"
)
for consume in self._description.properties["consume"]:
if "resource" in consume:
resource_id = consume["resource"]
resource_description = self._kernel.game.config.resources[resource_id]
quantity = consume["quantity"]
quantity_str = quantity_to_str(quantity, resource_description.unit, self._kernel)
if not self._kernel.resource_lib.have_resource(
character.id, resource_id=resource_id, quantity=quantity
):
resource_description = self._kernel.game.config.resources[resource_id]
raise ImpossibleAction(
f"Vous ne possédez pas assez de {resource_description.name}: {quantity_str} nécessaire(s)"
)
elif "stuff" in consume:
stuff_id = consume["stuff"]
quantity = consume["quantity"]
if (
self._kernel.stuff_lib.have_stuff_count(character.id, stuff_id=stuff_id)
< quantity
):
stuff_properties = self._kernel.game.stuff_manager.get_stuff_properties_by_id(
stuff_id
)
raise ImpossibleAction(
f"Vous ne possédez pas assez de {stuff_properties.name}: {quantity} nécessaire(s)"
)
def check_request_is_possible(self, character: "CharacterModel", input_: BuildModel) -> None:
check_common_is_possible(
kernel=self._kernel, description=self._description, character=character
)
build_id = self._description.properties["build_id"]
build_description = self._kernel.game.config.builds[build_id]
if character.action_points < self.get_cost(character, input_):
raise ImpossibleAction("Pas assez de points d'actions")
for require in build_description.build_require_resources:
if not self._kernel.resource_lib.have_resource(
character.id, resource_id=require.resource_id, quantity=require.quantity
):
resource_properties = self._kernel.game.config.resources[require.resource_id]
required_quantity_str = quantity_to_str(
require.quantity, resource_properties.unit, self._kernel
)
raise ImpossibleAction(
f"Vous ne possedez pas assez de {resource_properties.name} "
f"({required_quantity_str} requis)"
)
def check_is_possible(self, character: "CharacterModel",
stuff: "StuffModel") -> None:
for fill_acceptable_type in self._kernel.game.config.fill_with_material_ids:
for resource in self._kernel.game.world_manager.get_resource_on_or_around(
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
zone_row_i=character.zone_row_i,
zone_col_i=character.zone_col_i,
material_type=fill_acceptable_type,
):
return
raise ImpossibleAction("Rien à proximité ne correspond")
def check_common_is_possible(
kernel: "Kernel", description: "ActionDescriptionModel", character: "CharacterModel"
) -> None:
character_stuff_ids = [s.stuff_id for s in kernel.stuff_lib.get_carried_by(character.id)]
character_skill_ids = [] # TODO BS 2019-09-26: code it
one_of_required_stuff_found = False
one_of_required_skill_found = False
one_of_required_abilities = False
for required_one_of_stuff_id in description.properties["required_one_of_stuff_ids"]:
if required_one_of_stuff_id in character_stuff_ids:
one_of_required_stuff_found = True
for required_one_of_skill in description.properties["required_one_of_skills"]:
if required_one_of_skill.id in character_skill_ids:
one_of_required_skill_found = True
if kernel.character_lib.have_from_of_abilities(
character, abilities=description.properties["required_one_of_abilities"]
):
one_of_required_abilities = True
if description.properties["required_one_of_stuff_ids"] and not one_of_required_stuff_found:
raise ImpossibleAction("Manque de matériel")
if description.properties["required_one_of_skills"] and not one_of_required_skill_found:
raise ImpossibleAction("Manque d'expérience")
if description.properties["required_one_of_abilities"] and not one_of_required_abilities:
raise ImpossibleAction("Manque de matériels ou de compétences")
for required_all_stuff_id in description.properties["required_all_stuff_ids"]:
if required_all_stuff_id not in character_stuff_ids:
raise ImpossibleAction("Manque de matériels")
for required_all_skill_id in description.properties["required_all_skills"]:
if required_all_skill_id not in character_skill_ids:
raise ImpossibleAction("Manque de compétences")
def check_is_possible(self, character: "CharacterModel") -> None:
accept_resources_ids = [
rd.id for rd in self._description.properties["accept_resources"]
]
for resource in self._kernel.game.world_manager.get_resource_on_or_around(
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
zone_row_i=character.zone_row_i,
zone_col_i=character.zone_col_i,
material_type=self._kernel.game.config.liquid_material_id,
):
if resource.type_.value in accept_resources_ids:
return
raise ImpossibleAction("Il n'y a pas à boire à proximité")
def check_request_is_possible(self, character: "CharacterModel",
input_: DrinkResourceModel) -> None:
accept_resources_ids = [
rd.id for rd in self._description.properties["accept_resources"]
]
for resource in self._kernel.game.world_manager.get_resource_on_or_around(
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
zone_row_i=character.zone_row_i,
zone_col_i=character.zone_col_i,
material_type=self._kernel.game.config.liquid_material_id,
):
if resource.id == input_.resource_id and input_.resource_id in accept_resources_ids:
return
raise ImpossibleAction(
f"Il n'y a pas de {input_.resource_id} à proximité")
def check_request_is_possible(self, character: "CharacterModel",
input_: input_model) -> None:
# FIXME BS 2019-08-27: check input_.row_i and input_.col_i are near
# FIXME BS 2019-08-29: check if quantity is possible
resources = self._kernel.game.world_manager.get_resources_at(
world_row_i=character.world_row_i,
world_col_i=character.world_col_i,
zone_row_i=input_.row_i,
zone_col_i=input_.col_i,
)
resource_ids = [resource.id for resource in resources]
if input_.resource_id in resource_ids:
return
raise ImpossibleAction(
f"Il n'y a pas de '{input_.resource_id}' à cet endroit")
def check_request_is_possible(self, character: "CharacterModel",
resource_id: str,
input_: EatResourceModel) -> None:
self.check_is_possible(character, resource_id)
# TODO BS 2019-09-14: perf
carried_resource = next(
(cr
for cr in self._kernel.resource_lib.get_carried_by(character.id)
if cr.id == resource_id))
require = self._description.properties["require"]
if carried_resource.quantity >= require:
return
unit_name = self._kernel.translation.get(carried_resource.unit)
raise ImpossibleAction(
f"Vous ne possédez pas assez de {carried_resource.name} "
f"({require} {unit_name} requis)")
def check_request_is_possible(self, character: "CharacterModel",
resource_id: str,
input_: input_model) -> None:
self.check_is_possible(character, resource_id)
if input_.quantity is not None:
resource_mix = self._kernel.game.config.resource_mixs[
input_.resource_mix_id]
unit_name = self._kernel.translation.get(
resource_mix.produce_resource.unit)
for required_resource in resource_mix.required_resources:
carried_resource = self._kernel.resource_lib.get_one_carried_by(
character_id=character.id,
resource_id=required_resource.resource.id)
required_quantity = required_resource.coeff * input_.quantity
if carried_resource.quantity < required_quantity:
raise ImpossibleAction(
f"Vous ne possédez pas assez de {required_resource.resource.name}: "
f"Quantité nécessaire: {required_quantity} {unit_name}, "
f"vous n'en avez que {carried_resource.quantity} {unit_name}"
)
def check_is_possible(self, character: "CharacterModel",
stuff: "StuffModel") -> None:
if stuff.carried_by != character.id:
raise ImpossibleAction("Vous ne possedez pas cet objet")
def check_is_possible(self, character: "CharacterModel",
resource_id: str) -> None:
if not self._kernel.resource_lib.have_resource(character.id,
resource_id):
raise ImpossibleAction("Vous ne possedez pas cette resource")
