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