示例#1
0
 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 
示例#2
0
文件: mob.py 项目: abbacode/avaloria
    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()
示例#3
0
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
示例#4
0
 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
示例#5
0
    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
示例#6
0
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
示例#7
0
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 
示例#8
0
    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))
示例#9
0
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
示例#10
0
 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)
示例#11
0
 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()
示例#12
0
文件: tests.py 项目: Zurriel/evennia
    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)
示例#13
0
    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)
示例#14
0
 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))
示例#15
0
    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()
示例#16
0
 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
示例#17
0
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)
示例#18
0
 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()
示例#19
0
    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
示例#20
0
    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))
示例#21
0
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)
示例#22
0
    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")
示例#23
0
    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()
示例#24
0
    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
示例#25
0
    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
示例#26
0
    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))
示例#27
0
    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
示例#28
0
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
示例#29
0
#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"
示例#30
0
    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
示例#31
0
    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()
示例#32
0
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 
示例#33
0
    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)
示例#34
0
 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)
示例#35
0
    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
示例#37
0
    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))
示例#38
0
#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()