def func(self):
"""
Implement the command.
This works both as a look and a search command; there is a
random chance of eventually finding a light source.
"""
caller = self.caller
# count how many searches we've done
nr_searches = caller.ndb.dark_searches
if nr_searches is None:
nr_searches = 0
caller.ndb.dark_searches = nr_searches
if nr_searches < 4 and random.random() < 0.90:
# we don't find anything
caller.msg(random.choice(DARK_MESSAGES))
caller.ndb.dark_searches += 1
else:
# we could have found something!
if any(obj for obj in caller.contents if utils.inherits_from(obj, LightSource)):
# we already carry a LightSource object.
caller.msg(ALREADY_LIGHTSOURCE)
else:
# don't have a light source, create a new one.
create_object(LightSource, key="splinter", location=caller)
caller.msg(FOUND_LIGHTSOURCE)
def locationTunnel(location1, location1_exit_name, location2, location2_exit_name):
exit1 = location2_exit_name if (location2_exit_name) else location2.key
exit2 = location1_exit_name if (location1_exit_name) else location1.key
print "Create tunnel between '%s' and '%s'" % ( exit1, exit2 )
exit1 = create_object(settings.BASE_EXIT_TYPECLASS, exit1, location = location1, destination = location2)
exit2 = create_object(settings.BASE_EXIT_TYPECLASS, exit2, location = location2, destination = location1)
return [ exit1, exit2 ]
def at_get(self, getter):
super(Bundlable, self).at_get(getter)
bundle_key = self.aliases.all()[0]
others = [obj for obj in getter.contents
if obj.is_typeclass('typeclasses.items.Bundlable')
and bundle_key in obj.aliases.all()]
if len(others) >= self.db.bundle_size \
and self.db.prototype_name and self.aliases.all():
# we have enough to create a bundle
bundle = create_object(
typeclass='typeclasses.items.Bundle',
key='a bundle of {}s'.format(bundle_key),
aliases=['bundle {}'.format(bundle_key)],
location=self.location
)
bundle.db.desc = ("A bundle of {item}s held together "
"with a thin leather strap.").format(
item=bundle_key
)
bundle.db.value = self.db.bundle_size * self.db.value
bundle.db.weight = self.db.bundle_size * self.db.weight
bundle.db.quantity = self.db.bundle_size
bundle.db.prototype_name = self.db.prototype_name
for obj in others[:self.db.bundle_size]:
obj.delete()
def create_room(self, room):
new_room = create_object('typeclasses.rooms.Box', key = room['name'])
new_room.db.desc = room['desc']
if (new_room.name == u'Кухня'):
new_room.scripts.add(KitchenKnife)
try:
for npc in room['npc']:
create_object(npc['typeclass'], key = npc['name'], location = new_room)
except KeyError:
pass
#locationTunnelDefault(self, new_room);
locationTunnel(self, "Прихожка", new_room, new_room.name);
return new_room
def func(self):
caller = self.caller
if caller.db.hands:
caller.msg("У тебя уже есть руки")
else:
caller.db.hands = create_object(settings.BASE_OBJECT_TYPECLASS, "hands")
caller.msg("Теперь у тебя есть руки")
if caller.db.frags:
caller.msg("У тебя уже есть параметр фрагов")
else:
caller.db.frags = 0
caller.msg("Теперь у тебя есть фраги")
if caller.db.death_count:
caller.msg("У тебя уже есть параметр смертей")
else:
caller.db.death_count = 0
caller.msg("Теперь у тебя есть количество смертей")
if caller.db.effects:
caller.msg("У тебя уже есть массив с эффектами")
else:
caller.db.effects = []
caller.msg("Теперь у тебя есть массив с эффектами")
def spell_conjure(caster, spell_name, targets, cost, **kwargs):
"""
Spell that creates an object.
kwargs:
obj_key (str): Key of the created object.
obj_desc (str): Desc of the created object.
obj_typeclass (str): Typeclass path of the object.
If you want to make more use of this particular spell funciton,
you may want to modify it to use the spawner (in evennia.utils.spawner)
instead of creating objects directly.
"""
obj_key = "a nondescript object"
obj_desc = "A perfectly generic object."
obj_typeclass = "evennia.objects.objects.DefaultObject"
# Retrieve some variables from kwargs, if present
if "obj_key" in kwargs:
obj_key = kwargs["obj_key"]
if "obj_desc" in kwargs:
obj_desc = kwargs["obj_desc"]
if "obj_typeclass" in kwargs:
obj_typeclass = kwargs["obj_typeclass"]
conjured_obj = create_object(obj_typeclass, key=obj_key, location=caster.location) # Create object
conjured_obj.db.desc = obj_desc # Add object desc
caster.db.mp -= cost # Deduct MP cost
# Message the room to announce the creation of the object
caster.location.msg_contents("%s casts %s, and %s appears!" % (caster, spell_name, conjured_obj))
def func(self):
caller = self.caller
pantsu = create_object(settings.BASE_OBJECT_TYPECLASS, "Детские трусики", caller, home=caller)
talking_to = caller.search(caller.db.last_talk_with, location=caller.location)
pantsu.db.desc = "Трусики принадлежат: %s!" % talking_to.key
self.menutree.goto("END")
def test_lightsource(self):
light = create_object(tutobjects.LightSource, key="torch", location=self.room1)
self.call(tutobjects.CmdLight(), "", "You light torch.", obj=light)
light._burnout()
if hasattr(light, "deferred"):
light.deferred.cancel()
self.assertFalse(light.pk)
def test_mob(self):
mobobj = create_object(mob.Mob, key="mob")
self.assertEqual(mobobj.db.is_dead, True)
mobobj.set_alive()
self.assertEqual(mobobj.db.is_dead, False)
mobobj.set_dead()
self.assertEqual(mobobj.db.is_dead, True)
mobobj._set_ticker(0, "foo", stop=True)
def _create_room(self, coordinates, report_to):
"""
Gets a new WildernessRoom to be used for the provided coordinates.
It first tries to retrieve a room out of storage. If there are no rooms
left a new one will be created.
Args:
coordinates (tuple): coordinate tuple of (x, y)
report_to (object): the obj to return error messages to
"""
if self.db.unused_rooms:
# There is still unused rooms stored in storage, let's get one of
# those
room = self.db.unused_rooms.pop()
else:
# No more unused rooms...time to make a new one.
# First, create the room
room = create_object(typeclass=self.mapprovider.room_typeclass,
key="Wilderness",
report_to=report_to)
# Then the exits
exits = [("north", "n"),
("northeast", "ne"),
("east", "e"),
("southeast", "se"),
("south", "s"),
("southwest", "sw"),
("west", "w"),
("northwest", "nw")]
for key, alias in exits:
create_object(typeclass=self.mapprovider.exit_typeclass,
key=key,
aliases=[alias],
location=room,
destination=room,
report_to=report_to)
room.ndb.active_coordinates = coordinates
room.ndb.wildernessscript = self
self.db.rooms[coordinates] = room
return room
def at_object_creation(self):
#добавляем прочность нашему оружию(int)
self.db.durability = 50
self.db.is_weapon = True
#добавим часть тела, куда одевается предмет
#self.db.placing = "RightHand"
self.db.desc = "Пистолет ТТ."
mag = create_object(settings.BASE_OBJECT_TYPECLASS, "Магазин на 12 патронов", self, home=self)
mag.db.desc = "Магазин на 12 патронов"
def test_cmdtutorial(self):
room = create_object(tutrooms.TutorialRoom, key="tutroom")
self.char1.location = room
self.call(tutrooms.CmdTutorial(), "", "Sorry, there is no tutorial help available here.")
self.call(tutrooms.CmdTutorialSetDetail(), "detail;foo;foo2 = A detail", "Detail set: 'detail;foo;foo2': 'A detail'", obj=room)
self.call(tutrooms.CmdTutorialLook(), "", "tutroom(", obj=room)
self.call(tutrooms.CmdTutorialLook(), "detail", "A detail", obj=room)
self.call(tutrooms.CmdTutorialLook(), "foo", "A detail", obj=room)
room.delete()
def test_bridgeroom(self):
room = create_object(tutrooms.BridgeRoom, key="bridgeroom")
room.update_weather()
self.char1.move_to(room)
self.call(tutrooms.CmdBridgeHelp(), "", "You are trying hard not to fall off the bridge ...", obj=room)
self.call(tutrooms.CmdLookBridge(), "", "bridgeroom\nYou are standing very close to the the bridge's western foundation.", obj=room)
room.at_object_leave(self.char1, self.room1)
tutrooms.TICKER_HANDLER.remove(interval=room.db.interval, callback=room.update_weather, idstring="tutorial")
room.delete()
def func(self):
"creates the object and names it"
caller = self.caller
if not self.args:
caller.msg("Usage: +createNPC <name>")
return
if not caller.location:
# may not create npc when OOC
caller.msg("You must have a location to create an npc.")
return
# make name always start with capital letter
name = self.args.capitalize()
# create npc in caller's location
npc = create_object("characters.Character",
key=name,
location=caller.location,
locks="edit:id(%i) and perm(Builders)" % caller.id)
# announce
message = "%s created the NPC '%s'.\n"
caller.msg(message % ("You", name))
caller.location.msg_contents(message % (caller.key, name),
exclude=caller)
#Let's set the initial stats for the NPC --SG
hitpoints = random.randint(5,10)
npc.db.hitpoints = hitpoints
caller.msg("Your current hitpoints was set to %i." % hitpoints)
manapoints = random.randint(5,10)
npc.db.manapoints = manapoints
caller.msg("Your current manapoints was set to %i." % manapoints)
strength = random.randint(1, 18)
npc.db.strength = strength
message = "%s's Strength was set to %i."
caller.msg(message % (name, strength))
dexterity = random.randint(1, 18)
npc.db.dexterity = dexterity
message = "%s's Dexterity was set to %i."
caller.msg(message % (name, dexterity))
charisma = random.randint(1, 18)
npc.db.charisma = charisma
message = "%s's Charisma was set to %i."
caller.msg(message % (name, charisma))
intelligence = random.randint(1, 18)
npc.db.intelligence = intelligence
message = "%s's Intelligence was set to %i."
caller.msg(message % (name, intelligence))
stamina = random.randint(1, 18)
npc.db.stamina = stamina
message = "%s's Stamina was set to %i.\n"
caller.msg(message % (name, stamina))
def example2_build_verticle_exit(x, y, **kwargs):
"""Creates two exits to and from the two rooms north and south."""
# If on the first iteration - Do nothing.
if kwargs["iteration"] == 0:
return
north_room = kwargs["room_dict"][(x, y-1)]
south_room = kwargs["room_dict"][(x, y+1)]
north = create_object(exits.Exit, key="south",
aliases=["s"], location=north_room,
destination=south_room)
south = create_object(exits.Exit, key="north",
aliases=["n"], location=south_room,
destination=north_room)
kwargs["caller"].msg("Connected: " + north_room.key +
" & " + south_room.key)
def example2_build_horizontal_exit(x, y, **kwargs):
"""Creates two exits to and from the two rooms east and west."""
# If on the first iteration - Do nothing.
if kwargs["iteration"] == 0:
return
west_room = kwargs["room_dict"][(x-1, y)]
east_room = kwargs["room_dict"][(x+1, y)]
create_object(exits.Exit, key="east",
aliases=["e"], location=west_room,
destination=east_room)
create_object(exits.Exit, key="west",
aliases=["w"], location=east_room,
destination=west_room)
kwargs["caller"].msg("Connected: " + west_room.key +
" & " + east_room.key)
def at_post_login(self, sessid = None):
super(Player, self).at_post_login(sessid)
try:
if (settings.TEST_SERVER):
self.permissions.add('Builders')
except AttributeError:
pass
character = self.character
# Вероятно, этот код нужно убрать в at_first_login хук
try:
homeLocation = character.search(u"1-Общий дворик", global_search = True, quiet = True)[0]
except IndexError:
# сервер после вайпа, нужно выполнить инцилизацию локаций вручную
# bathccommand mu2ch_init
# пока заглушка
return
if (homeLocation and character.home != homeLocation):
character.home = character.location = homeLocation
character.move_to(homeLocation)
apartment = None
if (character.db.flat):
return
i = 1
while (apartment is None):
try:
building = character.search(u"1-Дом%d" % i, global_search = True, quiet = True)[0]
except IndexError:
try:
building_home = character.search(u"Преддомовая территория", global_search = True, quiet = True)[0]
except IndexError:
# что то пошло не так
return
building = create_object('typeclasses.building.Hrushevka', key = u"Дом%d" % i)
locationTunnel(building, u"Дом%d" % i , building_home, u"Улица")
if (not building):
print "Что-то пошло не так"
# never happend
break
# db.flat - локация хаты персонажа
apartment = building.assignCharacter(character)
if (apartment):
character.msg("Тебя заселили по адресу: %s" % repr(apartment))
i = i + 1
def example2_build_forest(x, y, **kwargs):
"""A basic room"""
# If on anything other than the first iteration - Do nothing.
if kwargs["iteration"] > 0:
return None
room = create_object(rooms.Room, key="forest" + str(x) + str(y))
room.db.desc = "Basic forest room."
kwargs["caller"].msg(room.key + " " + room.dbref)
return room
def test_clothingcommands(self):
wearer = create_object(clothing.ClothedCharacter, key="Wearer")
friend = create_object(clothing.ClothedCharacter, key="Friend")
room = create_object(DefaultRoom, key="room")
wearer.location = room
friend.location = room
# Make a test hat
test_hat = create_object(clothing.Clothing, key="test hat")
test_hat.db.clothing_type = 'hat'
test_hat.location = wearer
# Make a test scarf
test_scarf = create_object(clothing.Clothing, key="test scarf")
test_scarf.db.clothing_type = 'accessory'
test_scarf.location = wearer
# Test wear command
self.call(clothing.CmdWear(), "", "Usage: wear <obj> [wear style]", caller=wearer)
self.call(clothing.CmdWear(), "hat", "Wearer puts on test hat.", caller=wearer)
self.call(clothing.CmdWear(), "scarf stylishly", "Wearer wears test scarf stylishly.", caller=wearer)
# Test cover command.
self.call(clothing.CmdCover(), "", "Usage: cover <worn clothing> [with] <clothing object>", caller=wearer)
self.call(clothing.CmdCover(), "hat with scarf", "Wearer covers test hat with test scarf.", caller=wearer)
# Test remove command.
self.call(clothing.CmdRemove(), "", "Could not find ''.", caller=wearer)
self.call(clothing.CmdRemove(), "hat", "You have to take off test scarf first.", caller=wearer)
self.call(clothing.CmdRemove(), "scarf", "Wearer removes test scarf, revealing test hat.", caller=wearer)
# Test uncover command.
test_scarf.wear(wearer, True)
test_hat.db.covered_by = test_scarf
self.call(clothing.CmdUncover(), "", "Usage: uncover <worn clothing object>", caller=wearer)
self.call(clothing.CmdUncover(), "hat", "Wearer uncovers test hat.", caller=wearer)
# Test drop command.
test_hat.db.covered_by = test_scarf
self.call(clothing.CmdDrop(), "", "Drop what?", caller=wearer)
self.call(clothing.CmdDrop(), "hat", "You can't drop that because it's covered by test scarf.", caller=wearer)
self.call(clothing.CmdDrop(), "scarf", "You drop test scarf.", caller=wearer)
# Test give command.
self.call(clothing.CmdGive(), "", "Usage: give <inventory object> = <target>", caller=wearer)
self.call(clothing.CmdGive(), "hat = Friend", "Wearer removes test hat.|You give test hat to Friend.", caller=wearer)
# Test inventory command.
self.call(clothing.CmdInventory(), "", "You are not carrying or wearing anything.", caller=wearer)
def example1_build_mountains(x, y, **kwargs):
"""A room that is a little more advanced"""
# Create the room.
room = create_object(rooms.Room, key="mountains" + str(x) + str(y))
# Generate a description by randomly selecting an entry from a list.
room_desc = ["Mountains as far as the eye can see",
"Your path is surrounded by sheer cliffs",
"Haven't you seen that rock before?"]
room.db.desc = random.choice(room_desc)
# Create a random number of objects to populate the room.
for i in xrange(randint(0, 3)):
rock = create_object(key="Rock", location=room)
rock.db.desc = "An ordinary rock."
# Send a message to the player
kwargs["caller"].msg(room.key + " " + room.dbref)
# This is generally mandatory.
return room
def example1_build_forest(x, y, **kwargs):
"""A basic example of build instructions. Make sure to include **kwargs
in the arguments and return an instance of the room for exit generation."""
# Create a room and provide a basic description.
room = create_object(rooms.Room, key="forest" + str(x) + str(y))
room.db.desc = "Basic forest room."
# Send a message to the player
kwargs["caller"].msg(room.key + " " + room.dbref)
# This is generally mandatory.
return room
def build(self):
i = 0
prev_floor = None
for i in xrange(1, self.db.floor_n):
new_floor = create_object('floor.BuildingFloor', key = u"%d Этаж" % i)
new_floor.build(self, i)
new_floor.move_to(self, quiet = True, move_hooks = False)
locationTunnel(self, self.db.desc, new_floor, None)
if (prev_floor):
locationTunnelDefault(prev_floor, new_floor)
prev_floor = new_floor
def at_die(self):
"""
Хук смерти игрока. Создает труп, скидывает в него вещи, деньги, переносит игрока в лимб.
"""
# создаем труп
corpse = create_object(Corpse, self.key, location=self.location)
# денюшки
if self.db.money:
corpse.db.money = self.db.money
self.db.money = 0
# corpse.key = "Труп %s" % self.key
descriptions = [
"Изуродованный труп %s" % self.key,
"Бренное тело %s" % self.key,
"Останки %s" % self.key,
"Все, что оcталось от %s" % self.key,
]
corpse.db.desc = random.choice(descriptions)
# скидываем внего вещи
items = self.contents
if items:
for item in items:
item.move_to(corpse, quiet=True)
if self.db.hands:
in_hands = self.db.hands.contents
if in_hands:
item = in_hands[0]
item.move_to(corpse, quiet=True)
# сбарсываем пати, если ты умер, или умер лидер
leader = self.db.party_leader
party = self.db.party
if party:
for member in party:
player = self.search(member, global_search=True, nofound_string="Сопартиец %s не найден!" % member)
if not player:
return
player.db.party_leader = None
player.msg("Ваш лидер погиб и ваша группа распалась.")
self.db.party = []
self.msg("Твоя группа распалась.")
if leader:
your_leader = self.search(leader, global_search=True, nofound_string="Лидер %s не найден!" % leader)
your_leader.db.party.remove(self.key)
your_leader.msg("%s погиб и вышел и твой группы." % self.key)
self.db.party_leader = None
self.msg("Ты покинул группу %s" % your_leader.key)
# задрежка
delay(5, callback=self.TelToLimb)
def build(self, building, n):
self.db.n = n
self.db.key = self.db.desc = u"%d этаж" % n
self.db.building = building
per_floor = building.db.apartment_per_floor
i = 1
for i in xrange(1, per_floor + 1):
room_n = ((n - 1) * per_floor) + i
roomEntryLocation = create_object('apartment.BuildingApartmentUnused', key = u"Кв-%d" % room_n)
roomEntryLocation.build(self, room_n)
roomEntryLocation.move_to(self, quiet = True, move_hooks = False)
locationTunnel(roomEntryLocation, roomEntryLocation.key, self, u"Лестничная площадка")
return self
def test_clothingfunctions(self):
wearer = create_object(clothing.ClothedCharacter, key="Wearer")
room = create_object(DefaultRoom, key="room")
wearer.location = room
# Make a test hat
test_hat = create_object(clothing.Clothing, key="test hat")
test_hat.db.clothing_type = 'hat'
test_hat.location = wearer
# Make a test shirt
test_shirt = create_object(clothing.Clothing, key="test shirt")
test_shirt.db.clothing_type = 'top'
test_shirt.location = wearer
# Make a test pants
test_pants = create_object(clothing.Clothing, key="test pants")
test_pants.db.clothing_type = 'bottom'
test_pants.location = wearer
test_hat.wear(wearer, 'on the head')
self.assertEqual(test_hat.db.worn, 'on the head')
test_hat.remove(wearer)
self.assertEqual(test_hat.db.worn, False)
test_hat.worn = True
test_hat.at_get(wearer)
self.assertEqual(test_hat.db.worn, False)
clothes_list = [test_shirt, test_hat, test_pants]
self.assertEqual(clothing.order_clothes_list(clothes_list), [test_hat, test_shirt, test_pants])
test_hat.wear(wearer, True)
test_pants.wear(wearer, True)
self.assertEqual(clothing.get_worn_clothes(wearer), [test_hat, test_pants])
self.assertEqual(clothing.clothing_type_count(clothes_list), {'hat':1, 'top':1, 'bottom':1})
self.assertEqual(clothing.single_type_count(clothes_list, 'hat'), 1)
def assignApartmentToCharacter(self, apartment_location, character):
# TODO проверяеть тип локации который нам дают
floor = apartment_location.db.floor
# Уничтожаем пустую квартиру
room_n = apartment_location.db.n
db_key = apartment_location.name
apartment_location.delete()
# Создаем кваритру с комнатами
new_apartment = create_object('apartment.BuildingApartmentUsed', key = db_key)
new_apartment.build(floor, room_n)
new_apartment.db.assign_to = character
exits = locationTunnel(new_apartment, new_apartment.name, floor, u"Лестничная площадка")
exits[1].locks.add("traverse: id(%d) or perm(Wizard)" % character.id)
new_apartment.move_to(floor, quiet = True, move_hooks = False)
return new_apartment
def func(self):
caller = self.caller
if not self.args:
caller.msg("Использование (без <>): алхимия <ингредиент 1>+<ингредиент 2>+<ингредиент 3>+...")
return
componets = self.args.strip().split("+")
if not componets:
caller.msg("Не верно указаны ингредиенты.")
return
avaible_components,to_delete = [],[]
for componet in componets:
avaible = caller.search(componet, location=caller, nofound_string="У тебя нет компонента: %s" % componet)
if not avaible:
continue
avaible_components.append(avaible.key)
to_delete.append(avaible)
if len(componets) != len(avaible_components):
caller.msg("У тебя не хватает компонентов!")
return
recipes = Alchemy().recipes.values()
created= False
for recipe in recipes:
if self.comp(list1=avaible_components, list2=recipe["components"]):
result = create_object(recipe["typeclass"], recipe["name"], caller, home=caller)
created = True
if not created:
caller.msg("Нет такого рецепта!")
return
string = "Ты потратил: "
for item in to_delete:
string += "%s, " % item.key
item.delete()
string+="и нахимичил %s" % result.key
caller.msg(string)
def at_tick(self):
tickerhandler.remove(self, self.db.last_ticker_deley_value)
self.db.last_ticker_deley_value = random.randint(15, 120)
tickerhandler.add(self, self.db.last_ticker_deley_value)
if not self.goods:
return
goods_to_create = self.goods.values()
for good in goods_to_create:
good_in_inv = self.search(good["name"], location=self, nofound_string="")
if not good_in_inv:
new_good = create_object(good["typeclass"], good["name"], self, home=self)
if not new_good.db.desc:
if good["desc"]:
new_good.db.desc = good["desc"]
new_good.db.coast = good["coast"]
def func(self):
"""
Tries to create the Character object. We also put an
attribute on ourselves to remember it.
"""
# making sure caller is really a player
self.character = None
if utils.inherits_from(self.caller, "evennia.objects.objects.Object"):
# An object of some type is calling. Convert to player.
#print self.caller, self.caller.__class__
self.character = self.caller
if hasattr(self.caller, "player"):
self.caller = self.caller.player
if not self.args:
self.caller.msg("Usage: create <character name>")
return
charname = self.args.strip()
old_char = managers.objects.get_objs_with_key_and_typeclass(charname, CHARACTER_TYPECLASS)
if old_char:
self.caller.msg("Character {c%s{n already exists." % charname)
return
# create the character
new_character = create_object(CHARACTER_TYPECLASS, key=charname)
if not new_character:
self.caller.msg("{rThe Character couldn't be created. This is a bug. Please contact an admin.")
return
# make sure to lock the character to only be puppeted by this player
new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" %
(new_character.id, self.caller.id))
# save dbref
avail_chars = self.caller.db._character_dbrefs
if avail_chars:
avail_chars.append(new_character.id)
else:
avail_chars = [new_character.id]
self.caller.db._character_dbrefs = avail_chars
self.caller.msg("{gThe Character {c%s{g was successfully created!" % charname)
def at_object_creation(self):
#прикручиваем руку
self.db.hands = create_object(settings.BASE_OBJECT_TYPECLASS, "hands")
#прикручиваем фраги
self.db.frags = 0
#прикручиваем количество смертей
self.db.death_count = 0
#прикручиваем хеш ээфектов
self.db.effects = {}
#ассоциация с хатой.
self.db.flat = None
#прикручивам группу
self.db.party = []
#прикручиваем лидера группы
self.db.party_leader = None
#прикручиваем деньги
self.db.money = 3
#прикручиваем религию
self.db.religion = "атеист"
#прикручиваем предыдущую локацию
self.db.last_location = None
def example1_build_temple(x, y, **kwargs):
"""A unique room that does not need to be as general"""
# Create the room.
room = create_object(rooms.Room, key="temple" + str(x) + str(y))
# Set the description.
room.db.desc = ("In what, from the outside, appeared to be a grand and "
"ancient temple you've somehow found yourself in the the "
"Evennia Inn! It consists of one large room filled with "
"tables. The bardisk extends along the east wall, where "
"multiple barrels and bottles line the shelves. The "
"barkeep seems busy handing out ale and chatting with "
"the patrons, which are a rowdy and cheerful lot, "
"keeping the sound level only just below thunderous. "
"This is a rare spot of mirth on this dread moor.")
# Send a message to the player
kwargs["caller"].msg(room.key + " " + room.dbref)
# This is generally mandatory.
return room
def func(self):
"creates the object and names it"
caller = self.caller
if not self.args:
caller.msg("Usage: +createNPC <name>")
return
if not caller.location:
# may not create npc when OOC
caller.msg("You must have a location to create an NPC.")
return
# make name always start with a capital letter
name = self.args.strip().capitalize()
# create npc in caller's location
npc = create_object("characters.Character",
key=name, location=caller.location,
locks="edit:id(%i) and perm(Builders)"
% caller.id)
# announce
message = "%s created the NPC '%s'."
caller.msg(message % ("You", name))
caller.location.msg_contents(message % (caller.key, npc.key),
exclude=caller)
def test_crumblingwall(self):
wall = create_object(tutobjects.CrumblingWall,
key="wall",
location=self.room1)
self.assertFalse(wall.db.button_exposed)
self.assertFalse(wall.db.exit_open)
wall.db.root_pos = {"yellow": 0, "green": 0, "red": 0, "blue": 0}
self.call(
tutobjects.CmdShiftRoot(),
"blue root right",
"You shove the root adorned with small blue flowers to the right.",
obj=wall)
self.call(tutobjects.CmdShiftRoot(),
"red root left",
"You shift the reddish root to the left.",
obj=wall)
self.call(
tutobjects.CmdShiftRoot(),
"yellow root down",
"You shove the root adorned with small yellow flowers downwards.",
obj=wall)
self.call(
tutobjects.CmdShiftRoot(),
"green root up",
"You shift the weedy green root upwards.|Holding aside the root you think you notice something behind it ...",
obj=wall)
self.call(
tutobjects.CmdPressButton(),
"",
"You move your fingers over the suspicious depression, then gives it a decisive push. First",
obj=wall)
self.assertTrue(wall.db.button_exposed)
self.assertTrue(wall.db.exit_open)
wall.reset()
if hasattr(wall, "deferred"):
wall.deferred.cancel()
wall.delete()
def func(self):
ch = self.caller
if not self.args:
ch.msg("supply a rvnum to goto")
return
vnum = self.args.strip()
try:
vnum = int(vnum)
except:
ch.msg("That is not a valid vnum")
return
# handle special case of void here
if vnum == 1:
void = search_object('#2')[0]
ch.move_to(void)
ch.execute_cmd('look')
return
# try to find vnum in database
room = search_object(str(vnum),
typeclass='typeclasses.rooms.rooms.Room')
roomdb = GLOBAL_SCRIPTS.roomdb
if not room:
# make sure a blueprint of room exists
try:
_ = roomdb.vnum[vnum]
except KeyError:
ch.msg("That room does not exist")
return
room = create_object('typeclasses.rooms.rooms.Room', key=vnum)
ch.move_to(room)
else:
ch.move_to(room[0])
def spell_conjure(caster, spell_name, targets, cost, **kwargs):
"""
Spell that creates an object.
kwargs:
obj_key (str): Key of the created object.
obj_desc (str): Desc of the created object.
obj_typeclass (str): Typeclass path of the object.
If you want to make more use of this particular spell funciton,
you may want to modify it to use the spawner (in evennia.utils.spawner)
instead of creating objects directly.
"""
obj_key = "a nondescript object"
obj_desc = "A perfectly generic object."
obj_typeclass = "evennia.objects.objects.DefaultObject"
# Retrieve some variables from kwargs, if present
if "obj_key" in kwargs:
obj_key = kwargs["obj_key"]
if "obj_desc" in kwargs:
obj_desc = kwargs["obj_desc"]
if "obj_typeclass" in kwargs:
obj_typeclass = kwargs["obj_typeclass"]
conjured_obj = create_object(
obj_typeclass, key=obj_key, location=caster.location
) # Create object
conjured_obj.db.desc = obj_desc # Add object desc
caster.db.mp -= cost # Deduct MP cost
# Message the room to announce the creation of the object
caster.location.msg_contents(
"%s casts %s, and %s appears!" % (caster, spell_name, conjured_obj)
)
def spawnRooms(self):
if self.rooms_created:
print("Rooms already created!")
else:
firstRoom = True
for vnum, room in self.rooms.items():
if (self.last_area != room['area']):
self.last_area = room['area']
firstRoom = True
newroom = create_object(
typeclass="typeclasses.rooms.LegacyRoom", key=room['name'])
newroom.db.desc = room['desc']
newroom.tags.add(room['area'], category='area')
newroom.db.area = room['area']
self.room_translate[vnum] = newroom.id
if self.verbose:
print("Area: %s Room: %s Vnum: %s Evid: %s" %
(room['area'], room['name'], vnum, newroom.id))
if (firstRoom):
print(room['area'] + ': ' + str(newroom.id) + " = " +
room['name'])
firstRoom = False
self.rooms_created = True
self._spawnRooms_exits()
def func(self):
ch = self.caller
args = self.args.strip().split()
if not args:
ch.msg(f"{self.__doc__}")
return
if len(args) == 1:
ch.msg("must supply valid vnum number")
return
# <obj/mob> <vnum>
obj_type, vnum = args
if obj_type.lower() not in ('obj', 'mob'):
ch.msg("must supply either `obj` or `mob`")
return
try:
vnum = int(vnum)
except ValueError:
ch.msg("invalid vnum number")
return
# check to see if vnum exists
if vnum not in GLOBAL_SCRIPTS.objdb.vnum.keys():
ch.msg(f"that {obj_type}:{vnum} does not exist")
return
obj_bp = GLOBAL_SCRIPTS.objdb.vnum[vnum]
# create instance of object and either put in room
obj_type = CUSTOM_OBJS[obj_bp['type']]
obj = create_object(obj_type, key=vnum)
obj.move_to(ch.location)
act_msg = "$n motions $s hands around and $e creates"\
f" |G{obj.db.sdesc}|n"
act(act_msg, False, False, ch, None, None, Announce.ToRoom)
act(f"You create |G{obj.db.sdesc}|n", False, False, ch, None, None,
Announce.ToChar)
def spawnObjects(self):
if self.objects_created:
print("Objects already created!")
else:
print("spawning items")
for vnum, ob in self.objects.items():
if vnum not in self.object_location.keys():
#if self.verbose: print("Object vnum not found in object_location table: %s" % vnum)
continue
else:
evid = "#" + str(
self.room_translate[self.object_location[vnum]])
try:
loc = search_object(evid)[0]
except Exception as e:
print("location for object vnum %s not found: %s" %
(vnum, evid))
continue
try:
newob = create_object(
key=ob['name'],
location=loc,
home=loc,
aliases=ob['aliases'],
typeclass="typeclasses.objects.LegacyObject",
attributes=[('desc', ob['desc']),
('ext_desc', ob['ext']),
('type', ob['type']),
('area', ob['area'])])
print("%s created in %s - #%s" %
(ob['name'], loc.name, newob.id))
except Exception as e:
print("Error creating %s, vnum: %s location: %s" %
(ob['name'], vnum, loc.id))
print(str(e))
def func(self):
errmsg = "Usage: createnpc <name>"
"create the object and name it"
caller = self.caller
# Error handling
if not self.args:
caller.msg(errmsg)
return
if not caller.location:
# May not create npc when OOC
caller.msg("|430You must be in a location to build an npc.|n")
return
# make name always start with capital letter
name = self.args.strip().capitalize()
# create npc in caller's location
npc = create_object(
"characters.Character",
key=name,
location=caller.location,
locks="edit:id(%i) and perm(Builders);call:false()" % caller.id)
# announce
message = "%s created the NPC '%s'."
caller.msg(message % ("You", name))
def connect_all_areas():
CARDINAL_DIRS = {
"north": "south",
"south": "north",
"east": "west",
"west": "east",
"northeast": "southwest",
"southwest": "northeast",
"southeast": "northwest",
"northwest": "southeast"
}
EXIT_OPPOSITE = {
"north": "south",
"south": "north",
"east": "west",
"west": "east",
"northeast": "southwest",
"southwest": "northeast",
"southeast": "northwest",
"northwest": "southeast"
}
def is_cardinal_direction(mech_exit):
return mech_exit.name in CARDINAL_DIRS
# Gets the exit of of the opposite direction from destRoom (i.e.
# if mech_exit is North, it will return the Exit object of South
# from destRoom.
# If opposite exit is not found, it will return None.
def get_opposite_exit(mech_exit, destRoom):
for exit in destRoom.exits:
if EXIT_OPPOSITE[exit.name] == mech_exit.name:
return exit
return None
# Get all the rooms that match the <area> tag
connector_from_rooms = evennia.utils.search.search_object_by_tag(
key="connector_from", category="map_builder")
connector_to_rooms = evennia.utils.search.search_object_by_tag(
key="connector_to", category="map_builder")
for from_room in connector_from_rooms:
# get the connector dict
connectorDict = from_room.db.map_builder_connector_dict
if not connectorDict:
raise Exception(
"No connector dictionary assigned to connector from_room "
"%s/#%d in zone %s" % (from_room.name, int(
from_room.id), from_room.tags.get(category="zone")))
zoneDest = connectorDict["zoneDestination"]
connectorName = connectorDict["connectorName"]
for rooms in connector_to_rooms:
print "TEST"
print "zoneDest: " + zoneDest
print "connectorname: " + connectorName
print rooms.tags.all(return_key_and_category=True)
print rooms.ndb.connector_name
print "connectorname == rooms.ndb.connector_name" + \
str(str(connectorName) == str(rooms.ndb.connector_name))
# Search the to rooms for the one with a tag with zoneDest as zone
# TROUBLE HERE. connector_name == connectorName doesn't seem to work.
to_room = [to_room for to_room in connector_to_rooms if \
to_room.tags.get(zoneDest, category="zone") and \
(str(to_room.ndb.connector_name) == str(connectorName))]
# Do we have multiple to rooms?
if len(to_room) > 1:
exMsg = "Multiple to_room for connector to zone %s:%s" % (
zoneDest, connectorName)
raise Exception(exMsg)
if len(to_room) == 0:
exMsg = "No to_room matching %s:%s" % (zoneDest, connectorName)
raise Exception(exMsg)
if to_room == None:
exMsg = "No to_room for connector to zone %s:%s" % (zoneDest,
connectorName)
raise Exception(exMsg)
to_room = to_room[0]
# Gather exits leading into this room.
# Check to make sure to_room doesn't already have these exits.
# Follow the exit to exit's distination, and then set the cardinal
# direction exit to the to_room instead
# Then delete the from_room connector.
#Gather exits
from_room_exits = from_room.exits
to_room_exits = to_room.exits
# Gather exits in "from_room", and move them to "to_room"
for from_exit in from_room_exits:
exit_in_to_room = False
create_exit_name = from_exit.name
if (is_cardinal_direction(from_exit)):
for to_exit in to_room_exits:
if to_exit.name == create_exit_name:
exit_in_to_room = True
if exit_in_to_room:
raise Exception("Can't connect connector room exit. There"
"is already an exit named %s in room #%s" %
(create_exit_name, to_room.id))
# Create the exit in the to_room, same as exit in from_room
evennia.create_object(typeclass="exits.Exit",
key=create_exit_name,
location=to_room,
destination=from_exit.destination,
aliases=from_exit.aliases.all())
# Now iterate over all the rooms with exits to the "from_room", and
# set their destination to the to room.
for currExit in Exit.objects.all_family():
if currExit.destination == from_room:
currExit.destination = to_room
def at_repeat(self):
knife = self.obj.search(u"Картонный нож", quiet = True)
if (not knife):
create_object('typeclasses.weapons.Knife', u"Картонный нож", self.obj)
def setUp(self):
super(TestWilderness, self).setUp()
self.char1 = create_object(DefaultCharacter, key="char1")
self.char2 = create_object(DefaultCharacter, key="char2")
def setUp(self):
super(TestRPSystem, self).setUp()
self.room = create_object(rpsystem.ContribRPRoom, key="Location")
self.speaker = create_object(rpsystem.ContribRPCharacter, key="Sender", location=self.room)
self.receiver1 = create_object(rpsystem.ContribRPCharacter, key="Receiver1", location=self.room)
self.receiver2 = create_object(rpsystem.ContribRPCharacter, key="Receiver2", location=self.room)
def test_tutorialobj(self):
obj1 = create_object(tutobjects.TutorialObject, key="tutobj")
obj1.reset()
self.assertEqual(obj1.location, obj1.home)
Batchcode for Balamb Garden. """ from evennia import create_object from typeclasses import rooms, exits, characters ############################################################################### # INITIATE ROOMS # Rooms are created first, as adding exits and details will cross refer to # different locations which would otherwise not be instantiated yet. ############################################################################### # BASEMENT underground_chamber = create_object(rooms.Room, key="Underground Chamber") garden_masters_office = create_object(rooms.Room, key="Garden Master's Office") # FLOOR 1 front_gate = create_object(rooms.Room, key="Front Gate") front_courtyard = create_object(rooms.Room, key="Front Courtyard") reception = create_object(rooms.Room, key="Reception") lobby = create_object(rooms.Room, key="Lobby") infirmary = create_object(rooms.Room, key="Infirmary") quad = create_object(rooms.Room, key="Quad") cafeteria = create_object(rooms.Room, key="Cafeteria")
def build_the1st_lodge():
lodge = create_object(LodgeInstance, key='lodge01')
hall = lodge.create_room(key='hall', position=(3, 3), size=(7, 5))
passage_l = lodge.create_room(key='left passage',
position=(2, 3),
size=(1, 5))
passage_r = lodge.create_room(key='right passage',
position=(10, 0),
size=(1, 8))
passage_m = lodge.create_room(key='middle passage',
position=(3, 2),
size=(7, 1))
room_1 = lodge.create_room(key='room 1',
aliases=['r1'],
position=(0, 7),
size=(2, 1))
room_2 = lodge.create_room(key='room 2',
aliases=['r2'],
position=(0, 3),
size=(2, 4))
room_3 = lodge.create_room(key='room 3',
aliases=['r3'],
position=(0, 0),
size=(3, 3))
room_4 = lodge.create_room(key='room 4',
aliases=['r4'],
position=(3, 0),
size=(4, 2))
room_5 = lodge.create_room(key='room 5',
aliases=['r5'],
position=(7, 0),
size=(3, 2))
room_6 = lodge.create_room(key='room 6',
aliases=['r6'],
position=(11, 0),
size=(2, 8))
hall.link_with_exit(passage_l, aliases=['left'])
hall.link_with_exit(passage_r, aliases=['right'])
hall.link_with_exit(passage_m, aliases=['middle', 'mid'])
passage_l.link_with_exit(room_1, back_aliases=['out'])
passage_l.link_with_exit(room_2, back_aliases=['out'])
passage_l.link_with_exit(room_3, back_aliases=['out'])
room_3.link_with_exit(room_4)
passage_m.link_with_exit(room_4, back_aliases=['out'])
passage_m.link_with_exit(room_5, back_aliases=['middle', 'mid'])
passage_m.link_with_exit(passage_r,
aliases=['right'],
back_aliases=['middle', 'mid'])
passage_r.link_with_exit(room_5, back_aliases=['right'])
passage_r.link_with_exit(room_6, back_aliases=['out'])
def setUp(self):
super(TestBarter, self).setUp()
self.tradeitem1 = create_object(key="TradeItem1", location=self.char1)
self.tradeitem2 = create_object(key="TradeItem2", location=self.char1)
self.tradeitem3 = create_object(key="TradeItem3", location=self.char2)
def func(self):
args = self.args.strip().split()
if not args:
self.caller.msg("Craft what?")
return
items = list()
action = args.pop(0).lower()
if action not in ["add", "remove", "recipe", "cancel"]:
self.caller.msg("Invalid syntax.")
return
if action in ["add", "remove"]:
args = " ".join(args).split(",")
for item in args:
items.append(item.strip())
self.items = items
self.action = action
caller = self.caller
recipe_script = search_script("recipescript", typeclass="world.recipescript.RecipeScript")
try:
recipe_script = recipe_script[0]
except IndexError:
recipe_script = create_script(key="recipescript", typeclass="world.recipescript.RecipeScript")
if self.action == "add":
for _item in self.items:
item = caller.search(_item, location=caller)
if not item:
continue
if item.tags.get(category="craftable"):
caller.db.craft_stack.append(item)
caller.msg("Added '%s' to the crafting stack..." % item)
elif self.action == "remove":
pass
elif self.action == "cancel":
pass
elif self.action == "recipe":
inv = []
recipe_name = self.args.strip()
for item in caller.db.craft_stack:
tag = item.tags.get(category="craftable")
if type(tag) is type(""):
inv.append(tag.lower())
elif type(tag) is type([]):
inv.extend(t.lower() for t in tag)
found_recipe = None
for recipe in recipe_script.recipes:
for recipe_key in recipe.keys():
if recipe_key == recipe_name:
found_recipe = recipe
break
if found_recipe:
break
if not found_recipe:
caller.msg("No such recipe.")
recipe = found_recipe
missing = []
for comp in recipe["components"]:
for needed_count in recipe["components"][comp]
inv_count = inv.count(comp)
if inv_count < needed_count:
# missing ingredients
missing.append((comp, needed_count - inv_count))
else:
# we have all we need of this ingredient
pass
if len(missing) > 0:
for row in missing:
caller.msg("You are missing %s %s." % row)
return
for component in recipe['components']:
for c in range(recipe['components'][component]):
# remove component from caller
for item in self.caller.db.craft_stack:
if item.tags.get(component, category="crafting"):
caller.db.craft_stack.remove(item)
# item.delete()
# _item = caller.search("#%i" % item.id, use_dbref=True, quiet=True)
# if _item:
# _item.pop().delete()
obj = create_object(key=recipe_name, typeclass=recipe['typeclass'], location=caller)
caller.msg("You crafted %s." % obj)
def _maintain_demo_room(caller, delete=False):
"""
Handle the creation/cleanup of demo assets. We store them
on the character and clean them when leaving the menu later.
"""
# this is a tuple (room, obj)
roomdata = caller.db.tutorial_world_demo_room_data
if delete:
if roomdata:
# we delete directly for simplicity. We need to delete
# in specific order to avoid deleting rooms moves
# its contents to their default home-location
prev_loc, room1, sign, room2, stone, door_out, door_in = roomdata
caller.location = prev_loc
sign.delete()
stone.delete()
door_out.delete()
door_in.delete()
room1.delete()
room2.delete()
del caller.db.tutorial_world_demo_room_data
elif not roomdata:
# create and describe the cabin and box
room1 = create_object("evennia.objects.objects.DefaultRoom", key="A small, cozy cabin")
room1.db.desc = _ROOM_DESC.lstrip()
sign = create_object(
"evennia.objects.objects.DefaultObject", key="small wooden sign", location=room1
)
sign.db.desc = _SIGN_DESC.strip()
sign.locks.add("get:false()")
sign.db.get_err_msg = "The sign is nailed to the wall. It's not budging."
# create and describe the meadow and stone
room2 = create_object("evennia.objects.objects.DefaultRoom", key="A lush summer meadow")
room2.db.desc = _MEADOW_DESC.lstrip()
stone = create_object(
"evennia.objects.objects.DefaultObject", key="carved stone", location=room2
)
stone.db.desc = _STONE_DESC.strip()
# make the linking exits
door_out = create_object(
"evennia.objects.objects.DefaultExit",
key="Door",
location=room1,
destination=room2,
locks=["get:false()"],
)
door_out.db.desc = _DOOR_DESC_OUT.strip()
door_in = create_object(
"evennia.objects.objects.DefaultExit",
key="entrance to the cabin",
aliases=["door", "in", "entrance"],
location=room2,
destination=room1,
locks=["get:false()"],
)
door_in.db.desc = _DOOR_DESC_IN.strip()
# store references for easy removal later
caller.db.tutorial_world_demo_room_data = (
caller.location,
room1,
sign,
room2,
stone,
door_out,
door_in,
)
# move caller into room
caller.location = room1
def create_room_exits_from_xml(xml_exit_node, xml_rooms_dict, mechRoomsDict):
# Create the exits
#TODO: ONE-WAY EXITS! This is useful for non-cardinal direction exits which
# might have different discriptions on either side of the exit...
# A list - First 2 entries are source and destination.
roomsSrcDest = []
# Get the ids. Each "dock" has ids in continous order for a single exit,
# so store in a list.
dockNodes = {}
isOneWay = False
if xml_exit_node.attrib.get("flow") == "oneWay":
isOneWay = True
for child in xml_exit_node:
if (child.tag == "dock"):
dockIndex = child.attrib.get("index")
dockNodes[dockIndex] = child
roomId = child.attrib.get("id")
roomsSrcDest.append(mechRoomsDict[roomId])
# Create exits on both rooms.
for dockKey, dock in dockNodes.iteritems():
print dock
dockIndex = int(dock.attrib.get("index"))
if isOneWay:
print "Is one way? " + str(isOneWay)
if dockIndex != 0:
continue
# Check if this is one way, and we are going the correct way.
exitNameList = []
if xml_exit_node.attrib.get("name"):
if (xml_exit_node.attrib.get("name") != ""):
# Names on exits override
exitNameList = get_named_exit_aliases_from_line(xml_exit_node)
print(exitNameList)
if (len(exitNameList) == 0):
exitNameList = get_cardinal_name_and_aliases_from_dock_node(dock)
# TODO Tags?
srcRoom = roomsSrcDest[dockIndex]
dstRoom = roomsSrcDest[(dockIndex + 1) % 2]
for exit in srcRoom.exits:
if exit.name == exitNameList[0]:
msg = "Trying to create an exit {0}:#{1} on room" \
"{2}:#{3} that already has that exit " \
"created!".format(exit.name, exit.id, \
srcRoom.name, srcRoom.id)
print(msg)
raise Exception(msg)
evennia.create_object(typeclass="exits.Exit",
key=exitNameList[0],
location=srcRoom,
aliases=exitNameList[1:],
destination=dstRoom)
delete_tagged(tag)
# Tag players
try:
p1 = search_object('Foo')[0]
p2 = search_object('Bar')[0]
except IndexError:
assert(False), 'Please create the "Foo" and "Bar" users before running this script.'
p1.tags.add("p1", category="duo")
p1.tags.remove("p2", category="duo")
p2.tags.add("p2", category="duo")
p2.tags.remove("p1", category="duo")
blue_room = create_object(Room,
key="Blue Room",
aliases=["blue"])
blue_room.tags.add(tag)
red_room = create_object(Room,
key="Red Room",
aliases=["red"])
red_room.tags.add(tag)
caller.msg("About to link...")
links = link([blue_room, limbo])
[x.tags.add(tag) for x in links]
links = link([blue_room, red_room])
# Only one player can traverse between the red and blue room.
for link in links:
def at_object_creation(self):
self.db.is_corpse = True
self.db.hands = create_object(settings.BASE_OBJECT_TYPECLASS, "hands")
#создаем таймер для трупа
tickerhandler.add(self, 60*3)
# -*- coding:utf-8 -*-
from evennia import create_object
from evennia import DefaultObject
from world import map_module
map = create_object(DefaultObject, key="Map", location=caller.location)
map.db.desc = map_module.return_map()
caller.msg("A map appears out of thin air and falls to the ground.")
def test_introroom(self):
room = create_object(tutrooms.IntroRoom, key="introroom")
room.at_object_receive(self.char1, self.room1)
def build_map(caller, game_map, legend, iterations=1, build_exits=True):
"""
Receives the fetched map and legend vars provided by the player.
Args:
caller (Object): The creator of the map.
game_map (str): An ASCII map string.
legend (dict): Mapping of map symbols to object types.
iterations (int): The number of iteration passes.
build_exits (bool): Create exits between new rooms.
Notes:
The map
is iterated over character by character, comparing it to the trigger
characters in the legend var and executing the build instructions on
finding a match. The map is iterated over according to the `iterations`
value and exits are optionally generated between adjacent rooms according
to the `build_exits` value.
"""
# Split map string to list of rows and create reference list.
caller.msg("Creating Map...")
caller.msg(game_map)
game_map = _map_to_list(game_map)
# Create a reference dictionary which be passed to build functions and
# will store obj returned by build functions so objs can be referenced.
room_dict = {}
caller.msg("Creating Landmass...")
for iteration in range(iterations):
for y in range(len(game_map)):
for x in range(len(game_map[y])):
for key in legend:
# obs - we must use == for strings
if game_map[y][x] == key:
room = legend[key](x,
y,
iteration=iteration,
room_dict=room_dict,
caller=caller)
if iteration == 0:
room_dict[(x, y)] = room
if build_exits:
# Creating exits. Assumes single room object in dict entry
caller.msg("Connecting Areas...")
for loc_key, location in room_dict.items():
x = loc_key[0]
y = loc_key[1]
# north
if (x, y - 1) in room_dict:
if room_dict[(x, y - 1)]:
create_object(
exits.Exit,
key="north",
aliases=["n"],
location=location,
destination=room_dict[(x, y - 1)],
)
# east
if (x + 1, y) in room_dict:
if room_dict[(x + 1, y)]:
create_object(
exits.Exit,
key="east",
aliases=["e"],
location=location,
destination=room_dict[(x + 1, y)],
)
# south
if (x, y + 1) in room_dict:
if room_dict[(x, y + 1)]:
create_object(
exits.Exit,
key="south",
aliases=["s"],
location=location,
destination=room_dict[(x, y + 1)],
)
# west
if (x - 1, y) in room_dict:
if room_dict[(x - 1, y)]:
create_object(
exits.Exit,
key="west",
aliases=["w"],
location=location,
destination=room_dict[(x - 1, y)],
)
caller.msg("Map Created.")
def test_darkroom(self):
room = create_object(tutrooms.DarkRoom, key="darkroom")
self.char1.move_to(room)
self.call(tutrooms.CmdDarkHelp(), "", "Can't help you until")
def give_starting_gold(character):
gold = create_object("typeclasses.objects.Gold", key="gold")
gold.add(STARTING_GOLD_AMOUNT)
# use move_to() so we invoke StackableObject accumulation
gold.move_to(character, quiet=True)
character.msg(f"You now have {gold.db.amount} gold.")
def test_teleportroom(self):
create_object(tutrooms.TeleportRoom, key="teleportroom")
def func(self):
myObj = create_object(DefaultObject,
key="MyObj",
location=self.caller.location)
self.caller.msg(
"An object appears out of thin air and falls to the ground.")
def test_outroroom(self):
create_object(tutrooms.OutroRoom, key="outroroom")
