def born_to_be_wild_or_something(brain, room): # Se il cervello non si trova più tra gli oggetti allora il gamescript è # già scattato in precedenza if brain.code not in database["items"]: return # Rimuove il cervello dalla stanza e dal database, abbiamo nella funzione # brain che possiamo utilizzare fino alla fine della stessa, poi # l'oggetto sarà come se non esistesse più brain.extract(1) # Crea una nuova entità dal nostro conosciutissimo mindf passandogli il # codice identificativo del prototipo mindf = Mob("mfdonald_mob_mindflayer_01") # Imposta tutti i riferimenti per il neonato mindf, sarà da controllare che # siano tutti a posto! mindf.inject(room) # Avvisiamo tutti quanti del lieto evento mindf.act("$n nasce da $N e inizia subito a muovere i tentacolini, che carino!", TO.OTHERS, brain) mindf.act("Nasci da $N e inizi subito ad avere un certo languorino; ma la tua non è proprio fame... e solo voglia di qualcosa di buono!", TO.ENTITY, brain) mindf.act("$n nasce da te, e ti senti subito molto orGoglione di quello che hai fatto!", TO.TARGET, brain) # Ora che è nato facciamogli dire qualcosa di intelligente in un tempo # variabili di secondi (qui in realtà sarebbe meglio utilizzare la funzione # interpret per inviare i comandi, cosicché mob che, per esempio, dormono # si mettono nella posizione alzata per inviare il comando, ma vabbe') defer_random_time(15, 30, command_say, mindf, "Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl, fhtagn!")
def caterpillar_chrysalis(caterpillar, mother): if not caterpillar: log.bug("caterpillar non è un parametro valido: %r" % caterpillar) return if not mother: log.bug("mother non è un parametro valido: %r" % mother) return butterfly_chrysalis = generic_creation(caterpillar, PROTO_CHRYSALIS_CODE) if not butterfly_chrysalis: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return # Se il bruco nel frattempo non si trova più tra i mob allora esce if caterpillar.code not in database["mobs"]: return location = caterpillar.location if not location: log.bug("location non valida: %r" % location) return # Rimuove il bruco caterpillar.extract(1) # Inserisce la crisalide butterfly_chrysalis.inject(location) butterfly_chrysalis.act("$N s'è inbozzolato in $n", TO.OTHERS, caterpillar) butterfly_chrysalis.act("$N s'è inbozzolato in $n", TO.ENTITY, caterpillar) defer_random_time(60, 80, chrysalis_open, butterfly_chrysalis, mother)
def caldarrostaio_act(caldarrostaio, player, castagne): # Normale visto che questa funzione viene deferrata if not caldarrostaio or not player or not castagne: return if player.location != caldarrostaio.location: to_yell = "Hei %s, dove cavolo te ne sei andato?" % player.get_name( looker=caldarrostaio) command_yell(caldarrostaio, to_yell) return castagne.inject(caldarrostaio) player_code = player.get_numbered_keyword(looker=caldarrostaio) pietanza_code = castagne.get_numbered_keyword(looker=caldarrostaio) argument = "%s %s" % (pietanza_code, player_code) success_result = command_give(caldarrostaio, argument) if success_result: defer_if_possible(1, 2, caldarrostaio, player, command_say, caldarrostaio, "a %s Buon appetito!" % player_code) else: # (TD) Lo lascia per terra! è proprio grezzo, bisognerebbe che lo appoggi # su di un tavolo, appena vi sarà il sistema della mobilia lo farò defer_if_possible(1, 2, caldarrostaio, player, command_say, caldarrostaio, "a %s Scuso ma te l'appoggio qui, eh?" % player_code) defer_random_time(3, 4, command_drop, caldarrostaio, pietanza_code)
def before_listen_rpg_channel(locandiera, player, target, phrase, ask, exclaim, behavioured): # Mi assicuro che si stia parlando rivolgendosi alla locandiera if target != locandiera: return if is_infix("menù", phrase): to_say = "a %s Il nostro menù di oggi lo potete leggere anche da qui, è lì sul bancone." % player.code defer_if_possible(1, 2, locandiera, player, command_say, locandiera, to_say) return proto_cibi = [] for proto_code in PROTO_FOODS_CODES: table_name = "proto_" + proto_code.split("_")[1] + "s" proto_entity = database[table_name][proto_code] for keyword in multiple_arguments(proto_entity.get_keywords_attr(looker=locandiera)): if is_infix(keyword, phrase): proto_cibi.append(proto_entity) player_code = player.get_numbered_keyword(looker=locandiera) if not proto_cibi: to_say = "a %s Non abbiam nessun cibo di quel tipo..." % player_code command_say(locandiera, to_say) return proto_pietanza = random.choice(proto_cibi) pietanza = proto_pietanza.CONSTRUCTOR(proto_pietanza.code) to_say = "a %s Ottimo! %s in arrivo." % (player_code, first_color_upper(pietanza.get_name(looker=locandiera))) defer_random_time(1, 2, command_say, locandiera, to_say) defer_random_time(5, 7, locandiera_act, locandiera, player, pietanza)
def born_mushrum(spore, room): # Se le spore non si trovan più tra gli oggetti allora il gamescript è # già scattato in precedenza if spore.code not in database["items"]: return # Rimuove le spore dalla stanza e dal database, abbiamo nella funzione # spore che possiamo utilizzare fino alla fine della stessa, poi # l'oggetto sarà come se non esistesse più spore = spore.extract(1) # Crea una nuova entità dal nostro conosciutissimo mushroom passandogli il # codice identificativo del prototipo mushroom = Mob("torreelementi_mob_faura_01") # Imposta tutti i riferimenti per il neonato mushroom, sarà da controllare che # siano tutti a posto! mushroom.inject(room) # Avvisiamo tutti quanti del lieto evento mushroom.act( "Qualcuno ha fatto l'errore di seminarti tramite $N ma lo raggiungerai", TO.ENTITY, spore) mushroom.act("L'orrore non avrà dunque mai fine! Ecco enuclearsi $n!", TO.OTHERS, spore) mushroom.act("$n 'enuclea ed ora tu te ne devi andare", TO.TARGET, spore) # Rendiamo conto della velocità di germinazione con genuina sorpresa defer_random_time(15, 30, command_emote, mushroom, "è cresciuto a vista d'occhio!")
def before_listen_rpg_channel(locandiera, player, target, phrase, ask, exclaim, behavioured): # Mi assicuro che si stia parlando rivolgendosi alla locandiera if target != locandiera: return if is_infix("menù", phrase): to_say = "a %s Il nostro menù di oggi lo potete leggere anche da qui, è lì sul bancone." % player.code defer_if_possible(1, 2, locandiera, player, command_say, locandiera, to_say) return proto_cibi = [] for proto_code in PROTO_FOODS_CODES: table_name = "proto_" + proto_code.split("_")[1] + "s" proto_entity = database[table_name][proto_code] for keyword in multiple_arguments( proto_entity.get_keywords_attr(looker=locandiera)): if is_infix(keyword, phrase): proto_cibi.append(proto_entity) player_code = player.get_numbered_keyword(looker=locandiera) if not proto_cibi: to_say = "a %s Non abbiam nessun cibo di quel tipo..." % player_code command_say(locandiera, to_say) return proto_pietanza = random.choice(proto_cibi) pietanza = proto_pietanza.CONSTRUCTOR(proto_pietanza.code) to_say = "a %s Ottimo! %s in arrivo." % ( player_code, first_color_upper(pietanza.get_name(looker=locandiera))) defer_random_time(1, 2, command_say, locandiera, to_say) defer_random_time(5, 7, locandiera_act, locandiera, player, pietanza)
def before_giving(player, cibo, bimba, direction, behavioured): if player.IS_PLAYER or not player.race == RACE.TUAREG: to_say = "a %s La mia zietta mi ha detto di non accettare cibo dagli sconosciuti!" % player.code command_say(bimba, to_say) return True else: #print "pappa in arrivo" defer_random_time(1, 3, cibo_eat, cibo, bimba)
def generic_creation(parent, proto_code, show_act=True): # Si assicura che il codice passato esista if proto_code in database["proto_items"]: proto_son = database["proto_items"][proto_code] elif proto_code in database["proto_mobs"]: proto_son = database["proto_mobs"][proto_code] else: log.bug("Il codice %s non è stato trovato nel database" % proto_code, log_stack=False) return None if show_act: parent.act("My name is $n: deposing reloaded!", TO.OTHERS) parent.act("My name is $n: deposing reloaded!", TO.ENTITY) # Se eccede il numero di entità definito in MaxGlobalQuantity allora esce if proto_son.has_reached_max_global_quantity(): #if proto_son.max_global_quantity != 0 and proto_son.current_global_quantity >= proto_son.max_global_quantity: if show_act: parent.act("My name is $n: ther'are too many %s!" % proto_code, TO.OTHERS) parent.act("My name is $n: ther'are too many %s!" % proto_code, TO.ENTITY) if random.randint(1, 5) == 1: # Faccio il death istantaneo per verificare che non sia qui il # problema da un certo punto in poi pare che le uova non si # schiudano più anche senza che vi sian pulcini #defer_random_time(150, 300), death, parent) if show_act: parent.act("My name is $n and I'll die now!", TO.OTHERS) parent.act("My name is $n and I'll die now!", TO.ENTITY) death(parent) else: defer_random_time(150, 300, start_deposing , parent) if show_act: parent.act("My name is $n I'll try later!", TO.OTHERS) parent.act("My name is $n I'll try later!", TO.ENTITY) # Esce da qui in tutti e due i casi return None # Crea un nuovo figlio type = proto_code.split("_")[1] if type == "mob": son = Mob(proto_code) elif type == "item": son = Item(proto_code) else: log.bug("type non è valido con codice %s: %s" % (proto_code, type)) return None if not son: log.bug("Non è stato possibile creare un figlio con codice %s: %r" % (proto_code, son), log_stack=False) return None if show_act: parent.act("My name is $n: son $N created!", TO.OTHERS, son) parent.act("My name is $n: son $N created!", TO.ENTITY, son) return son
def before_giving(player, farfalla, idrusa, direction, behavioured): if not player.IS_PLAYER: to_say = "a %s *concentrato* No grazie. Non accetto nulla da chicchessia." % player.get_numbered_keyword( ) defer_if_possible(1, 2, command_say, idrusa, to_say) return True command_look(idrusa, player.code) # Idrusa non ha iniziato a dare nessuna quest if "quest_status" not in idrusa.specials: to_say = "a %s *impensierito* No grazie. Ora non sono interessata." % player.code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True quest_player_code = idrusa.specials["player_code"] quest_player = database["players"][quest_player_code] quest_player_name = quest_player.get_name(looker=idrusa) quest_status = idrusa.specials["quest_status"] if quest_status == "domanda": to_say = "a %s *concentrato* No grazie. Sto attendendo che %s mi risponda." % ( player.code, quest_player_name) defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True # Controlla che l'entità che dà sia il giocatore della quest if player.code != quest_player_code: to_say = "a %s No grazie. Sto aspettando che %s mi porti ciò che deve." % ( player.code, quest_player_name) defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True # Controlla se l'oggetto dato sia una farfalla if not farfalla.race == RACE.BUTTERFLY: to_say = "a %s *critica* Stai cercando di muovermi a pena o di turlupinarmi?" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True else: idrusa.specials["quest_status"] = "completa" # Ora che la quest è completa ne blocca un eventuale reset delete_deferred_reset(idrusa) to_yell = "a %s *scortese* Pensavo avessi desistito ormai!" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_yell, idrusa, to_yell) to_say = "a %s *con un largo sorriso di scherno* La via per Klirbe non è però accessibile per te..." % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) to_say = "a %s In compenso hai fatto un po' d'esperienza!" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) player.experience += 100 # Tra un po' di tempo si potranno cercare farfalle defer_random_time(3600, 4800, its_farfalla_time, idrusa)
def before_giving(player, farfalla, idrusa, direction, behavioured): if not player.IS_PLAYER: to_say = "a %s *concentrato* No grazie. Non accetto nulla da chicchessia." % player.get_numbered_keyword() defer_if_possible(1, 2, command_say, idrusa, to_say) return True command_look(idrusa, player.code) # Idrusa non ha iniziato a dare nessuna quest if "quest_status" not in idrusa.specials: to_say = "a %s *impensierito* No grazie. Ora non sono interessata." % player.code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True quest_player_code = idrusa.specials["player_code"] quest_player = database["players"][quest_player_code] quest_player_name = quest_player.get_name(looker=idrusa) quest_status = idrusa.specials["quest_status"] if quest_status == "domanda": to_say = "a %s *concentrato* No grazie. Sto attendendo che %s mi risponda." % ( player.code, quest_player_name) defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True # Controlla che l'entità che dà sia il giocatore della quest if player.code != quest_player_code: to_say = "a %s No grazie. Sto aspettando che %s mi porti ciò che deve." % ( player.code, quest_player_name) defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True # Controlla se l'oggetto dato sia una farfalla if not farfalla.race == RACE.BUTTERFLY: to_say = "a %s *critica* Stai cercando di muovermi a pena o di turlupinarmi?" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) return True else: idrusa.specials["quest_status"] = "completa" # Ora che la quest è completa ne blocca un eventuale reset delete_deferred_reset(idrusa) to_yell = "a %s *scortese* Pensavo avessi desistito ormai!" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_yell, idrusa, to_yell) to_say = "a %s *con un largo sorriso di scherno* La via per Klirbe non è però accessibile per te..." % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) to_say = "a %s In compenso hai fatto un po' d'esperienza!" % quest_player_code defer_if_possible(1, 2, idrusa, player, command_say, idrusa, to_say) player.experience += 100 # Tra un po' di tempo si potranno cercare farfalle defer_random_time(3600, 4800, its_farfalla_time, idrusa)
def after_listen_say(tessi, player, target, phrase, behavioured): if not player.IS_PLAYER: return # Nel qual caso il giocatore stia parlando con qualcun'altro esce if target and target != tessi: return # Se la tessitrice non è in modalità questosa esce if tessi.race == RACE.BIRD: return # Se la tessitrice non è in attesa di risposta allora esce if "player_for_reply" not in tessi.specials or not tessi.specials["player_for_reply"]: return # Si assicura che il giocatore che ha parlato sia quello che ha attivato la quest if player.code != tessi.specials["player_for_reply"]: return phrase = ALFA_ONLY_PATTERN.sub("", phrase) if is_same(phrase, "no"): defer_random_time(1, 2, stop_waiting_for_reply, tessi, player) return if not is_same(phrase, ("si", "certo")): return print "villaggio-zingaro_mob_test-tessi - tessi ", tessi.code tessi.specials["player_for_reply"] = "" print "villaggio-zingaro_mob_test-tessi - >>> ora cerco una room <<<" room = find_room(ROOM_PROTO_CODE) if not room: print "villaggio-zingaro_mob_test-tessi - >>> nessuna room trovata per testtessi. Exit <<<" to_say = "a %s *imbarazzata* Uh, oh... ora ricordo dove ho messo il fermaglio; perdonami, tutto risolto." % player.code defer_if_possible(1, 2, tessi, player, command_say, tessi, to_say) tessi.specials["player_on_quest"] = "" return ragno = inject_if_inexist_on_area(RAGNO_PROTO_CODE, room) bozzolo = inject_if_inexist_on_area(BOZZOLO_PROTO_CODE, room) fermaglio = inject_if_inexist_on_area(FERMAGLIO_PROTO_CODE, bozzolo) to_say_1 = "a %s *compiaciuta* Ti ringrazio! Ricordo d'aver smarrito il fermaglio tornando qui dopo aver bevuto al pozzo." % player.code to_say_2 = "a %s Non impiegare più di tre giorni nella ricerca, se tornerai in tempo verrai ricompensat$o." % player.code defer_if_possible(1, 2, tessi, player, command_say, tessi, to_say_1) defer_if_possible(3, 4, tessi, player, command_say, tessi, to_say_2) tessi.specials["player_on_quest"] = player.code start_quest_timer(player, tessi)
def direction_choice(list_direction, room): # Normale che possa accadere visto che la funzione è una deferred if not room: return direction = random.choice(list_direction) print "DIREZIONE = ", direction if direction in room.exits: return exit = Exit(direction) room.exits[direction] = exit room.act("\n[plum]Un bocciolo si è appena schiuso[close]") defer_random_time(700, 1200, direction_close, direction, room)
def before_get(player, grappolo, room, behavioured): if not room: log.bug("room non è valida: %r" % room) return if random.randint(0, 3) == 0: grappolo.act("$N Cerchi di prenderti ma ci son troppe api per ora e rinuncia.", TO.ENTITY, player) grappolo.act("$N cerca di prendere gualcosa nel glicine ma rinuncia ben prima di allungare la $HAND.", TO.OTHERS, player) grappolo.act("Cerchi di prendere $n, ma ci son troppe api per ora e rinunci.", TO.TARGET, player) return True if FLAG.NO_LOOK_LIST in grappolo.flags: grappolo.flags -= FLAG.NO_LOOK_LIST change_item(grappolo) defer_random_time(10, 60, popping_new_grappolo, room)
def before_giving(player, pesce, gatto, direction, behavioured): if not player.IS_PLAYER: player.act("$N ti soffia e fa come per graffiarti, non sei una compagnia desiderabile.", TO.ENTITY, gatto) player.act("$N, con il pelo ritto sulla schiena, scaccia $n in malomodo.", TO.OTHERS, gatto) player.act("$n ti si avvicina un po' troppo per i tuoi gusti e lo scacci senza troppi complimenti.", TO.TARGET, gatto) return True pesce_keywords = multiple_arguments(pesce.get_keywords_attr(looker=gatto)) if is_same(pesce_keywords, ("agrumi", "agrume", "arance", "arancia", "limone", "limoni", "bergamotto", "mandarino", "mandarini", "pompelmo", "pompelmi", "cedro", "cedri", "mandarancio", "mandaranci", "lime")): num_rand = random.randint(1, 100) if num_rand < 75: player.act("$N ti attacca in un raptus di furia assassina!", TO.ENTITY, gatto) player.act("Apparentemente senza ragione $N attacca $n.", TO.OTHERS, gatto) player.act("Quel pazzo di $n ha tentato di darti un agrume, la dovrà pagare!", TO.TARGET, gatto) player.life -= give_damage(player) return True else: player.act("$N sguaina le unghie e tenta di attaccarti ma fortunatamente manca il colpo.", TO.ENTITY, gatto) player.act("$N fa uno scatto verso $n come per attaccarlo ma la zampata non va a buon fine.", TO.OTHERS, gatto) player.act("Tenti di attacare $n ma non ci riesci", TO.TARGET, gatto) return True if not pesce.entitype == ENTITYPE.FOOD or not is_same(pesce_keywords, ("pesce", "pesci")): player.act("$N storce i baffi schizzinoso.", TO.ENTITY, gatto) player.act("$n tenta inutilmente di dare qualcosa a $N che lo snobba schizzinoso.", TO.OTHERS, gatto) player.act("$n tenta di propinarti qualcosa che anche un cane rifiuterebbe.", TO.TARGET, gatto) return True if pesce.weight > PESO_MASSIMO: player.act("$N ti guarda perplesso dopo aver valutato il peso di ciò che gli vorresti dare.", TO.ENTITY, gatto) player.act("Noti uno strano gioco di sguardi tra $N e $n.", TO.OTHERS, gatto) player.act("$n cerca di darti qualcosa di veramente troppo pesante per te.", TO.TARGET, gatto) return True for content in gatto.iter_contains(use_reversed=True): if FLAG.INGESTED in content.flags: if content.entitype == ENTITYPE.FOOD: player.act("$N rifiuta il cibo che gli offri, d'evessere sazio!", TO.ENTITY, gatto) player.act("$n vorrebbe dare qualcosa a $N che però non sembra interessato..", TO.OTHERS, gatto) player.act("$n vorrebbe ingozzarti, la tua dignità di impedisce di far la figura del maiale all'ingrasso..", TO.TARGET, gatto) return True else: content.extract(1) return True palla = Item(PROTO_FUR_CODE) defer_random_time(1, 3, puke_hairs, gatto, player, palla) defer_random_time(4, 5, fish_eat, player, gatto, pesce)
def from_caterpillar_to_chrysalis(caterpillar): # Se non è valido significa che è stato estratto prima che la deferred scattasse if not caterpillar: return chrysalis = generic_creation(caterpillar, PROTO_CHRYSALIS_CODE) # Può capitare se l'entità ha raggiunto il suo massimo globale creabile if not chrysalis: return chrysalis.inject(caterpillar.location) chrysalis.act("$N s'è inbozzolato in $n", TO.OTHERS, caterpillar) chrysalis.act("$N s'è inbozzolato in $n", TO.ENTITY, caterpillar) caterpillar.extract(1) defer_random_time(20, 30, from_chrysalis_to_butterfly, chrysalis)
def chick_grow(chick, mother): if not chick: log.bug("chick non è un parametro valido: %r" % chick) return if not mother: log.bug("mother non è un parametro valido: %r" % mother) return gallina_adulta = generic_creation(chick, PROTO_CHICKEN_CODE) if not gallina_adulta: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return location = chick.location if not location.IS_ROOM: return # Se il settore della stanza non è corretto esce if location.sector not in (SECTOR.PLAIN, SECTOR.WOOD, SECTOR.FARMLAND, SECTOR.HOUSE): return # Se il gallinotto nel frattempo non si trova più tra i mob allora esce if chick.code not in database["mobs"]: return # Rimuove il gallinozzo dalla stanza e dal database, chick.extract(1) # Imposta tutti i riferimenti per la gallina gallina_adulta.inject(location) # shortizza la gallina.. gallina_adulta.short = "una [red]gallina[close]" # Avvisiamo tutti quanti del lieto evento gallina_adulta.act("$N non è più un piccolino ma $n!", TO.OTHERS, chick) gallina_adulta.act("Ti origini da $N e sei un $n.", TO.ENTITY, chick) gallina_adulta.act("$n nasce da te!", TO.TARGET, chick) # Ora che è nato, è certo contento e lo dirà al mondo! defer_random_time(15, 30, command_say, gallina_adulta, "Ero piccolo ma adesso non più!") # Ora che è cresciuta comincerà a depositare defer_random_time(35, 40, start_deposing, gallina_adulta)
def on_booting(idrusa): print "on_booting dell'idrusa", idrusa # Concettualmente al riavvio del gioco è meglio raddoppiare i tempi di # reset in maniera tale che il giocatore abbia il tempo di "riprendersi" deferred_reset = defer_random_time(400, 600, reset_farfalla_quest, idrusa) idrusa.specials["deferred_reset"] = deferred_reset idrusa.specials["before_lookeding_me"] = True
def generate_item(apprendista, player, choosed_material, room): # Normale che possa accadere visto che la funzione viene deferrata if not apprendista or not player or not room: return to_say = "Uhm... un golem di %s... Cominciamo un po'..." % choosed_material command_say(apprendista, to_say) proto_item_code = ITEM_PROTO_CODE[choosed_material] item = Item(proto_item_code) item.flags += FLAG.NO_GET item.inject(room) # (bb) perché funzioni al meglio il sistema di persistent act qui bisogna # che esista anche il messaggio a TO.ENTITY, da aggiungere quindi apprendista.act(PHRASES[choosed_material], TO.OTHERS, item) defer_random_time(12, 20, generate_golem, apprendista, player, choosed_material, room, item)
def caterpillar_born(egg, butterfly): if not egg: log.bug("egg non è un parametro valido: %r" % egg) return None if not butterfly: log.bug("butterfly non è un parametro valido: %r" % butterfly) return None caterpillar = generic_creation(egg, random.choice(PROTO_CATERPILLAR_CODES)) if not caterpillar: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return # @GATTO: Veramente si vuole questa cosa? # @GATTO: Altrimenti il check sottostante dei settori lo puoi fare aggiungendo: # @GATTO: if location.IS_ROOM and room.sector not in [...] # @GATTO: così fai funzionare il tutto anche il zone non room, e se room # @GATTO: solo per quei settori # @GATTO c'è un caso simile nella funzione più sotto location = egg.location if not location.IS_ROOM: return # Se il settore della stanza non è corretto esce #if location.sector not in (SECTOR.PLAIN, SECTOR.WOOD, SECTOR.FARMLAND, SECTOR.HOUSE): # return # Se l'uovo nel frattempo già non si trova più tra gli oggetti allora esce if egg.code not in database["items"]: return # Rimuove l'uovo dalla stanza e dal database egg.extract(1) # Inserisce il bruco nel gioco caterpillar.inject(location) # Avvisiamo tutti quanti del lieto evento caterpillar.act("$N si schiude e se ne esce $n!", TO.OTHERS, egg) caterpillar.act("Nasci da $N e sei un $n.", TO.ENTITY, egg) caterpillar.act("$n nasce da te!", TO.TARGET, egg) # Ora che è nato, è certo contento e lo dirà al mondo! #defer_random_time(15, 30), command_say, caterpillar, "Nemmeno la morte ti può salvare da me!") defer_random_time(60, 80, caterpillar_chrysalis, caterpillar, butterfly)
def chrysalis_open(chrysalis, mother): if not chrysalis: log.bug("chrysalis non è un parametro valido: %r" % chrysalis) return if not mother: log.bug("mother non è un parametro valido: %r" % mother) return baby_butterfly = generic_creation(chrysalis, PROTO_BUTTERFLY_CODE) if not baby_butterfly: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return location = chrysalis.location if not location.IS_ROOM: return # Se il settore della stanza non è corretto esce #if location.sector not in (SECTOR.PLAIN, SECTOR.WOOD, SECTOR.FARMLAND, SECTOR.HOUSE): # return # Se la crisalide nel frattempo non si trova più tra i mob allora esce if chrysalis.code not in database["items"]: return # Rimuove la crisalide dalla stanza e dal database, chrysalis.extract(1) # Imposta tutti i riferimenti per la farfalla baby_butterfly.inject(location) # shortizza la farfalla.. #baby_butterfly.short = "una [red]farfalla[close]" # Avvisiamo tutti quanti del lieto evento baby_butterfly.act("$N non è più un piccolino ma $n!", TO.OTHERS, chrysalis) baby_butterfly.act("Ti origini da $N e sei un $n.", TO.ENTITY, chrysalis) baby_butterfly.act("$n nasce da te!", TO.TARGET, chrysalis) # Ora che è nato, è certo contento e lo dirà al mondo! #defer_random_time(15, 30), command_say, baby_butterfly, "Ero piccolo ma adesso non più!") # Ora che è cresciuta comincerà a depositare defer_random_time(35, 40, start_deposing, baby_butterfly)
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 locandiera_act(locandiera, player, cibo): # Normale che possa capitare visto che la funzione è deferrata if not locandiera or not cibo or not player: return cibo.inject(locandiera) player_code = player.get_numbered_keyword(looker=locandiera) cibo_code = cibo.get_numbered_keyword(looker=locandiera) argument = "%s %s" % (cibo_code, player_code) success_result = command_give(locandiera, argument) if success_result: defer_if_possible(1, 2, locandiera, player, command_say, locandiera, "a %s Buon appetito!" % player_code) else: # (TD) Lo lascia per terra! è proprio grezzo, bisognerebbe che lo appoggi # su di un tavolo, appena vi sarà il sistema della mobilia lo farò defer_if_possible(1, 2, locandiera, player, command_say, locandiera, "a %s Mi scuso ma la appoggio qui..." % player_code) defer_random_time(3, 4, command_drop, locandiera, cibo_code)
def generic_creation(parent, proto_code, show_act=True): # E' normale visto che la funzione viene anche deferrata if not parent: return None # Si assicura che il codice passato esista if proto_code in database["proto_items"]: proto_son = database["proto_items"][proto_code] elif proto_code in database["proto_mobs"]: proto_son = database["proto_mobs"][proto_code] else: log.bug("Il codice %s non è stato trovato nel database" % proto_code, log_stack=False) return None # if show_act: # parent.act("My name is $n: preparazione all'evoluzione!", TO.OTHERS) # Se eccede il numero di entità definito in MaxGlobalQuantity allora esce if proto_son.has_reached_max_global_quantity(): #if proto_son.max_global_quantity != 0 and proto_son.current_global_quantity >= proto_son.max_global_quantity: if show_act: parent.act("My name is $n: troppi %s!" % proto_code, TO.OTHERS) parent.act("My name is $n: troppi %s!" % proto_code, TO.ENTITY) if random.randint(1, 5) == 1: if show_act: parent.act("My name is $n: muoio!", TO.OTHERS) parent.act("My name is $n: muoio!", TO.ENTITY) death(parent) else: defer_random_time(60, 61, generic_creation, parent, proto_code) if show_act: parent.act("My name is $n I'll try later!", TO.OTHERS) parent.act("My name is $n I'll try later!", TO.ENTITY) # Esce da qui in tutti e due i casi return None # Crea un nuovo figlio son = proto_son.CONSTRUCTOR(proto_son.code) if show_act: parent.act("My name is $n: son $N created!", TO.OTHERS, son) parent.act("My name is $n: son $N created!", TO.ENTITY, son) return son
def before_look(player, tessi, descr, detail, use_examine, behavioured): if not player.IS_PLAYER: print "villaggio-zingaro_mob_test-tessi - >>> NO PLAYER <<<" return if "lookable" in tessi.specials and not tessi.specials["lookable"]: print "villaggio-zingaro_mob_test-tessi - >>> NON LOOK <<<" return if tessi.race == RACE.TUAREG: print "villaggio-zingaro_mob_test-tessi - >>> TUAREG <<<" defer_if_possible(1, 2, tessi, player, ask_help, tessi, player) else: print "villaggio-zingaro_mob_test-tessi - >>> BAGGIA <<<" to_say = "a %s skreee skreee!" % player.code defer_if_possible(1, 2, tessi, player, command_say, tessi, to_say) tessi.specials["lookable"] = False defer_random_time(10, 12, lookable_again, tessi)
def ask_help(tessi, player): if not tessi or not player: return print "villaggio-zingaro_mob_test-tessi - >>> ask_help <<<" # (TD) calcolo del tempo rimanente per la quest già in corso if "player_on_quest" in tessi.specials and tessi.specials["player_on_quest"]: if player.code == tessi.specials["player_on_quest"]: to_say = "a %s *speranzosa* Hai novità riguardo al mio fermaglio scomparso?" % player.code else: to_say = "a %s *misteriosa* Gentile viandante che mi osservi, dai anche tu manforte agli avventurieri che si son offerti e stanno cercando il mio fermaglio. L'ho perduto mentre mi recavo al pozzo." % player.code command_say(tessi, to_say) return to_say = "a %s *misteriosa* Viandante, tu che poggi l'occhio su di me; sei dispost$o ad aiutarmi a recuperare il fermaglio che ho smarrito oggi?" % player.code command_say(tessi, to_say) tessi.specials["player_for_reply"] = player.code defer_random_time(30, 40, stop_waiting_for_reply, tessi, player)
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 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 after_listen_rpg_channel(listener, speaker, target, phrase, ask, exclaim, behavioured): words = multiple_arguments(phrase) if not is_prefix(("drin", "ring"), words): return if speaker.prototype.code != "mfdonald_mob_unicorno-rosa": return # Aggiunge casualmente un prefisso, qualche o finale e punti esclamativi # e di domanda finali, risponde all'unicorno rosa prefix = "" if random.randint(1, 10) == 1: prefix = "Ha%s " % ("." * random.randint(2, 4)) to_say = "a %s %sHall%s?%s" % (speaker.get_numbered_keyword(looker=listener), prefix, "o" * random.randint(1, 3), random_marks(1, 1)) # Attende qualche secondo.. dopotutto deve raggiungere il telefono! # Attenzione ad inserire un numero di secondi troppo alto, altrimenti # l'unicorno rosa potrebbe dire più spesso ring ring di quanto l'unicorno # azzurro possa rispondere, riempiendo così la ram di callback :P # Comunque in questo caso non abbiamo assolutamente questo problema defer_random_time(1, 3, command_say, listener, to_say)
def locandiera_act(locandiera, pietanza, player): # Normale che possa capitare visto che la funzione è deferrata if not locandiera or not pietanza or not player: return pietanza.inject(locandiera) player_code = player.get_numbered_keyword(looker=locandiera) pietanza_code = pietanza.get_numbered_keyword(looker=locandiera) argument = "%s %s" % (pietanza_code, player_code) success_result = command_give(locandiera, argument) if success_result: defer_if_possible(1, 2, locandiera, player, command_say, locandiera, "a %s Buon appetito!" % player_code) else: # (TD) Lo lascia per terra! è proprio grezzo, bisognerebbe che lo appoggi # su di un tavolo, appena vi sarà il sistema della mobilia lo farò defer_if_possible(1, 2, locandiera, player, command_say, locandiera, "a %s Mi scuso ma la appoggio qui..." % player_code) defer_random_time(3, 4, command_drop, locandiera, pietanza_code)
def before_dig(entity, location, target, dir, behavioured): if not dir or dir == DIR.NONE: log.bug("none dir dig: %s" % dir) return # Impedisco di andare up come scavo if dir == DIR.UP: return # get_destination_room ritorna None se non vi è nessuna coordinata # valida in quella direzione dig_dest = location.get_destination_room(dir) if dig_dest: #log.bug("il get_destination nella dir specificata è: %s" % dig_dest) return new_room = Room(random.choice(PROTO_ROOMS_TEMPORARY_CODES)) coords = "%d %d %d" % (location.x + dir.shift[0], location.y + dir.shift[1], location.z + dir.shift[2]) new_room.to_area(database["areas"]["miniere-kezaf"], coords) defer_random_time(30, 60, descr_modify, new_room) # Crea la nuova uscita da zero exit = Exit(dir) location.exits[dir] = exit destination = Destination(location.x + dir.shift[0], location.y + dir.shift[1], location.z + dir.shift[2], "miniere-kezaf") if destination: exit.destination = destination reverse_exit = Exit(dir.reverse_dir) new_room.exits[dir.reverse_dir] = reverse_exit current_location = Destination(location.x, location.y, location.z, "miniere-kezaf") if current_location: reverse_exit.destination = current_location entity.act("\nSei riuscit$o a procedere per un certo tratto.\n", TO.ENTITY) entity.act("\n$n ha scavato per un certo tratto.\n", TO.OTHERS) return True
def before_listen_rpg_channel(caldarrostaio, player, target, phrase, ask, exclaim, behavioured): if not player.IS_PLAYER: return # Mi assicuro che si stia parlando rivolgendosi al caldarrostaio if target != caldarrostaio: return if is_infix("menù", phrase): to_say = "a %s Car$o, io vendo solo caldarroste." % player.code defer_random_time(1, 2, command_say, caldarrostaio, to_say) return proto_cibi = [] for proto_code in PROTO_FOODS_CODES: table_name = "proto_" + proto_code.split("_")[1] + "s" # E con questo hai scoperto come mai i codici prototipo delle entità devono avere l'identificativo della tipologia tra due underscore proto_entity = database[table_name][proto_code] for keyword in multiple_arguments(proto_entity.get_keywords_attr()): #print ">>> Keyword <<<", proto_entity.code, keyword if is_infix(keyword, phrase): proto_cibi.append(proto_entity) if not proto_cibi: to_say = "a %s Ma io vendo solo castagne!" % player.code command_say(caldarrostaio, to_say) return to_say = "a %s Castagne in arrivo!" % player.code defer_random_time(1, 2, command_say, caldarrostaio, to_say) proto_pietanza = random.choice(proto_cibi) castagne = proto_pietanza.CONSTRUCTOR(proto_pietanza.code) defer_random_time(5, 7, caldarrostaio_act, caldarrostaio, player, castagne)
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 from_chrysalis_to_butterfly(chrysalis): # Se non è valido significa che è stato estratto prima che la deferred scattasse if not chrysalis: return baby_butterfly = generic_creation(chrysalis, PROTO_BUTTERFLY_CODE) # Può capitare se l'entità ha raggiunto il suo massimo globale creabile if not baby_butterfly: return if not chrysalis.location.IS_ROOM: return baby_butterfly.inject(chrysalis.location) # Avvisiamo tutti quanti del lieto evento baby_butterfly.act("$N non è più un piccolino ma $n!", TO.OTHERS, chrysalis) baby_butterfly.act("$N non è più un piccolino ma $n!", TO.ENTITY, chrysalis) chrysalis.extract(1) # Ora che è cresciuta comincerà a depositare defer_random_time(35, 40, start_deposing, baby_butterfly)
def after_listen_rpg_channel(listener, speaker, target, phrase, ask, exclaim, behavioured): words = multiple_arguments(phrase) if not is_prefix(("drin", "ring"), words): return if speaker.prototype.code != "mfdonald_mob_unicorno-rosa": return # Aggiunge casualmente un prefisso, qualche o finale e punti esclamativi # e di domanda finali, risponde all'unicorno rosa prefix = "" if random.randint(1, 10) == 1: prefix = "Ha%s " % ("." * random.randint(2, 4)) to_say = "a %s %sHall%s?%s" % (speaker.get_numbered_keyword( looker=listener), prefix, "o" * random.randint(1, 3), random_marks( 1, 1)) # Attende qualche secondo.. dopotutto deve raggiungere il telefono! # Attenzione ad inserire un numero di secondi troppo alto, altrimenti # l'unicorno rosa potrebbe dire più spesso ring ring di quanto l'unicorno # azzurro possa rispondere, riempiendo così la ram di callback :P # Comunque in questo caso non abbiamo assolutamente questo problema defer_random_time(1, 3, command_say, listener, to_say)
def caldarrostaio_act(caldarrostaio, player, castagne): # Normale visto che questa funzione viene deferrata if not caldarrostaio or not player or not castagne: return if player.location != caldarrostaio.location: to_yell = "Hei %s, dove cavolo te ne sei andato?" % player.get_name(looker=caldarrostaio) command_yell(caldarrostaio, to_yell) return castagne.inject(caldarrostaio) player_code = player.get_numbered_keyword(looker=caldarrostaio) pietanza_code = castagne.get_numbered_keyword(looker=caldarrostaio) argument = "%s %s" % (pietanza_code, player_code) success_result = command_give(caldarrostaio, argument) if success_result: defer_if_possible(1, 2, caldarrostaio, player, command_say, caldarrostaio, "a %s Buon appetito!" % player_code) else: # (TD) Lo lascia per terra! è proprio grezzo, bisognerebbe che lo appoggi # su di un tavolo, appena vi sarà il sistema della mobilia lo farò defer_if_possible(1, 2, caldarrostaio, player, command_say, caldarrostaio, "a %s Scuso ma te l'appoggio qui, eh?" % player_code) defer_random_time(3, 4, command_drop, caldarrostaio, pietanza_code)
def from_egg_to_caterpillar(egg): # E' normale visto che la funzione viene deferrata if not egg: return caterpillar = generic_creation(egg, random.choice(PROTO_CATERPILLAR_CODES)) # Può capitare se l'entità ha raggiunto il suo massimo globale creabile if not caterpillar: return # @GATTO: if location.IS_ROOM and room.sector not in [...] # @GATTO: così fai funzionare il tutto anche il zone non room, e se room # @GATTO: solo per quei settori if not egg.location.IS_ROOM: return caterpillar.inject(egg.location) # Avvisiamo tutti quanti del lieto evento caterpillar.act("$N si schiude e se ne esce $n!", TO.OTHERS, egg) caterpillar.act("Nasci da $N e sei un $n.", TO.ENTITY, egg) caterpillar.act("$n nasce da te!", TO.TARGET, egg) egg.extract(1) defer_random_time(20, 22, from_caterpillar_to_chrysalis, caterpillar)
def chick_born(egg, chicken): if not egg: log.bug("egg non è un parametro valido: %r" % egg) return None if not chicken: log.bug("chicken non è un parametro valido: %r" % chicken) return None chick = generic_creation(egg, PROTO_CHICK_CODE) if not chick: # Può capitare se l'entità ha raggiunto il suo massimo globale creabile return # @GATTO: Veramente si vuole questa cosa? # @GATTO: Altrimenti il check sottostante dei settori lo puoi fare aggiungendo: # @GATTO: if location.IS_ROOM and room.sector not in [...] # @GATTO: così fai funzionare il tutto anche il zone non room, e se room # @GATTO: solo per quei settori # @GATTO c'è un caso simile nella funzione più sotto location = egg.location if not location.IS_ROOM: return # Se il settore della stanza non è corretto esce if location.sector not in (SECTOR.PLAIN, SECTOR.WOOD, SECTOR.FARMLAND, SECTOR.HOUSE): return # Se l'uovo nel frattempo già non si trova più tra gli oggetti allora esce if egg.code not in database["items"]: return # Rimuove l'uovo dalla stanza e dal database egg.extract(1) # Inserisce il pulcino nel gioco chick.inject(location) # Diversifichiamo un po' a a caso la short if random.randint(1, 2) == 1: chick.short = "un [yellow]pulcino[close]" # Avvisiamo tutti quanti del lieto evento chick.act("$N si schiude e se ne esce $n!", TO.OTHERS, egg) chick.act("Nasci da $N e sei un $n.", TO.ENTITY, egg) chick.act("$n nasce da te!", TO.TARGET, egg) # Ora che è nato, è certo contento e lo dirà al mondo! defer_random_time(15, 30, command_say, chick, "Nemmeno la morte ti può salvare da me!") defer_random_time(30, 60, chick_color, chick) defer_random_time(60, 80, chick_grow, chick, chicken)
def beg_the_player(idrusa, player): idrusa.specials["before_lookeding_me"] = False idrusa.specials["quest_status"] = "domanda" idrusa.specials["player_code"] = player.code to_say = "a %s *supponente* sei qui forse per accedere al regno di Klirbe?" % player.code command_say(idrusa, to_say) # Dopo un po' chiede nuovamente al giocatore di rispondere alla sua # richiesta di aiuto nel qual caso che il giocatore non abbia afferrato # l'indizio di quello che deve fare defer_if_possible(15, 30, idrusa, player, ask_for_answer, idrusa, player) # L'idrusa non starà ad aspettare in eterno che il giocatore si decida a # iniziare la quest, se dopo un po' di tempo lo status della quest non # è cambiato allora gli specials vengono azzerati deferred_reset = defer_random_time(60, 90, reset_farfalla_quest, idrusa) idrusa.specials["deferred_reset"] = deferred_reset
def after_listen_say(idrusa, speaker, target, phrase, behavioured): if not speaker.IS_PLAYER: return # Controlla se la quest non sia già stata resettata oppure avanzata if "quest_status" not in idrusa.specials or idrusa.specials[ "quest_status"] != "domanda": return # Ricava la frase ripulita dalla punteggiatura e non continua la quest fino # a che il giocatore non dice: sì phrase = ALFA_ONLY_PATTERN.sub("", phrase) if not is_same(phrase, "si"): return # Guarda il giocatore che ha risposto command_look(idrusa, speaker.code) # Ignora coloro che hanno risposto ma che non hanno avviato la quest quest_player_code = idrusa.specials["player_code"] if speaker.code != quest_player_code: quest_player = database["players"][quest_player_code] # Ricava il nome o la short per come lo vede idrusa to_say = "a %s No, non la tua risposta attendo ma di %s." % ( speaker.code, quest_player.get_name(looker=idrusa)) command_say(idrusa, to_say) return # Visto che il secondo stadio della missione si sta attivando cancella il # precedente reset che è meglio che sia reimpostato a fine funzione delete_deferred_reset(idrusa) # Facciamo avanzare lo stato della quest idrusa.specials["quest_status"] = "cerca" # Descriviamo quello che vogliamo to_say = "a %s *in tono grave* L'accesso ti verrà indicato solo se porterai una farfalla!" % speaker.code defer_if_possible(1, 2, idrusa, speaker, command_say, idrusa, to_say) # Ecco qui, qui viene impostata la durata media della quest, ovvero quanto # idrusa attenderà che il giocatore gli porti la farfalla deferred_reset = defer_random_time(200, 300, reset_farfalla_quest, idrusa) idrusa.specials["deferred_reset"] = deferred_reset
def after_listen_say(idrusa, speaker, target, phrase, behavioured): if not speaker.IS_PLAYER: return # Controlla se la quest non sia già stata resettata oppure avanzata if "quest_status" not in idrusa.specials or idrusa.specials["quest_status"] != "domanda": return # Ricava la frase ripulita dalla punteggiatura e non continua la quest fino # a che il giocatore non dice: sì phrase = ALFA_ONLY_PATTERN.sub("", phrase) if not is_same(phrase, "si"): return # Guarda il giocatore che ha risposto command_look(idrusa, speaker.code) # Ignora coloro che hanno risposto ma che non hanno avviato la quest quest_player_code = idrusa.specials["player_code"] if speaker.code != quest_player_code: quest_player = database["players"][quest_player_code] # Ricava il nome o la short per come lo vede idrusa to_say = "a %s No, non la tua risposta attendo ma di %s." % (speaker.code, quest_player.get_name(looker=idrusa)) command_say(idrusa, to_say) return # Visto che il secondo stadio della missione si sta attivando cancella il # precedente reset che è meglio che sia reimpostato a fine funzione delete_deferred_reset(idrusa) # Facciamo avanzare lo stato della quest idrusa.specials["quest_status"] = "cerca" # Descriviamo quello che vogliamo to_say = "a %s *in tono grave* L'accesso ti verrà indicato solo se porterai una farfalla!" % speaker.code defer_if_possible(1, 2, idrusa, speaker, command_say, idrusa, to_say) # Ecco qui, qui viene impostata la durata media della quest, ovvero quanto # idrusa attenderà che il giocatore gli porti la farfalla deferred_reset = defer_random_time(200, 300, reset_farfalla_quest, idrusa) idrusa.specials["deferred_reset"] = deferred_reset
def before_listen_rpg_channel(caldarrostaio, player, target, phrase, ask, exclaim, behavioured): if not player.IS_PLAYER: return # Mi assicuro che si stia parlando rivolgendosi al caldarrostaio if target != caldarrostaio: return if is_infix("menù", phrase): to_say = "a %s Car$o, io vendo solo caldarroste." % player.code defer_random_time(1, 2, command_say, caldarrostaio, to_say) return proto_cibi = [] for proto_code in PROTO_FOODS_CODES: table_name = "proto_" + proto_code.split( "_" )[1] + "s" # E con questo hai scoperto come mai i codici prototipo delle entità devono avere l'identificativo della tipologia tra due underscore proto_entity = database[table_name][proto_code] for keyword in multiple_arguments(proto_entity.get_keywords_attr()): #print ">>> Keyword <<<", proto_entity.code, keyword if is_infix(keyword, phrase): proto_cibi.append(proto_entity) if not proto_cibi: to_say = "a %s Ma io vendo solo castagne!" % player.code command_say(caldarrostaio, to_say) return to_say = "a %s Castagne in arrivo!" % player.code defer_random_time(1, 2, command_say, caldarrostaio, to_say) proto_pietanza = random.choice(proto_cibi) castagne = proto_pietanza.CONSTRUCTOR(proto_pietanza.code) defer_random_time(5, 7, caldarrostaio_act, caldarrostaio, player, castagne)
def after_move(entity, from_room, direction, to_room, running, behavioured): defer_random_time(4, 6, throw_down, entity, from_room, direction, to_room)
def on_dawn(room): defer_random_time(10, 500, direction_choice, LIST_DIR_ONE, room) defer_random_time(300, 800, direction_choice, LIST_DIR_TWO, room)