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 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 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 after_open(player, bozzolo, reverse_target, container_only, behavioured):
ragnetti = Mob(PROTO_RAGNETTI_CODE)
ragnetti.inject(player.location)
player.act("Un brivido ti percorre lungo tutta la schiena mentre senti un urlo lontano.", TO.ENTITY)
player.act("Un urlo lontano accompagna l'apertura del $N.", TO.OTHERS, bozzolo)
fight = Fight(ragnetti, player)
fight.start()
def caterpillar_creation():
room_code = random.choice(PROTO_ROOMS_CODE)
print room_code
injection_room = find_room(room_code)
if not injection_room:
log.bug("proto code room non valido: %r" % room_code)
return
bruco = Mob(PROTO_CATERPILLAR_BEFORE_CODE)
bruco.inject(injection_room)
def caterpillar_creation():
room_code = random.choice(PROTO_ROOMS_CODE)
print room_code
injection_room = find_room(room_code)
if not injection_room:
log.bug("proto code room non valido: %r" % room_code)
return
bruco = Mob(PROTO_CATERPILLAR_BEFORE_CODE)
bruco.inject(injection_room)
def after_open(player, bozzolo, reverse_target, container_only, behavioured):
ragnetti = Mob(PROTO_RAGNETTI_CODE)
ragnetti.inject(player.location)
player.act(
"Un brivido ti percorre lungo tutta la schiena mentre senti un urlo lontano.",
TO.ENTITY)
player.act("Un urlo lontano accompagna l'apertura del $N.", TO.OTHERS,
bozzolo)
fight = Fight(ragnetti, player)
fight.start()
def generate_golem(apprendista, player, choosed_material, room, item):
# Normale che possa accadere visto che la funzione viene deferrata
if not apprendista or not player or not room or not item:
return
proto_mob_code = GOLEM_PROTO_CODE[choosed_material]
mob = Mob(proto_mob_code)
mob.inject(room)
mob_calibration(mob, player, choosed_material)
item.act(WAKE_UP[choosed_material], TO.OTHERS, mob)
item.extract(1)
apprendista.specials["work_in_progress"] = False
def generate_golem(apprendista, player, choosed_material, room, item):
# Normale che possa accadere visto che la funzione viene deferrata
if not apprendista or not player or not room or not item:
return
proto_mob_code = GOLEM_PROTO_CODE[choosed_material]
mob = Mob(proto_mob_code)
mob.inject(room)
mob_calibration(mob, player, choosed_material)
item.act(WAKE_UP[choosed_material], TO.OTHERS, mob)
item.extract(1)
apprendista.specials["work_in_progress"] = False
def on_sunset(tessitrice):
barbagianni = Mob(BAGGIA_PROTO_CODE)
barbagianni.inject(tessitrice.location)
for content in tessitrice.iter_contains():
content.from_location()
content.to_location(barbagianni)
command_yell(tessitrice, "Aahhh%s Dolore%s" % (random_marks(0, 2), random_marks(0, 3)))
barbagianni.act("Ti origini da $N e sei $n.", TO.ENTITY, tessitrice)
barbagianni.act("In un istante $N si trasforma in $n!", TO.OTHERS, tessitrice)
barbagianni.act("$n si origina da te!", TO.TARGET, tessitrice)
tessitrice.extract(1)
def inject_if_inexist_on_area(proto_code, location):
type = proto_code.split("_")[1]
# Se trova già un'entità esistente nell'area della locazione la recupera per la quest
# (TD) attenzione che per ora ignora il fatto che vi possano essere più
# entità in gioco, magari non in quest'area
for entity in getattr(location.area, type + "s"):
if not entity.IS_PLAYER and entity.prototype.code == proto_code:
return entity.split_entity(1)
if type == "mob":
entity = Mob(proto_code)
else:
entity = Item(proto_code)
entity.inject(location)
return entity
def on_sunrise(barbagianni):
tessy = Mob(TESSY_PROTO_CODE)
tessy.inject(barbagianni.location)
for content in barbagianni.iter_contains():
content.from_location()
content.to_location(tessy)
#Nel caso volessi resettare lo slot dell'item:
#content.wear_mode.clear()
command_yell(barbagianni, "Screeeh%s Scretch%s" % (random_marks(0, 2), random_marks(0, 3)))
tessy.act("Ti origini da $N e sei $n.", TO.ENTITY, barbagianni)
tessy.act("In un istante $N si trasforma in $n!", TO.OTHERS, barbagianni)
tessy.act("$n si origina da te!", TO.TARGET, barbagianni)
#print "barbagianni proto glob qty prima dell'estract", barbagianni.current_global_quantity
barbagianni.extract(1)
def coming(locanda):
"""
Controlla non ci siano bimbe in giro e poi la inietta.
"""
# È possibile visto che questa funzione viene deferrata
if not locanda:
return
for mob in database["mobs"].itervalues():
if mob.prototype.code == PROTO_MOB_CODE:
return
bimba = Mob(PROTO_MOB_CODE)
bimba.inject(locanda)
bimba.act("Entri trotterellante in $N", TO.ENTITY, locanda)
bimba.act("$n entra trotterellando in $N.", TO.OTHERS, locanda)
bimba.act("Ti senti calpestare dal trotterellare di $n", TO.TARGET,
locanda)
def on_sunset(dosso):
if not dosso:
log.bug("dosso non è un parametro valido: %r" % dosso)
return
lupo = Mob(PROTO_LUPO_CODE)
lupo.inject(dosso.location)
#for content in tessitrice.iter_contains(use_reversed=True):
# content = content.from_location(content.quantity)
# content.to_location(barbagianni)
lupo.act("Ti origini da $N e sei $n.", TO.ENTITY, dosso)
lupo.act(
"$N emmette un risonante fruscio e si trasforma improvvisamente in $n!",
TO.OTHERS, dosso)
lupo.act("$n si origina da te!", TO.TARGET, dosso)
dosso.stop_repop()
dosso.extract(1)
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 on_sunset(dosso):
if not dosso:
log.bug("dosso non è un parametro valido: %r" % dosso)
return
lupo = Mob(PROTO_LUPO_CODE)
lupo.inject(dosso.location)
#for content in tessitrice.iter_contains(use_reversed=True):
# content = content.from_location(content.quantity)
# content.to_location(barbagianni)
lupo.act("Ti origini da $N e sei $n.", TO.ENTITY, dosso)
lupo.act("$N emmette un risonante fruscio e si trasforma improvvisamente in $n!", TO.OTHERS, dosso)
lupo.act("$n si origina da te!", TO.TARGET, dosso)
dosso.stop_repop()
dosso.extract(1)
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 get_money_instance(self, type):
from src.log import log
from src.item import Item
from src.mob import Mob
if not type:
log.bug("type non è un parametr valido: %r" % type)
return ""
# ---------------------------------------------------------------------
money_code = getattr(self, type + "_coin")
if "item" in money_code.split("_"):
return Item(money_code)
else:
return Mob(money_code)
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 create_handler(entity, argument, command_name, table_name, can_create_multiple=False):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not command_name:
log.bug("command_name non è un parametro valido: %r" % command_name)
return False
if not table_name:
log.bug("table_name non è un parametro valido: %r" % table_name)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, command_name)
entity.send_output(syntax, break_line=False)
return False
if can_create_multiple:
quantity, argument = quantity_argument(argument)
else:
quantity = 1
target = None
if table_name == "players":
target = search_online_player(argument, only_exact=True)
if not target:
target = entity.find_proto(argument, entity_tables=[table_name])
if not target:
entity.send_output("Non è stato trovato nessun %s con argomento [green]%s[close]." % (table_name, argument))
return False
if quantity == 0:
quantity = target.quantity
if not target.IS_PLAYER and target.max_global_quantity > 0 and target.current_global_quantity + quantity > target.max_global_quantity:
if entity.trust == TRUST.IMPLEMENTOR:
entity.send_to_admin("Ti è possibile iniettare in gioco %s nonostante questo raggiungerà il suo MaxGlobalQuantity di %d" % (
target.get_name(looker=entity), target.max_global_quantity))
else:
entity.send_output("Non ti è possibile iniettare in gioco questa entità perché ha già raggiunto il suo MaxGlobalQuantity di %d" % target.max_global_quantity)
return False
if target.IS_PLAYER:
result = Mob("limbo_mob_clone-pg")
copy_existing_attributes(target, result, except_these_attrs=["code", "prototype"])
result.short = result.name # (TD) creazione dinamica della short, un po' come la long
result.incognito = False
elif target.IS_MOB:
result = Mob(target.code)
elif target.IS_ITEM:
result = Item(target.code)
else:
log.bug("Entità base non valida: %s" % target.code)
entity.send_output("C'è stato un'errore nell'esecuzione del comando.")
return False
# Se l'oggetto è uno dell'area rip avrà il tag %material da dover sostituire
if "%material" in result.short:
result.short.replace("%material", "qualcosa")
if "%material" in result.short_night:
result.short_night.replace("%material", "qualcosa")
if "%material" in result.name:
result.name.replace("%material", "qualcosa")
result.quantity = quantity
result.inject(entity)
if entity == target:
entity.act("Crei dal nulla una copia di te stess$O.", TO.ENTITY, target)
entity.act("$n crea dal nulla una copia di se stess$O.", TO.OTHERS, target)
elif entity.location == target.location:
entity.act("Crei dal nulla una copia di $N.", TO.ENTITY, target)
entity.act("$n crea dal nulla una copia di $N, ma ora qual'è quello vero?", TO.OTHERS, target)
entity.act("$n crea dal nulla una copia di te stess$O!", TO.TARGET, target)
else:
entity.act("Crei dal nulla una copia di $N.", TO.ENTITY, target)
entity.act("$n crea dal nulla una copia di $N.", TO.OTHERS, target)
return True
def generic_creation(parent, proto_code, show_act=False):
if not parent:
log.bug("parent non è un parametro valido: %r" % parent)
return None
if not proto_code:
log.bug("proto_code non è un parametro valido: %r" % proto_code)
return None
# Dà una controllatina a chi contiene il parente
if not parent.location:
log.bug(
"parent.location per qualche strano motivo è %r con codice %s e parent %s"
% (parent.location, proto_code, parent.prototype.code))
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)
parent.act("My name is $n: preparazione all'evoluzione!", TO.ENTITY)
# Se eccede il numero di entità definito in MaxGlobalQuantity allora esce
if proto.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:
# 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: muoio!", TO.OTHERS)
parent.act("My name is $n: muoio!", 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 digging_a_location_2(entity, location, verbs, behavioured):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return
if not location:
log.bug("location non è un parametro valido: %r" % location)
return
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return
# -------------------------------------------------------------------------
targets = []
for target in location.iter_contains():
if FLAG.BURIED in target.flags:
targets.append(target)
# C'è una possibilità su cento che venga trovato qualcosa di interessante
# (TD) magari la probabilità aumentarla facendola sulla base della skill scava
# (TD) magari aggiungere un affect per invalidare tentativi robotizzati di scavaggio continuo
if not targets and random.randint(1, 100) < DIG_PROBABILITY:
codes = database["areas"]["rip"].proto_items.keys()
codes += database.randomizable_codes
codes += database.race_money_codes
codes += database.seed_codes
code = random.choice(codes)
if code.split("_")[1] == "item":
targets = [Item(code)]
else:
targets = [Mob(code)]
# Per le monete viene impostata anche una quantità casuale.
# Qui in sostanza viene detto che si possono trovare da 1 a 1000 monete
# di rame e al massimo solo 1 moneta di mithril, valori intermedi sono
# inversamente proporzionali al valore della moneta stessa
if targets[0].money_type:
copper_value = min(targets[0].money_type.copper_value, 1000)
targets[0].quantity = random.randint(1, int(1000 / copper_value))
# (TD) Bisognerebbe inserire un affect nella locazione che impedisca di
# scavare ancora lì per tot tempo
targets[0].inject(location)
# L'esperienza per aver scavato la prima volta nella stanza viene data
# a prescindere che sia stato trovata un'entità o meno
if entity.IS_PLAYER and location.IS_ROOM:
if location.prototype.code in entity.digged_rooms:
entity.digged_rooms[location.prototype.code] += 1
else:
entity.digged_rooms[location.prototype.code] = 1
reason = "per aver scavato %s" % location.get_name(looker=entity)
entity.give_experience(location.area.level, reason=reason)
if not targets:
entity.act(
"\n%s ma non trovi proprio nulla di interessante." %
color_first_upper(verbs["you"]), TO.ENTITY, location)
entity.act(
"$n %s una buca in $N senza trovare nulla di interessante." %
verbs["it"], TO.OTHERS, location)
entity.act(
"$n ti %s una buca senza trovare nulla di interessante." %
verbs["it"], TO.TARGET, location)
entity.send_prompt()
entity.action_in_progress = None
return
target = random.choice(targets)
target = target.split_entity(random.randint(1, target.quantity))
entity.action_in_progress = None
entity.act("\nFinisci di %s scoprendo $N!" % verbs["infinitive"],
TO.ENTITY, target)
entity.act(
"$n termina di %s dopo che ha scoperto qualcosa." %
verbs["infinitive"], TO.OTHERS, target)
entity.act(
"$n termina di %s dopo che ti ha scoperto nel terreno." %
verbs["infinitive"], TO.TARGET, target)
entity.act(
"$n termina di %s dopo che ha scoperto $a dentro di te." %
verbs["infinitive"], TO.TARGET, location, target)
entity.send_prompt()
target.flags -= FLAG.BURIED
# Se era un seme o una pianta allora ne ferma la crescita
if target.seed_type:
target.seed_type.stop_growth()
if target.plant_type:
target.plant_type.stop_growth()
# (TD) imparare un po' la skill scava dai propri successi
force_return = check_trigger(entity, "after_dig", entity, location, target,
DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(location, "after_digged", entity, location,
target, DIR.NONE, behavioured)
if force_return:
return True
def create_handler(entity,
argument,
command_name,
table_name,
can_create_multiple=False):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not command_name:
log.bug("command_name non è un parametro valido: %r" % command_name)
return False
if not table_name:
log.bug("table_name non è un parametro valido: %r" % table_name)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, command_name)
entity.send_output(syntax, break_line=False)
return False
if can_create_multiple:
quantity, argument = quantity_argument(argument)
else:
quantity = 1
target = None
if table_name == "players":
target = search_online_player(argument, only_exact=True)
if not target:
target = entity.find_proto(argument, entity_tables=[table_name])
if not target:
entity.send_output(
"Non è stato trovato nessun %s con argomento [green]%s[close]."
% (table_name, argument))
return False
if quantity == 0:
quantity = target.quantity
if not target.IS_PLAYER and target.max_global_quantity > 0 and target.current_global_quantity + quantity > target.max_global_quantity:
if entity.trust == TRUST.IMPLEMENTOR:
entity.send_to_admin(
"Ti è possibile iniettare in gioco %s nonostante questo raggiungerà il suo MaxGlobalQuantity di %d"
% (target.get_name(looker=entity), target.max_global_quantity))
else:
entity.send_output(
"Non ti è possibile iniettare in gioco questa entità perché ha già raggiunto il suo MaxGlobalQuantity di %d"
% target.max_global_quantity)
return False
if target.IS_PLAYER:
result = Mob("limbo_mob_clone-pg")
copy_existing_attributes(target,
result,
except_these_attrs=["code", "prototype"])
result.short = result.name # (TD) creazione dinamica della short, un po' come la long
result.incognito = False
elif target.IS_MOB:
result = Mob(target.code)
elif target.IS_ITEM:
result = Item(target.code)
else:
log.bug("Entità base non valida: %s" % target.code)
entity.send_output("C'è stato un'errore nell'esecuzione del comando.")
return False
# Se l'oggetto è uno dell'area rip avrà il tag %material da dover sostituire
if "%material" in result.short:
result.short.replace("%material", "qualcosa")
if "%material" in result.short_night:
result.short_night.replace("%material", "qualcosa")
if "%material" in result.name:
result.name.replace("%material", "qualcosa")
result.quantity = quantity
result.inject(entity)
if entity == target:
entity.act("Crei dal nulla una copia di te stess$O.", TO.ENTITY,
target)
entity.act("$n crea dal nulla una copia di se stess$O.", TO.OTHERS,
target)
elif entity.location == target.location:
entity.act("Crei dal nulla una copia di $N.", TO.ENTITY, target)
entity.act(
"$n crea dal nulla una copia di $N, ma ora qual'è quello vero?",
TO.OTHERS, target)
entity.act("$n crea dal nulla una copia di te stess$O!", TO.TARGET,
target)
else:
entity.act("Crei dal nulla una copia di $N.", TO.ENTITY, target)
entity.act("$n crea dal nulla una copia di $N.", TO.OTHERS, target)
return True