def before_move(entity, from_room, direction, to_room, running, behavioured): if not entity.IS_PLAYER: return if direction != DIR.NORTHEAST: return for content in to_room.iter_contains(): if content.IS_PLAYER: continue if content.prototype.code == oggetti["contenitore_01"]: return funghi = Item(oggetti["funghi"]) contenitore_01 = Item(oggetti["contenitore_01"]) contenitore_02 = Item(oggetti["contenitore_02"]) contenitore_03 = Item(oggetti["contenitore_03"]) premio_01 = Item(oggetti["premio_01"]) premio_02 = Item(oggetti["premio_02"]) premio_03 = Item(oggetti["premio_03"]) funghi.inject(to_room) contenitore_01.inject(to_room) contenitore_02.inject(to_room) contenitore_03.inject(to_room) premio_01.inject(contenitore_01) premio_02.inject(contenitore_02) premio_03.inject(contenitore_03) to_room.act("\n[mediumturquoise]Una luce provieniente dal centro della cupola ti acceca per pochi attimi... qualcosa è cambiato attorno a te[close].") defer(3600, cleaning, to_room)
def after_putting(player, item, container, direction, behavioured): if not player.IS_PLAYER: return location = find_room(PROTO_ROOM_CODE) if not location: return if container.get_carried_weight() < PESO_MINIMO: player.act("Avverti una soffusa vibrazione generata da $N.", TO.ENTITY, container) player.act("Una leggera vibrazione accompagna il gesto di $n.", TO.OTHERS, container) player.act("Ti senti in grado di reggere almeno fino ai due chili!", TO.TARGET, container) return player.act( "Una bassa vibrazione ti avvolge, mentre da lontano si sente il rumore di massi che cedono.", TO.ENTITY, container) player.act( "Una bassa vibrazione avvolge tutto intorno, mentre da lontano si sente il rumore di massi che cedono.", TO.OTHERS, container) player.act("Senti d'aver superato la soglia dei due chili!", TO.TARGET, container) # Crea la nuova uscita nella room remota exit = Exit(EXIT_TO_OPEN) location.exits[EXIT_TO_OPEN] = exit location.act("La terra comincia a tremare....") # Dopo un certo tempo si richiude tutto defer(TIME_DELAY, close_exit_again, container, location)
def look_for_caterpillar(dust, show_act=True): if not dust: log.bug("dust non è un parametro valido: %r" % dust) return caterpillar = dust.find_entity("bruco", dust.location, ["mobs"]) if not caterpillar: if show_act: dust.act("My name is $n: niente bruchi" % dust, TO.OTHERS) dust.act("My name is $n: niente bruchi" % dust, TO.ENTITY) defer(60, look_for_caterpillar, dust) return if show_act: dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.OTHERS) dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.ENTITY) command_say(caterpillar, "sa la vist cus'è?") #defer(60, look_for_caterpillar, dust) # il bruco potrebbe essere soggetto a script che lo potrebbero mutare senza # avvisaglie quindi tolgo di mezzo il bruco per sostituirlo con un altro # che so non essere afflitto da script location = caterpillar.location caterpillar.extract(1) new_caterpillar = Mob(PROTO_CATERPILLAR_CODE) new_caterpillar.inject(location) new_caterpillar.act("$n cambia aspetto in modo repentino.", TO.OTHERS) dust_eating(dust, new_caterpillar)
def after_touch(entity, target, descr, detail, behavioured): if not entity.IS_PLAYER: return False if target.weight < 200: entity.act("$n pigia al pompetta di $N ma a vuoto.", TO.OTHERS, target) entity.act("Pigi la pompetta di $N ma a vuoto.", TO.ENTITY, target) return False else: target.weight = target.weight - PROFUMO_PROTO.weight for mode in PROFUMO_PROTO.wear_type.modes: for part in mode: already_weared_part, already_weared_possession = check_if_part_is_already_weared(entity, part) if already_weared_part: entity.act("[plum]$N si dissolve immediatamente nell'aria.[close]", TO.ENTITY, PROFUMO_PROTO) entity.act("[plum]$N si dissolve immediatamente nell'aria.[close]", TO.OTHERS, PROFUMO_PROTO) return profumo = Item(PROTO_PROFUMO_CODE) profumo.inject(entity) profumo.wear_mode += part part_descriptions = get_part_descriptions(mode, "wear") send_wear_messages(entity, profumo, "Indossi", "indossa", part_descriptions) break defer(10, profumo_cleaning, profumo, entity)
def after_listen_say(mob, player, target, phrase, behavioured): if not player.IS_PLAYER: return # Verifico che gli si parli con "a" if target != mob: return # Se non sta attendendo una risposta chiede l'indovinello if not mob.specials or not mob.specials["wait_for_reply"]: riddle_number = random.choice(RIDDLES.keys()) to_say = "a %s *zugiolone* " % player.code to_say += RIDDLES[riddle_number][0] defer_if_possible(1, mob, player, command_say, mob, to_say) mob.specials["wait_for_reply"] = True mob.specials["player"] = player.code mob.specials["riddle"] = riddle_number message = "*asciutto* tempo scaduto e nessuno ha indovinato..." defer(WAITING_TIME, reset_timer, mob, message) return # Ripulisce la risposta del giocatore da paccottaglie e da articoli e simili phrase = ALFA_ONLY_PATTERN.sub("", phrase) phrase = remove_little_words(phrase) riddle_number = mob.specials["riddle"] print riddle_number solutions = RIDDLES[riddle_number][1 : ] for solution in solutions: print "soluzioni: ", solution, " frasi: ", phrase # (TD) qui al posto della is_same ci starebbe bene una futura implementazione di soundex if is_same(phrase, solution): congratulation(mob, player) reset_timer(mob) break
def after_drop(entity, spore, room, behavioured): # Se l'oggetto non è stato abbandonato in una stanza esce if not room.IS_ROOM: entity.act("$N si diradano e spariscono in volo...", TO.ENTITY, spore) if spore.code not in database["items"]: return spore.extract(1) return # Se il settore della stanza non è tra quelli fertili esce if not room.sector.fertile: entity.act( "$N si diradano e spariscono in volo ancor prima di toccar terra!", TO.ENTITY, spore) if spore.code not in database["items"]: return spore.extract(1) return # Tra 10 secondi Aarit avrà terminato di assorbire le spore nel terreno # facendone nascere un mob fungoso! entity.act( "$N acquistano consistenza ovattosa e si depositano in terra formando una muffina bianca.", TO.ENTITY, spore) defer(10, born_mushrum, spore, room)
def dust_eating(dust, caterpillar): if not dust: log.bug("dust non è un parametro valido: %r" % dust) return if not caterpillar: log.bug("caterpillar non è un parametro valido: %r" % caterpillar) return dust_location = dust.location caterpillar_location = caterpillar.location if dust_location != caterpillar_location: caterpillar.act("$n vaga disorientato alla ricerca diqualcosa", TO.OTHERS) caterpillar.act("$n vaga disorientato alla ricerca diqualcosa", TO.ENTITY) defer(60, dust_eating, dust, caterpillar) return #command_eat(caterpillar, dust) caterpillar.act("$n viene avvolto dalla polvere bianca", TO.OTHERS) caterpillar.act("$n viene avvolto dalla polvere bianca", TO.ENTITY) dust.extract(1) caterpillar.extract(1) crisalide = Item(PROTO_CR_CRISALIDE_CODE) if not crisalide: log.bug("crisalide non trovata: %r" % crisalide) return crisalide.inject(location) crisalide.act("Il bruco rallenta e muta lentamente in $n", TO.OTHERS) crisalide.act("Il bruco rallenta e muta lentamente in $n", TO.ENTITY)
def nausea(entity, pescetto): # Può capitare visto che questa funzione viene usata in una defer if not pescetto or not entity: return if FLAG.INGESTED not in pescetto.flags: return if entity.race in likes_fish_races: return entity.act( "Un forte senso di nausea ti si aggrappa alla bocca dello stomaco facendoti vomitare.", TO.ENTITY) entity.act( "L'espressione di $n cambia in un tangibile disgusto poco prima di vomitare.", TO.OTHERS, pescetto) entity.act("$n ti vomita all'esterno verso la libertà.", TO.TARGET, pescetto) pescetto.flags -= FLAG.INGESTED pescetto.extract(1) pescetto.inject(entity.location) pescetto.long = "$N " + pescetto_long defer(TIME_LONG_RESET, reset_long, pescetto)
def after_listen_say(mob, player, target, phrase, behavioured): if not player.IS_PLAYER: return # Verifico che gli si parli con "a" if target != mob: return # Se non sta attendendo una risposta chiede l'indovinello if not mob.specials or not mob.specials["wait_for_reply"]: riddle_number = random.choice(RIDDLES.keys()) to_say = "a %s *zugiolone* " % player.code to_say += RIDDLES[riddle_number][0] defer_if_possible(1, mob, player, command_say, mob, to_say) mob.specials["wait_for_reply"] = True mob.specials["player"] = player.code mob.specials["riddle"] = riddle_number message = "*asciutto* tempo scaduto e nessuno ha indovinato..." defer(WAITING_TIME, reset_timer, mob, message) return # Ripulisce la risposta del giocatore da paccottaglie e da articoli e simili phrase = ALFA_ONLY_PATTERN.sub("", phrase) phrase = remove_little_words(phrase) riddle_number = mob.specials["riddle"] print riddle_number solutions = RIDDLES[riddle_number][1:] for solution in solutions: print "soluzioni: ", solution, " frasi: ", phrase # (TD) qui al posto della is_same ci starebbe bene una futura implementazione di soundex if is_same(phrase, solution): congratulation(mob, player) reset_timer(mob) break
def after_putting(player, item, container, direction, behavioured): if not player.IS_PLAYER: return location = find_room(PROTO_ROOM_CODE) if not location: return if container.get_carried_weight() < PESO_MINIMO: player.act("Avverti una soffusa vibrazione generata da $N.", TO.ENTITY, container) player.act("Una leggera vibrazione accompagna il gesto di $n.", TO.OTHERS, container) player.act("Ti senti in grado di reggere almeno fino ai due chili!", TO.TARGET, container) return player.act("Una bassa vibrazione ti avvolge, mentre da lontano si sente il rumore di massi che cedono.", TO.ENTITY, container) player.act("Una bassa vibrazione avvolge tutto intorno, mentre da lontano si sente il rumore di massi che cedono.", TO.OTHERS, container) player.act("Senti d'aver superato la soglia dei due chili!", TO.TARGET, container) # Crea la nuova uscita nella room remota exit = Exit(EXIT_TO_OPEN) location.exits[EXIT_TO_OPEN] = exit location.act("La terra comincia a tremare....") # Dopo un certo tempo si richiude tutto defer(TIME_DELAY, close_exit_again, container, location)
def quest_reward(player, item, tessi): if tessi.location != player.location: to_say = "a %s %s, ma dove scappi? Non vuoi la ricompensa dopo tanto affanno? Vabbè!" % (player.code, player.name) command_say(tessi, to_say) return # (GATTO) il valore forse è da tarare experience = 100 * max(1, player.level / 2) player.experience += experience player.send_output("Guadagni [white]%d[close] di esperienza!" % experience) tessi.specials["player_on_quest"] = "" #to_say = "Quest False" #command_say(tessi, to_say) to_say_1 = "a %s È proprio il mio fermacapelli! Dopo tanto affanno ecco a te un piccolo presente come ringraziamento." % player.code defer_if_possible(1, 1, tessi, player, command_say, tessi, to_say_1) # Poiché un'iniezione silenziosa di un oggetto ad un giocatore non è molto # friendly allora dà il medaglione alla tessitrice e quest'ultima lo dà # al giocatore tramite un give medaglione = Item(MEDAGLIONE_PROTO_CODE) unguento = Item(UNGUENTO_PROTO_CODE) medaglione.inject(tessi) unguento.inject(medaglione) defer_if_possible(2, 2, tessi, player, give_reward, tessi, medaglione, player) to_say_2 = "a %s Adoperalo con saggezza, solo quando saprai che farne perché potrai utilizzarlo una sola volta." % player.code defer_if_possible(3, 3, tessi, player, command_say, tessi, to_say_2) defer(4, reset_quest, tessi)
def hit_turn(self, active_entity, passive_entity, active, passive, modifier=1.0): # Calcola il danno e controlla se chi lo subisce muore damage = self.give_damage(active_entity, passive_entity, active, passive, modifier=modifier) # Ricava il messaggio di danno: for dam_message in DAM_MESSAGES: if damage <= dam_message[0]: break dam_color = '''<span style="color:rgb(%d,%d,255)">''' % (255-dam_message[1], 255-dam_message[1]) dam_punct = random_marks(0, dam_message[2]) # Colpisce la vittima wielded_entity = active_entity.get_wielded_entity() if wielded_entity: active_entity.act("\n%s%s</span> $N con $a%s" % (dam_color, dam_message[3], dam_punct), TO.ENTITY, passive_entity, wielded_entity) active_entity.act("$n %s%s</span> $N con $a%s" % (dam_color, dam_message[4], dam_punct), TO.OTHERS, passive_entity, wielded_entity) active_entity.act("$n ti %s%s</span> con $a%s" % (dam_color, dam_message[4], dam_punct), TO.TARGET, passive_entity, wielded_entity) else: active_entity.act("\n%s%s</span> $N col %s%s" % (dam_color, dam_message[3], active_entity.skin_colorize("pugno"), dam_punct), TO.ENTITY, passive_entity) active_entity.act("$n %s%s</span> $N con un %s%s" % (dam_color, dam_message[4], active_entity.skin_colorize("pugno"), dam_punct), TO.OTHERS, passive_entity) active_entity.act("$n ti %s%s</span> con un %s%s" % (dam_color, dam_message[4], active_entity.skin_colorize("pugno"), dam_punct), TO.TARGET, passive_entity) active_entity.send_prompt() if passive_entity.life <= 0: # Poiché è possibile che il combattimento non si fermi in tempo # ci possono essere errori nel qual caso che la vittima muoia nella # stessa stanza in cui viene rigenerata, quindi viene inserita # una deferred per assicurarsi che il True, cioè il segnale di # fine combattimento, venga prima di tutto defer(0.001, self.defeat, active_entity, passive_entity, active, passive) return True return False
def nausea(entity, polpetta): # Può capitare visto che questa funzione viene usata in una defer if not polpetta or not entity: return entity.act("Dal profondo giunge un fetido lezzo che ti induce un certo tremito.", TO.ENTITY) entity.act("$n è scosso da un tremito improvviso.", TO.OTHERS, polpetta) entity.act("Ti vendichi inducendo le prime avvisaglie in $n.", TO.TARGET, polpetta) defer(TIME_DELAY, puke_polpetta, entity, polpetta)
def before_listen_say(listener, speaker, target, phrasei, ask, exclaim, behavioured): if not target: return if target.can_see(speaker): to_say = "a %s *adirato* [red]prima[close] che mi arrabbi vattene!" % speaker.code else: to_say = "*spaventato* Chi sei? Cosa vuoi da me? Lasciami in pace, vai via [red]prima[close] che mi arrabbi!" #command_say(target, to_say) defer(1, command_say, target, to_say)
def after_inject(seme, room): print ">>> inserimento seme via inject ()" if seme.location.IS_ITEM: print "######## seme è in oggetto" cespuglio = seme.location else: print "######## seme non è in oggetto" cespuglio = None defer(1, after_inject_deferred, seme, cespuglio) return False
def after_inject(seme, room): # Defer necessaria perché l'inject avviene priam che sian assegnate # le special dal next_stage del cespuglio di semi # ORCOCAN! # Se passo alla defer seme e poi faccio un seme.location dice che non esiste quando invece # non crea problemi se lo faccio qui. PERCHE'? print ">>> inserimento seme via inject ()" if seme.location.IS_ITEM and seme.location.prototype.code == PROTO_CESPUGLIO_CODE: cespuglio = seme.location else: cespuglio = None defer(1, after_inject_deferred, seme, cespuglio) return False
def after_listen_say(listener, speaker, target, phrase, ask, exclaim, behavioured): if not target: return if target.can_see(speaker): to_say = "a %s *adirato* è [red]tardi[close] mi hai indisposto!" % speaker.code else: to_say = "*spaventato* Chi sei? Cosa vuoi da me? Lasciami in pace, vai via [red]ora[close] che mi hai adirato!" command_say(target, to_say) if "vagytur" in target.specials: to_say = "Vagytur nelle special!" else: to_say = "Vagytur non è nelle special" defer(2, command_say, target, to_say)
def after_get(player, unguento, medaglione, behavioured): for mode in unguento.wear_type.modes: for part in mode: unguento.wear_mode += part part_descriptions = get_part_descriptions(mode, "wear") send_wear_messages(player, unguento, "Indossi", "indossa", part_descriptions) break defer(3600, unguento_cleaning, unguento, player) if medaglione.IS_ITEM: print medaglione.code defer(120, medaglione_corruption, medaglione, player) return False
def after_move(entity, from_room, direction, to_room, running, behavioured): if not entity.IS_PLAYER: return for content in to_room.iter_contains(): if content.IS_PLAYER: continue if content.prototype.code == oggetti["chiave"]: return chiave = Item(oggetti["chiave"]) chiave.inject(to_room) defer(3, ambience_act_1, to_room) defer(5, ambience_act_2, to_room, chiave)
def after_dropped(entity, brain, room, behavioured): # Se l'oggetto non è stato abbandonato in una stanza esce if not room.IS_ROOM: return # Se il settore della stanza non è tra quelli fertili esce if room.sector not in (SECTOR.PLAIN, SECTOR.WOOD): entity.act("$N pulsa come se... come se... come se volesse conquistare il mondo, ma oggi il mondo non è disponibile!", TO.ENTITY, brain) return entity.act("$N pulsa come se... come se... come se volesse conquistare il mondo!", TO.ENTITY, brain) # Tra 10 secondi il reattore di aarit avrà terminato di assorbire il # cervello nel terreno facendone nascere un mindflayer defer(10, born_to_be_wild_or_something, brain, room)
def after_listened(player, astronoma, descr, detail, behavioured): if "expecting_answer" in astronoma.specials and astronoma.specials["expecting_answer"] == True: return player_code = player.get_numbered_keyword(looker=astronoma) if player.race in HATED_RACES: to_say = "a %s *astiosamente* Ti hanno condotto sin qui propositi di distruzione? La tua razza non è qui ben accetta." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) return to_say = "a %s *placidamente* Sei giunt$o sin qui stranier$o perché ti ha spinto il desiderio d'osservar il cielo e perderti negli infiniti spazi stellari?" % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) astronoma.specials["expecting_answer"] = True defer(15, reset_expecting_answer, player, astronoma)
def dust_eating(dust, caterpillar): if not dust: log.bug("dust non è un parametro valido: %r" % dust) return if not caterpillar: log.bug("caterpillar non è un parametro valido: %r" % caterpillar) return if dust.location != caterpillar.location: caterpillar.act("$n vaga disorientato alla ricerca diqualcosa", TO.OTHERS) defer(60, dust_eating, dust, caterpillar) return #command_eat(caterpillar, dust) caterpillar.act("$n viene avvolto dalla polvere bianca.", TO.OTHERS) dust.extract(1)
def start_deposing(butterfly): if not butterfly: log.bug("butterfly non è un parametro valido: %r" % butterfly) return None egg = generic_creation(butterfly, PROTO_EGG_CODE) if not egg: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return # Inserisce l'uovo in gioco egg.inject(butterfly.location) # Tra un po' farà nascere il bruco dall'uovo defer(10, caterpillar_born, egg, butterfly) # la farfalla farà un altro uovo defer_random_time(10, 100, start_deposing, butterfly)
def after_listened(player, astronoma, descr, detail, behavioured): if "expecting_answer" in astronoma.specials and astronoma.specials[ "expecting_answer"] == True: return player_code = player.get_numbered_keyword(looker=astronoma) if player.race in HATED_RACES: to_say = "a %s *astiosamente* Ti hanno condotto sin qui propositi di distruzione? La tua razza non è qui ben accetta." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) return to_say = "a %s *placidamente* Sei giunt$o sin qui stranier$o perché ti ha spinto il desiderio d'osservar il cielo e perderti negli infiniti spazi stellari?" % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) astronoma.specials["expecting_answer"] = True defer(15, reset_expecting_answer, player, astronoma)
def medaglione_corruption(medaglione, player): # Normale perché la funzione è deferrata if not medaglione or not player: return old_medallion = Item("villaggio-zingaro_item_medaglione-rotto") old_medallion.inject(medaglione.location) medaglione.act("$n si consuma lentamente...", TO.ENTITY, send_to_location=player.location) medaglione.act("$n si consuma lentamente...", TO.OTHERS, send_to_location=player.location) medaglione.extract(1) defer(120, medaglione_remove, old_medallion, player) return False
def start_deposing(chicken): if not chicken: log.bug("chicken non è un parametro valido: %r" % chicken) return None egg = generic_creation(chicken, PROTO_EGG_CODE) if not egg: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return # Inserisce l'uovo in gioco location = chicken.location egg.inject(location) # Tra un po' farà nascere il pulcino dall'uovo defer(10, chick_born, egg, chicken) # La gallina che canta è quella che ha fatto l'uovo e ne farà un altro defer_random_time(10, 100, start_deposing, chicken)
def start_deposing(butterfly): # E' normale visto che la funzione viene anche deferrata if not butterfly: return None egg = generic_creation(butterfly, PROTO_EGG_CODE) # Può capitare se l'entità ha raggiunto il suo massimo globale creabile # oppure se la farfalla muore if not egg: return # Inserisce l'uovo in gioco egg.inject(butterfly.location) # Tra un po' farà nascere il bruco dall'uovo defer(10, from_egg_to_caterpillar, egg) # La farfalla farà un altro uovo defer_random_time(15, 20, start_deposing, butterfly)
def nausea(entity, pescetto): # Può capitare visto che questa funzione viene usata in una defer if not pescetto or not entity: return if FLAG.INGESTED not in pescetto.flags: return if entity.race in likes_fish_races: return entity.act("Un forte senso di nausea ti si aggrappa alla bocca dello stomaco facendoti vomitare.", TO.ENTITY) entity.act("L'espressione di $n cambia in un tangibile disgusto poco prima di vomitare.", TO.OTHERS, pescetto) entity.act("$n ti vomita all'esterno verso la libertà.", TO.TARGET, pescetto) pescetto.flags -= FLAG.INGESTED pescetto.extract(1) pescetto.inject(entity.location) pescetto.long = "$N " + pescetto_long defer(TIME_LONG_RESET, reset_long, pescetto)
def after_looked(player, apprendista, descr, detail, use_examine, behavioured): print " >>> SPECIALS <<<", apprendista.specials if not player.IS_PLAYER: return if apprendista.specials: to_say = "a %s *allegro* Benvenuto nella bottega del tagliapietre! Eseguiamo lavorazioni per tutti i gusti e tutte le voglie!" % player.code command_say(apprendista, to_say) return if random.randint(1, 2) != 1: return apprendista.specials["apprendista:player_code"] = player.code apprendista.specials["apprendista_situation"] = "look" to_say = "a %s Il tuo sguardo indagatore mi dice che ti piacerebbe conoscere qualche segreto riguardo a questo villaggio, mi sbaglio?" % player.code command_say(apprendista, to_say) defer(60, del_specials_status, apprendista, "look")
def after_listen_rpg_channel(apprendista, player, target, phrase, ask, exclaim, behavioured): if target != apprendista: return if "work_in_progress" in apprendista.specials and apprendista.specials["work_in_progress"]: return apprendista.specials["work_in_progress"] = True defer(10, change_status, apprendista) phrase = ALFA_ONLY_PATTERN.sub("", phrase) choosed_materials = [] for materiale in ITEM_PROTO_CODE.keys(): if is_infix(materiale, phrase): choosed_materials.append(materiale) if not choosed_materials: defer_if_possible(1, 2, target, player, spiegazioni, target, player) else: choosed_material = random.choice(choosed_materials) defer_random_time(1, 2, generate_item, apprendista, player, choosed_material, apprendista.location)
def incites_to_follow(player, astronoma): # Possibile visto che questa funzione è deferrata if not player or not astronoma: return player_code = player.get_numbered_keyword(looker=astronoma) if calendar.is_day(): to_say = "a %s *sorridendo* Allora torna da me quando è notte." % player_code command_say(astronoma, to_say) return to_say = "a %s *sorridendo* Seguimi allora stranier$o curios$o!" % player_code command_say(astronoma, to_say) defer_random_time(1, 2, command_up, astronoma) # Invia tra quasi due minuti un messaggio al pg se è ancora lì e poi poco dopo torna giù to_say = "a %s *sorridendo* Torno giù a seguire le mie occupazioni..." % player_code defer_if_possible(115, 118, astronoma, player, command_say, astronoma, to_say) defer(120, command_down, astronoma)
def greet_the_astronoma(player, astronoma): # Se astronoma non è valida significa che i social non sono diretti # esplicitamente all'astronoma e quindi esce if not astronoma: return if "is_greetable" in astronoma.specials and astronoma.specials["is_greetable"] == False: return player_code = player.get_numbered_keyword(looker=astronoma) if player.race in HATED_RACES: to_say = "a %s *astiosamente* Il tuo inchino non è accettato in questo luogo per il sangue innocente sparso, per l'avidità di alcuni..." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) return to_say = "a %s *placidamente* Buongiorno a te stranier$o curios$o, sei benvenut$o nella Torre per guardare le Stelle...." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) astronoma.specials["is_greetable"] = False defer(60, reset_greetable, astronoma)
def start_growth(self, entity, type_attr_name): if not entity: log.bug("entity non è parametro valido: %r" % entity) return if type_attr_name not in ("plant_type", "seed_type"): log.bug("type_attr_name non è parametro valido: %r" % type_attr_name) return # --------------------------------------------------------------------- seconds = self.rpg_hours * (config.seconds_in_minute * config.minutes_in_hour) self.deferred_stage = defer(seconds, self.next_stage, entity, type_attr_name)
def look_for_caterpillar(dust, show_act=True): if not dust: log.bug("dust non è un parametro valido: %r" % dust) return location = dust.location caterpillar = dust.find_entity("bruco", location, ["mobs"]) if not caterpillar: if show_act: dust.act("My name is $n: niente bruchi %r" % dust, TO.OTHERS) dust.act("My name is $n: niente bruchi %r" % dust, TO.ENTITY) defer(60, look_for_caterpillar, dust) return if show_act: dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.OTHERS) dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.ENTITY) command_say(caterpillar, "sa la vist cus'è?") #defer( 60, look_for_caterpillar, dust) # il bruco potrebbe essere soggetto a script che lo potrebbero mutare senza avvisaglie quindi # tolgo di mezzo il bruco per sostituirlo con un altro che so non essere afflitto da script location = caterpillar.location caterpillar.extract(1) new_caterpillar = Mob(PROTO_CATERPILLAR_CODE) if not caterpillar: log.bug("impossibile crare un nuovo bruco: %r" % new_caterpillar) new_caterpillar.inject(location) new_caterpillar.act("$n cambia aspetto in modo repentino.", TO.OTHERS) new_caterpillar.act("$n cambia aspetto in modo repentino.", TO.ENTITY) dust_eating(dust, new_caterpillar) #ora resta solo da far mangiare la polvere che è bene rimuovere e rimpiazzare con con qualcosaltro return
def greet_the_astronoma(player, astronoma): # Se astronoma non è valida significa che i social non sono diretti # esplicitamente all'astronoma e quindi esce if not astronoma: return if "is_greetable" in astronoma.specials and astronoma.specials[ "is_greetable"] == False: return player_code = player.get_numbered_keyword(looker=astronoma) if player.race in HATED_RACES: to_say = "a %s *astiosamente* Il tuo inchino non è accettato in questo luogo per il sangue innocente sparso, per l'avidità di alcuni..." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) return to_say = "a %s *placidamente* Buongiorno a te stranier$o curios$o, sei benvenut$o nella Torre per guardare le Stelle...." % player_code defer_if_possible(1, 2, astronoma, player, command_say, astronoma, to_say) astronoma.specials["is_greetable"] = False defer(60, reset_greetable, astronoma)
def after_listen_rpg_channel(apprendista, player, target, phrase, ask, exclaim, behavioured): if target != apprendista: return if "work_in_progress" in apprendista.specials and apprendista.specials[ "work_in_progress"]: return apprendista.specials["work_in_progress"] = True defer(10, change_status, apprendista) phrase = ALFA_ONLY_PATTERN.sub("", phrase) choosed_materials = [] for materiale in ITEM_PROTO_CODE.keys(): if is_infix(materiale, phrase): choosed_materials.append(materiale) if not choosed_materials: defer_if_possible(1, 2, target, player, spiegazioni, target, player) else: choosed_material = random.choice(choosed_materials) defer_random_time(1, 2, generate_item, apprendista, player, choosed_material, apprendista.location)
def render_GET(self, request, conn): if "file" not in request.args: page = ['''<h3>Lista dei File di Log consultabili:</h3>'''] for root, filename in iter_filenames("log"): page.append('''<a href="show_logs.html?file=%s">%s</a><br>''' % (filename, filename)) return "".join(page) # Stampa il contenuto del file scelto filepath = "log/" + request.args["file"][0] try: file = open(filepath, "r") except: return "Impossibile aprire il file %s in lettura." % filepath # Per evitare che attenda la scrittura del contenuto completo crea # una "deferred fasulla" per scrivere la pagina piano piano d = defer(0, self.send_log_content, request, conn, file) d.addErrback(self.error_on_sending_log) return NOT_DONE_YET
def moved_on_init(mob): defer(300, remove_mob, mob)
def check_social(entity, command, argument="", behavioured=False): """ Invia i messaggi corretti relativamente ad un comando di social. """ if not entity: log.bug("entity non è un parametro valido: %r" % entity) return if not command: log.bug("command non è un parametro valido: %r" % command) return # ------------------------------------------------------------------------- try: social = database["socials"][command.fun_name] except NameError: log.bug("Social %s, inviato dall'entità %s, errato o inesistente nel database dei social." % (entity.code, command.fun_name)) return active_trigger_suffix = "active_" + social.get_input_argument() passive_trigger_suffix = "passive_" + social.get_input_argument() # Se non è stato passato nessun argomento invia il messaggio di social adatto if not argument: force_return = check_trigger(entity, "before_" + active_trigger_suffix, entity, None, argument, behavioured) if force_return: return force_return = check_trigger(entity.location, "before_" + passive_trigger_suffix, entity, None, argument, behavioured) if force_return: return # Esegue il trigger anche sulle altre entità perché così funziona il # caso in cui per esempio un player ha eseguito un nod e un mob è in # attesa di un sì for contain in entity.location.iter_contains(use_reversed=True): force_return = check_trigger(contain, "before_" + passive_trigger_suffix, entity, None, argument, behavioured) if force_return: continue entity.act(social.get_racial_message(entity, "entity_no_arg"), TO.ENTITY) # others_no_arg è un messaggio facoltativo racial_message = social.get_racial_message(entity, "others_no_arg") if racial_message: entity.act(racial_message, TO.OTHERS) force_return = check_trigger(entity, "after_" + active_trigger_suffix, entity, None, argument, behavioured) if force_return: return force_return = check_trigger(entity.location, "after_" + passive_trigger_suffix, entity, None, argument, behavioured) if force_return: return for contain in entity.location.iter_contains(use_reversed=True): force_return = check_trigger(contain, "after_" + passive_trigger_suffix, entity, None, argument, behavioured) if force_return: continue return # Se invece è stato passato un argomento trova la vittima target = entity.find_entity_extensively(argument) if not target: target = entity.find_entity(argument, location=entity) if not target: entity.send_output("Non trovi nessun [white]%s[close] qui intorno." % argument) return # Se la vittima e l'entità sono uguali cerca il messaggio di sociale _auto # oppure se questo non esiste il no_arg che ne fa le veci if target == entity: force_return = check_trigger(entity, "before_" + active_trigger_suffix, entity, target, argument, behavioured) if force_return: return force_return = check_trigger(target, "before_" + passive_trigger_suffix, entity, target, argument, behavioured) if force_return: return # Se non c'è il messaggio entity_auto c'è entity_no_arg msg_auto = social.get_racial_message(entity, "entity_auto") if not msg_auto: msg_auto = social.get_racial_message(entity, "entity_no_arg") entity.act(msg_auto, TO.ENTITY, target) # Se non c'è il messaggio others_auto c'è others_no_arg msg_auto = social.get_racial_message(entity, "others_auto") if not msg_auto: msg_auto = social.get_racial_message(entity, "others_no_arg") entity.act(msg_auto, TO.OTHERS, target) force_return = check_trigger(entity, "after_" + active_trigger_suffix, entity, target, argument, behavioured) if force_return: return force_return = check_trigger(target, "after_" + passive_trigger_suffix, entity, target, argument, behavioured) if force_return: return return # Se la vittima non è entity provvede ad inviare il messaggio di social adatto force_return = check_trigger(entity, "before_" + active_trigger_suffix, entity, target, argument, behavioured) if force_return: return force_return = check_trigger(target, "before_" + passive_trigger_suffix, entity, target, argument, behavioured) if force_return: return entity.act(social.get_racial_message(entity, "entity_found", target, "tuo"), TO.ENTITY, target) entity.act(social.get_racial_message(entity, "others_found", target, "suo"), TO.OTHERS, target) entity.act(social.get_racial_message(entity, "target_found"), TO.TARGET, target) force_return = check_trigger(entity, "after_" + active_trigger_suffix, entity, target, argument, behavioured) if force_return: return force_return = check_trigger(target, "after_" + passive_trigger_suffix, entity, target, argument, behavioured) if force_return: return # Da qui in poi gestisce l'invio dei social automatici da parte dei mob # rispondendo ai social dei pg if not entity.IS_PLAYER or not target.IS_MOB: return # Invia a caso e dopo un secondo invia un social con la stessa intenzione. # Non viene inviata la risposta social automatica se ci sono dei trigger # relativi a quel social da qualche parte # (bb) tuttavia la ricerca così dei trigger è fallace e ci vorrebbe una funzione a parte if ("before_" + active_trigger_suffix not in entity.gamescripts and "after_" + active_trigger_suffix not in entity.gamescripts and "before_" + active_trigger_suffix not in target.gamescripts and "after_" + active_trigger_suffix not in target.gamescripts and "before_" + active_trigger_suffix not in entity.location.gamescripts and "after_" + active_trigger_suffix not in entity.location.gamescripts and random.randint(0, 3) == 0 and not behavioured): defer(1, social.send_to, target, entity)
def cycle(self): """ Sostanzialmente la classica funzione di game_loop presente in tutti i Diku-Like. """ if self.paused: return self.elapsed_seconds += 1 #- Parte relativa lo shutdown --------------------------------------- if engine.seconds_to_shutdown >= 0: if engine.seconds_to_shutdown in SHUTDOWN_INTERVALS: for conn in reversed(connections.values()): if not conn.player or not conn.player.game_request: continue if engine.seconds_to_shutdown > 60: time_descr = "%d minuti" % engine.seconds_to_shutdown / 60 elif engine.seconds_to_shutdown == 60: time_descr = "1 minuto" elif engine.seconds_to_shutdown == 1: time_descr = "ORA!!" else: time_descr = "%d secondi" % engine.seconds_to_shutdown # (bb) Ok, lo si risolve così questo problema dei colori, # ma bisognerebbe supportare le colorazioni annidate, # visto che il nome del mud potrebbe essere colorato, e # sarebbe meglio la riga commentata sotto #conn.player.send_output("\n[red]Attenzione! Lo Shutdown di %s avverrà tra %s![close]" % ( conn.player.send_output("\n[red]Attenzione! Lo Shutdown di[close] %s [red]avverrà tra %s![close]" % ( config.game_name, time_descr)) conn.player.send_prompt() engine.seconds_to_shutdown -= 1 if engine.seconds_to_shutdown < 0: # Bisogna uscire dallo scope del loop tramite una deferred # per eseguire uno shutdown senza fastidiose eccezioni defer(0, shutdown_mud) #- Cose aggiornate ad ogni minuto RPG: --------------------------------- if self.elapsed_seconds % config.seconds_in_minute == 0: # Aggiorna il calendario rpg calendar.update() # Aggiorna i punti di vita, mana e movimento dei mob e dei pg # (TD) yield iter dei valori del database for entity in database["mobs"].values() + database["players"].values(): if not entity.location: continue if entity.location.IS_ROOM: if FLAG.INGESTED not in entity.flags.data: entity.update_points() else: player_carrier = entity.get_player_carrier() if not player_carrier or player_carrier.game_request: if FLAG.INGESTED not in entity.flags.data: entity.update_points() # Aggiorna l'exp e invia le informazioni per il client for player in database["players"].itervalues(): if player.game_request: player.update() # Controlla che gli eventi di reset siano attivi correttamente; # una volta trovato un possibile room reset senza evento lo # ricontrolla dopo più di due secondi per essere sicuri che non # sia una transizione tra l'estinzione di un evento di reset e # la creazione di quello successivo if config.check_references: pass # (TT) Per ora disattivato che magari fa casino con i reset #check_room_reset_events() # Questo si attiva ogni ora rpg if calendar.minute == 0: remake_mazes() # Per bilanciare il carico della cpu visto che su Aarit un minuto è # formato da due secondi l'altro secondo è utilizzato per eseguire # i comportamenti if (self.elapsed_seconds % config.seconds_in_minute == 1 or config.seconds_in_minute == 1): areas = database["areas"].values() # Può capitare che il gioco sia stato avviato vergine di aree if areas: self.update_behaviours(areas, "mobs") self.update_behaviours(areas, "items") #- Cose aggiornate ogni mezz'ora RPG: --------------------------------- if self.elapsed_seconds % ((config.seconds_in_minute * config.minutes_in_hour) / 2) == 0: # Aggiornamento delle condizioni: fame, sete, sonno... etc etc # (TD) fare quel sistema di iter database for entity in database["mobs"].values() + database["players"].values(): if not entity.location: continue if entity.location.IS_ROOM: if FLAG.INGESTED not in entity.flags.data: entity.update_conditions() else: player_carrier = entity.get_player_carrier() if not player_carrier or player_carrier.game_request: if FLAG.INGESTED not in entity.flags.data: entity.update_conditions()