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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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)
