def generate_boss_mob(self): if 'crypt' in self.db.dungeon_type: self.db.boss_names = ['Skeletal Lich', 'Frostbourne Witch'] boss_name = random.choice(self.db.boss_names) boss_mob = create.create_object("game.gamesrc.objects.world.mob.Mob", key="%s" % boss_name, location=self.location) boss_mob.aliases = ['boss_mob'] boss_mob.db.level = self.location.db.level boss_mob.db.rating = 'hero' boss_mob.db.boss_mob = True boss_mob.generate_stats() boss_mob.generate_rewards() boss_mob.generate_physical_loot() boss_mob.generate_skillset() boss_mob.update_stats() return boss_mob if 'ruins' in self.db.dungeon_type: self.db.boss_names = ['Pygmy Lord', 'Ghastly Ghoul', 'Spider Queen'] boss_name = random.choice(self.db.boss_names) boss_mob = create.create_object("game.gamesrc.objects.world.mob.Mob", key="%s" % boss_name, location=self.location) boss_mob.aliases = ['boss_mob'] boss_mob.db.level = self.location.db.level boss_mob.db.rating = 'hero' boss_mob.db.boss_mob = True boss_mob.generate_stats() boss_mob.generate_rewards() boss_mob.generate_physical_loot() boss_mob.generate_skillset() boss_mob.update_stats() return boss_mob
def generate_physical_loot(self): if self.db.boss_mob is True: loot_generator = create.create_object("game.gamesrc.objects.world.generators.LootGenerator") loot_item = loot_generator.create_rare_lootset() loot_item.move_to(self, quiet=True) loot_generator.delete() return rn = random.random() if self.db.rating in 'hero': if rn < AVCONFIG['hero_mob_rare_loot_rate']: num_of_items = random.randrange(1,2) loot_generator = create.create_object("game.gamesrc.objects.world.generators.LootGenerator") loot = loot_generator.create_loot_set(loot_rating='rare', number_of_items=num_of_items, item_type='mixed') for item in loot: item.move_to(self, quiet=True) loot_generator.delete() if rn < AVCONFIG['mob_physical_loot_drop_rate']: num_of_items = random.randrange(1,3) loot_generator = create.create_object("game.gamesrc.objects.world.generators.LootGenerator") ratings = ['uncommon', 'average', 'rare'] rating = random.choice(ratings) loot = loot_generator.create_loot_set(loot_rating=rating, number_of_items=num_of_items, item_type='mixed') for item in loot: item.move_to(self, quiet=True) loot_generator.delete()
def create_objects(): """ Creates the #1 player and Limbo room. """ print " Creating objects (Player #1 and Limbo room) ..." # Set the initial User's account object's username on the #1 object. # This object is pure django and only holds name, email and password. god_user = get_god_user() # Create a Player 'user profile' object to hold eventual # mud-specific settings for the bog standard User object. This is # accessed by user.get_profile() and can also store attributes. # It also holds mud permissions, but for a superuser these # have no effect anyhow. character_typeclass = settings.BASE_CHARACTER_TYPECLASS # Create the Player object as well as the in-game god-character # for user #1. We can't set location and home yet since nothing # exists. Also, all properties (name, email, password, is_superuser) # is inherited from the user so we don't specify it again here. god_player = create.create_player(god_user.username, None, None, user=god_user) god_character = create.create_object(character_typeclass, key=god_user.username) god_character.id = 1 god_character.db.desc = _('This is User #1.') god_character.locks.add("examine:perm(Immortals);edit:false();delete:false();boot:false();msg:all();puppet:false()") god_character.permissions = "Immortals" god_character.save() god_player.set_attribute("_first_login", True) god_player.set_attribute("_last_puppet", god_character) god_player.db._playable_characters.append(god_character) # Limbo is the default "nowhere" starting room room_typeclass = settings.BASE_ROOM_TYPECLASS limbo_obj = create.create_object(room_typeclass, _('Limbo')) limbo_obj.id = 2 string = " ".join([ "Welcome to your new {wEvennia{n-based game. From here you are ready to begin development.", "Visit http://evennia.com if you should need help or would like to participate in community discussions.", "If you are logged in as User #1 you can create a demo/tutorial area with '@batchcommand contrib.tutorial_world.build'.", "Log out and create a new non-admin account at the login screen to play the tutorial properly."]) string = _(string) limbo_obj.db.desc = string limbo_obj.save() # Now that Limbo exists, try to set the user up in Limbo (unless # the creation hooks already fixed this). if not god_character.location: god_character.location = limbo_obj if not god_character.home: god_character.home = limbo_obj
def on_use(self, caller): manager = caller.db.spellbook spells = manager.db.spells if self.db.level_requirement is not None: if caller.db.attributes['level'] < self.db.level_requirement: caller.msg("{RYou are not high enough level to learn this spell.{n") return if 'heal' in self.db.spell: if 'heal' not in spells.keys(): healing_spell_obj = create.create_object("game.gamesrc.objects.world.spells.Heal", key="Heal") healing_spell_obj.db.character = caller manager.add_item(healing_spell_obj.name.title(), healing_spell_obj) caller.msg("{CYou have learned the spell: {G%s{n{C.{n" % healing_spell_obj.name) else: caller.msg("You already know that spell.") if 'fireball' in self.db.spell: if 'fireball' not in spells.keys(): fireball_spell_obj = create.create_object("game.gamesrc.objects.world.spells.Fireball", key="Fireball") fireball_spell_obj.db.character = caller manager.add_item(fireball_spell_obj.name, fireball_spell_obj) caller.msg("{CYou have learned the spell: {G%s{n{C.{n" % fireball_spell_obj.name) else: caller.msg("You already know that spell.") if 'mageshield' in self.db.spell: if 'mage shield' not in spells.keys(): mageshield_spell_obj = create.create_object("game.gamesrc.objects.world.spells.MageShield", key="Mage Shield") mageshield_spell_obj.db.character = caller manager.add_item(mageshield_spell_obj.name, mageshield_spell_obj) caller.msg("{CYou have learned the spell:{n {G%s{n{C.{n" % mageshield_spell_obj.name) else: caller.msg("You already know that spell.") elif 'strength' in self.db.spell: if 'strength of the bear' not in spells.keys(): strength_spell = create.create_object("game.gamesrc.objects.world.spells.StrOfBear", key="Strength Of The Bear") strength_spell.db.character = caller manager.add_item(strength_spell.name, strength_spell) caller.msg("{CYou have learned the spell:{n {G%s{C.{n" % strength_spell.name) else: caller.msg("You alredy know that spell.") elif 'magic missile' in self.db.spell: if 'magic missile' not in spells.keys(): mm_spell = create.create_object("game.gamesrc.objects.world.spells.MagicMissile", key="Magic Missile") mm_spell.db.character = caller manager.add_item(mm_spell.name, mm_spell) caller.msg("{CYou have learned the spell:{n {G%s{C.{n" % mm_spell.name) else: caller.msg("You alreadyg know that spell.") caller.db.spellbook = manager
def copy_object(self, original_object, new_key=None, new_location=None, new_player=None, new_home=None, new_permissions=None, new_locks=None, new_aliases=None, new_destination=None): """ Create and return a new object as a copy of the original object. All will be identical to the original except for the arguments given specifically to this method. original_object (obj) - the object to make a copy from new_key (str) - name the copy differently from the original. new_location (obj) - if not None, change the location new_home (obj) - if not None, change the Home new_aliases (list of strings) - if not None, change object aliases. new_destination (obj) - if not None, change destination """ # get all the object's stats typeclass_path = original_object.typeclass_path if not new_key: new_key = original_object.key if not new_location: new_location = original_object.location if not new_home: new_home = original_object.home if not new_player: new_player = original_object.player if not new_aliases: new_aliases = original_object.aliases if not new_locks: new_locks = original_object.db_lock_storage if not new_permissions: new_permissions = original_object.permissions if not new_destination: new_destination = original_object.destination # create new object from src.utils import create from src.scripts.models import ScriptDB new_object = create.create_object(typeclass_path, key=new_key, location=new_location, home=new_home, player=new_player, permissions=new_permissions, locks=new_locks, aliases=new_aliases, destination=new_destination) if not new_object: return None # copy over all attributes from old to new. for attr in original_object.get_all_attributes(): new_object.set_attribute(attr.key, attr.value) # copy over all cmdsets, if any for icmdset, cmdset in enumerate(original_object.cmdset.all()): if icmdset == 0: new_object.cmdset.add_default(cmdset) else: new_object.cmdset.add(cmdset) # copy over all scripts, if any for script in original_object.scripts.all(): ScriptDB.objects.copy_script(script, new_obj=new_object.dbobj) return new_object
def _create_character(session, new_player, typeclass, start_location, home, permissions): """ Helper function, creates a character based on a player's name. This is meant for Guest and MULTISESSION_MODE < 2 situations. """ try: if not start_location: start_location = home # fallback new_character = create.create_object(typeclass, key=new_player.key, location=start_location, home=home, permissions=permissions) # set playable character list new_player.db._playable_characters.append(new_character) # allow only the character itself and the player to puppet this character (and Immortals). new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, new_player.id)) # If no description is set, set a default description if not new_character.db.desc: new_character.db.desc = "This is a Player." # We need to set this to have @ic auto-connect to this character new_player.db._last_puppet = new_character except Exception, e: session.msg("There was an error creating the Character:\n%s\n If this problem persists, contact an admin." % e) logger.log_trace() return False
def debug_object_scripts(obj_path, caller): """ Create an object and test all its associated scripts independently. """ try: string = "\n Testing scripts on {w%s{n ... " % obj_path obj = create.create_object(obj_path) obj.location = caller.location obj = obj.dbobj string += "{gOk{n." except Exception: string += trace() try: obj.delete() except: pass return string scripts = obj.scripts.all() if scripts: string += "\n Running tests on %i object scripts ... " % (len(scripts)) for script in scripts: string += "\n {wTesting %s{n ..." % script.key path = script.typeclass_path string += debug_script(path, obj=obj) #string += debug_run_script(path, obj=obj) else: string += "\n No scripts defined on object." try: obj.delete() except: string += trace() return string
def func(self): "create the new character" player = self.player if not self.args: self.msg("Usage: @charcreate <charname> [= description]") return key = self.lhs desc = self.rhs if not player.is_superuser and \ (player.db._playable_characters and len(player.db._playable_characters) >= MAX_NR_CHARACTERS): self.msg("You may only create a maximum of %i characters." % MAX_NR_CHARACTERS) return # create the character from src.objects.models import ObjectDB start_location = ObjectDB.objects.get_id(settings.START_LOCATION) default_home = ObjectDB.objects.get_id(settings.DEFAULT_HOME) typeclass = settings.BASE_CHARACTER_TYPECLASS permissions = settings.PERMISSION_PLAYER_DEFAULT new_character = create.create_object(typeclass, key=key, location=start_location, home=default_home, permissions=permissions) # only allow creator (and immortals) to puppet this char new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, player.id)) player.db._playable_characters.append(new_character) if desc: new_character.db.desc = desc elif not new_character.db.desc: new_character.db.desc = "This is a Player." self.msg("Created new character %s. Use {w@ic %s{n to enter the game as this character." % (new_character.key, new_character.key))
def setUp(self): "sets up testing environment" self.room1 = create.create_object("src.objects.objects.Room", key="Room%i"%self.CID) self.room1.db.desc = "room_desc" self.room2 = create.create_object("src.objects.objects.Room", key="Room%ib"%self.CID) self.obj1 = create.create_object("src.objects.objects.Object", key="Obj%i"%self.CID, location=self.room1, home=self.room1) self.obj2 = create.create_object("src.objects.objects.Object", key="Obj%ib"%self.CID, location=self.room1, home=self.room1) self.player = create.create_player("TestPlayer%i"%self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayer, create_character=False) self.caller = create.create_player("Caller%i"%self.CID, "*****@*****.**", "testpassword", player_dbobj=self.player.dbobj, character_typeclass="src.objects.objects.Character", permissions=["Immortals"], character_home=self.room1, character_location=self.room1) self.caller.player = self.player self.char = create.create_player("Char%i"%self.CID, "*****@*****.**", "testpassword2", typeclass=TestPlayer, character_typeclass="src.objects.objects.Character", permissions=["Immortals"], character_home=self.room1, character_location=self.room1) self.char = create.create_script("src.scripts.scripts.Script", key="Script%i"%self.CID)
def generate_contents(self): loot_generator = create.create_object("game.gamesrc.objects.world.generators.LootGenerator", location=self) rn = random.random() if rn < .05: rare_item = loot_generator.create_rare_lootset() else: rn = random.randrange(1,4) loot_set = loot_generator.create_loot_set(item_type='mixed', number_of_items=rn, loot_rating='average') for item in loot_set: item.move_to(self, quiet=True) loot_generator.delete()
def setUp(self): "sets up testing environment" settings.DEFAULT_HOME = "#2" # print "creating player %i: %s" % (self.CID, self.__class__.__name__) self.player = create.create_player( "TestPlayer%i" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass ) self.player2 = create.create_player( "TestPlayer%ib" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass ) self.room1 = create.create_object("src.objects.objects.Room", key="Room%i" % self.CID, nohome=True) self.room1.db.desc = "room_desc" self.room2 = create.create_object("src.objects.objects.Room", key="Room%ib" % self.CID) self.obj1 = create.create_object(TestObjectClass, key="Obj%i" % self.CID, location=self.room1, home=self.room1) self.obj2 = create.create_object(TestObjectClass, key="Obj%ib" % self.CID, location=self.room1, home=self.room1) self.char1 = create.create_object( TestCharacterClass, key="Char%i" % self.CID, location=self.room1, home=self.room1 ) self.char1.permissions.add("Immortals") self.char2 = create.create_object( TestCharacterClass, key="Char%ib" % self.CID, location=self.room1, home=self.room1 ) self.char1.player = self.player self.char2.player = self.player2 self.script = create.create_script("src.scripts.scripts.Script", key="Script%i" % self.CID) self.player.permissions.add("Immortals") # set up a fake session global SESSIONS session = ServerSession() session.init_session("telnet", ("localhost", "testmode"), SESSIONS) session.sessid = self.CID SESSIONS.portal_connect(session.get_sync_data()) SESSIONS.login(SESSIONS.session_from_sessid(self.CID), self.player, testmode=True)
def setUp(self): "sets up testing environment" settings.DEFAULT_HOME = "#2" #print "creating player %i: %s" % (self.CID, self.__class__.__name__) self.player = create.create_player("TestPlayer%i" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass) self.player2 = create.create_player("TestPlayer%ib" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass) self.room1 = create.create_object("src.objects.objects.Room", key="Room%i"%self.CID, nohome=True) self.room1.db.desc = "room_desc" self.room2 = create.create_object("src.objects.objects.Room", key="Room%ib" % self.CID) self.obj1 = create.create_object(TestObjectClass, key="Obj%i" % self.CID, location=self.room1, home=self.room1) self.obj2 = create.create_object(TestObjectClass, key="Obj%ib" % self.CID, location=self.room1, home=self.room1) self.char1 = create.create_object(TestCharacterClass, key="Char%i" % self.CID, location=self.room1, home=self.room1) self.char1.permissions.add("Immortals") self.char2 = create.create_object(TestCharacterClass, key="Char%ib" % self.CID, location=self.room1, home=self.room1) self.char1.player = self.player self.char2.player = self.player2 self.script = create.create_script("src.scripts.scripts.Script", key="Script%i" % self.CID) self.player.permissions.add("Immortals") # set up a fake session global SESSIONS session = ServerSession() session.init_session("telnet", ("localhost", "testmode"), SESSIONS) session.sessid = self.CID SESSIONS.portal_connect(session.get_sync_data()) SESSIONS.login(SESSIONS.session_from_sessid(self.CID), self.player, testmode=True)
def generate_zone_manager(self): self.db.dungeon_type_picked = random.choice(self.db.dungeon_types) zone = create.create_object('game.gamesrc.objects.world.rooms.Zone', key="%s Zone Manager" % self.db.dungeon_type_picked.title()) zone.db.zone_type = self.db.dungeon_type_picked mg = zone.db.mob_generator mg.db.dungeon_type = self.db.dungeon_type_picked zone.db.mob_generator = mg zone.aliases = ['zone_runner'] zone.db.zone_name = '%s' % self.db.dungeon_type_picked.title() zone.db.is_dungeon = True zone.db.quest_items = ['Deity Seal'] self.db.zone = zone self.refresh_level() zone.db.zone_level = "%s;%s" % (self.db.level, (self.db.level + 3))
def at_start(self): self.obj.db.in_combat = True self.db.unbalanced_message_sent = False cm = create.create_object("game.gamesrc.objects.world.combat.CombatManager", key="%s_combat_manager" % self.obj.name) if self.obj.db.cmd_id is not None: cm = self.obj.db.cm_id cm.delete() self.obj.db.cm_id = cm cm.db.rounds = 0 cm.attacker = self.obj cm.attacker_queue = self.obj.db.combat_queue cm.defender = self.obj.db.target cm.defender_queue = cm.defender.db.combat_queue cm.generate_texts()
def at_repeat(self): rn = random.random() check = self.obj.search("Treasure Chest", global_search=False) if check is None: pass else: return if self.db.chest_spawn_attempt is False: if rn < AVCONFIG['chest_spawn_rate']: chest = create.create_object("game.gamesrc.objects.world.storage.StorageItem", key="Treasure Chest") chest.location = self.obj chest.generate_contents() self.db.chest_spawn_attempt = True else: self.db.chest_spawn_attempt = False
def new_player(name, email, password, request): """ Easier front-end for creating a new player. Also sends reg email. """ player = create_player(key=name, email=email, password=password, permissions=settings.PERMISSION_PLAYER_DEFAULT, typeclass=settings.BASE_PLAYER_TYPECLASS) player.is_active = False player.save() character = create_object(typeclass=settings.BASE_CHARACTER_TYPECLASS, key=name, permissions=settings.PERMISSION_PLAYER_DEFAULT, home=settings.CHARACTER_DEFAULT_HOME) character.db.spirit = player player.db.avatar = character player.db._last_puppet = character player.db._playable_characters = [ character ] character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (character.id, player.id)) character.new_character() send_activation_email(player, request)
def at_object_creation(self): self.db.zone_name = None self.aliases = ['zone_manager'] self.db.enemy_npcs = [] self.db.map = {} self.db.path_map = {} self.db.grid_size = None self.db.valid_zones = ['dungeon', 'woodlands', 'marshlands', 'tutorial'] self.db.zone_type = 'marshlands' self.db.player_map = {} self.db.quest_items = [] self.db.looted = False labels = string.ascii_uppercase self.db.x_axis_labels = list(labels) self.db.y_axis_labels = [x for x in range(0, len(self.db.x_axis_labels))] mob_generator = create.create_object("game.gamesrc.objects.world.generators.MobGenerator", key="%s mob_gen" % self.name) mob_generator.location = self mob_generator.db.dungeon_type = self.db.zone_type self.db.is_dungeon = False self.db.mob_generator = mob_generator self.set_zone_level()
def setUp(self): "sets up testing environment" self.room1 = create.create_object("src.objects.objects.Room", key="Room%i"%self.CID) self.room1.db.desc = "room_desc" self.room2 = create.create_object("src.objects.objects.Room", key="Room%ib" % self.CID) self.obj1 = create.create_object("src.objects.objects.Object", key="Obj%i" % self.CID, location=self.room1, home=self.room1) self.obj2 = create.create_object("src.objects.objects.Object", key="Obj%ib" % self.CID, location=self.room1, home=self.room1) self.char1 = create.create_object("src.objects.objects.Character", key="Char%i" % self.CID, location=self.room1, home=self.room1) self.char2 = create.create_object("src.objects.objects.Character", key="Char%ib" % self.CID, location=self.room1, home=self.room1) self.script = create.create_script("src.scripts.scripts.Script", key="Script%i" % self.CID) self.player = create.create_player("TestPlayer%i" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass) self.player2 = create.create_player("TestPlayer%ib" % self.CID, "*****@*****.**", "testpassword", typeclass=TestPlayerClass) self.player.permissions = "Immortals" self.char1.player = self.player self.char1.sessid = 1
def func(self): "create the new character" player = self.player if not self.args: self.msg("Usage: @charcreate <charname> [= description]") return key = self.lhs desc = self.rhs if not player.is_superuser and \ (player.db._playable_characters and len(player.db._playable_characters) >= MAX_NR_CHARACTERS): self.msg("You may only create a maximum of %i characters." % MAX_NR_CHARACTERS) return # create the character from src.objects.models import ObjectDB start_location = ObjectDB.objects.get_id(settings.START_LOCATION) default_home = ObjectDB.objects.get_id(settings.DEFAULT_HOME) typeclass = settings.BASE_CHARACTER_TYPECLASS permissions = settings.PERMISSION_PLAYER_DEFAULT new_character = create.create_object(typeclass, key=key, location=start_location, home=default_home, permissions=permissions) # only allow creator (and immortals) to puppet this char new_character.locks.add( "puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, player.id)) player.db._playable_characters.append(new_character) if desc: new_character.db.desc = desc else: new_character.db.desc = "This is a Player." self.msg( "Created new character %s. Use {w@ic %s{n to enter the game as this character." % (new_character.key, new_character.key))
def new_player(name, email, password, request): """ Easier front-end for creating a new player. Also sends reg email. """ player = create_player(name=name, email=email, password=password, permissions=settings.PERMISSION_PLAYER_DEFAULT, typeclass=settings.BASE_PLAYER_TYPECLASS) player.user.is_active = False player.user.save() character = create_object(typeclass=settings.BASE_CHARACTER_TYPECLASS, key=name, permissions=settings.PERMISSION_PLAYER_DEFAULT, home=settings.CHARACTER_DEFAULT_HOME) character.db.spirit = player player.db.avatar = character player.db._last_puppet = character player.db._playable_characters = [character] character.locks.add( "puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (character.id, player.id)) character.new_character() send_activation_email(player, request)
def setUp(self): "sets up the testing environment" self.obj1 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj1") self.obj2 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj2")
def on_use(self, caller): """ Here we check what skill we train, then we copy/create the skill object and append it to the caller's skill list. IMPORTANT: Every skill must set its character attribute to the caller object as this attribute is used extensively throughout the skill system, and is what ties the skill floating in the ether to the character. """ manager = caller.db.skill_log if 'kick' in self.db.skill: if 'kick' not in [ manager.db.skills.keys() ] : kick_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Kick", key='kick') kick_skill_obj.db.character = caller manager.add_item(kick_skill_obj.name, kick_skill_obj) caller.msg("{CYou have learned a new skill: Kick.{n") else: caller.msg("You already know this skill.") elif 'brawling' in self.db.skill: if 'brawling' not in [ manager.db.skills.keys() ]: brawling_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Brawling", key='brawling') brawling_skill_obj.db.character = caller manager.add_item(brawling_skill_obj.name, brawling_skill_obj) caller.msg("{CYou have learned a new skill: Brawling.{n") else: caller.msg("You already know this skill.") elif 'rend' in self.db.skill: if 'rend' not in [manager.db.skills.keys() ]: rend_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Rend", key='rend') rend_skill_obj.db.character = caller manager.add_item(rend_skill_obj.name, rend_skill_obj) caller.msg("{CYou have learned a new skill: Rend.{n") else: caller.msg("You already know this skill.") elif 'strike' in self.db.skill: if 'strike' not in [ manager.db.skills.keys() ]: strike_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Strike", key='strike') strike_skill_obj.db.character = caller manager.add_item(strike_skill_obj.name, strike_skill_obj) caller.msg("{CYou have learned a new skill: Strike.{n") else: caller.msg("You already know this skill.") elif 'cripple' in self.db.skill: if 'cripple' not in [manager.db.skills.keys()]: cripple_skill_obj = create.create_object("game.gamesrc.objects.world.skills.CripplingStrike", key="crippling strike") cripple_skill_obj.db.character = caller manager.add_item(cripple_skill_obj.name, cripple_skill_obj) caller.msg("{CYou have learned a new skill: Crippling Strike.{n") else: caller.msg("You already know this skill") elif 'shield bash' in self.db.skill: if 'shield bash' not in [manager.db.skills.keys()]: sb_obj = create.create_object("game.gamesrc.objects.world.skills.ShieldBash", key="shield bash") sb_obj.db.character = caller manager.add_item(sb_obj.name, sb_obj) caller.msg("{CYou have learned a new skill: Shield Bash.{n") else: caller.msg("You already know this skill.") elif 'spellweaving' in self.db.skill: if 'spellweaving' not in [ manager.db.skills.keys()]: spellweaving_skill_obj = create.create_object("game.gamesrc.objects.world.skills.SpellWeaving", key='spellweaving') spellweaving_skill_obj.db.character = caller manager.add_item(spellweaving_skill_obj.name, spellweaving_skill_obj) caller.msg("{CYou have learned a new skill: Spellweaving{n") else: caller.msg("You already know this skill.") elif 'toughness' in self.db.skill: if 'toughness' not in [manager.db.skills.keys()]: percentages = caller.db.percentages toughness_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Toughness", key='toughness') toughness_skill_obj.db.character = caller manager.add_item(toughness_skill_obj.name, toughness_skill_obj) percentages['constitution_bonus'] = .01 caller.db.percentages = percentages caller.refresh_attributes(health_and_mana=False) caller.msg("{CYou have learned a new skill: Toughness{n") else: caller.msg("You already know this skill.") elif 'dodge' in self.db.skill: if 'dodge' not in [manager.db.skills.key()]: percentages = caller.db.percentages dodge_skill_obj = create.create_object("game.gamesrc.objects.world.skills.Dodge", key="dodge") dodge_skill_obj.db.character = caller manager.add_item(dodge_skill_obj.name, dodge_skill_obj) percentages['dodge'] += .01 caller.db.percentages = percentages caller.msg("{CYou have learned a new skill: Dodge{n") else: caller.msg("{CYou already know that skill.") caller.db.manager = manager self.delete()
def copy_object(self, original_object, new_key=None, new_location=None, new_home=None, new_permissions=None, new_locks=None, new_aliases=None, new_destination=None): """ Create and return a new object as a copy of the original object. All will be identical to the original except for the arguments given specifically to this method. original_object (obj) - the object to make a copy from new_key (str) - name the copy differently from the original. new_location (obj) - if not None, change the location new_home (obj) - if not None, change the Home new_aliases (list of strings) - if not None, change object aliases. new_destination (obj) - if not None, change destination """ # get all the object's stats typeclass_path = original_object.typeclass_path if not new_key: new_key = original_object.key if not new_location: new_location = original_object.location if not new_home: new_home = original_object.home if not new_aliases: new_aliases = original_object.aliases.all() if not new_locks: new_locks = original_object.db_lock_storage if not new_permissions: new_permissions = original_object.permissions.all() if not new_destination: new_destination = original_object.destination # create new object from src.utils import create from src.scripts.models import ScriptDB new_object = create.create_object(typeclass_path, key=new_key, location=new_location, home=new_home, permissions=new_permissions, locks=new_locks, aliases=new_aliases, destination=new_destination) if not new_object: return None # copy over all attributes from old to new. for attr in original_object.attributes.all(): new_object.attributes.add(attr.key, attr.value) # copy over all cmdsets, if any for icmdset, cmdset in enumerate(original_object.cmdset.all()): if icmdset == 0: new_object.cmdset.add_default(cmdset) else: new_object.cmdset.add(cmdset) # copy over all scripts, if any for script in original_object.scripts.all(): ScriptDB.objects.copy_script(script, new_obj=new_object.dbobj) return new_object
def generate_mob_type(self): split_level_range = self.location.db.zone_level.split(';') low = int(split_level_range[0]) high = int(split_level_range[1]) level = random.randrange(low, high) if 'crypt' in self.db.dungeon_type: self.db.ratings = ['average', 'strong'] self.db.skeleton_prefixes = [ 'Charred', 'Darkbone', 'Earthen', 'Frail'] self.db.zombie_prefixes = ['Headless', 'Rotting', 'Bloated', 'Crazed'] self.db.ghoul_prefixes = ['Hungry', 'Blood-stained', 'Slobbering', 'Disgusting'] self.db.apparition_prefixes = ['Shadowy', 'Smokey', 'Skeletal', 'Chillborn'] self.db.average_mob_names = ['Skeleton', 'Zombie', 'Ghoul', 'Apparition' ] mob_name = random.choice(self.db.average_mob_names) if 'Skeleton' in mob_name: prefix = random.choice(self.db.skeleton_prefixes) elif 'Zombie' in mob_name: prefix = random.choice(self.db.zombie_prefixes) elif 'Ghoul' in mob_name: prefix = random.choice(self.db.ghoul_prefixes) elif 'Apparition' in mob_name: prefix = random.choice(self.db.apparition_prefixes) mob_name = "%s %s" % (prefix, mob_name) mob = create.create_object("game.gamesrc.objects.world.mob.Mob", key = "%s" % mob_name, location=self.location) mob.aliases = ['%s_mobs' % self.dbref, 'kill_dungeon_mobs', 'mob_runner', 'irregular_runner', 'kill_crypt_mobs', 'crypt_mobs', 'kill_undead', 'kill_%s' % mob.name.lower()] try: mob.desc = copyreader.read_file("gamesrc/copy/mobs/%s_%s.txt" % (prefix.lower(), mob_name.lower())) except: mob.desc = "Placeholder, no desc written" mob.db.attributes['level'] = level mob.db.rating = random.choice(self.db.ratings) mob.db.is_kos = True mob.db.mob_type = 'undead' elif 'ruins' in self.db.dungeon_type: self.db.ratings = ['average', 'strong'] self.db.spider_prefixes = [ 'Common', 'Large', 'Hulking', 'Behemoth' ] self.db.pigmy_prefixes = [ 'Small', 'Mature', 'Young'] self.db.gnoll_prefixes = [ 'Juvenile', 'Adult', 'Ancient'] self.db.ancestral_spirit_prefixes = [ 'Ethereal', 'Shadowy', 'Lightbourne', 'Ancestral' ] self.db.average_mob_names = ['Spider', 'Pigmy', 'Spirit', 'Gnoll'] mob_name_original = random.choice(self.db.average_mob_names) if 'Spider' in mob_name_original: prefix = random.choice(self.db.spider_prefixes) elif 'Pigmy' in mob_name_original: prefix = random.choice(self.db.pigmy_prefixes) elif 'Spirit' in mob_name_original: prefix = random.choice(self.db.ancestral_spirit_prefixes) elif 'Gnoll' in mob_name_original: prefix = random.choice(self.db.gnoll_prefixes) mob_name = "%s %s" % (prefix, mob_name_original) mob = create.create_object("game.gamesrc.objects.world.mob.Mob", key="%s" % mob_name, location=self.location) mob.aliases = ['%s_mobs' % self.dbref, 'kill_dungeon_mobs','mob_runner', 'irregular_runner', 'ruins_mobs', 'kill_ruins_mobs', 'kill_%s' % mob_name_original.lower()] mob.db.attributes['level'] = level mob.db.rating = random.choice(self.db.ratings) mob.db.mob_type = '%s' % mob_name_original.lower() mob.db.is_kos= True elif 'marshlands' in self.db.dungeon_type: self.db.ratings = ['average', 'strong', 'hero'] self.db.slythain_prefixes = [ 'Young', 'Mature', 'Adolescent' ] self.db.slythain_suffixes = [ 'Marauder', 'Assassin', 'Hunter', 'Tracker', 'Guardian' ] self.db.grasswhip_prefixes = [ 'Young', 'Adult', 'Weathered', 'Juvenile' ] self.db.bearcat_prefixes = [ 'Matriarch', 'Patriarch', 'Juvenile', 'Young' ] self.db.mob_names = ['Bearcat','Slythain', 'Grasswhip' ] mob_name_original = random.choice(self.db.mob_names) if 'Slythain' in mob_name_original: prefix = random.choice(self.db.slythain_prefixes) suffix = random.choice(self.db.slythain_suffixes) mob_name = "%s Slythain %s" % (prefix, suffix) desc = copyreader.read_file("gamesrc/copy/mobs/%s_%s.txt" % (mob_name_original.lower(), suffix.lower())) deity = 'slyth' elif 'Grasswhip' in mob_name_original: prefix = random.choice(self.db.grasswhip_prefixes) mob_name = "%s Grasswhip" % prefix desc = copyreader.read_file("gamesrc/copy/mobs/%s_%s.txt" % (prefix.lower(), mob_name_original.lower())) deity = 'slyth' elif 'Bearcat' in mob_name_original: deity = 'warden' prefix = random.choice(self.db.bearcat_prefixes) mob_name = "%s Bearcat" % prefix desc = copyreader.read_file("gamesrc/copy/mobs/%s_%s.txt" % (prefix.lower(), mob_name_original.lower())) mob = create.create_object("game.gamesrc.objects.world.mob.Mob", key = "%s" % mob_name, location=self.location) mob.db.deity = deity mob.desc = desc mob.aliases = ['%s_mobs' % self.dbref,'kill_%s' % deity, 'kill_%s' % mob_name.lower(), 'mob_runner', 'irregular_runner','kill_marshlands', 'kill_%s' % mob_name_original.lower(), 'marshlands_mobs'] mob.db.attributes['level'] = level mob.db.rating = random.choice(self.db.ratings) mob.db.is_kos = True mob.db.mob_type = '%s' % mob_name_original.lower() elif 'tutorial' in self.db.dungeon_type: pass try: mob.generate_stats() mob.generate_skillset() mob.generate_rewards() mob.update_stats() except UnboundLocalError: return None rn = random.random() if rn <= .40: weapon = self.search('mob_blade', global_search=True, ignore_errors=True)[0] mob_weapon = weapon.copy() mob_weapon.move_to(mob, quiet=True) mob_weapon.name = weapon.name equipment = mob.db.equipment equipment['weapon'] = mob_weapon mob.db.equipment = equipment return mob
def func(self): "Do checks and create account" session = self.caller args = self.args.strip() # extract quoted parts parts = [part.strip() for part in re.split(r"\"|\'", args) if part.strip()] if len(parts) == 1: # this was (hopefully) due to no quotes being found parts = parts[0].split(None, 1) if len(parts) != 2: string = "\n Usage (without <>): create <name> <password>" string += "\nIf <name> or <password> contains spaces, enclose it in quotes." session.msg(string) return playername, password = parts # sanity checks if not re.findall('^[\w. @+-]+$', playername) or not (0 < len(playername) <= 30): # this echoes the restrictions made by django's auth # module (except not allowing spaces, for convenience of # logging in). string = "\n\r Playername can max be 30 characters or fewer. Letters, spaces, digits and @/./+/-/_ only." session.msg(string) return # strip excessive spaces in playername playername = re.sub(r"\s+", " ", playername).strip() if PlayerDB.objects.filter(username__iexact=playername): # player already exists (we also ignore capitalization here) session.msg("Sorry, there is already a player with the name '%s'." % playername) return if not re.findall('^[\w. @+-]+$', password) or not (3 < len(password)): string = "\n\r Password should be longer than 3 characers. Letters, spaces, digits and @\.\+\-\_ only." string += "\nFor best security, make it longer than 8 characters. You can also use a phrase of" string += "\nmany words if you enclose the password in quotes." session.msg(string) return # everything's ok. Create the new player account. try: default_home = ObjectDB.objects.get_id(settings.DEFAULT_HOME) typeclass = settings.BASE_CHARACTER_TYPECLASS permissions = settings.PERMISSION_PLAYER_DEFAULT try: new_player = create.create_player(playername, None, password, permissions=permissions) except Exception, e: session.msg("There was an error creating the default Player/Character:\n%s\n If this problem persists, contact an admin." % e) logger.log_trace() return # This needs to be called so the engine knows this player is # logging in for the first time. (so it knows to call the right # hooks during login later) utils.init_new_player(new_player) # join the new player to the public channel pchanneldef = settings.CHANNEL_PUBLIC if pchanneldef: pchannel = ChannelDB.objects.get_channel(pchanneldef[0]) if not pchannel.connect(new_player): string = "New player '%s' could not connect to public channel!" % new_player.key logger.log_errmsg(string) if MULTISESSION_MODE < 2: # if we only allow one character, create one with the same name as Player # (in mode 2, the character must be created manually once logging in) start_location = settings.START_LOCATION new_character = create.create_object(typeclass, key=playername, location=start_location, home=default_home, permissions=permissions) # set playable character list new_player.db._playable_characters.append(new_character) # allow only the character itself and the player to puppet this character (and Immortals). new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, new_player.id)) # If no description is set, set a default description if not new_character.db.desc: new_character.db.desc = "This is a Player." # We need to set this to have @ic auto-connect to this character new_player.db._last_puppet = new_character # tell the caller everything went well. string = "A new account '%s' was created. Welcome!" if " " in playername: string += "\n\nYou can now log in with the command 'connect \"%s\" <your password>'." else: string += "\n\nYou can now log with the command 'connect %s <your password>'." session.msg(string % (playername, playername))
def create_loot_set(self, loot_rating, number_of_items, item_type): """ This needs to be renamed. This creates a fairly RANDOM lootset. This is meant to be used within dungeons or other closely packed mob infested areas. Just generate a loot generator on the mob, have it create a lootset, and you are golden. By tweaking loot_rating and item type you can generate different things. This is the method that uses the name banks declared at creation. """ self.loot_rating = loot_rating self.number_of_items = number_of_items self.item_type = item_type loot_set = [] if 'weapon' in self.item_type: if 'average' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.avg_weapon_prefixes) weapontype = random.choice(self.db.weapon_choices) name = "%s %s" % (prefix, weapontype) weapon = create.create_object("game.gamesrc.objects.world.items.Weapon", key="%s" % name) weapon.db.value = random.randrange(1,10) weapon.db.item_level = 'common' weapon = self.set_weapon_type(weapon, weapontype) weapon = self.set_weapon_damage(weapon) desc = "%s looks to be a fairly common %s that most inhabitants of Avaloria would use." % (weapon.name, weapon.db.weapon_type) weapon.desc = desc loot_set.append(weapon) return loot_set elif 'uncommon' in self.loot_rating: bonus_choices = ['strength', 'constitution', 'dexterity', 'intelligence'] bonus = random.choice(bonus_choices) for i in range(number_of_items): prefix = random.choice(self.db.unc_weapon_prefixes) weapontype = random.choice(self.db.weapon_choices) name = "%s %s" % (prefix, weapontype) weapon = create.create_object("game.gamesrc.objects.world.items.Weapon", key="%s" % name) weapon.db.value = random.randrange(5,30) weapon.db.item_level = 'uncommon' weapon = self.set_weapon_type(weapon, weapontype) weapon = self.set_weapon_damage(weapon) weapon.db.attribute_bonuses = { '%s' % bonus: 1 } desc = "The craftsmanship of %s is more refined than most of the other weapons you find." % weapon.name desc += "\nThis is a well made %s." % weapon.db.weapon_type weapon.desc = desc loot_set.append(weapon) return loot_set elif 'rare' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.rare_weapon_prefixes) weapontype = random.choice(self.db.weapon_choices) name = "%s %s" % (prefix, weapontype) weapon = create.create_object("game.gamesrc.objects.world.items.Weapon", key="%s" % name) weapon.db.value = random.randrange(15,70) weapon.db.item_level = 'rare' weapon = self.set_weapon_type(weapon, weapontype) weapon = self.set_weapon_damage(weapon) weapon.db.attribute_bonuses = { 'strength': 2, 'constitution': 2, 'intelligence': 2, 'dexterity': 2 } loot_set.append(weapon) return loot_set elif 'artifact' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.art_weapon_prefixes) weapontype = random.choice(self.db.weapon_choices) name = "%s %s" % (prefix, weapontype) weapon = create.create_object("game.gamesrc.objects.world.items.Weapon", key="%s" % name) weapon.db.value = random.randrange(50,1000) weapon.db.item_level = 'artifact' weapon = self.set_weapon_type(weapon, weapontype) weapon = self.set_weapon_damage(weapon) loot_set.append(weapon) return loot_set elif 'shield' in self.item_type: if 'average' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.avg_shield_prefixes) suffix = random.choice(self.db.shield_choices) name = "%s %s" % (prefix, suffix) shield = create.create_object("game.gamesrc.objects.world.items.Armor", key=name) shield.db.value = random.randrange(1,10) shield = self.set_shield_armor(shield) shield.db.item_level = "common" shield.db.slot = "shield" shield.db.type = 'shield' shield.desc = "A crudely crafted shield that has very clearly seen \"better days\"." loot_set.append(shield) return loot_set elif 'uncommon' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.unc_shield_prefixes) suffix = random.choice(self.db.shield_choices) name = "%s %s" % (prefix, suffix) shield = create.create_object("game.gamesrc.objects.world.items.Armor", key=name) shield.db.value = random.randrange(10,18) shield = self.set_shield_armor(shield) shield.db.item_level = "uncommon" shield.db.slot = "shield" shield.db.type = "shield" shield.desc = "A well made shield that has been used, but kept in very good condition" loot_set.append(shield) return loot_set elif 'rare' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.rare_shield_prefixes) suffix = random.choice(self.db.shield_choices) name = "%s %s" % (prefix, suffix) shield = create.create_object("game.gamesrc.objects.world.items.Armor", key=name) shield.db.value = random.randrange(18, 26) shield.db.item_level = "rare" shield.db.slot = "shield" shield.db.type = "shield" shield = self.set_shield_armor(shield) shield.desc = "A finely crafted shield that could withstand the deepest amounts of physical punishment." loot_set.append(shield) return loot_set elif 'artifact' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.art_shield_prefixes) suffix = random.choice(self.db.shield_choices) name = "%s %s" % (prefix, suffix) shield = create.create_object("game.gamesrc.objects.world.items.Armor", key=name) shield.db.slot = "shield" shield.db.type = "shield" shield.db.value = random.randrange(27, 50) shield.db.item_level = "artifact" shield.desc = "A magnificently crafting shield forged by the greatest of shieldsmiths." shield = self.set_shield_armor(shield) loot_set.appect(shield) return loot_set elif 'ring' in self.item_type: if 'average' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.avg_ring_prefixes) suffix = random.choice(self.db.ring_choices) name = "%s %s" % (prefix, suffix) ring = create.create_object("game.gamesrc.objects.world.items.Item", key=name) ring.db.value = random.randrange(1,15) ring.db.item_level = "common" ring = self.set_ring_type(ring) ring = self.set_ring_bonuses(ring) desc = "%s is a common ring found in Avaloria, however it does seem to have some magical properties to it." % name ring.desc = desc loot_set.append(ring) return loot_set elif 'uncommon' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.unc_ring_prefixes) suffix = random.choice(self.db.ring_choices) name = "%s %s" % (prefix, suffix) ring = create.create_object("game.gamesrc.objects.world.items.Item", key=name) ring.db.value = random.randrange(15, 60) ring.db.item_level = "uncommon" ring = self.set_ring_type(ring) ring = self.set_ring_bonuses(ring) desc = "%s is a uncommon piece of jewlery, fashioned in a more peaceful time." % name ring.desc = desc loot_set.append(ring) return loot_set elif 'rare' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.rare_ring_prefixes) suffix = random.choice(self.db.ring_choices) name = "%s %s" % (prefix, suffix) ring = create.create_object("game.gamesrc.objects.world.items.Item", key=name) ring.db.value = random.randrange(50, 160) ring.db.item_level = "rare" ring = self.set_ring_type(ring) ring = self.set_ring_bonuses(ring) desc = "%s is a rare piece of jewlery, fashioned in a more peaceful time." % name ring.desc = desc loot_set.append(ring) return loot_set elif 'artifact' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.art_ring_prefixes) suffix = random.choice(self.db.ring_choices) name = "%s %s" % (prefix, suffix) ring = create.create_object("game.gamesrc.objects.world.items.Item", key=name) ring.db.value = random.randrange(160, 300) ring.db.item_level = "rare" ring = self.set_ring_type(ring) ring = self.set_ring_bonuses(ring) desc = "%s is a extremely rare, one of a kind piece of jewlery, fashioned in a more peaceful time." % name ring.desc = desc loot_set.append(ring) return loot_set elif 'armor' in self.item_type: if 'average' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.avg_armor_prefixes) armortype = random.choice(self.db.armor_choices) name = "%s %s Armor" % (prefix, armortype) armor = create.create_object("game.gamesrc.objects.world.items.Armor", key="%s" % name) armor.db.value = random.randrange(1,10) armor.db.item_level='common' armor = self.set_armor_type(armor, armortype) armor = self.set_armor_rating(armor) desc = "%s is a very common, everyday piece of %s armor that people use to protect themselves." % (armor.name, armor.db.armor_type) armor.desc = desc loot_set.append(armor) return loot_set elif 'uncommon' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.unc_armor_prefixes) armortype = random.choice(self.db.armor_choices) name = "%s %s Armor" % (prefix, armortype) armor = create.create_object("game.gamesrc.objects.world.items.Armor", key="%s" % name) armor.db.value = random.randrange(10,30) armor.db.item_level='uncommon' armor = self.set_armor_type(armor, armortype) armor = self.set_armor_rating(armor) desc = "As you inspect the %s, it is apparent it is not like the other hastily crafted armors you have seen." % armor.name desc += "\nThis is a well made piece of %s armor" % armor.db.armor_type armor.desc = desc loot_set.append(armor) return loot_set elif 'rare' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.rare_armor_prefixes) armortype = random.choice(self.db.armor_choices) name = "%s %s Armor" % (prefix, armortype) armor = create.create_object("game.gamesrc.objects.world.items.Armor", key="%s" % name) armor.db.value = random.randrange(45,150) armor.db.item_level='rare' armor = self.set_armor_type(armor, armortype) armor = self.set_armor_rating(armor) loot_set.append(armor) return loot_set elif 'artifact' in self.loot_rating: for i in range(number_of_items): prefix = random.choice(self.db.rare_armor_prefixes) armortype = random.choice(self.db.armor_choices) name = "%s %s Armor" % (prefix, armortype) armor = create.create_object("game.gamesrc.objects.world.items.Armor", key="%s" % name) armor.db.value = random.randrange(100,350) armor.db.item_level='artifact' armor = self.set_armor_type(armor, armortype) armor = self.set_armor_rating(armor) loot_set.append(armor) return loot_set elif 'mixed' in self.item_type: loot_choices = ['weapon', 'potion', 'armor', 'ring', 'shield'] for i in range(number_of_items): random_number = random.random() if random_number < .05: choice = 'spellbook' elif random_number < 0.1: choice = 'skillbook' else: choice = random.choice(loot_choices) if 'weapon' in choice: weapon = self.create_loot_set(loot_rating=self.loot_rating, number_of_items=1, item_type='weapon') loot_set.append(weapon[0]) elif 'armor' in choice: armor = self.create_loot_set(loot_rating=self.loot_rating, number_of_items=1, item_type='armor') loot_set.append(armor[0]) elif 'ring' in choice: ring = self.create_loot_set(loot_rating=self.loot_rating, number_of_items=1, item_type='ring') loot_set.append(ring[0]) elif 'shield' in choice: shield = self.create_loot_set(loot_rating=self.loot_rating, number_of_items=1, item_type="shield") loot_set.append(shield[0]) elif 'potion' in choice: potion_types = ['healing', 'mana_regen', 'buff'] effect = random.choice(potion_types) if 'healing' in effect: attribute_affected = 'hp' elif 'mana_regen' in effect: attribute_affected = 'mp' elif 'buff' in effect: buffs = ['hp', 'mp'] attribute_affected = random.choice(buffs) decider = random.random() if decider < 0.2: level = 20 elif decider < 0.4 and decider > 0.2: level = 10 else: level = 1 potion = create.create_object("game.gamesrc.objects.world.items.Potion", key = "potion") potion.db.level = level potion.db.effect = effect potion.db.attribute_affected = attribute_affected potion.generate_item_stats() loot_set.append(potion) elif 'skillbook' in choice: skillbooks = [ 'kick', 'brawling', 'strike', 'toughness', 'crippling strike', 'rend', 'shield bash'] book = random.choice(skillbooks) if 'kick' in book: book = create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Kick") book.db.skill = 'kick' book.db.value = random.randrange(10,35) book.db.level_requirement = 1 elif 'brawling' in book: book = create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Brawling") book.db.skill = 'brawling' book.db.value = random.randrange(10,35) book.db.level_requirement = 1 elif 'strike' in book: book = create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Strike") book.db.skill = 'strike' book.db.value = random.randrange(10,35) book.db.level_requirement = 3 elif 'toughness' in book: book = create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Toughness") book.db.skill = 'toughness' book.db.value = random.randrange(10,35) book.db.level_requirement = 5 elif 'rend ' in book: book= create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Rend") book.db.skill = 'rend' book.db.value = random.randrange(50,80) book.db.level_requirement = 8 elif 'crippling strike' in book: book = create.create_object("game.gamesrc.objects.world.skills.TrainingBook", key="Training Manual: Crippling Strik") book.db.skill = "cripple" book.db.value = random.randrange(80,100) book.db.level_requirement = 8 elif 'shield bash' in book: book.db.skill = 'shield bash' book.db.value = random.randrange(100,120) book.db.level_requirement = 8 loot_set.append(book) elif 'spellbook' in choice: spellbooks = ['fireball', 'mageshield', 'heal', 'strength of the bear'] book = random.choice(spellbooks) if 'fireball' in book: book = create.create_object("game.gamesrc.objects.world.spells.SpellBook", key="Spell Tome: Fireball") book.db.spell = 'fireball' book.db.value = random.randrange(30,65) book.db.level_requirement = 1 elif 'mageshield' in book: book = create.create_object("game.gamesrc.objects.world.spells.SpellBook", key="Spell Tome: Mage Shield") book.db.spell = 'mageshield' book.db.value = random.randrange(30,65) elif 'heal' in book: book = create.create_object("game.gamesrc.objects.world.spells.SpellBook", key="Spell Tome: Heal") book.db.spell = 'heal' book.db.value = random.randrange(30, 65) elif 'strength of the bear' in book: book = create.create_object("game.gamesrc.objects.world.spells.SpellBook", key="Spell Tome: Strength of the Bear") book.db.spell = 'strength' book.db.value = random.randrange(30,65) elif 'magic missile' in book: book = create.create_object("game.gamesrc.objects.world.spells.SpellBook", key="Spell Tome: Magic Missile") book.db.spell = 'magic missile' book.db.value = random.randrange(30,65) loot_set.append(book) return loot_set
def create_objects(): """ Creates the #1 player and Limbo room. """ print " Creating objects (Player #1 and Limbo room) ..." # Set the initial User's account object's username on the #1 object. # This object is pure django and only holds name, email and password. god_player = get_god_player() # Create a Player 'user profile' object to hold eventual # mud-specific settings for the PlayerDB object. player_typeclass = settings.BASE_PLAYER_TYPECLASS # run all creation hooks on god_player (we must do so manually # since the manage.py command does not) god_player.typeclass_path = player_typeclass god_player.basetype_setup() god_player.at_player_creation() god_player.locks.add( "examine:perm(Immortals);edit:false();delete:false();boot:false();msg:all()" ) # this is necessary for quelling to work correctly. god_player.permissions.add("Immortals") # Limbo is the default "nowhere" starting room # Create the in-game god-character for player #1 and set # it to exist in Limbo. character_typeclass = settings.BASE_CHARACTER_TYPECLASS god_character = create.create_object(character_typeclass, key=god_player.username, nohome=True) god_character.id = 1 god_character.db.desc = _('This is User #1.') god_character.locks.add( "examine:perm(Immortals);edit:false();delete:false();boot:false();msg:all();puppet:false()" ) god_character.permissions.add("Immortals") god_character.save() god_player.attributes.add("_first_login", True) god_player.attributes.add("_last_puppet", god_character) god_player.db._playable_characters.append(god_character) room_typeclass = settings.BASE_ROOM_TYPECLASS limbo_obj = create.create_object(room_typeclass, _('Limbo'), nohome=True) limbo_obj.id = 2 string = " ".join([ "Welcome to your new {wEvennia{n-based game. From here you are ready", "to begin development. Visit http://evennia.com if you should need", "help or would like to participate in community discussions. If you", "are logged in as User #1 you can create a demo/tutorial area with", "'@batchcommand contrib.tutorial_world.build'. Log out and create", "a new non-admin account at the login screen to play the tutorial", "properly." ]) string = _(string) limbo_obj.db.desc = string limbo_obj.save() # Now that Limbo exists, try to set the user up in Limbo (unless # the creation hooks already fixed this). if not god_character.location: god_character.location = limbo_obj if not god_character.home: god_character.home = limbo_obj
#HEADER from src.utils import create, search #CODE (create the backend room that contains all items in the game) room_check = search("storage", global_search=True) if room_check is None: caller.msg("Backend room exists, skipping. Room id: %s" % room_check.dbref) pass else: room = create.create_object("game.gamesrc.objects.baseobjects.Room", key="storage", aliases=["items"]) caller.msg("Backend Room created, id: %s" % room.dbref) #CODE preset_weapons = ['Sword of Truth', 'Blessed Hammer of An\'Karith', 'Axe of Ferocity', 'Arm of the Tyrant', 'Staff of Clarity', 'Mace of the Druid King', 'Wizards Staff of Omen', 'Roderick\'s Claymore', ] room = search("storage", global_search=True) for weapon in preset_weapons: weapon = create.create_object("game.gamesrc.objects.world.items.Weapon", key=weapon, location=room) caller.msg("%s created!" % weapon.name) if 'Sword of Truth' in weapon: weapon.db.damage = "2d10" weapon.db.desc = "The sword's blade glimmers even when there is no light source. It seeks evil." weapon.db.value = 1250 weapon.db.item_level = "rare" weapon.db.slot = "weapon" weapon.db.weapon_type = "sword" weapon.db.attribute_bonuses = { 'str': 10, 'dex': 5, 'int': 1, 'con': 10 } elif 'Blessed Hammer of' in weapon: weapon.db.damage = "4d12" weapon.db.desc = "This giant two handed hammer looks impossible to lift, but is quite light in hand. Runes are carved up and down the stone handle"
def generate_rooms(self): """ This generates the actual room objects of the dungeon TODO: Add cardinal direction to where exits point. """ #is there already a dungeon built? manager = self.db.manager if len(manager.db.dungeon) >= 1: manager.delete_previous_dungeon() #we need to nuke to zone object as well so it re-creates itself on this use zone = self.db.zone zone.delete() self.db.zone = None #If we have no zone attribute, make a zone object and assign one. if not hasattr(self, 'zone'): self.generate_zone_manager() zone = self.db.zone #or if the zone attribute is None, create and assign on elif self.db.zone is None: self.generate_zone_manager() zone = self.db.zone else: #or just use whats there. zone = self.db.zone #grab the zone path map for the dungeon path_map = zone.db.path_map dungeon = [] #first we build a list of rooms. for i in range(self.db.number_of_rooms): room = create.create_object("game.gamesrc.objects.world.rooms.DungeonRoom", key = "%s - Room %s" % (self.db.dungeon_type_picked, i)) self.generate_room_texts(room) room.db.level = self.db.level room.db.dungeon_type = self.db.dungeon_type_picked if i == self.db.number_of_rooms - 1: room.db.last_room = True else: room.db.last_room = False #add the script that spawns and watches the rooms treasure spawn (chests, loot caches and what not) room.scripts.add("game.gamesrc.scripts.world_scripts.dungeon_scripts.TreasureSpawner") room.db.manager = zone #add the room to the dungeon list of rooms dungeon.append(room) #add the cell to the path_map so the zone manager knows where to look for things. path_map['A%s' % i] = room #add a cell number to the dungeon room room.db.cell_number = 'A%s' % i if i > 0: room.aliases = ['%s_quest_item_spawn' % self.db.dungeon_type_picked] zone.db.path_map = path_map manager.db.dungeon = dungeon self.db.zone = zone #manually trigger zone_runner to spawn mobs zone.update() i = 0 lair = self.search(self.location.db.lair_id, global_search=True) rooms = manager.db.dungeon for room in manager.db.dungeon: exit_name = random.choice(self.db.exit_types) if i != 0: #if not the first room previous_room = rooms[i - 1] destination_obj = previous_room #link to previous room exit = create.create_object("game.gamesrc.objects.baseobjects.Exit", key="Previous Room", location=room, destination=destination_obj) exit.aliases = [exit.key.lower(), 'prev', 'pr'] exit_name = random.choice(self.db.exit_types) #link to the next room try: next_room = rooms[i + 1] except IndexError: return destination_obj = next_room exit2 = create.create_object("game.gamesrc.objects.baseobjects.Exit", key=exit_name, location=room, destination=destination_obj) else: #portal back home exit = create.create_object("game.gamesrc.objects.baseobjects.Exit", key="Glowing Red Portal", location=room, destination=lair) exit.aliases = [ 'portal', 'glowing portal', 'red portal' ] #portal to the dungeon entrance_to_dungeon = create.create_object("game.gamesrc.objects.baseobjects.Exit", key="Glowing Red Portal", location=lair, destination=room) entrance_to_dungeon.aliases = [ 'portal', 'glowing portal', 'red portal' ] next_room = rooms[1] exit_name = random.choice(self.db.exit_types) destination_obj = next_room next_room_exit = create.create_object("game.gamesrc.objects.baseobjects.Exit", key=exit_name, location=room, destination=destination_obj) i += 1
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, "src.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() split_charname = charname.split(' ') if len(split_charname) > 2: self.caller.msg("Character name must be in the following format: Firstname Surname. Or: Firstname.") return old_char = ObjectDB.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.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) if self.caller.swap_character(new_character): attributes = new_character.db.attributes nodes = [] copy_dir = '/var/mud/evennia/game/gamesrc/copy/' for option in ['race', 'deity', 'alignment', 'gender', 'weapon skills', 'armor skills']: if 'race' in option: for race in ['bardok', 'erelania', 'the unknowns', 'earthen', 'gerdling']: confirm_node = MenuNode("confirm-%s" % race, links=['deity'], linktexts=['Choose your deity.'], code="self.caller.set_race('%s')" % race) nodes.append(confirm_node) if 'bardok' in race: text = copyreader.read_file("%s/races/bardok_desc.txt" % copy_dir) race_node = MenuNode("%s" % race, text=text, links=['confirm-bardok', 'race'], linktexts=['Confirm Race Selection', 'Back to Races']) elif 'erelania' in race: text = copyreader.read_file("%s/races/erelania_desc.txt" % copy_dir) race_node = MenuNode("%s" % race, text=text, links=['confirm-erelania', 'race'], linktexts=['Confirm Race Selection', 'Back to Races']) elif 'gerdling' in race: text = copyreader.read_file("%s/races/gerdling_desc.txt" % copy_dir) race_node = MenuNode("%s" % race, text=text, links=['confirm-gerdling', 'race'], linktexts=['Confirm Race Selection', 'Back to Races']) elif 'earthen' in race: text = copyreader.read_file("%s/races/earthen_desc.txt" % copy_dir) race_node = MenuNode("%s" % race, text=text, links=['confirm-earthen', 'race'], linktexts=['Confirm Race Selection', 'Back to Races']) nodes.append(race_node) text = copyreader.read_file("%s/races/races_desc.txt" % copy_dir) root_race_node = MenuNode("%s" % option, text=text, links=['bardok', 'erelania', 'gerdling', 'earthen'], linktexts=['The Bardok', 'The Erelania', 'The Gerdling', 'The Earthen']) nodes.append(root_race_node) elif 'deity' in option: deities = ['ankarith', 'slyth', 'green warden', 'kaylynne'] for deity in deities: confirm_node = MenuNode('confirm-%s' % deity, links=['gender'], linktexts=['Choose your gender.'], code="self.caller.set_deity('%s')" % deity) nodes.append(confirm_node) if 'karith' in deity: text = copyreader.read_file("%s/deities/ankarith_desc.txt" % copy_dir) deity_node = MenuNode("%s" % deity, text=text, links=['confirm-ankarith', 'deity'], linktexts=['Confirm Deity Selection', 'Back to Deities']) #self.obj.msg("links: %s, linktexts: %s" % (deity_node.links, deity_node.linktexts)) elif 'slyth' in deity: text = copyreader.read_file("%s/deities/slyth_desc.txt" % copy_dir) deity_node = MenuNode("%s" % deity, text=text, links=['confirm-slyth', 'deity'], linktexts=['Confirm Deity Selection', 'Back to Deities']) elif 'green warden' in deity: text = copyreader.read_file("%s/deities/greenwarden_desc.txt" % copy_dir) deity_node = MenuNode("%s" % deity, text=text, links=['confirm-green warden', 'deity'], linktexts=['Confirm Deity Selection', 'Back to Deities']) elif 'kaylynne' in deity: text = copyreader.read_file("%s/deities/kaylynne_desc.txt" % copy_dir) deity_node = MenuNode("%s" % deity, text=text, links=['confirm-kaylynne', 'deity'], linktexts=['Confirm Deity Selection', 'Back to Deities']) nodes.append(deity_node) deity_node_text = copyreader.read_file("%s/deities/deities_desc.txt" % copy_dir) root_deity_node = MenuNode("deity", text=deity_node_text, links=['ankarith', 'slyth', 'green warden', 'kaylynne'], linktexts=['An\'Karith', 'Slyth of the Glade', 'The Green Warden', 'Kaylynne']) nodes.append(root_deity_node) elif 'gender' in option: confirm_male = MenuNode("confirm-gender-male", links=['weapons'], linktexts=['Choose which weapon to specialize in.'], code="self.caller.set_gender('male')") confirm_female = MenuNode("confirm-gender-female", links=['weapons'], linktexts=['Choose which weapon to specialize in.'], code="self.caller.set_gender('female')") nodes.append(confirm_male) nodes.append(confirm_female) text = """ --{rGender Selection{n-- Please select which gender you would like to be: """ gender_node = MenuNode("gender", text=text, links=['confirm-gender-male', 'confirm-gender-female'], linktexts=['Male', 'Female']) nodes.append(gender_node) elif 'weapon skills' in option: confirm_blades = MenuNode("confirm-blades", links=['armor'], linktexts=['Choose Armor Specialization .'], code="self.caller.set_weapon_skill('blades')") confirm_heavy = MenuNode("confirm-heavy", links=['armor'], linktexts=['Choose Armor Specialization'], code="self.caller.set_weapon_skill('heavy')") confirm_bludgeon = MenuNode("confirm-bludgeon", links=['armor'], linktexts=['Choose Armor Specialization.'], code="self.caller.set_weapon_skill('bludgeon')") nodes.append(confirm_blades) nodes.append(confirm_heavy) nodes.append(confirm_bludgeon) text = """ --{rWeapon Type Selection{n-- Please select which weapon type you would like to specialize in: {GTypes:{n {cBludgeoning{n - Weapons that bash and smash. (Maces, hammers, staves). {cBladed{n - Weapons that slash and cut. (Swords, daggers, axes). {cHeavy{n - Large, often two handed weaponry. (Bastard sword, Great Axe, Polearm). Using weaponry you are not skilled in will result is an increased chance of scoring only glancing blows on a target (damage / 2). You may also take large and more consistent balance reduction. """ weapons_node = MenuNode("weapons", links=['confirm-bludgeon', 'confirm-blades', 'confirm-heavy'], linktexts=['Bludgeoning Weapons', 'Bladed Weapons', 'Heavy Weapons'], text=text) nodes.append(weapons_node) elif 'armor skills' in option: confirm_light = MenuNode("confirm-lightarmor", links=['END'], linktexts=['Begin Your Journey!'], code="self.caller.set_armor_skill('light')") confirm_medium = MenuNode("confirm-mediumarmor", links=['END'], linktexts=['Begin Your Journey!'], code="self.caller.set_armor_skill('medium')") confirm_heavy = MenuNode("confirm-heavyarmor", links=['END'], linktexts=['Begin Your Journey!'], code="self.caller.set_armor_skill('heavy')") nodes.append(confirm_light) nodes.append(confirm_medium) nodes.append(confirm_heavy) text = """ --{rArmor Specilization{n-- Please select which armory type you would like to specialize in: {GTypes:{n {cLight{n - Lightweight, mobile armors. (leather, cloth). {cMedium{n - Moderate weight, semi-mobile armor. (scalemail, ring mail, chainmail). {cHeavy{n - Heavy weight, hard to move in armor. (plate and half plate) Using armor you are not specialized in, will result in large balance loss which in turn will result in stat loss and most likely death. """ armor_node = MenuNode("armor", links=['confirm-lightarmor', 'confirm-mediumarmor', 'confirm-heavyarmor'], linktexts=['Light Armor', 'Medium Armor', 'Heavy Armor'], text=text) nodes.append(armor_node) """ elif 'alignment' in option: confirm_good = MenuNode("confirm-good", links=['END'], linktexts=['Begin your journey.'], text="{rYou begin your journey down the path of light.{n", code="self.caller.set_alignment('good')") confirm_evil = MenuNode("confirm-evil", links=['END'], linktexts=['Begin your journey.'], text="{rYou begin your journey down the path of darkness.{n", code="self.caller.set_alignment('evil')") nodes.append(confirm_good) nodes.append(confirm_evil) text = --{rAlignment Selection{n-- Which path to do you desire to walk? alignment_node = MenuNode("alignment", text=text, links=['confirm-evil', 'confirm-good', 'START'], linktexts=['Path of Darkness', 'Path of Light', 'Back to Customization']) nodes.append(alignment_node) """ start_node = MenuNode("START", text="{bWelcome to Avaloria. Please proceed through the menu to customize your character.{n", links=['race' ], linktexts=['Choose your race.']) nodes.append(start_node) endnode = MenuNode("END", links=[], linktexts=[], code="self.caller.post_creation()") nodes.append(endnode) # node_string = ' '.join([node.key for node in nodes]) # self.obj.msg("{mDEBUG: nodes: %s{n" % node_string) menutree = MenuTree(caller=self.caller.character, nodes=nodes, exec_end=None) flags = new_character.db.flags flags['in_menu'] = True self.caller.db.flags = flags menutree.start()
def debug_object(obj_path, caller): """ Auto-test an object's hooks and methods. """ try: string = "\n Test-creating a new object of path {w%s{n ... " % obj_path obj = create.create_object(obj_path) obj.location = caller.location string += "{gOk{n." except Exception: string += trace() try: obj.delete() except: pass return string string += "\nRunning syntax checks ..." try: string += "\nCalling at_first_login(self) ... " ret = obj.at_first_login() string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_pre_login(self) ... " ret = obj.at_pre_login() string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_post_login(self) ... " ret = obj.at_post_login() string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_disconnect(self) ... " ret = obj.at_disconnect() string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_before_move(self, dest) ... " ret = obj.at_before_move(caller.location) string += "{gOk{n: returns %s" % ret except Exception: string += trace() try: string += "\nCalling announce_move_from(self, dest) ... " ret = obj.announce_move_from(caller.location) string += "{gOk{n" except Exception: string += trace() try: string += "\nCalling announce_move_to(self, source_loc) ... " ret = obj.announce_move_from(caller.location) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_after_move(self, source_loc) ... " ret = obj.at_after_move(caller.location) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_object_receive(self, caller, source_loc) ... " ret = obj.at_object_receive(caller, caller.location) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling return_appearance(self, caller) ... " ret = obj.return_appearance(caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_msg_receive(self, msg, from_obj) ... " ret = obj.at_msg_receive("test_message_receive", caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_msg_send(self, msg, to_obj) ... " ret = obj.at_msg_send("test_message_send", caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_desc(self, looker) ... " ret = obj.at_desc(caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_object_delete(self) ... " ret = obj.at_object_delete() string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_get(self, getter) ... " ret = obj.at_get(caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_drop(self, dropper) ... " ret = obj.at_drop(caller) string += "{gOk{n." except Exception: string += trace() try: string += "\nCalling at_say(self, speaker, message) ... " ret = obj.at_say(caller, "test_message_say") string += "{gOk{n." except Exception: string += trace() try: obj.delete() except: string += trace() return string
def func(self): caller = self.caller location = caller.location if not location: location = caller # Parse input target = None name = None if self.lhs: target = self.lhs.split(' ', 1)[0] if len(self.lhs.split(' ', 1)) > 1: name = self.lhs.split(' ', 1)[1] if not target: caller.msg("Which object do you wish create?") return # Find global script script_key = "GlobalDatabase" script = ev.search_script(script_key) if not script: caller.msg("Global script by name '%s' could not be found." % script_key) return script = script[0] # all ev.search_* methods always return lists # Make sure the "template_objects" dictionary already exists in the global database script. if "template_objects" not in script.db.database: script.db.database["template_objects"] = {} lockstring = "control:id(%s);examine:perm(Builders);delete:id(%s) or perm(Wizards)" % (caller.id, caller.id) # Create blank object if target == "object" or target == "obj": typeclass = settings.BASE_OBJECT_TYPECLASS new_obj = create.create_object(typeclass, "untitled object", location, home=location, locks=lockstring, report_to=caller) new_obj.db.desc = '' # Create blank character elif target == "character" or target == "char": typeclass = settings.BASE_CHARACTER_TYPECLASS new_obj = create.create_object(typeclass, "untitled character", location, home=location, locks=lockstring, report_to=caller) new_obj.db.desc = '' # Create object/character from template else: target = self.lhs name = self.rhs # Search for target in template database if not target in script.db.database["template_objects"]: caller.msg("Cannot find template '%s'." % target) return old_obj = script.db.database["template_objects"][target]["object"] from game.gamesrc.utils.copy_object_recursive import copy_object_recursive new_obj = copy_object_recursive(old_obj) # Set object location new_obj.home = location new_obj.move_to(location, quiet=True) new_obj.start_scripts() if new_obj.db.is_template: del new_obj.db.is_template # Set object name if supplied if name: new_obj.key = name caller.msg("Created %s." % new_obj.name) location.msg_contents("%s creates %s." % (caller.name, new_obj.name), exclude=caller) #if not self.args: # string = "Usage: @create[/drop] <newname>[;alias;alias...] [:typeclass_path]" # caller.msg(string) # return # ## create the objects #for objdef in self.lhs_objs: # string = "" # name = objdef['name'] # aliases = objdef['aliases'] # typeclass = objdef['option'] # # # create object (if not a valid typeclass, the default # # object typeclass will automatically be used) # lockstring = "control:id(%s);examine:perm(Builders);delete:id(%s) or perm(Wizards)" % (caller.id, caller.id) # obj = create.create_object(typeclass, name, caller, # home=caller, aliases=aliases, # locks=lockstring, report_to=caller) # if not obj: # continue # if aliases: # string = "You create a new %s: %s (aliases: %s)." # string = string % (obj.typeclass.typename, obj.name, ", ".join(aliases)) # else: # string = "You create a new %s: %s." # string = string % (obj.typeclass.typename, obj.name) # # # set a default desc # if not obj.db.desc: # obj.db.desc = "You see nothing special." # # # Set object location # if caller.location: # obj.home = caller.location # obj.move_to(caller.location, quiet=True) # #if string: # self.caller.msg(string)
def setUp(self): "set up the test" self.attr = models.ObjAttribute() self.obj1 = create.create_object(objects.Object, key="testobj1", location=None) self.obj2 = create.create_object(objects.Object, key="testobj2", location=self.obj1)
def func(self): "Do checks and create account" session = self.caller args = self.args.strip() # extract quoted parts parts = [part.strip() for part in re.split(r"\"|\'", args) if part.strip()] if len(parts) == 1: # this was (hopefully) due to no quotes being found parts = parts[0].split(None, 1) if len(parts) != 2: string = "\n Usage (without <>): create <name> <password>" string += "\nIf <name> or <password> contains spaces, enclose it in quotes." session.msg(string) return playername, password = parts # sanity checks if not re.findall('^[\w. @+-]+$', playername) or not (0 < len(playername) <= 30): # this echoes the restrictions made by django's auth # module (except not allowing spaces, for convenience of # logging in). string = "\n\r Playername can max be 30 characters or fewer. Letters, spaces, digits and @/./+/-/_ only." session.msg(string) return # strip excessive spaces in playername playername = re.sub(r"\s+", " ", playername).strip() if PlayerDB.objects.filter(username__iexact=playername): # player already exists (we also ignore capitalization here) session.msg("Sorry, there is already a player with the name '%s'." % playername) return if not re.findall('^[\w. @+-]+$', password) or not (3 < len(password)): string = "\n\r Password should be longer than 3 characers. Letters, spaces, digits and @\.\+\-\_ only." string += "\nFor best security, make it longer than 8 characters. You can also use a phrase of" string += "\nmany words if you enclose the password in quotes." session.msg(string) return # everything's ok. Create the new player account. try: default_home = ObjectDB.objects.get_id(settings.DEFAULT_HOME) typeclass = settings.BASE_CHARACTER_TYPECLASS permissions = settings.PERMISSION_PLAYER_DEFAULT try: new_player = create.create_player(playername, None, password, permissions=permissions) except Exception, e: session.msg("There was an error creating the default Player/Character:\n%s\n If this problem persists, contact an admin." % e) logger.log_trace() return # This needs to be called so the engine knows this player is # logging in for the first time. (so it knows to call the right # hooks during login later) utils.init_new_player(new_player) # join the new player to the public channel pchanneldef = settings.CHANNEL_PUBLIC if pchanneldef: pchannel = ChannelDB.objects.get_channel(pchanneldef[0]) if not pchannel.connect(new_player): string = "New player '%s' could not connect to public channel!" % new_player.key logger.log_errmsg(string) if MULTISESSION_MODE < 2: # if we only allow one character, create one with the same name as Player # (in mode 2, the character must be created manually once logging in) start_location = ObjectDB.objects.get_id(settings.START_LOCATION) if not start_location: start_location = default_home # fallback new_character = create.create_object(typeclass, key=playername, location=start_location, home=default_home, permissions=permissions) # set playable character list new_player.db._playable_characters.append(new_character) # allow only the character itself and the player to puppet this character (and Immortals). new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, new_player.id)) # If no description is set, set a default description if not new_character.db.desc: new_character.db.desc = "This is a Player." # We need to set this to have @ic auto-connect to this character new_player.db._last_puppet = new_character # tell the caller everything went well. string = "A new account '%s' was created. Welcome!" if " " in playername: string += "\n\nYou can now log in with the command 'connect \"%s\" <your password>'." else: string += "\n\nYou can now log with the command 'connect %s <your password>'." session.msg(string % (playername, playername))
def create_objects(): """ Creates the #1 player and Limbo room. """ print " Creating objects (Player #1 and Limbo room) ..." # Set the initial User's account object's username on the #1 object. # This object is pure django and only holds name, email and password. god_player = get_god_player() # Create a Player 'user profile' object to hold eventual # mud-specific settings for the PlayerDB object. player_typeclass = settings.BASE_PLAYER_TYPECLASS # run all creation hooks on god_player (we must do so manually # since the manage.py command does not) god_player.typeclass_path = player_typeclass god_player.basetype_setup() god_player.at_player_creation() god_player.locks.add("examine:perm(Immortals);edit:false();delete:false();boot:false();msg:all()") # this is necessary for quelling to work correctly. god_player.permissions.add("Immortals") # Limbo is the default "nowhere" starting room # Create the in-game god-character for player #1 and set # it to exist in Limbo. character_typeclass = settings.BASE_CHARACTER_TYPECLASS god_character = create.create_object(character_typeclass, key=god_player.username, nohome=True) god_character.id = 1 god_character.db.desc = _('This is User #1.') god_character.locks.add("examine:perm(Immortals);edit:false();delete:false();boot:false();msg:all();puppet:false()") god_character.permissions.add("Immortals") god_character.save() god_player.attributes.add("_first_login", True) god_player.attributes.add("_last_puppet", god_character) god_player.db._playable_characters.append(god_character) room_typeclass = settings.BASE_ROOM_TYPECLASS limbo_obj = create.create_object(room_typeclass, _('Limbo'), nohome=True) limbo_obj.id = 2 string = " ".join([ "Welcome to your new {wEvennia{n-based game. From here you are ready", "to begin development. Visit http://evennia.com if you should need", "help or would like to participate in community discussions. If you", "are logged in as User #1 you can create a demo/tutorial area with", "'@batchcommand contrib.tutorial_world.build'. Log out and create", "a new non-admin account at the login screen to play the tutorial", "properly."]) string = _(string) limbo_obj.db.desc = string limbo_obj.save() # Now that Limbo exists, try to set the user up in Limbo (unless # the creation hooks already fixed this). if not god_character.location: god_character.location = limbo_obj if not god_character.home: god_character.home = limbo_obj
def func(self): "Do checks and create account" session = self.caller try: playername, email, password = self.playerinfo except ValueError: string = "\n\r Usage (without <>): create \"<playername>\" <email> <password>" session.msg(string) return if not re.findall('^[\w. @+-]+$', playername) or not (0 < len(playername) <= 30): session.msg( "\n\r Playername can max be 30 characters or fewer. Letters, spaces, dig\ its and @/./+/-/_ only." ) # this echoes the restrictions made by django's auth module. return if not email or not password: session.msg( "\n\r You have to supply an e-mail address followed by a password." ) return if not utils.validate_email_address(email): # check so the email at least looks ok. session.msg("'%s' is not a valid e-mail address." % email) return # Run sanity and security checks if PlayerDB.objects.filter(username=playername): # player already exists session.msg( "Sorry, there is already a player with the name '%s'." % playername) return if PlayerDB.objects.get_player_from_email(email): # email already set on a player session.msg( "Sorry, there is already a player with that email address.") return if len(password) < 3: # too short password string = "Your password must be at least 3 characters or longer." string += "\n\rFor best security, make it at least 8 characters long, " string += "avoid making it a real word and mix numbers into it." session.msg(string) return # everything's ok. Create the new player account. try: default_home = ObjectDB.objects.get_id(settings.DEFAULT_HOME) typeclass = settings.BASE_CHARACTER_TYPECLASS permissions = settings.PERMISSION_PLAYER_DEFAULT try: new_player = create.create_player(playername, email, password, permissions=permissions) except Exception, e: session.msg( "There was an error creating the default Player/Character:\n%s\n If this problem persists, contact an admin." % e) logger.log_trace() return # This needs to be called so the engine knows this player is # logging in for the first time. (so it knows to call the right # hooks during login later) utils.init_new_player(new_player) # join the new player to the public channel pchanneldef = settings.CHANNEL_PUBLIC if pchanneldef: pchannel = ChannelDB.objects.get_channel(pchanneldef[0]) if not pchannel.connect(new_player): string = "New player '%s' could not connect to public channel!" % new_player.key logger.log_errmsg(string) if MULTISESSION_MODE < 2: # if we only allow one character, create one with the same name as Player # (in mode 2, the character must be created manually once logging in) new_character = create.create_object(typeclass, key=playername, location=default_home, home=default_home, permissions=permissions) # set playable character list new_player.db._playable_characters.append(new_character) # allow only the character itself and the player to puppet this character (and Immortals). new_character.locks.add( "puppet:id(%i) or pid(%i) or perm(Immortals) or pperm(Immortals)" % (new_character.id, new_player.id)) # If no description is set, set a default description if not new_character.db.desc: new_character.db.desc = "This is a Player." # We need to set this to have @ic auto-connect to this character new_player.db._last_puppet = new_character # tell the caller everything went well. string = "A new account '%s' was created. Welcome!" if " " in playername: string += "\n\nYou can now log in with the command 'connect %s <your password>'." else: string += "\n\nYou can now log with the command 'connect %s <your password>'." session.msg(string % (playername, email))
#HEADER from src.utils import create, search from game.gamesrc.objects.world.rooms import Zone #CODE (Tutorial) zone = create.create_object(Zone, key="Tutorial Zone Object") zone.aliases = ['zone_runner'] zone.db.zone_name = "Tutorial Area" zone.db.zone_type = 'tutorial' zone.db.quest_items = ["Training Manual", "Spell Tome"] zone.db.enemy_npcs = ["Battle Dummy"] zone.db.mobs_spawn = False zone.refresh_mg_dungeon_type() zone.generate_zone_path() zone.spawn_enemy_npcs() #CODE (Marshlands) zone = create.create_object(Zone, key="Marshlands Zone Object") zone.aliases = ['zone_runner'] zone.db.zone_name = "Marshlands" zone.db.quest_items = ['Family Heirloom'] zone.db.enemy_npcs = ['Synesh Algreense'] zone.db.mobs_spawned = False zone.generate_zone_path() #actually sets up the room path. zone.spawn_enemy_npcs() #zone.cleanup()