Ejemplo n.º 1
0
def learn_1(required_intel: Intel):
    """
    You already know it.
    :param required_intel:
    :return:
    """
    player = Player.current()
    # update player intel
    PlayerKnowledgeBook.get_or_create(player=player, intel=required_intel)

    if (required_intel.npc_place or
            required_intel.item_place) and not required_intel.place_location:
        # if player knows an NPC's place but doesn't know the location of that place, add the location too
        if required_intel.npc_place:
            place = required_intel.npc_place.place
        else:
            place = required_intel.item_place.place
        if not place:
            Message.debug("Error! npc_place or item_place are empty")

        PlayerKnowledgeBook.get_or_create(
            player=player, intel=Intel.construct(place_location=place))

    Message.event("Intel '%s' discovered" % required_intel.detail())
    return [[]]
Ejemplo n.º 2
0
def sub_quest_2(suggested_destination: Place = None) -> list:
    player = Player.current()

    if suggested_destination:
        return_point = suggested_destination
    else:
        return_point = player.place

    results = Place.select()\
        .join(Intel)\
        .join(PlayerKnowledgeBook, JOIN.LEFT_OUTER)\
        .group_by(Intel).having(fn.COUNT(PlayerKnowledgeBook.id) == 0)

    locations_scores = [player.distance(place) for place in results]
    results = sort_by_list(results, locations_scores)

    if results:
        place_to_go = results[0]
    else:
        # not enough places to go, then create a new place unknown to player
        place_to_go = narrative_helper.create_place()

    player.next_location = place_to_go
    player.save()

    # steps:
    #   goto
    #   Quest
    #   goto
    steps = [[place_to_go], [], [return_point]]
    Message.instruction("Goto '%s' do another Quest, then go to '%s'" %
                        (place_to_go, return_point))
    return steps
Ejemplo n.º 3
0
def comfort_2(motivated: NPC) -> list:
    """
    Kill pests
    :param motivated:
    :return:
    """
    # find enemy of motivated, or create one
    results = NPC.select().where(NPC.clan != motivated.clan).order_by(
        fn.Random()).limit(1)
    if results:
        enemy = results.get()
    else:
        # No NPC left in the world except the motivated
        enemies_clan = Clan.select().where(Clan.id != motivated.clan).order_by(
            fn.Random()).get()
        enemy = NPC.create(place=Place.select().order_by(fn.Random()).get(),
                           clan=enemies_clan,
                           name=NPCName.fetch_new())

    player = Player.current()
    damage_report_intel = Intel.construct(
        other='arbitrary_pest_damage_report_' + str(randint(100, 999)))
    PlayerKnowledgeBook.create(player=player, intel=damage_report_intel)

    # steps:
    #   goto enemies place
    #   kill enemies
    #   goto motivated place
    #   T.report intel(?) to motivated
    steps = [[enemy.place, enemy], [enemy], [motivated.place, motivated],
             [damage_report_intel, motivated]]

    Message.instruction("%s: Take care of that pest '%s' for me" %
                        (motivated, enemy))
    return steps
Ejemplo n.º 4
0
def sub_quest_1(suggested_destination: Place = None):
    # just go somewhere - pick a place_location unknown to player to go to
    # the reason for unknown place_location is, if "learn" comes up in next level, we'll be lucky,
    # if it doesn't, intel can be added to Players knowledge right away.
    player = Player.current()

    if suggested_destination:
        place_to_go = suggested_destination
    else:
        results = Place.select()\
            .join(Intel)\
            .join(PlayerKnowledgeBook, JOIN.LEFT_OUTER)\
            .group_by(Intel).having(fn.COUNT(PlayerKnowledgeBook.id) == 0)

        locations_scores = [player.distance(place) for place in results]
        results = sort_by_list(results, locations_scores)

        if results:
            place_to_go = results[0]
        else:
            # not enough places to go, then create a new place unknown to player
            place_to_go = narrative_helper.create_place()

    player.next_location = place_to_go
    player.save()

    # steps:
    # goto
    steps = [[place_to_go]]
    Message.instruction("Goto '%s'" % place_to_go)
    return steps
Ejemplo n.º 5
0
def reputation_3(motivated: NPC) -> list:
    """
    Visit a dangerous place
    :param motivated:
    :return:
    """
    # goto an enemies place
    enemies = NPC.select().where(NPC.clan != motivated.clan).order_by(
        fn.Random()).limit(1)
    if enemies:
        place = enemies[0].place
    else:
        place = Place.select().order_by(fn.Random()).limit(1)
        if place:
            place = place[0]
        else:
            Message.debug("No place found in the World!")
            place = helper.create_place()

    player = Player.current()
    danger_report_intel = Intel.construct(other='arbitrary_danger_report_' +
                                          str(randint(100, 999)))
    PlayerKnowledgeBook.create(player=player, intel=danger_report_intel)

    # steps
    #   goto
    #   goto
    #   report
    steps = [[place], [motivated.place, motivated],
             [danger_report_intel, motivated]]
    Message.instruction(
        "%s: Goto the dangerous '%s' and report what you've seen there" %
        (motivated, place))
    return steps
Ejemplo n.º 6
0
def reputation_2(motivated: NPC) -> list:
    """
    Kill enemies of motivated
    :param motivated: given from higher level nodes
    :return:
    """
    results = NPC.select().where(NPC.clan != motivated.clan).order_by(
        fn.Random()).limit(1)
    if results:
        enemy = results.get()
    else:
        # No NPC left in the world except the motivated
        enemies_clan = Clan.select().where(Clan.id != motivated.clan).order_by(
            fn.Random()).get()
        enemy = NPC.create(place=Place.select().order_by(fn.Random()).get(),
                           clan=enemies_clan,
                           name=NPCName.fetch_new())

    player = Player.current()
    killing_report_intel = Intel.construct(other='arbitrary_killing_report_' +
                                           str(randint(100, 999)))
    PlayerKnowledgeBook.create(player=player, intel=killing_report_intel)

    # steps:
    #   goto enemies place
    #   kill enemies
    #   goto motivated place
    #   T.report intel(?) to motivated
    steps = [[enemy.place, enemy], [enemy], [motivated.place, motivated],
             [killing_report_intel, motivated]]
    Message.instruction("%s: Kill my enemy '%s', and report it" %
                        (motivated, enemy))
    return steps
Ejemplo n.º 7
0
def report(intel: Intel, target: NPC):

    player = Player.current()

    # check if player has the intel
    if not PlayerKnowledgeBook.get_or_none(player=player, intel=intel):
        Message.error("You don't have the intel '%s'" % intel)
        return False

    # check if player is in the target place_location
    if target.place != player.place:
        Message.debug("Player is not at the target (%s) location (%s)" %
                      (target, target.place))
        Message.error("You are not at the target's (%s) location" % target)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=target)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      target)
        Message.error("Player does not know where the NPC is located")
        return False

    # update Player's favours book if target hasn't have it already
    if not NPCKnowledgeBook.get_or_none(npc=target, intel=intel):
        FavoursBook.construct(target, intel.worth_())
        # update target's intel list
        NPCKnowledgeBook.create(npc=target, intel=intel)

    Message.achievement("Intel '%s' reported to the NPC '%s'" %
                        (intel.detail(), target))
    return True
Ejemplo n.º 8
0
def print_player_belongings(player: Player = None):
    if not player:
        player = Player.current()

    results = Item.select().where(Item.belongs_to_player == player)
    print("items:")
    print_indented(results)
Ejemplo n.º 9
0
def damage(target: NPC):

    player = Player.current()

    # check if player is at target place_location
    if player.place != target.place:
        Message.error("You are not at the target '%s's location" % target)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=target)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      target)
        Message.error("Player does not know where the NPC is located")
        return False

    target.health_meter -= 0.3
    if target.health_meter <= 0:
        return kill(target)
    else:
        Message.debug("NPC '%s' has been damaged, current health meter: %s" %
                      (target, target.health_meter))
        Message.achievement("NPC '%s' has been damaged" % target)
        target.save()

    return True
Ejemplo n.º 10
0
def listen(intel: Intel, informer: NPC):

    # check if informer has the intel
    if not NPCKnowledgeBook.get_or_none(intel=intel, npc=informer):
        Message.error("Informer doesn't have the intel (%s) player wants" %
                      intel)
        return False

    player = Player.current()

    # check if player is in the informer place_location
    if informer.place != player.place:
        Message.error("You are not at the informer's (%s) location" % informer)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=informer)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      informer)
        Message.error("Player does not know where the NPC is located")
        return False

    # update Player's intel
    NarrativeHelper.add_intel(intel)
    FavoursBook.construct(informer, -intel.worth_(), player)

    Message.achievement("Intel '%s' acquired by listening to '%s'" %
                        (intel.detail(), informer))
    return True
Ejemplo n.º 11
0
def take_loot(item_to_take: Item, loot_npc: NPCDead = None):

    player = Player.current()

    # check if the item belongs to dead
    if not loot_npc:
        # NPC confirmed dead already, object among dead is given
        try:
            holder = item_to_take.belongs_to
        except:
            # holder not found = dead
            Message.debug("Item '%s' holder is dead")
            holder = None

        if holder:
            # holder is alive
            return take(item_to_take, item_holder=holder)

    # remove item from holder's belongings and add to player's
    item_to_take.belongs_to = None
    item_to_take.belongs_to_player = player
    item_to_take.save()

    # FavoursBook.construct(item_holder, -item_to_take.worth_(), player)

    Message.achievement("Item '%s' has taken by looting" % item_to_take)
    return True
Ejemplo n.º 12
0
def spy(spy_on: NPC, intel_target: Intel):

    player = Player.current()

    # check if player is at target's location
    if player.place != spy_on.place:
        Message.debug("Player is not at the NPC (%s) location (%s) to spy" %
                      (spy_on, spy_on.place))
        Message.error("You are not at the NPC '%s's location to spy" % spy_on)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=intel_target)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      intel_target)
        Message.error("Player does not know where the NPC is located")
        return False

    # check if the target has the piece of intel
    if not NPCKnowledgeBook.get_or_none(npc=spy_on, intel=intel_target):
        Message.debug(
            "Target (%s) does not have the intel (%s) player wanted" %
            (spy_on, intel_target))
        Message.error(
            "Target (%s) does not have the intel (%s) player wanted" %
            (spy_on, intel_target))
        return False

    # update Player's intel
    NarrativeHelper.add_intel(intel_target)

    Message.achievement("Intel '%s' gathered by spying on '%s'" %
                        (intel_target.detail(), spy_on))
    return True
Ejemplo n.º 13
0
def protection_1(motivated: NPC) -> list:
    """
    Attack threatening entities
    :param motivated:
    :return:
    """
    # find enemy of motivated, or create one
    results = NPC.select().where(NPC.clan != motivated.clan).order_by(
        fn.Random()).limit(1)
    if results:
        enemy = results.get()
    else:
        # No NPC left in the world except the motivated
        enemies_clan = Clan.select().where(Clan.id != motivated.clan).order_by(
            fn.Random()).get()
        enemy = NPC.create(place=Place.select().order_by(fn.Random()).get(),
                           clan=enemies_clan,
                           name=NPCName.fetch_new())

    player = Player.current()
    threat_report_intel = Intel.construct(
        other='arbitrary_threat_damage_report_' + str(randint(100, 999)))
    PlayerKnowledgeBook.create(player=player, intel=threat_report_intel)

    # steps:
    #   goto enemies place
    #   kill enemies
    #   goto motivated place
    #   T.report intel(?) to motivated
    steps = [[enemy.place, enemy], [enemy], [motivated.place, motivated],
             [threat_report_intel, motivated]]

    Message.instruction("%s: Relieve me of '%s' threats, then report it" %
                        (motivated, enemy))
    return steps
Ejemplo n.º 14
0
def give(item: Item, receiver: NPC):

    # check if player has the item
    player = Player.current()
    if item.belongs_to_player != player:
        Message.error("You don't have the item (%s) to give" % item)
        return False

    # check if player is at receiver's location
    if player.place != receiver.place:
        Message.debug("Player is not at the receiver NPC (%s) location (%s)" %
                      (receiver, receiver.place))
        Message.error("You are not at the receiver's (%s) location" % receiver)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=receiver)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      receiver)
        Message.error("Player does not know where the NPC is located")
        return False

    item.belongs_to_player = None
    item.belongs_to = receiver
    item.save()

    # update favours book
    FavoursBook.construct(npc=receiver,
                          owe_factor=item.worth_(),
                          player=player)

    Message.achievement("Item '%s' has been given to the NPC '%s'" %
                        (item, receiver))
    return True
Ejemplo n.º 15
0
def use(item_to_use: Item, target: NPC):

    player = Player.current()
    # check if player has the item
    if item_to_use.belongs_to_player != player:
        Message.error("You don't have the item (%s)" % item_to_use)
        return False

    # check if player at target's place_location
    if target.place != player.place:
        Message.debug("Player is not at the target '%s's location (%s)" %
                      (target, target.place))
        Message.error("You are not at the target '%s's location" % target)
        return False

    # check if player know where the receiver is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=target)):
        Message.debug("Player does not know where the NPC (%s) is located" %
                      target)
        Message.error("Player does not know where the NPC is located")
        return False

    item_to_use.use(npc=target)

    # depending on positive or negative impact_factor of the item usage, target record in player's favour gets updated
    FavoursBook.construct(target, float(item_to_use.impact_factor or 0.0))

    Message.achievement("Item '%s' used on the '%s'" % (item_to_use, target))
    return True
Ejemplo n.º 16
0
def steal_1(item_to_steal: Item, item_holder: NPC):
    """
    Go someplace, sneak up on somebody, and take something.
    :return:
    """
    # item[1] is to be stolen from NPC[1] who has it

    # place_location[1] is where NPC[1] lives
    item_holder_place = item_holder.place

    player = Player.current()
    player.next_location = item_holder_place
    player.save()

    intel = Intel.construct(item_place=item_to_steal)
    PlayerKnowledgeBook.get_or_create(player=player, intel=intel)
    Message.achievement("Intel '%s' learned" % intel.detail())

    # steps:
    #   goto: place_location[1]
    #   T.stealth: stealth NPC[1]
    #   T.take: take item[1] from NPC[1]
    steps = [[item_holder_place, item_holder], [item_holder],
             [item_to_steal, item_holder]]
    Message.instruction("Sneak up on '%s', and take '%s'" %
                        (item_holder, item_to_steal))

    return steps
Ejemplo n.º 17
0
def gather(item_to_gather: Item):

    player = Player.current()

    # check if player is at item location
    if item_to_gather.place != player.place:
        Message.debug(
            "Player is not at the item '%s's location (%s) to gather it" %
            (item_to_gather, item_to_gather.place))
        Message.error("You are not at the item '%s's location to gather it" %
                      item_to_gather)
        return False

    # check if player know where the item is
    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(item_place=item_to_gather)):
        Message.debug("Player does not know where the item (%s) is located" %
                      item_to_gather)
        Message.error("Player does not know where the item is located")
        return False

    # update Player's belongings
    item_to_gather.belongs_to_player = player
    item_to_gather.save()

    Message.achievement("Item '%s' gathered" % item_to_gather)
    return True
Ejemplo n.º 18
0
def get_1(item_to_fetch: Item):

    # if not, add it to player's belongings
    item_to_fetch.belongs_to_player = Player.current()
    item_to_fetch.save()

    Message.event("Item '%s' acquired" % item_to_fetch)
    return []
Ejemplo n.º 19
0
    def construct(npc: NPC, owe_factor: float, player: Player = None):
        if not player:
            player = Player.current()

        fav, created = FavoursBook.get_or_create(
            player=player, npc=npc, defaults={'owe_factor': owe_factor})
        if not created:
            fav.owe_factor += owe_factor
Ejemplo n.º 20
0
def knowledge_2(NPC_knowledge_motivated: NPC):
    player = Player.current()
    # find someone enemy to the given NPC who has a worthy intel that the given NPC doesn't have.
    # or player already know them
    already_known_intel_list = Intel.select(Intel.id)\
        .join(NPCKnowledgeBook)\
        .where(NPCKnowledgeBook.npc == NPC_knowledge_motivated)
    already_known_intel_list += Intel.select(Intel.id)\
        .join(PlayerKnowledgeBook)\
        .where(PlayerKnowledgeBook.player == player)

    results = NPC.select(NPC, Intel.id.alias('intel_id'))\
        .join(NPCKnowledgeBook)\
        .join(Intel)\
        .where(NPC.clan != NPC_knowledge_motivated.clan, Intel.id.not_in(already_known_intel_list))\
        .order_by(Intel.worth.desc()).group_by(NPC).objects()

    if results:
        locations_scores = [player.distance(res.place) for res in results]
        results = sort_by_list(results, locations_scores)
        spy_target = results[0]
        spy_intel = Intel.get_by_id(spy_target.intel_id)
        del spy_target.intel_id
    else:
        # enemies
        results = NPC.select().where(NPC.clan != NPC_knowledge_motivated.clan)
        if not results:
            # no enemy found, pick any NPC
            Message.debug("knowledge_2: no enemy found, pick any NPC")
            results = NPC.select()

        locations_scores = [player.distance(res.place) for res in results]
        results = sort_by_list(results, locations_scores)
        spy_target = results[0]

        new_intel_list = Intel.select().where(
            Intel.id.not_in(already_known_intel_list)).order_by(
                Intel.worth.desc())
        if new_intel_list:
            # add the most valuable intel to the NPC knowledge book
            Message.debug(
                "knowledge_2: add the most valuable intel to the NPC knowledge book"
            )
            spy_intel = new_intel_list[0]
        else:
            # no new intel found, create a new intel
            spy_intel = Intel.construct(spell=Spell.create(
                name=SpellName.fetch_new(), text='magical arbitrary spell'))
        NPCKnowledgeBook.create(npc=spy_target, intel=spy_intel)

    # steps:
    # spy: on target, to get intel, then report it to knowledge_motivated NPC
    steps = [[spy_target, spy_intel, NPC_knowledge_motivated]]

    Message.instruction("%s: Spy on '%s' to get the intel '%s' for me" %
                        (NPC_knowledge_motivated, spy_target, spy_intel))
    return steps
Ejemplo n.º 21
0
 def place_(self):
     if self.place:
         return self.place
     elif self.belongs_to:
         return self.belongs_to.place
     elif self.belongs_to_player:
         return Player.current().place
     else:
         return None
Ejemplo n.º 22
0
def print_player_places(player: Player = None):
    if not player:
        player = Player.current()

    results = [
        "current: " + str(player.place), "next: " + str(player.next_location)
    ]
    print("places:")
    print_indented(results)
Ejemplo n.º 23
0
def add_intel(intel: Intel):
    player = Player.current()
    PlayerKnowledgeBook.get_or_create(player=player, intel=intel)

    # add additional intel if needed
    if intel.npc_place:
        place = intel.npc_place.place
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(place_location=place))

    elif intel.item_place:
        add_item_place_intel(intel.item_place)
Ejemplo n.º 24
0
def goto_1(destination: Place, npc: NPC = None, item: Item = None):
    """
    You are already there.
    :return:
    """
    player = Player.current()
    if npc or item:
        event_dest_str = str(npc if npc else item) + ' (' + str(
            destination) + ')'
    else:
        event_dest_str = str(destination)

    if npc:
        # move the npc
        npc.place = player.place
        npc.save()
        intel = Intel.construct(npc_place=npc)
        PlayerKnowledgeBook.get_or_create(player=player, intel=intel)
        Message.debug("NPC (%s) moved to the player location (%s)" %
                      (npc, player.place))
        Message.event("%s moved to your location" % npc)
    elif item:
        # move item or the holder
        if item.belongs_to:
            holder = item.belongs_to  # type: NPC
            holder.place = player.place
            holder.save()
            intel = Intel.construct(npc_place=holder)
            PlayerKnowledgeBook.get_or_create(player=player, intel=intel)
            Message.debug(
                "Item (%s) holder (%s) moved to the player location (%s)" %
                (item, item.belongs_to, player.place))
            Message.event("Item '%s's holder moved to your location" % item)
        elif item.belongs_to_player:
            Message.debug("Player already has the item %s" % item)
            Message.event("You already have the item '%s'" % item)
        else:
            item.place = player.place
            item.save()
            intel = Intel.construct(item_place=item)
            PlayerKnowledgeBook.get_or_create(player=player, intel=intel)
            Message.debug("Item (%s) moved to the player location (%s)" %
                          (item, player.place))
            Message.event("Item '%s' has been moved to your location" % item)
    else:
        # update player's location
        player.place = destination
        player.save()
        Message.debug("Player moved to %s location" % event_dest_str)
        Message.event("Player has been moved to %s location" % destination)

    return [[]]
Ejemplo n.º 25
0
def create_place():
    player = Player.current()
    player_place = player.place  # type: Place
    new_x = abs(player_place.x
                + randint(WorldParams.minimum_distance, WorldParams.reachable_distance)
                * (1 if random() < 0.5 else -1))
    new_y = abs(player_place.y
                + randint(WorldParams.minimum_distance, WorldParams.reachable_distance)
                * (1 if random() < 0.5 else -1))
    place_to_go = Place.create(name=PlaceName.fetch_new(), x=new_x, y=new_y)
    PlayerKnowledgeBook.create(player=player, intel=Intel.construct(place_location=place_to_go))

    return place_to_go
Ejemplo n.º 26
0
def print_player_intel(player: Player = None, print_locations: bool = False):
    if not player:
        player = Player.current()

    results = Intel.select().join(PlayerKnowledgeBook).where(
        PlayerKnowledgeBook.player == player)
    if not print_locations:
        results = results.where(Intel.type != IntelTypes.location)
    detailed = []
    for intel in results:
        detailed.append(intel.detail())
    print("intel:")
    print_indented(detailed)
Ejemplo n.º 27
0
def talk(npc: NPC):
    player = Player.current()
    if player.place != npc.place:
        Message.error("You are not at the NPC '%s's place, can't talk to him" %
                      npc)
        return False

    if not PlayerKnowledgeBook.get_or_none(
            player=player, intel=Intel.construct(npc_place=npc)):
        Message.error("NPC '%s's current location is unknown" % npc)
        return False

    Message.achievement("Talking to '%s'" % npc)
    return True
Ejemplo n.º 28
0
def explore(area_location: Place, npc: NPC = None, item: Item = None):

    player = Player.current()

    if player.place != area_location:
        Message.error("You are not at the area '%s'" % area_location)
        return False

    if (npc and npc.place != area_location) or (item and
                                                item.place != area_location):
        Message.error("What you're looking for, is not here")
        return False

    # check if player knows the location
    results = PlayerKnowledgeBook.select().join(Intel)\
        .where(PlayerKnowledgeBook.player == player, Intel.place_location == area_location).limit(1)
    if not results:
        Message.debug(
            "Location %s unknown (Intel not found in player's knowledge book)"
            % area_location)
        Message.error("Location %s is unknown" % area_location)
        return False

    # update Player's location
    player.place = area_location
    player.save()

    if npc:
        target = npc
    elif item:
        target = item
    else:
        target = ''

    Message.achievement("You have found '%s' by exploring '%s'" %
                        (target, area_location))

    if npc:
        # find npc for player (give npc place intel to player)
        intel = Intel.construct(npc_place=npc)
    elif item:
        intel = Intel.construct(item_place=item)
    else:
        intel = None
    if intel:
        PlayerKnowledgeBook.get_or_create(player=player, intel=intel)
        Message.achievement("Intel '%s' learned" % intel.detail())

    return True
Ejemplo n.º 29
0
def explore(area_location: Place, npc: NPC, item: Item):
    player = Player.current()

    if npc:
        intel = Intel.construct(npc_place=npc)
    elif item:
        intel = Intel.construct(item_place=item)
    else:
        intel = None

    if intel and not PlayerKnowledgeBook.get_or_none(player=player,
                                                     intel=intel):
        return False

    return player.place == area_location
Ejemplo n.º 30
0
def add_item_place_intel(item: Item):
    player = Player.current()

    if item.place:
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(item_place=item))
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(place_location=item.place))
    elif item.belongs_to:
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(item_place=item))
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(npc_place=item.belongs_to))
        PlayerKnowledgeBook.get_or_create(player=player, intel=Intel.construct(place_location=item.belongs_to.place))
    else:
        # player has the item
        pass

    return True