コード例 #1
0
def command_delexit(entity, argument=""):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # -------------------------------------------------------------------------

    if not argument:
        syntax = get_command_syntax(entity, "command_delexit")
        entity.send_output(syntax, break_line=False)
        return False

    if not entity.location.IS_ROOM:
        entity.send_output("Non ti trovi in una stanza ma in %s" % entity.location.code)
        return False

    room = entity.location

    arg1, argument = one_argument(argument)
    direction = get_direction(arg1)
    if direction == DIR.NONE:
        entity.send_output("Direzione non valida ricavata dall'argomento %s" % arg1)
        return False

    if direction not in room.exits:
        entity.send_output("Non c'è nessuna uscita %s da distruggere." % direction.to_dir)
        return False

    del(room.exits[direction])
    entity.send_output("E' stata cancellata l'uscita %s." % direction.to_dir)
    return True
コード例 #2
0
ファイル: find_entity.py プロジェクト: Carlovan/aaritmud
    def find_entity_from_args(self, arg, argument, quantity=1, location=None, entity_tables=None):
        """
        Serve a trovare un'entità nell'inventario di self a seconda degli
        argomenti passati.
        Se vi è un solo argomento allora prende quello (look target).
        Se ve ne sono due allora prende il secondo (look extra target).
        Se si passa il parametro location allora viene utilizzata la find_entity
        e non la find_entity_extensively.
        """
        if not arg:
            log.bug("arg non è un parametro valido: %r" % arg)
            return None, "", ""

        if not argument and argument != "":
            log.bug("argument non è un parametro valido: %r" % argument)
            return None, "", ""

        if quantity < 0:
            log.bug("quantity non è un parametro valido: %d" % quantity)
            return

        # -------------------------------------------------------------------------

        if not entity_tables:
            entity_tables = self.ENTITY_TABLES

        if not argument:
            target_argument = arg
            extra_argument = ""
        else:
            target_argument = argument
            extra_argument = arg

        if is_same(target_argument, ("me", "self")):
            target = self
        else:
            if location:
                target = self.find_entity(target_argument, quantity=quantity, location=location, entity_tables=entity_tables)
            else:
                target = self.find_entity_extensively(target_argument, quantity=quantity, entity_tables=entity_tables)

        #global get_direction
        #if not get_direction:
        #    from src.room import get_direction

        # Se il target è una porta aperta ricavata tramite una direzione allora
        # dà la precedenza all'uscita e non alla porta
        if (target and target.door_type and DOOR.CLOSED not in target.door_type.flags
        and get_direction(target_argument, exact=False) != DIR.NONE):
            return None, target_argument, extra_argument

        if quantity == 0:
            return target, target_argument, extra_argument
        else:
            return target.split_entity(quantity) if target else None, target_argument, extra_argument
コード例 #3
0
def dig_an_exit(entity, argument, verbs, behavioured):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return False

    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    # behavioured ha valore di verità

    # -------------------------------------------------------------------------

    location = entity.location

    arg, argument = one_argument(argument)
    direction = get_direction(arg)
    if direction == DIR.NONE:
        entity.act(
            "Non trovi nessuna direzione [white]%s[close] in cui %s." %
            (arg, verbs["infinitive"]), TO.ENTITY, location)
        entity.act(
            "$n sembra voler %s in una direzione, ma appare spaesato." %
            verbs["infinitive"], TO.OTHERS, location)
        entity.act(
            "$n sembra voler %s in una direzione, ma appare spaesato." %
            verbs["you2"], TO.TARGET, location)
        return False

    if not location.IS_ROOM:
        entity.act(
            "Non trovi in un luogo ove poter %s %s." %
            (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
        entity.act(
            "$n sembra voler %s %s nonostante non si trovi in un luogo con delle uscite."
            % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
        entity.act(
            "Non sei un luogo in cui si possa %s %s, eppure $n ci sta provando lo stesso."
            % (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
        return False

    # (TD) Questo si potrebbe convertire in metodo se dovesse servire nuovamente
    exit = None
    has_secret_door = False
    if direction in location.exits:
        exit = location.exits[direction]
        door = location.get_door(direction)
        if door and door.door_type and DOOR.SECRET in door.door_type.flags and DOOR.CLOSED in door.door_type.flags:
            has_secret_door = True

    if exit and EXIT.DIGGABLE not in exit.flags and not has_secret_door:
        entity.act(
            "Non sapresti proprio come %s %s: c'è già un'uscita!" %
            (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
        entity.act(
            "$n sembra voler %s %s: ma c'è già un'uscita!" %
            (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
        entity.act(
            "$n sembra voler %s %s: ma li hai già un'uscita!" %
            (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
        return False

    entity.act("Cominci a %s %s." % (verbs["infinitive"], direction.to_dir),
               TO.ENTITY, location)
    entity.act(
        "$n comincia a %s %s." % (verbs["infinitive"], direction.to_dir),
        TO.OTHERS, location)
    entity.act("$n comincia a %s %s." % (verbs["you2"], direction.to_dir),
               TO.TARGET, location)

    force_return = check_trigger(entity, "before_dig", entity, location, exit,
                                 direction, behavioured)
    if force_return:
        return True
    force_return = check_trigger(location, "before_digged", entity, location,
                                 exit, direction, behavioured)
    if force_return:
        return True

    # (TD) Togliere un po' di energie nella scavata
    if exit and not has_secret_door:
        defer_later_function = digging_a_diggable_exit_1
    else:
        defer_later_function = digging_an_inexistent_exit_1
    entity.action_in_progress = ActionInProgress(DIG_SECONDS,
                                                 defer_later_function,
                                                 stop_digging_on_exit, entity,
                                                 location, direction, verbs,
                                                 behavioured)
    return True
コード例 #4
0
def give_or_put(entity, argument, verbs, behavioured, entity_tables, noflag,
                noroom, gamescript_suffix1, gamescript_suffix2,
                gamescript_suffix3, preposition):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # argument può essere una stringa vuota

    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    if not entity_tables:
        log.bug("entity_tables non è un parametro valido: %r" % entity_tables)
        return False

    if noflag not in (FLAG.NO_PUT, FLAG.NO_GIVE):
        log.bug("noflag non è un parametro valido: %r" % noflag)
        return False

    if noroom not in (ROOM.NO_PUT, ROOM.NO_GIVE):
        log.bug("noroom non è un parametro valido: %r" % noroom)
        return False

    if gamescript_suffix1 not in ("put", "give"):
        log.bug("gamescript_suffix1 non è un parametro valido: %r" %
                gamescript_suffix1)
        return False

    if gamescript_suffix2 not in ("putted", "gave"):
        log.bug("gamescript_suffix2 non è un parametro valido: %r" %
                gamescript_suffix2)
        return False

    if gamescript_suffix3 not in ("putting", "giving"):
        log.bug("gamescript_suffix3 non è un parametro valido: %r" %
                gamescript_suffix3)
        return False

    if preposition not in ("in", "a"):
        log.bug("gamescript_suffix non è un parametro valido: %r" %
                gamescript_suffix)
        return False

    # -------------------------------------------------------------------------

    entity = entity.split_entity(1)

    if not argument:
        entity.send_output(
            "Che [white]cosa[close] vorresti %s %s [white]%s[close]?" %
            (verbs["infinitive"], preposition,
             "qualcuno" if preposition == "a" else "qualcosa"))
        if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
            syntax = get_command_syntax(entity, "command_put")
            entity.send_output(syntax)
        return False

    # Ricava l'eventuale quantità d'oggetti da posare
    quantity, argument = quantity_argument(argument)
    arg1, argument = one_argument(argument)

    # (TD) Controllo del mental state deviato

    # Ricerca nell'inventario dell'entità quella da dare o mettere
    target = entity.find_entity(arg1, quantity=quantity, location=entity)

    arg2 = ""
    receiver = None
    if argument:
        arg2, argument = one_argument(argument)
        # Rimuove eventuali argomenti facoltativi
        if argument and arg2 == "a":
            arg2, argument = one_argument(argument)
        # Ricerca dell'entità bersaglio a cui dare l'entità target
        receiver = entity.find_entity_extensively(arg2,
                                                  entity_tables=entity_tables)

        # Controlla se si vuole inserire una porta sui cardini di un'uscita
        direction = get_direction(arg2)
        if target and not receiver and direction != DIR.NONE:
            if not entity.location.IS_ROOM:
                entity.act(
                    "Vorresti %s $N sui cardini di un'eventuale uscita %s, ma non ti trovi in una stanza."
                    % (verbs["infinitive"], direction.to_dir), TO.ENTITY,
                    target)
                entity.act(
                    "$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza."
                    % (verbs["infinitive"], direction.to_dir), TO.OTHERS,
                    target)
                entity.act(
                    "$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza."
                    % (verbs["infinitive"], direction.to_dir), TO.TARGET,
                    target)
                return False
            if not direction in entity.location.exits:
                entity.act(
                    "Vorresti %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste."
                    % (verbs["infinitive"], direction.to_dir), TO.ENTITY,
                    target)
                entity.act(
                    "$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste."
                    % (verbs["infinitive"], direction.to_dir), TO.OTHERS,
                    target)
                entity.act(
                    "$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma questa non esiste."
                    % (verbs["infinitive"], direction.to_dir), TO.TARGET,
                    target)
                return False
            exit_door = entity.location.exits[direction].door
            if exit_door:
                entity.act(
                    "Vorresti %s $N sui cardini dell'uscita %s, ma questa possiede già $a."
                    % (verbs["infinitive"], direction.to_dir), TO.ENTITY,
                    target, exit_door)
                entity.act(
                    "$n vorrebbe %s $N sui cardini dell'uscita %s, ma questa possiede già $a."
                    % (verbs["infinitive"], direction.to_dir), TO.OTHERS,
                    target, exit_door)
                entity.act(
                    "$n ti vorrebbe %s sui cardini dell'uscita %s, ma questa possiede già $a."
                    % (verbs["infinitive"], direction.to_dir), TO.TARGET,
                    target, exit_door)
                return False
            if not target.door_type:
                entity.act(
                    "Vorresti %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta."
                    % (verbs["infinitive"], direction.to_dir), TO.ENTITY,
                    target, exit_door)
                entity.act(
                    "$n vorrebbe %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta."
                    % (verbs["infinitive"], direction.to_dir), TO.OTHERS,
                    target, exit_door)
                entity.act(
                    "$n ti vorrebbe %s sui cardini dell'uscita %s, ma non sei una porta."
                    % (verbs["infinitive"], direction.to_dir), TO.TARGET,
                    target, exit_door)
                return False
            if quantity > 1:
                entity.act(
                    "Vorresti %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O."
                    % (verbs["infinitive"], direction.to_dir), TO.ENTITY,
                    target, exit_door)
                entity.act(
                    "$n vorrebbe %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O"
                    % (verbs["infinitive"], direction.to_dir), TO.OTHERS,
                    target, exit_door)
                entity.act(
                    "$n ti vorrebbe %s sui cardini dell'uscita %s, ma è possibile inserirti solo in un'unità."
                    % (verbs["infinitive"], direction.to_dir), TO.TARGET,
                    target, exit_door)
                return False

            force_return = check_trigger(entity,
                                         "before_" + gamescript_suffix1,
                                         entity, target, None, direction,
                                         behavioured)
            if force_return:
                return True
            force_return = check_trigger(target,
                                         "before_" + gamescript_suffix2,
                                         entity, target, None, direction,
                                         behavioured)
            if force_return:
                return True
            force_return = check_trigger(receiver,
                                         "before_" + gamescript_suffix3,
                                         entity, target, None, direction,
                                         behavioured)
            if force_return:
                return True

            entity.act(
                "%s $N sui cardini dell'uscita %s." %
                (verbs["you"], direction.to_dir), TO.ENTITY, target)
            entity.act(
                "$n %s $N sui cardini dell'uscita %s." %
                (verbs["it"], direction.to_dir), TO.OTHERS, target)
            entity.act(
                "$n ti %s sui cardini dell'uscita %s." %
                (verbs["it"], direction.to_dir), TO.TARGET, target)
            target = target.from_location(1)
            target.to_location(entity.location)
            entity.location.exits[direction].door = target

            force_return = check_trigger(entity, "after_" + gamescript_suffix1,
                                         entity, target, None, direction,
                                         behavioured)
            if force_return:
                return True
            force_return = check_trigger(target, "after_" + gamescript_suffix2,
                                         entity, target, None, direction,
                                         behavioured)
            if force_return:
                return True
            force_return = check_trigger(receiver,
                                         "after_" + gamescript_suffix3, entity,
                                         target, None, direction, behavioured)
            if force_return:
                return True

            return True

    # -------------------------------------------------------------------------

    if not arg2:
        arg2 = "qualcuno" if preposition == "a" else "qualcosa"

    # Se l'entità a cui dare si trova nell'inventario allora lo indica
    on_message_you = ""
    on_message_it = ""
    if receiver and receiver.location and receiver.location == entity:
        if receiver and len(receiver.wear_mode) > 0:
            on_message_you = " che stai [khaki]indossando[close]"
            on_message_it = " che sta [khaki]indossando[close]"
        else:
            on_message_you = " nel tuo [yellow]inventario[close]"
            on_message_it = " nel suo [yellow]inventario[close]"

    # Gestisce le varie combinazioni di entità non trovate e/o uguali
    # all'entità che ha digitato il comando
    if target:
        if not receiver:
            entity.act(
                "Cerchi di %s $N %s [white]%s[close] che non trovi da nessuna parte."
                % (verbs["infinitive"], preposition, arg2), TO.ENTITY, target)
            entity.act(
                "$n cerca di %s $N %s [white]%s[close] che non sembra trovare da nessuna parte."
                % (verbs["infinitive"], preposition, arg2), TO.OTHERS, target)
            entity.act(
                "$n cerca di %s %s [white]%s[close] che non sembra trovare da nessuna parte."
                % (verbs["you2"], preposition, arg2), TO.TARGET, target)
            return False
        elif receiver == entity:
            entity.act(
                "Cerchi di %s $N %s te stess$o, ma è già tu$O!" %
                (verbs["infinitive"], preposition), TO.ENTITY, target)
            entity.act(
                "$n cerca di %s $N %s se stess$o, ma è già su$O." %
                (verbs["infinitive"], preposition), TO.OTHERS, target)
            entity.act(
                "$n cerca di %s $N %s se stess$o, ma è già su$O." %
                (verbs["infinitive"], preposition), TO.TARGET, target)
            return False
        elif receiver == target:
            entity.act(
                "Cerchi di %s $N %s se stess$o, ma ciò è impossibile!" %
                (verbs["infinitive"], preposition), TO.ENTITY, target)
            entity.act(
                "$n cerca di %s $N %s se stess$o, ma ciò è impossibile." %
                (verbs["infinitive"], preposition), TO.OTHERS, target)
            entity.act(
                "$n cerca di %s $N %s te stess$o, ciò è impossibile." %
                (verbs["infinitive"], preposition), TO.TARGET, target)
            return False
    elif not target:
        if not receiver:
            entity.act(
                "Cerchi di %s [white]%s[close] %s [white]%s[close], ma non trovi nulla e nessuno nel tuo inventario."
                % (verbs["infinitive"], arg1, preposition, arg2), TO.ENTITY)
            entity.act(
                "$n cerca di %s [white]qualcosa[close] %s [white]quacuno[close], ma senza molti risultati nel suo inventario."
                % (verbs["infinitive"], preposition), TO.OTHERS)
            return False
        elif receiver == entity:
            if entity.IS_ITEM:
                entity.act(
                    "Cerchi di [orange]passarti [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
                    % arg1, TO.ENTITY, receiver)
                entity.act(
                    "$n cerca di [orange]passarsi [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].",
                    TO.OTHERS, receiver)
            else:
                entity.act(
                    "Cerchi di [orange]passarti[close] da una $hand all'altra [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
                    % arg1, TO.ENTITY, receiver)
                entity.act(
                    "$n cerca di [orange]passarsi[close] da una $hand all'altra [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].",
                    TO.OTHERS, receiver)
            return False
        else:
            if on_message_you and on_message_it:
                entity.act(
                    "Cerchi di %s un [white]%s[close] %s $N%s, ma non trovi [gray]nulla del genere[close]."
                    % (verbs["infinitive"], arg1, preposition, on_message_you),
                    TO.ENTITY, receiver)
                entity.act(
                    "$n cerca di %s [white]qualcosa[close] %s $N%s, ma non sembra trovare [gray]nulla del genere[close]."
                    % (verbs["infinitive"], preposition, on_message_it),
                    TO.OTHERS, receiver)
                entity.act(
                    "$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]."
                    % (verbs["infinitive"]), TO.TARGET, receiver)
            else:
                entity.act(
                    "Cerchi di %s un [white]%s[close] %s $N, ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
                    % (verbs["infinitive"], arg1, preposition), TO.ENTITY,
                    receiver)
                entity.act(
                    "$n cerca di %s [white]qualcosa[close] %s $N, ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]."
                    % (verbs["infinitive"], preposition[2:]), TO.OTHERS,
                    receiver)
                entity.act(
                    "$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]."
                    % (verbs["infinitive"]), TO.TARGET, receiver)
            return False

    if quantity == 0:
        quantity = target.quantity
    elif target.quantity < quantity:
        entity.act(
            "Non puoi %s $N perché ne possiedi solo %d e non %d." %
            (verbs["infinitive"], target.quantity, quantity), TO.ENTITY,
            target)
        entity.act(
            "$n sta cercando di ammucchiare un quantitativo voluto di $N per poterlo %s"
            % verbs["infinitive"], TO.OTHERS, target)
        entity.act(
            "$n sta cercando di ammucchiarti per un quantitativo voluto per poterti %s"
            % verbs["infinitive"], TO.TARGET, target)
        return False

    if receiver.container_type and CONTAINER.CLOSED in receiver.container_type.flags:
        entity.act(
            "Cerchi di %s $a %s $N ma l$O trovi chius$O." %
            (verbs["infinitive"], preposition), TO.ENTITY, receiver, target)
        entity.act(
            "$n cerca di %s $a %s $N ma l$O trova chius$O." %
            (verbs["infinitive"], preposition), TO.OTHERS, receiver, target)
        return False

    # Se l'obiettivo a cui dare l'entità è un oggetto e non è un contenitore
    # allora solo gli admin possono eseguire l'azione
    if receiver.IS_ITEM and not receiver.container_type:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin(
                "Il ricevitore non è un contenitore ma tu puoi eseguire comunque l'azione"
            )
        else:
            entity.act(
                "Cerchi di %s $N %s $a, ma quest'ultimo non ti sembra un contenitore."
                % (verbs["infinitive"], preposition), TO.ENTITY, target,
                receiver)
            entity.act(
                "$n cerca di %s $N %s $a, ma non riesce a trovare modo per farlo non essendo un contenitore."
                % (verbs["infinitive"], preposition), TO.OTHERS, target,
                receiver)
            entity.act(
                "$n cerca di %s %s $a, ma non sembra riuscirvi visto che quest'ultimo non è un contenitore."
                % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act(
                "$n cerca di %s $a, ma avrà ben poca fortuna visto che non sei un contenitore."
                % verbs["you"], TO.TARGET, receiver, target)
            return False

    # Se l'entità che ha inviato il comando ha la noflag viene evitata
    # l'azione
    if noflag in entity.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("Tu avresti in realtà la flag NO_GIVE")
        else:
            entity.act(
                "Cerchi di %s $N %s $a, ma qualche [blueroyal]forza misteriosa[close] ti blocca l'azione."
                % (verbs["infinitive"], preposition), TO.ENTITY, target,
                receiver)
            entity.act(
                "$n cerca di %s $N %s $a, ma sembra essere bloccat$n da una [royalblue]forza misteriosa[close]."
                % (verbs["infinitive"], preposition), TO.OTHERS, target,
                receiver)
            entity.act(
                "$n cerca di %s %s $a, ma sembra essere essere bloccat$o da una [royalblue]forza misteriosa[close]."
                % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act(
                "$n cerca di %s $a, ma sembre essere bloccat$o da una [royalblue]forza misteriosa[close]."
                % verbs["you"], TO.TARGET, receiver, target)
            return False

    # Se l'oggetto da dare ha la flag NO_GIVE allora evita di farsi
    if noflag in target.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin(
                "L'entità da dare avrebbe in realtà la flag NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act(
                    "Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close] addosso."
                    % (verbs["infinitive"], preposition), TO.ENTITY, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close] addosso."
                    % (verbs["infinitive"], preposition), TO.OTHERS, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] addosso."
                    % (verbs["you2"], preposition), TO.TARGET, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close] addosso."
                    % verbs["you2"], TO.TARGET, receiver, target)
            else:
                entity.act(
                    "Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close], in $hand."
                    % (verbs["infinitive"], preposition), TO.ENTITY, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close], in $hand."
                    % (verbs["infinitive"], preposition), TO.OTHERS, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] in $hand."
                    % (verbs["you2"], preposition), TO.TARGET, target,
                    receiver)
                entity.act(
                    "Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close], in $hand."
                    % verbs["you2"], TO.TARGET, receiver, target)
            return False

    # Se l'entità a cui dare l'oggetto ha la flag NO_GIVE allora non lo accetta
    if noflag in receiver.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin(
                "L'entità a cui dare avrebbe in realtà la flag NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act(
                    "Cerchi di %s $N %s $a, ma questi te l$O ridà." %
                    (verbs["infinitive"], preposition), TO.ENTITY, target,
                    receiver)
                entity.act(
                    "$n cerca di %s $N %s $a, ma questi gliel$O ridà." %
                    (verbs["infinitive"], preposition), TO.OTHERS, target,
                    receiver)
                entity.act(
                    "$n cerca di %s %s $a, ma questi gliel$O ridà." %
                    (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act(
                    "$n cerca di %s $a, ma gliel%s ridai." %
                    (verbs["you2"], grammar_gender(target)), TO.TARGET,
                    receiver, target)
            else:
                entity.act(
                    "Cerchi di %s $N %s $a, ma questi te l$O ridà in $hand." %
                    (verbs["infinitive"], preposition), TO.ENTITY, target,
                    receiver)
                entity.act(
                    "$n cerca di %s $N %s $a, ma questi gliel$O ridà in $hand."
                    % (verbs["infinitive"], preposition), TO.OTHERS, target,
                    receiver)
                entity.act(
                    "$n cerca di %s %s $a, ma questi gliel$O ridà in $hand." %
                    (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act(
                    "$n cerca di %s $a, ma gliel%s ridai in $hand." %
                    (verbs["you2"], grammar_gender(target)), TO.TARGET,
                    receiver, target)
            return False

    # Se la stanza ha la flag NO_GIVE non permette di dare oggetti
    if entity.location.IS_ROOM and noroom in entity.location.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin(
                "Questa stanza avrebbe in realtà la flag di NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act(
                    "Appena cerchi di %s $N %s $a%s te l$O ritrovi addosso come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!"
                    % (verbs["infinitive"], preposition, on_message_you),
                    TO.ENTITY, target, receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a%s $N se l$O ritrova addosso come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!"
                    % (verbs["infinitive"], preposition, on_message_it),
                    TO.OTHERS, target, receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a%s gli ritorni addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!"
                    % (verbs["you2"], preposition, on_message_it), TO.TARGET,
                    target, receiver)
                entity.act(
                    "Appena $n cerca di %s $a gli ritorna addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!"
                    % (verbs["you2"]), TO.TARGET, receiver, target)
            else:
                entity.act(
                    "Appena cerchi di %s $N %s $a%s te l$O ritrovi in $hand come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!"
                    % (verbs["infinitive"], preposition, on_message_you),
                    TO.ENTITY, target, receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a%s $N se l$O ritrova in $hand come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!"
                    % (verbs["infinitive"], preposition, on_message_it),
                    TO.OTHERS, target, receiver)
                entity.act(
                    "Appena $n cerca di %s %s $a%s gli ritorni in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!"
                    % (verbs["you2"], preposition, on_message_it), TO.TARGET,
                    target, receiver)
                entity.act(
                    "Appena $n cerca di %s $a gli ritorna in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!"
                    % (verbs["you2"]), TO.TARGET, receiver, target)
            return False

    # (TD) dare monete

    # (TD) gestione dell'argomento all, ultima cosa da supportare

    # Se il peso dell'entità da dare supera quello sopportabile dall'obiettivo
    # a cui darlo allora avverte e evita l'azione
    # (TD) size e carry_number come il get?
    if not receiver.can_carry_target(target, quantity=quantity):
        if receiver.trust > TRUST.PLAYER:
            receiver.send_to_admin(
                "Riesci comunque a %s %s anche se è troppo pesante per te." %
                (verbs["infinitive"], target.get_name(entity)))
        elif entity.trust > TRUST.PLAYER and not receiver.IS_PLAYER:
            entity.send_to_admin(
                "Riesci comunque a %s %s anche se è troppo pesante per %s." %
                (verbs["infinitive"], target.get_name(entity),
                 receiver.get_name(entity)))
        else:
            entity.act(
                "Non riesci %s %s $N a $a, non può portare con sé tutto quel peso."
                % (verbs["infinitive"], preposition), TO.ENTITY, target,
                receiver)
            entity.act(
                "$n non riesce a %s $N %s $a, non può portare con sé tutto quel peso."
                % (verbs["infinitive"], preposition), TO.OTHERS, target,
                receiver)
            entity.act(
                "$n non riesce a %s %s $a, non può portare con sé tutto il tuo peso."
                % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act(
                "$n non riesce a %s $a, non puoi portare con te tutto quel peso."
                % verbs["you2"], TO.TARGET, receiver, target)
            return False

    force_return = check_trigger(entity, "before_" + gamescript_suffix1,
                                 entity, target, receiver, DIR.NONE,
                                 behavioured)
    if force_return:
        return True
    force_return = check_trigger(target, "before_" + gamescript_suffix2,
                                 entity, target, receiver, DIR.NONE,
                                 behavioured)
    if force_return:
        return True
    force_return = check_trigger(receiver, "before_" + gamescript_suffix3,
                                 entity, target, receiver, DIR.NONE,
                                 behavioured)
    if force_return:
        return True

    if on_message_you and on_message_it:
        entity.act(
            "%s $N %s $a%s." %
            (color_first_upper(verbs["you"]), preposition, on_message_you),
            TO.ENTITY, target, receiver)
        entity.act(
            "$n %s $N %s $a%s." % (verbs["it"], preposition, on_message_it),
            TO.OTHERS, target, receiver)
        entity.act(
            "$n ti %s %s $a%s." % (verbs["it"], preposition, on_message_it),
            TO.TARGET, target, receiver)
        entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
    else:
        entity.act(
            "%s $N %s $a." % (color_first_upper(verbs["you"]), preposition),
            TO.ENTITY, target, receiver)
        entity.act("$n %s $N %s $a." % (verbs["it"], preposition), TO.OTHERS,
                   target, receiver)
        entity.act("$n ti %s %s $a." % (verbs["it"], preposition), TO.TARGET,
                   target, receiver)
        entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)

    target = target.from_location(quantity, use_repop=True)
    target.to_location(receiver)

    force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity,
                                 target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(target, "after_" + gamescript_suffix2, entity,
                                 target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(receiver, "after_" + gamescript_suffix3,
                                 entity, target, receiver, DIR.NONE,
                                 behavioured)
    if force_return:
        return True

    return True
コード例 #5
0
    def find_entity_from_args(self,
                              arg,
                              argument,
                              quantity=1,
                              location=None,
                              entity_tables=None):
        """
        Serve a trovare un'entità nell'inventario di self a seconda degli
        argomenti passati.
        Se vi è un solo argomento allora prende quello (look target).
        Se ve ne sono due allora prende il secondo (look extra target).
        Se si passa il parametro location allora viene utilizzata la find_entity
        e non la find_entity_extensively.
        """
        if not arg:
            log.bug("arg non è un parametro valido: %r" % arg)
            return None, "", ""

        if not argument and argument != "":
            log.bug("argument non è un parametro valido: %r" % argument)
            return None, "", ""

        if quantity < 0:
            log.bug("quantity non è un parametro valido: %d" % quantity)
            return

        # -------------------------------------------------------------------------

        if not entity_tables:
            entity_tables = self.ENTITY_TABLES

        if not argument:
            target_argument = arg
            extra_argument = ""
        else:
            target_argument = argument
            extra_argument = arg

        if is_same(target_argument, ("me", "self")):
            target = self
        else:
            if location:
                target = self.find_entity(target_argument,
                                          quantity=quantity,
                                          location=location,
                                          entity_tables=entity_tables)
            else:
                target = self.find_entity_extensively(
                    target_argument,
                    quantity=quantity,
                    entity_tables=entity_tables)

        #global get_direction
        #if not get_direction:
        #    from src.room import get_direction

        # Se il target è una porta aperta ricavata tramite una direzione allora
        # dà la precedenza all'uscita e non alla porta
        if (target and target.door_type
                and DOOR.CLOSED not in target.door_type.flags
                and get_direction(target_argument, exact=False) != DIR.NONE):
            return None, target_argument, extra_argument

        if quantity == 0:
            return target, target_argument, extra_argument
        else:
            return target.split_entity(
                quantity) if target else None, target_argument, extra_argument
コード例 #6
0
    def find_entity_extensively(self,
                                argument,
                                quantity=1,
                                entity_tables=None,
                                inventory_pos="",
                                direct_search=True,
                                reverse_search=True,
                                avoid_inventory=False,
                                avoid_equipment=False,
                                avoid_doors=False):
        """
        Esegue una ricerca standard, di una entità corrispondente all'argomento
        passato, il più estensivamente possibile.
        reverse_search serve a indicare se cercare anche le porte dall'altra
        parte o meno.
        """
        if quantity < 0:
            log.bug("quantity non è un parametro valido: %d" % quantity)
            return

        # ---------------------------------------------------------------------

        if not entity_tables:
            entity_tables = self.ENTITY_TABLES

        original_argument = argument

        if inventory_pos == "first":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_same,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        # Prima esegue una ricerca esatta di tutte le entità attorno
        target = self.find_entity(argument, quantity, self.location,
                                  entity_tables, [
                                      is_same,
                                  ], avoid_inventory, avoid_equipment,
                                  avoid_doors)
        if target:
            if quantity == 0:
                return target
            else:
                return target.split_entity(quantity)

        if inventory_pos == "":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_same,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        if self.trust >= TRUST.MASTER:
            find_entity_handler_function = _find_entity_handler_for_admin
        else:
            find_entity_handler_function = _find_entity_handler

        if not avoid_doors:
            doors = []
            if self.location.IS_ROOM:
                # (TD) se ci sarà il sistema di più uscite per stanza qui bisognerà
                # utilizzare una get_exit, per supportare i vari 1.nord 2.nord, al
                # posto della get_direction (idem per il codice simile sottostante)
                direction = get_direction(argument, exact=True)
                if direction != DIR.NONE:
                    door = self.location.get_door(direction, direct_search,
                                                  reverse_search)
                    if door and DOOR.NO_USE_DIR not in door.door_type.flags:
                        return door

                for direction in self.location.exits:
                    door = self.location.get_door(direction, direct_search,
                                                  reverse_search)
                    if door:
                        doors.append(door)

                if doors:
                    number, argument = number_argument(argument)
                    target = find_entity_handler_function(
                        self, argument, doors, number, is_same,
                        avoid_inventory, avoid_equipment, avoid_doors)
                    if target:
                        return target

        if inventory_pos == "last":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_same,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        # Poi esegue una ricerca prefissa delle entità attorno
        argument = original_argument

        if inventory_pos == "first":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_prefix,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        target = self.find_entity(argument, quantity, self.location,
                                  entity_tables, [
                                      is_prefix,
                                  ], avoid_inventory, avoid_equipment,
                                  avoid_doors)
        if target:
            if quantity == 0:
                return target
            else:
                return target.split_entity(quantity)

        if inventory_pos == "":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_prefix,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        if not avoid_doors:
            # find_entity_handler_function e doors le deve aver già ricavate
            # precedentemente
            if self.location.IS_ROOM:
                direction = get_direction(argument, exact=False)
                if direction != DIR.NONE:
                    door = self.location.get_door(direction, direct_search,
                                                  reverse_search)
                    if door and DOOR.NO_USE_DIR not in door.door_type.flags:
                        return door

                if doors:
                    number, argument = number_argument(argument)
                    target = find_entity_handler_function(
                        self, argument, doors, number, is_prefix,
                        avoid_inventory, avoid_equipment, avoid_doors)
                    if target:
                        return target

        if inventory_pos == "last":
            target = self.find_entity(argument, quantity, self, entity_tables,
                                      [
                                          is_prefix,
                                      ], avoid_inventory, avoid_equipment,
                                      avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        return None
コード例 #7
0
ファイル: __senses__.py プロジェクト: Carlovan/aaritmud
def five_senses_handler(entity, argument, behavioured, command_name, gamescript_suffix2, sense_name, has_sense_method_name, messages):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # argument può essere una stringa vuota

    # behavioured ha valore di verità

    if not command_name:
        log.bug("command_name non è un parametro valido: %r" % command_name)
        return False

    if not gamescript_suffix2:
        log.bug("gamescript_suffix2 non è un parametro valido: %r" % gamescript_suffix2)
        return False

    # sense_name può essere una stringa vuota, per il look

    if not has_sense_method_name:
        log.bug("has_sense_method_name non è un parametro valido: %r" % has_sense_method_name)
        return False

    if not messages:
        log.bug("messages non è un parametro valido: %r" % messages)
        return False

    # -------------------------------------------------------------------------

    entity = entity.split_entity(1)

    if entity.IS_ACTOR:
        if entity.position < POSITION.SLEEP:
            entity.act(messages["death_position_entity"], TO.ENTITY)
            entity.act(messages["death_position_others"], TO.OTHERS)
            return False
        if entity.position == POSITION.SLEEP:
            entity.act(messages["sleep_position_entity"], TO.ENTITY)
            entity.act(messages["sleep_position_others"], TO.OTHERS)
            return False
        if not getattr(entity, has_sense_method_name)():
            entity.act(messages["not_has_sense_entity"], TO.ENTITY)
            entity.act(messages["not_has_sense_others"], TO.OTHERS)
            return False

    # Se entity è una razza che non può annusare sott'acqua allora esce
    if (sense_name == "smell" and not entity.race.smell_on_water
    and entity.location.IS_ROOM and ROOM.UNDERWATER in entity.location.flags):
        entity.send_output("Stai per annusare quando ti ricordi che qui richieresti di annegare!")
        return False

    # Se non è stato passato nessun argomento allora procede alla ricerca della
    # descrizione sensoriale nella stanza
    if not argument:
        descr = entity.location.get_descr(sense_name, looker=entity)
        if descr and "no_send" not in descr:
            update_sensed_rooms(entity, entity.location, command_name)

            force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, None, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, None, behavioured)
            if force_return:
                return True

            entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
            entity.act(messages["room_descr_others"], TO.OTHERS)

            force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, None, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, None, behavioured)
            if force_return:
                return True
            return True
        else:
            force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, "", None, behavioured)
            if force_return:
                return False
            force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, "", None, behavioured)
            if force_return:
                return False

            entity.act(messages["no_argument_entity"], TO.ENTITY)
            entity.act(messages["no_argument_others"], TO.OTHERS)

            force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, "", None, behavioured)
            if force_return:
                return False
            force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, "", None, behavioured)
            if force_return:
                return False
            return False

    # ---------------------------------------------------------------------

    original_argument = argument
    arg1, argument = one_argument(argument)

    target, target_argument, extra_argument = entity.find_entity_from_args(arg1, argument)
    if ((target and not target.is_secret_door())
    or  (target and target.is_secret_door() and len(target_argument) >= config.min_secret_arg_len)):
        return sense_an_entity(entity, target, extra_argument, command_name, gamescript_suffix2, sense_name, messages, behavioured)

    # -------------------------------------------------------------------------

    # Cerca un'eventuale extra nella locazione, prima in maniera esatta
    extra = entity.location.extras.get_extra(original_argument, exact=True)
    if extra:
        descr = extra.get_descr(sense_name, looker=entity, parent=entity)
        if descr and "no_send" not in descr:
            update_sensed_rooms(entity, entity.location, command_name)

            force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True

            entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
            if EXTRA.NO_LOOK_ACT not in extra.flags:
                if "%s" in messages["room_extra_others"]:
                    word = add_article(extra.keywords.split()[0])
                    entity.act(messages["room_extra_others"] % add_article(word, GRAMMAR.INDETERMINATE), TO.OTHERS)
                else:
                    entity.act(messages["room_extra_others"], TO.OTHERS)

            force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            return True

    # Gestisce il look in una direzione, prima in maniera esatta
    if target_argument:
        direction = get_direction(target_argument, exact=True)
        if direction != DIR.NONE:
            return sense_at_direction(entity, direction, extra_argument, True, command_name, gamescript_suffix2, sense_name, messages, behavioured, "to_dir")

    # Cerca un'eventuale extra sensoriale nella stanza, ora in maniera prefissa
    extra = entity.location.extras.get_extra(original_argument, exact=False)
    if extra:
        descr = extra.get_descr(sense_name, looker=entity, parent=entity)
        if descr and "no_send" not in descr:
            update_sensed_rooms(entity, entity.location, command_name)

            force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True

            entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
            if EXTRA.NO_LOOK_ACT not in extra.flags:
                if "%s" in messages["room_extra_others"]:
                    word = add_article(extra.keywords.split()[0])
                    entity.act(messages["room_extra_others"] % add_article(word, GRAMMAR.INDETERMINATE), TO.OTHERS)
                else:
                    entity.act(messages["room_extra_others"], TO.OTHERS)

            force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
            if force_return:
                return True
            return True

    # Gestisce il look in una direzione, ora in maniera prefissa
    if target_argument:
        direction = get_direction(target_argument, exact=False)
        if direction != DIR.NONE:
            return sense_at_direction(entity, direction, extra_argument, False, command_name, gamescript_suffix2, sense_name, messages, behavioured, "to_dir")

    # -------------------------------------------------------------------------

    force_return = check_trigger(entity, "before_" + command_name, entity, None, "", extra, behavioured)
    if force_return:
        return False

    if extra:
        word = add_article(extra.keywords.split()[0])
        entity.act(messages["no_found_extra_entity_alt"].replace(" di $N", "") % word, TO.ENTITY)
    else:
        if "%s" in messages["no_found_entity"]:
            entity.act(messages["no_found_entity"] % original_argument, TO.ENTITY)
        else:
            entity.act(messages["no_found_entity"], TO.ENTITY)
    entity.act(messages["no_found_others"], TO.OTHERS)

    force_return = check_trigger(entity, "after_" + command_name, entity, None, "", extra, behavioured)
    if force_return:
        return False

    return False
コード例 #8
0
def command_flee(entity, argument="", verbs=VERBS, behavioured=False):
    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    # -------------------------------------------------------------------------

    # È possibile se il comando è stato deferrato
    if not entity:
        return False

    entity = entity.split_entity(1)

    # (TD) Se non si ha la skill non prova neppure a fuggire
    pass

    followers = []
    if not entity.is_fighting():
        followers = entity.get_followers_here()
        if not followers:
            entity.send_output(
                "Non stai combattendo contro nessuno e nessuno ti sta seguendo!"
            )
            return False

    # (TD) se l'adrenalina è al massimo o si è in berserker non si può fuggire

    if entity.vigour <= 0:
        entity.act("Sei troppo stanc$o per poter %s!" % verbs["infinitive"],
                   TO.ENTITY)
        entity.act("$n è troppo stanco per poter %s!" % verbs["infinitive"],
                   TO.OTHERS)
        return False

    # (TD) magari in futuro fare la fuga anche tramite comando exit se
    # location è un contenitore aperto
    if not entity.location.IS_ROOM:
        message = {}
        messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs[
            "noun"]
        messages[
            "others"] = "$n non trova nessuna via di %s qui dentro!" % verbs[
                "noun"]
        return flee_with_portal(entity, messages)

    # Se non ci sono uscite praticabili allora prova a cercare dei portali,
    # da cui è facile fuggire, però non si sa mai dove possano portare...
    directions = list(
        entity.location.iter_viable_directions(closed_doors=True))
    if not directions:
        message = {}
        messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs[
            "noun"]
        messages[
            "others"] = "$n non trova nessuna via di %s qui dentro!" % verbs[
                "noun"]
        return flee_with_portal(
            entity,
            "Non trovi nessuna uscita da cui poter %s!" % verbs["infinitive"])

    opponent = entity.get_opponent()
    if not opponent:
        opponent = random.choice(followers)
    if not opponent:
        log.bug("Inaspettato: opponent non è valido: %r (entità in fuga: %s)" %
                (opponent, entity.code))
        return False

    for direction in reversed(directions):
        door = entity.location.get_door(direction)
        if not door:
            continue
        if opponent == door:
            directions.remove(direction)
            break

    if not directions:
        message = {}
        messages[
            "entity"] = "$N blocca l'unica via di %s disponibile!" % verbs[
                "noun"]
        messages[
            "others"] = "$N blocca a $n l'unica via di %s disponibile!" % verbs[
                "noun"]
        messages[
            "target"] = "Blocchi a $n l'unica via di %s disponibile!" % verbs[
                "noun"]
        return flee_with_portal(entity, messages, opponent)

    # (TD) fino a che il flee non è una skill la fallacità è casuale e
    # proporzionale al numero di uscite praticabili della stanza
    if random.randint(1, 6) > len(directions):
        entity.act(
            "Nella foga non riesci ad orientarti e trovare una via di %s!" %
            verbs["noun"], TO.ENTITY)
        entity.act(
            "Nella foga $n non riesce ad orientarti e trovare una via di %s!" %
            verbs["noun"], TO.OTHERS)
        entity.wait(FLEE_WAIT)
        return False

    # Tramite queste righe è possibile scegliere dove fuggire, oppure se fugge
    # in una direzione a caso
    if argument:
        direction = get_direction(argument)
    else:
        direction = random.choice(directions)

    # (TD) bisognerà ricordarsi di far fuggire tramite porte se si ha il
    # pass door (anche se penso che come effetto costante ai player non lo
    # vorrò) però come incantesimo sì, e quindi anche come flag di
    exit = entity.location.exits[direction]
    if EXIT.NO_FLEE in exit.flags:
        entity.act(
            "Stai per %s verso %s ma ti rendi conto che ti è impossibile!" %
            (verbs["infinitive"], direction), TO.ENTITY)
        entity.act(
            "$n sta per %s verso %s ma si rendi conto che è impossibile..." %
            (verbs["infinitive"], direction), TO.OTHERS)
        entity.wait(FLEE_WAIT)
        return False

    if exit.door and exit.door.door_type:
        # Le uscite con le porte chiuse a chiave sono bloccate alla fuga
        if DOOR.LOCKED in exit.door.door_type.flags:
            entity.act(
                "Sbatti contro $N chiusa a chiave, non si può %s da qui!" %
                (verbs["infinitive"]), TO.ENTITY, exit.door)
            entity.act(
                "$n sbatte contro $N chiusa a chiave, non si può %s da lì!" %
                (verbs["infinitive"]), TO.OTHERS, exit.door)
            entity.wait(FLEE_WAIT)
            return False

        # Mentre per le porte semplicemente chiuse c'è la possibilità di entrarvi e fuggire
        if DOOR.CLOSED in exit.door.door_type.flags:
            if random.randint(0, 1) == 0:
                # (TD) e magari chiudergliela in faccia
                if not command_open(
                        entity, exit.door.get_numbered_keyword(looker=entity)):
                    entity.wait(FLEE_WAIT)
                    return False
            else:
                entity.act(
                    "Sbatti contro $N chiusa, non riesci a %s da qui!" %
                    (verbs["infinitive"]), TO.ENTITY, exit.door)
                entity.act(
                    "$n sbatte contro $N chiusa, non riesce a %s da lì!" %
                    (verbs["infinitive"]), TO.OTHERS, exit.door)
                entity.wait(FLEE_WAIT)
                return False

    force_return = check_trigger(entity, "before_flee", entity, opponent,
                                 direction, None, behavioured)
    if force_return:
        return True
    force_return = check_trigger(opponent, "before_fleeing", entity, opponent,
                                 direction, None, behavioured)
    if force_return:
        return True

    if followers:
        opponent.guide = None

    entity.act("$n riesce a %s da $N!" % (verbs["infinitive"]), TO.OTHERS,
               opponent)
    entity.act("$n riesce a %s!" % (verbs["you2"]), TO.TARGET, opponent)
    execution_result = entity.move(direction,
                                   behavioured=behavioured,
                                   fleeing=True)
    entity.act("Riesci a %s da $N!" % (verbs["infinitive"]), TO.ENTITY,
               opponent)

    if not followers:
        xp_loss_and_stop_fight(entity, opponent, verbs)

    entity.wait(FLEE_WAIT)

    force_return = check_trigger(entity, "after_flee", entity, opponent,
                                 direction, None, behavioured)
    if force_return:
        return True
    force_return = check_trigger(opponent, "after_fleeing", entity, opponent,
                                 direction, None, behavioured)
    if force_return:
        return True

    return execution_result
コード例 #9
0
ファイル: command_dig.py プロジェクト: Carlovan/aaritmud
def dig_an_exit(entity, argument, verbs, behavioured):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return False

    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    # behavioured ha valore di verità

    # -------------------------------------------------------------------------

    location = entity.location

    arg, argument = one_argument(argument);
    direction = get_direction(arg)
    if direction == DIR.NONE:
        entity.act("Non trovi nessuna direzione [white]%s[close] in cui %s." % (arg, verbs["infinitive"]), TO.ENTITY, location)
        entity.act("$n sembra voler %s in una direzione, ma appare spaesato." % verbs["infinitive"], TO.OTHERS, location)
        entity.act("$n sembra voler %s in una direzione, ma appare spaesato." % verbs["you2"], TO.TARGET, location)
        return False

    if not location.IS_ROOM:
        entity.act("Non trovi in un luogo ove poter %s %s." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
        entity.act("$n sembra voler %s %s nonostante non si trovi in un luogo con delle uscite." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
        entity.act("Non sei un luogo in cui si possa %s %s, eppure $n ci sta provando lo stesso." % (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
        return False

    # (TD) Questo si potrebbe convertire in metodo se dovesse servire nuovamente
    exit = None
    has_secret_door = False
    if direction in location.exits:
        exit = location.exits[direction]
        door = location.get_door(direction)
        if door and door.door_type and DOOR.SECRET in door.door_type.flags and DOOR.CLOSED in door.door_type.flags:
            has_secret_door = True

    if exit and EXIT.DIGGABLE not in exit.flags and not has_secret_door:
        entity.act("Non sapresti proprio come %s %s: c'è già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
        entity.act("$n sembra voler %s %s: ma c'è già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
        entity.act("$n sembra voler %s %s: ma li hai già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
        return False

    entity.act("Cominci a %s %s." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
    entity.act("$n comincia a %s %s." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
    entity.act("$n comincia a %s %s." % (verbs["you2"], direction.to_dir), TO.TARGET, location)

    force_return = check_trigger(entity, "before_dig", entity, location, exit, direction, behavioured)
    if force_return:
        return True
    force_return = check_trigger(location, "before_digged", entity, location, exit, direction, behavioured)
    if force_return:
        return True

    # (TD) Togliere un po' di energie nella scavata
    if exit and not has_secret_door:
        defer_later_function = digging_a_diggable_exit_1
    else:
        defer_later_function = digging_an_inexistent_exit_1
    entity.action_in_progress = ActionInProgress(DIG_SECONDS, defer_later_function, stop_digging_on_exit, entity, location, direction, verbs, behavioured)
    return True
コード例 #10
0
ファイル: __give_put__.py プロジェクト: Carlovan/aaritmud
def give_or_put(entity, argument, verbs, behavioured, entity_tables, noflag, noroom, gamescript_suffix1, gamescript_suffix2, gamescript_suffix3, preposition):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # argument può essere una stringa vuota

    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    if not entity_tables:
        log.bug("entity_tables non è un parametro valido: %r" % entity_tables)
        return False

    if noflag not in (FLAG.NO_PUT, FLAG.NO_GIVE):
        log.bug("noflag non è un parametro valido: %r" % noflag)
        return False

    if noroom not in (ROOM.NO_PUT, ROOM.NO_GIVE):
        log.bug("noroom non è un parametro valido: %r" % noroom)
        return False

    if gamescript_suffix1 not in ("put", "give"):
        log.bug("gamescript_suffix1 non è un parametro valido: %r" % gamescript_suffix1)
        return False

    if gamescript_suffix2 not in ("putted", "gave"):
        log.bug("gamescript_suffix2 non è un parametro valido: %r" % gamescript_suffix2)
        return False

    if gamescript_suffix3 not in ("putting", "giving"):
        log.bug("gamescript_suffix3 non è un parametro valido: %r" % gamescript_suffix3)
        return False

    if preposition not in ("in", "a"):
        log.bug("gamescript_suffix non è un parametro valido: %r" % gamescript_suffix)
        return False

    # -------------------------------------------------------------------------

    entity = entity.split_entity(1)

    if not argument:
        entity.send_output("Che [white]cosa[close] vorresti %s %s [white]%s[close]?" % (verbs["infinitive"], preposition, "qualcuno" if preposition == "a" else "qualcosa"))
        if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
            syntax = get_command_syntax(entity, "command_put")
            entity.send_output(syntax)
        return False

    # Ricava l'eventuale quantità d'oggetti da posare
    quantity, argument = quantity_argument(argument)
    arg1, argument = one_argument(argument)

    # (TD) Controllo del mental state deviato

    # Ricerca nell'inventario dell'entità quella da dare o mettere
    target = entity.find_entity(arg1, quantity=quantity, location=entity)

    arg2 = ""
    receiver = None
    if argument:
        arg2, argument = one_argument(argument)
        # Rimuove eventuali argomenti facoltativi
        if argument and arg2 == "a":
            arg2, argument = one_argument(argument)
        # Ricerca dell'entità bersaglio a cui dare l'entità target
        receiver = entity.find_entity_extensively(arg2, entity_tables=entity_tables)

        # Controlla se si vuole inserire una porta sui cardini di un'uscita
        direction = get_direction(arg2)
        if target and not receiver and direction != DIR.NONE:
            if not entity.location.IS_ROOM:
                entity.act("Vorresti %s $N sui cardini di un'eventuale uscita %s, ma non ti trovi in una stanza." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target)
                entity.act("$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target)
                entity.act("$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target)
                return False
            if not direction in entity.location.exits:
                entity.act("Vorresti %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target)
                entity.act("$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target)
                entity.act("$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target)
                return False
            exit_door = entity.location.exits[direction].door
            if exit_door:
                entity.act("Vorresti %s $N sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
                entity.act("$n vorrebbe %s $N sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
                entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
                return False
            if not target.door_type:
                entity.act("Vorresti %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
                entity.act("$n vorrebbe %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
                entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma non sei una porta." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
                return False
            if quantity > 1:
                entity.act("Vorresti %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
                entity.act("$n vorrebbe %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O" % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
                entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma è possibile inserirti solo in un'unità." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
                return False

            force_return = check_trigger(entity, "before_" + gamescript_suffix1, entity, target, None, direction, behavioured)
            if force_return:
                return True
            force_return = check_trigger(target, "before_" + gamescript_suffix2, entity, target, None, direction, behavioured)
            if force_return:
                return True
            force_return = check_trigger(receiver, "before_" + gamescript_suffix3, entity, target, None, direction, behavioured)
            if force_return:
                return True

            entity.act("%s $N sui cardini dell'uscita %s." % (verbs["you"], direction.to_dir), TO.ENTITY, target)
            entity.act("$n %s $N sui cardini dell'uscita %s." % (verbs["it"], direction.to_dir), TO.OTHERS, target)
            entity.act("$n ti %s sui cardini dell'uscita %s." % (verbs["it"], direction.to_dir), TO.TARGET, target)
            target = target.from_location(1)
            target.to_location(entity.location)
            entity.location.exits[direction].door = target

            force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity, target, None, direction, behavioured)
            if force_return:
                return True
            force_return = check_trigger(target, "after_" + gamescript_suffix2, entity, target, None, direction, behavioured)
            if force_return:
                return True
            force_return = check_trigger(receiver, "after_" + gamescript_suffix3, entity, target, None, direction, behavioured)
            if force_return:
                return True

            return True

    # -------------------------------------------------------------------------

    if not arg2:
        arg2 = "qualcuno" if preposition == "a" else "qualcosa"

    # Se l'entità a cui dare si trova nell'inventario allora lo indica
    on_message_you = ""
    on_message_it = ""
    if receiver and receiver.location and receiver.location == entity:
        if receiver and len(receiver.wear_mode) > 0:
            on_message_you = " che stai [khaki]indossando[close]"
            on_message_it  = " che sta [khaki]indossando[close]"
        else:
            on_message_you = " nel tuo [yellow]inventario[close]"
            on_message_it  = " nel suo [yellow]inventario[close]"

    # Gestisce le varie combinazioni di entità non trovate e/o uguali
    # all'entità che ha digitato il comando
    if target:
        if not receiver:
            entity.act("Cerchi di %s $N %s [white]%s[close] che non trovi da nessuna parte." % (verbs["infinitive"], preposition, arg2), TO.ENTITY, target)
            entity.act("$n cerca di %s $N %s [white]%s[close] che non sembra trovare da nessuna parte." % (verbs["infinitive"], preposition, arg2), TO.OTHERS, target)
            entity.act("$n cerca di %s %s [white]%s[close] che non sembra trovare da nessuna parte." % (verbs["you2"], preposition, arg2), TO.TARGET, target)
            return False
        elif receiver == entity:
            entity.act("Cerchi di %s $N %s te stess$o, ma è già tu$O!" % (verbs["infinitive"], preposition), TO.ENTITY, target)
            entity.act("$n cerca di %s $N %s se stess$o, ma è già su$O." % (verbs["infinitive"], preposition), TO.OTHERS, target)
            entity.act("$n cerca di %s $N %s se stess$o, ma è già su$O." % (verbs["infinitive"], preposition), TO.TARGET, target)
            return False
        elif receiver == target:
            entity.act("Cerchi di %s $N %s se stess$o, ma ciò è impossibile!" % (verbs["infinitive"], preposition), TO.ENTITY, target)
            entity.act("$n cerca di %s $N %s se stess$o, ma ciò è impossibile." % (verbs["infinitive"], preposition), TO.OTHERS, target)
            entity.act("$n cerca di %s $N %s te stess$o, ciò è impossibile." % (verbs["infinitive"], preposition), TO.TARGET, target)
            return False
    elif not target:
        if not receiver:
            entity.act("Cerchi di %s [white]%s[close] %s [white]%s[close], ma non trovi nulla e nessuno nel tuo inventario." % (verbs["infinitive"], arg1, preposition, arg2), TO.ENTITY)
            entity.act("$n cerca di %s [white]qualcosa[close] %s [white]quacuno[close], ma senza molti risultati nel suo inventario." % (verbs["infinitive"], preposition), TO.OTHERS)
            return False
        elif receiver == entity:
            if entity.IS_ITEM:
                entity.act("Cerchi di [orange]passarti [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % arg1, TO.ENTITY, receiver)
                entity.act("$n cerca di [orange]passarsi [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].", TO.OTHERS, receiver)
            else:
                entity.act("Cerchi di [orange]passarti[close] da una $hand all'altra [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % arg1, TO.ENTITY, receiver)
                entity.act("$n cerca di [orange]passarsi[close] da una $hand all'altra [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].", TO.OTHERS, receiver)
            return False
        else:
            if on_message_you and on_message_it:
                entity.act("Cerchi di %s un [white]%s[close] %s $N%s, ma non trovi [gray]nulla del genere[close]." % (verbs["infinitive"], arg1, preposition, on_message_you), TO.ENTITY, receiver)
                entity.act("$n cerca di %s [white]qualcosa[close] %s $N%s, ma non sembra trovare [gray]nulla del genere[close]." % (verbs["infinitive"], preposition, on_message_it), TO.OTHERS, receiver)
                entity.act("$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]." % (verbs["infinitive"]), TO.TARGET, receiver)
            else:
                entity.act("Cerchi di %s un [white]%s[close] %s $N, ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % (verbs["infinitive"], arg1, preposition), TO.ENTITY, receiver)
                entity.act("$n cerca di %s [white]qualcosa[close] %s $N, ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]." % (verbs["infinitive"], preposition[2 : ]), TO.OTHERS, receiver)
                entity.act("$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]." % (verbs["infinitive"]), TO.TARGET, receiver)
            return False

    if quantity == 0:
        quantity = target.quantity
    elif target.quantity < quantity:
        entity.act("Non puoi %s $N perché ne possiedi solo %d e non %d." % (verbs["infinitive"], target.quantity, quantity), TO.ENTITY, target)
        entity.act("$n sta cercando di ammucchiare un quantitativo voluto di $N per poterlo %s" % verbs["infinitive"], TO.OTHERS, target)
        entity.act("$n sta cercando di ammucchiarti per un quantitativo voluto per poterti %s" % verbs["infinitive"], TO.TARGET, target)
        return False

    if receiver.container_type and CONTAINER.CLOSED in receiver.container_type.flags:
        entity.act("Cerchi di %s $a %s $N ma l$O trovi chius$O." % (verbs["infinitive"], preposition), TO.ENTITY, receiver, target)
        entity.act("$n cerca di %s $a %s $N ma l$O trova chius$O." % (verbs["infinitive"], preposition), TO.OTHERS, receiver, target)
        return False

    # Se l'obiettivo a cui dare l'entità è un oggetto e non è un contenitore
    # allora solo gli admin possono eseguire l'azione
    if receiver.IS_ITEM and not receiver.container_type:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("Il ricevitore non è un contenitore ma tu puoi eseguire comunque l'azione")
        else:
            entity.act("Cerchi di %s $N %s $a, ma quest'ultimo non ti sembra un contenitore." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
            entity.act("$n cerca di %s $N %s $a, ma non riesce a trovare modo per farlo non essendo un contenitore." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
            entity.act("$n cerca di %s %s $a, ma non sembra riuscirvi visto che quest'ultimo non è un contenitore." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act("$n cerca di %s $a, ma avrà ben poca fortuna visto che non sei un contenitore." % verbs["you"], TO.TARGET, receiver, target)
            return False
    
    # Se l'entità che ha inviato il comando ha la noflag viene evitata
    # l'azione
    if noflag in entity.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("Tu avresti in realtà la flag NO_GIVE")
        else:
            entity.act("Cerchi di %s $N %s $a, ma qualche [blueroyal]forza misteriosa[close] ti blocca l'azione." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
            entity.act("$n cerca di %s $N %s $a, ma sembra essere bloccat$n da una [royalblue]forza misteriosa[close]." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
            entity.act("$n cerca di %s %s $a, ma sembra essere essere bloccat$o da una [royalblue]forza misteriosa[close]." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act("$n cerca di %s $a, ma sembre essere bloccat$o da una [royalblue]forza misteriosa[close]." % verbs["you"], TO.TARGET, receiver, target)
            return False

    # Se l'oggetto da dare ha la flag NO_GIVE allora evita di farsi
    if noflag in target.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("L'entità da dare avrebbe in realtà la flag NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act("Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close] addosso." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
                entity.act("Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close] addosso." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
                entity.act("Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] addosso." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act("Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close] addosso." % verbs["you2"], TO.TARGET, receiver, target)
            else:
                entity.act("Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close], in $hand." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
                entity.act("Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close], in $hand." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
                entity.act("Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] in $hand." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act("Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close], in $hand." % verbs["you2"], TO.TARGET, receiver, target)
            return False

    # Se l'entità a cui dare l'oggetto ha la flag NO_GIVE allora non lo accetta
    if noflag in receiver.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("L'entità a cui dare avrebbe in realtà la flag NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act("Cerchi di %s $N %s $a, ma questi te l$O ridà." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
                entity.act("$n cerca di %s $N %s $a, ma questi gliel$O ridà." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
                entity.act("$n cerca di %s %s $a, ma questi gliel$O ridà." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act("$n cerca di %s $a, ma gliel%s ridai." % (verbs["you2"], grammar_gender(target)), TO.TARGET, receiver, target)
            else:
                entity.act("Cerchi di %s $N %s $a, ma questi te l$O ridà in $hand." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
                entity.act("$n cerca di %s $N %s $a, ma questi gliel$O ridà in $hand." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
                entity.act("$n cerca di %s %s $a, ma questi gliel$O ridà in $hand." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
                entity.act("$n cerca di %s $a, ma gliel%s ridai in $hand." % (verbs["you2"], grammar_gender(target)), TO.TARGET, receiver, target)
            return False

    # Se la stanza ha la flag NO_GIVE non permette di dare oggetti
    if entity.location.IS_ROOM and noroom in entity.location.flags:
        if entity.trust > TRUST.PLAYER:
            entity.send_to_admin("Questa stanza avrebbe in realtà la flag di NO_GIVE")
        else:
            if entity.IS_ITEM:
                entity.act("Appena cerchi di %s $N %s $a%s te l$O ritrovi addosso come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!" % (
                    verbs["infinitive"], preposition, on_message_you), TO.ENTITY, target, receiver)
                entity.act("Appena $n cerca di %s %s $a%s $N se l$O ritrova addosso come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!" % (
                    verbs["infinitive"], preposition, on_message_it), TO.OTHERS, target, receiver)
                entity.act("Appena $n cerca di %s %s $a%s gli ritorni addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
                    verbs["you2"], preposition, on_message_it), TO.TARGET, target, receiver)
                entity.act("Appena $n cerca di %s $a gli ritorna addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
                    verbs["you2"]), TO.TARGET, receiver, target)
            else:
                entity.act("Appena cerchi di %s $N %s $a%s te l$O ritrovi in $hand come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!" % (
                    verbs["infinitive"], preposition, on_message_you), TO.ENTITY, target, receiver)
                entity.act("Appena $n cerca di %s %s $a%s $N se l$O ritrova in $hand come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!" % (
                    verbs["infinitive"], preposition, on_message_it), TO.OTHERS, target, receiver)
                entity.act("Appena $n cerca di %s %s $a%s gli ritorni in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
                    verbs["you2"], preposition, on_message_it), TO.TARGET, target, receiver)
                entity.act("Appena $n cerca di %s $a gli ritorna in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
                    verbs["you2"]), TO.TARGET, receiver, target)
            return False

    # (TD) dare monete

    # (TD) gestione dell'argomento all, ultima cosa da supportare

    # Se il peso dell'entità da dare supera quello sopportabile dall'obiettivo
    # a cui darlo allora avverte e evita l'azione
    # (TD) size e carry_number come il get?
    if not receiver.can_carry_target(target, quantity=quantity):
        if receiver.trust > TRUST.PLAYER:
            receiver.send_to_admin("Riesci comunque a %s %s anche se è troppo pesante per te." % (
                verbs["infinitive"], target.get_name(entity)))
        elif entity.trust > TRUST.PLAYER and not receiver.IS_PLAYER:
            entity.send_to_admin("Riesci comunque a %s %s anche se è troppo pesante per %s." % (
                verbs["infinitive"], target.get_name(entity), receiver.get_name(entity)))
        else:
            entity.act("Non riesci %s %s $N a $a, non può portare con sé tutto quel peso." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
            entity.act("$n non riesce a %s $N %s $a, non può portare con sé tutto quel peso." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
            entity.act("$n non riesce a %s %s $a, non può portare con sé tutto il tuo peso." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
            entity.act("$n non riesce a %s $a, non puoi portare con te tutto quel peso." % verbs["you2"], TO.TARGET, receiver, target)
            return False

    force_return = check_trigger(entity, "before_" + gamescript_suffix1, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(target, "before_" + gamescript_suffix2, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(receiver, "before_" + gamescript_suffix3, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True

    if on_message_you and on_message_it:
        entity.act("%s $N %s $a%s." % (color_first_upper(verbs["you"]), preposition, on_message_you), TO.ENTITY, target, receiver)
        entity.act("$n %s $N %s $a%s." % (verbs["it"], preposition, on_message_it), TO.OTHERS, target, receiver)
        entity.act("$n ti %s %s $a%s." % (verbs["it"], preposition, on_message_it), TO.TARGET, target, receiver)
        entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
    else:
        entity.act("%s $N %s $a." % (color_first_upper(verbs["you"]), preposition), TO.ENTITY, target, receiver)
        entity.act("$n %s $N %s $a." % (verbs["it"], preposition), TO.OTHERS, target, receiver)
        entity.act("$n ti %s %s $a." % (verbs["it"], preposition), TO.TARGET, target, receiver)
        entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)

    target = target.from_location(quantity, use_repop=True)
    target.to_location(receiver)

    force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(target, "after_" + gamescript_suffix2, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True
    force_return = check_trigger(receiver, "after_" + gamescript_suffix3, entity, target, receiver, DIR.NONE, behavioured)
    if force_return:
        return True

    return True
コード例 #11
0
def read_extra_from_location(entity, location, extra_argument, verbs, behavioured):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    if not location:
        log.bug("location non è un parametro valido: %r" % location)
        return False

    if not extra_argument:
        log.bug("extra_argument non è un parametro valido: %r" % extra_argument)
        return False

    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    # behavioured ha valore di verità

    # -------------------------------------------------------------------------

    # Cerca un'eventuale extra leggibile nella locazione, prima in maniera esatta
    extra = location.extras.get_extra(extra_argument, exact=True)
    if extra and EXTRA.READABLE in extra.flags:
        if can_read(entity, location, verbs, extra):
            descr = extra.get_descr("", looker=entity, parent=entity)
            if descr:
                force_return = check_trigger(entity, "before_read", entity, entity.location, descr, extra, behavioured)
                if force_return:
                    return True
                force_return = check_trigger(entity.location, "before_readed", entity, entity.location, descr, extra, behavioured)
                if force_return:
                    return True
                entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
                if EXTRA.NO_LOOK_ACT not in extra.flags:
                    entity.act("$n legge %s." % add_article(extra.keywords.split()[0], GRAMMAR.INDETERMINATE), TO.OTHERS)
                force_return = check_trigger(entity.location, "after_read", entity, entity.location, descr, extra, behavioured)
                if force_return:
                    return True
                force_return = check_trigger(entity.location, "after_readed", entity, entity.location, descr, extra, behavioured)
                if force_return:
                    return True
                return True

    # Gestisce il read in una direzione, prima in maniera esatta
    if extra_argument:
        direction = get_direction(extra_argument, True)
        if direction != DIR.NONE:
            return sense_at_direction(entity, direction, extra_argument, True, "read", "readed", "", MESSAGES, behavioured, "to_dir", readable=True)

    # Cerca un'eventuale extra leggibile nella locazione, ora in maniera prefissa
    extra = entity.location.extras.get_extra(extra_argument, exact=False)
    if extra and EXTRA.READABLE in extra.flags:
        if can_read(entity, location, verbs, extra):
            descr = extra.get_descr("", looker=entity, parent=entity)
            if descr:
                force_return = check_trigger(entity, "before_read", entity, entity.location, extra, descr, behavioured)
                if force_return:
                    return True
                force_return = check_trigger(entity.location, "before_readed", entity, entity.location, extra, descr, behavioured)
                if force_return:
                    return True
                entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
                if EXTRA.NO_LOOK_ACT not in extra.flags:
                    entity.act("$n legge %s." % add_article(extra.keywords.split()[0], GRAMMAR.INDETERMINATE), TO.OTHERS)
                force_return = check_trigger(entity.location, "after_read", entity, entity.location, extra, descr, behavioured)
                if force_return:
                    return True
                force_return = check_trigger(entity.location, "after_readed", entity, entity.location, extra, descr, behavioured)
                if force_return:
                    return True
                return True

    # Gestisce il read in una direzione, ora in maniera prefissa
    if extra_argument:
        direction = get_direction(extra_argument, exact=False)
        if direction != DIR.NONE:
            return sense_at_direction(entity, direction, extra_argument, False, "read", "readed", "", MESSAGES, behavioured, "to_dir", readable=True)

    if extra:
        entity.act("Guardi [white]%s[close] ma non vedi nulla di speciale da %s." % (extra_argument, verbs["infinitive"]), TO.ENTITY)
    else:
        entity.act("Non vedi nessun [green]%s[close] qui attorno da %s" % (extra_argument, verbs["infinitive"]), TO.ENTITY)
    entity.act("$n si guarda attorno alla ricerca di qualcuno o qualcosa che non trova", TO.OTHERS)
    return False
コード例 #12
0
ファイル: find_entity.py プロジェクト: Carlovan/aaritmud
    def find_entity_extensively(self, argument, quantity=1, entity_tables=None, inventory_pos="", direct_search=True, reverse_search=True, avoid_inventory=False, avoid_equipment=False, avoid_doors=False):
        """
        Esegue una ricerca standard, di una entità corrispondente all'argomento
        passato, il più estensivamente possibile.
        reverse_search serve a indicare se cercare anche le porte dall'altra
        parte o meno.
        """
        if quantity < 0:
            log.bug("quantity non è un parametro valido: %d" % quantity)
            return

        # ---------------------------------------------------------------------

        if not entity_tables:
            entity_tables = self.ENTITY_TABLES

        original_argument = argument

        if inventory_pos == "first":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        # Prima esegue una ricerca esatta di tutte le entità attorno
        target = self.find_entity(argument, quantity, self.location, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
        if target:
            if quantity == 0:
                return target
            else:
                return target.split_entity(quantity)

        if inventory_pos == "":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        if self.trust >= TRUST.MASTER:
            find_entity_handler_function = _find_entity_handler_for_admin
        else:
            find_entity_handler_function = _find_entity_handler

        if not avoid_doors:
            doors = []
            if self.location.IS_ROOM:
                # (TD) se ci sarà il sistema di più uscite per stanza qui bisognerà
                # utilizzare una get_exit, per supportare i vari 1.nord 2.nord, al
                # posto della get_direction (idem per il codice simile sottostante)
                direction = get_direction(argument, exact=True)
                if direction != DIR.NONE:
                    door = self.location.get_door(direction, direct_search, reverse_search)
                    if door and DOOR.NO_USE_DIR not in door.door_type.flags:
                        return door

                for direction in self.location.exits:
                    door = self.location.get_door(direction, direct_search, reverse_search)
                    if door:
                        doors.append(door)

                if doors:
                    number, argument = number_argument(argument)
                    target = find_entity_handler_function(self, argument, doors, number, is_same, avoid_inventory, avoid_equipment, avoid_doors)
                    if target:
                        return target

        if inventory_pos == "last":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        # Poi esegue una ricerca prefissa delle entità attorno
        argument = original_argument

        if inventory_pos == "first":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        target = self.find_entity(argument, quantity, self.location, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
        if target:
            if quantity == 0:
                return target
            else:
                return target.split_entity(quantity)

        if inventory_pos == "":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        if not avoid_doors:
            # find_entity_handler_function e doors le deve aver già ricavate
            # precedentemente
            if self.location.IS_ROOM:
                direction = get_direction(argument, exact=False)
                if direction != DIR.NONE:
                    door = self.location.get_door(direction, direct_search, reverse_search)
                    if door and DOOR.NO_USE_DIR not in door.door_type.flags:
                        return door

                if doors:
                    number, argument = number_argument(argument)
                    target = find_entity_handler_function(self, argument, doors, number, is_prefix, avoid_inventory, avoid_equipment, avoid_doors)
                    if target:
                        return target

        if inventory_pos == "last":
            target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
            if target:
                if quantity == 0:
                    return target
                else:
                    return target.split_entity(quantity)

        return None
コード例 #13
0
ファイル: command_flee.py プロジェクト: Carlovan/aaritmud
def command_flee(entity, argument="", verbs=VERBS, behavioured=False):
    if not verbs:
        log.bug("verbs non è un parametro valido: %r" % verbs)
        return False

    # -------------------------------------------------------------------------

    # È possibile se il comando è stato deferrato
    if not entity:
        return False

    entity = entity.split_entity(1)

    # (TD) Se non si ha la skill non prova neppure a fuggire
    pass

    followers = []
    if not entity.is_fighting():
        followers = entity.get_followers_here()
        if not followers:
            entity.send_output("Non stai combattendo contro nessuno e nessuno ti sta seguendo!")
            return False

    # (TD) se l'adrenalina è al massimo o si è in berserker non si può fuggire

    if entity.vigour <= 0:
        entity.act("Sei troppo stanc$o per poter %s!" % verbs["infinitive"], TO.ENTITY)
        entity.act("$n è troppo stanco per poter %s!" % verbs["infinitive"], TO.OTHERS)
        return False

    # (TD) magari in futuro fare la fuga anche tramite comando exit se
    # location è un contenitore aperto
    if not entity.location.IS_ROOM:
        message = {}
        messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs["noun"]
        messages["others"] = "$n non trova nessuna via di %s qui dentro!" % verbs["noun"]
        return flee_with_portal(entity, messages)

    # Se non ci sono uscite praticabili allora prova a cercare dei portali,
    # da cui è facile fuggire, però non si sa mai dove possano portare...
    directions = list(entity.location.iter_viable_directions(closed_doors=True))
    if not directions:
        message = {}
        messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs["noun"]
        messages["others"] = "$n non trova nessuna via di %s qui dentro!" % verbs["noun"]
        return flee_with_portal(entity, "Non trovi nessuna uscita da cui poter %s!" % verbs["infinitive"])

    opponent = entity.get_opponent()
    if not opponent:
        opponent = random.choice(followers)
    if not opponent:
        log.bug("Inaspettato: opponent non è valido: %r (entità in fuga: %s)" % (opponent, entity.code))
        return False

    for direction in reversed(directions):
        door = entity.location.get_door(direction)
        if not door:
            continue
        if opponent == door:
            directions.remove(direction)
            break;

    if not directions:
        message = {}
        messages["entity"] = "$N blocca l'unica via di %s disponibile!" % verbs["noun"]
        messages["others"] = "$N blocca a $n l'unica via di %s disponibile!" % verbs["noun"]
        messages["target"] = "Blocchi a $n l'unica via di %s disponibile!" % verbs["noun"]
        return flee_with_portal(entity, messages, opponent)

    # (TD) fino a che il flee non è una skill la fallacità è casuale e
    # proporzionale al numero di uscite praticabili della stanza
    if random.randint(1, 6) > len(directions):
        entity.act("Nella foga non riesci ad orientarti e trovare una via di %s!" % verbs["noun"], TO.ENTITY)
        entity.act("Nella foga $n non riesce ad orientarti e trovare una via di %s!" % verbs["noun"], TO.OTHERS)
        entity.wait(FLEE_WAIT)
        return False

    # Tramite queste righe è possibile scegliere dove fuggire, oppure se fugge
    # in una direzione a caso
    if argument:
        direction = get_direction(argument)
    else:
        direction = random.choice(directions)

    # (TD) bisognerà ricordarsi di far fuggire tramite porte se si ha il
    # pass door (anche se penso che come effetto costante ai player non lo
    # vorrò) però come incantesimo sì, e quindi anche come flag di
    exit = entity.location.exits[direction]
    if EXIT.NO_FLEE in exit.flags:
        entity.act("Stai per %s verso %s ma ti rendi conto che ti è impossibile!" % (verbs["infinitive"], direction), TO.ENTITY)
        entity.act("$n sta per %s verso %s ma si rendi conto che è impossibile..." % (verbs["infinitive"], direction), TO.OTHERS)
        entity.wait(FLEE_WAIT)
        return False

    if exit.door and exit.door.door_type:
        # Le uscite con le porte chiuse a chiave sono bloccate alla fuga
        if DOOR.LOCKED in exit.door.door_type.flags:
            entity.act("Sbatti contro $N chiusa a chiave, non si può %s da qui!" % (verbs["infinitive"]), TO.ENTITY, exit.door)
            entity.act("$n sbatte contro $N chiusa a chiave, non si può %s da lì!" % (verbs["infinitive"]), TO.OTHERS, exit.door)
            entity.wait(FLEE_WAIT)
            return False

        # Mentre per le porte semplicemente chiuse c'è la possibilità di entrarvi e fuggire
        if DOOR.CLOSED in exit.door.door_type.flags:
            if random.randint(0, 1) == 0:
                # (TD) e magari chiudergliela in faccia
                if not command_open(entity, exit.door.get_numbered_keyword(looker=entity)):
                    entity.wait(FLEE_WAIT)
                    return False
            else:
                entity.act("Sbatti contro $N chiusa, non riesci a %s da qui!" % (verbs["infinitive"]), TO.ENTITY, exit.door)
                entity.act("$n sbatte contro $N chiusa, non riesce a %s da lì!" % (verbs["infinitive"]), TO.OTHERS, exit.door)
                entity.wait(FLEE_WAIT)
                return False

    force_return = check_trigger(entity, "before_flee", entity, opponent, direction, None, behavioured)
    if force_return:
        return True
    force_return = check_trigger(opponent, "before_fleeing", entity, opponent, direction, None, behavioured)
    if force_return:
        return True

    if followers:
        opponent.guide = None

    entity.act("$n riesce a %s da $N!" % (verbs["infinitive"]), TO.OTHERS, opponent)
    entity.act("$n riesce a %s!" % (verbs["you2"]), TO.TARGET, opponent)
    execution_result = entity.move(direction, behavioured=behavioured, fleeing=True)
    entity.act("Riesci a %s da $N!" % (verbs["infinitive"]), TO.ENTITY, opponent)

    if not followers:
        xp_loss_and_stop_fight(entity, opponent, verbs)

    entity.wait(FLEE_WAIT)

    force_return = check_trigger(entity, "after_flee", entity, opponent, direction, None, behavioured)
    if force_return:
        return True
    force_return = check_trigger(opponent, "after_fleeing", entity, opponent, direction, None, behavioured)
    if force_return:
        return True

    return execution_result
コード例 #14
0
def command_addexit(entity, argument=""):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # -------------------------------------------------------------------------

    if not argument:
        syntax = get_command_syntax(entity, "command_addexit")
        entity.send_output(syntax, break_line=False)
        return False

    if not entity.location.IS_ROOM:
        entity.send_output("Non ti trovi in una stanza ma in %s" %
                           entity.location.code)
        return False

    room = entity.location

    arg1, argument = one_argument(argument)
    direction = get_direction(arg1)
    if direction == DIR.NONE:
        entity.send_output("Direzione non valida ricavata dall'argomento %s" %
                           arg1)
        return False

    if direction in room.exits:
        if room.exits[direction].destination:
            destination_message = " che porta a %s" % room.exits[
                direction].destination
        else:
            destination_message = ""
        entity.send_output(
            "C'è già un uscita %s%s, non puoi aggiungerne un'altra se non rimuovendola con il comando [limegreen]delexit[close] con il comando [limegreen]modifyexit[close]."
            % (direction.to_dir))
        return False

    # Supporto per la destinazione
    destination = None
    if argument:
        args = multiple_arguments(argument)
        if len(args) not in (3, 4):
            entity.send_output(
                "Sintassi del comando non valida, se si vuole specificare una destinazione servono le relative coordinate ed eventualmente il codice dell'area."
            )
            return False
        if not is_number(args[0]):
            entity.send_output("La coordinata X non è un numero valido: %s" %
                               args[0])
            return False
        if not is_number(args[1]):
            entity.send_output("La coordinata Y non è un numero valido: %s" %
                               args[1])
            return False
        if not is_number(args[2]):
            entity.send_output("La coordinata Z non è un numero valido: %s" %
                               args[2])
            return False
        if len(args) == 4:
            area = get_area_from_argument(args[3])
            if not area:
                entity.send_output("Area non trovata con argomento %s" %
                                   args[3])
                return False
        else:
            area = entity.area
        destination = Destination(int(args[0]), int(args[1]), int(args[2]),
                                  area)

    # Crea la nuova uscita da zero
    exit = Exit(direction)
    if destination:
        exit.destination = destination

    room.exits[direction] = exit
    entity.send_output("E' stata aggiunta l'uscita %s." % direction.to_dir)
    return True