def format(world, raw_data): """Deserialize a player character saved in ShinyFormat and adds it to the world. raw_data - the data to be deserialized into a player object. world - The World instance """ pc = json.loads(_match_shiny_tag('Player', raw_data)) items = json.loads(_match_shiny_tag('Inv Items', raw_data)) # Build the area from the assembled dictionary data try: new_pc = Player(('foo', 'bar')) new_pc.playerize(pc) new_pc.save() # Inventory time! containers = {} # old_container_dbid : [new_containee1, ...] old_new = {} # old dbid's mapped to their new ones for item in items: my_container = item[0].get('container') old_dbid = item[0]['dbid'] del item[0]['dbid'] if item[0].get('owner'): item[0]['owner'] = new_pc.dbid else: del item[0]['container'] i = GameItem(item[0]) i.save() load_item_types(i, item[1]) old_new[old_dbid] = i.dbid if my_container: if containers.get(my_container): containers[my_container].append(i) else: containers[my_container] = [i] for old_container_dbid, containees_list in containers.items(): for containee in containees_list: containee.container = old_new.get(old_container_dbid) containee.save() except Exception as e: # if anything went wrong, make sure we destroy any leftover character # data. This way, we won't run into problems if they try to import it # again, and we won't leave orphaned or erroneous data in the db. world.log.error(traceback.format_exc()) try: new_pc.destruct() except: # if something goes wrong destroying the pc, it probably means we # didn't get far enough to have anything to destroy. Just ignore any # errors. pass raise SportError('There was a horrible error on import! ' 'Aborting! Check logfile for details.') return 'Character "%s" has been successfully imported.' % new_pc.fancy_name( )
def setUp(self): ShinyTestCase.setUp(self) # add a builder from shinymud.data import config from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.commands.build_commands import build_list from shinymud.modes.build_mode import BuildMode self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER
def test_set_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Set bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name': 'bob', 'password': '******'}) # Test setting e-mail Set(bob, 'email [email protected]', 'set').run() self.assertEqual('*****@*****.**', bob.email) # Test setting title Set(bob, 'title is the best EVAR', 'set').run() self.assertEqual('is the best EVAR', bob.title) # Try to set goto_appear and goto_disappear (both should fail # since this player shouldn't have permissions) Set(bob, 'goto_appear Bob pops in from nowhere.', 'set').run() eresult = 'You don\'t have the permissions to set that.' self.assertTrue(eresult in bob.outq) bob.outq = [] Set(bob, 'goto_disappear foo', 'set').run() self.assertTrue(eresult in bob.outq) bob.permissions = bob.permissions | config.BUILDER # Try to set goto_appear and goto_disappear (both should now # succeed now that the player has adequate permissions) Set(bob, 'goto_appear Bob pops in from nowhere.', 'set').run() self.assertEqual('Bob pops in from nowhere.', bob.goto_appear) bob.outq = [] Set(bob, 'goto_disappear foo', 'set').run() self.assertEqual('foo', bob.goto_disappear)
def format(world, raw_data): """Deserialize a player character saved in ShinyFormat and adds it to the world. raw_data - the data to be deserialized into a player object. world - The World instance """ pc = json.loads(_match_shiny_tag('Player', raw_data)) items = json.loads(_match_shiny_tag('Inv Items', raw_data)) # Build the area from the assembled dictionary data try: new_pc = Player(('foo', 'bar')) new_pc.playerize(pc) new_pc.save() # Inventory time! containers = {} # old_container_dbid : [new_containee1, ...] old_new = {} # old dbid's mapped to their new ones for item in items: my_container = item[0].get('container') old_dbid = item[0]['dbid'] del item[0]['dbid'] if item[0].get('owner'): item[0]['owner'] = new_pc.dbid else: del item[0]['container'] i = GameItem(item[0]) i.save() load_item_types(i, item[1]) old_new[old_dbid] = i.dbid if my_container: if containers.get(my_container): containers[my_container].append(i) else: containers[my_container] = [i] for old_container_dbid, containees_list in containers.items(): for containee in containees_list: containee.container = old_new.get(old_container_dbid) containee.save() except Exception as e: # if anything went wrong, make sure we destroy any leftover character # data. This way, we won't run into problems if they try to import it # again, and we won't leave orphaned or erroneous data in the db. world.log.error(traceback.format_exc()) try: new_pc.destruct() except: # if something goes wrong destroying the pc, it probably means we # didn't get far enough to have anything to destroy. Just ignore any # errors. pass raise SportError('There was a horrible error on import! ' 'Aborting! Check logfile for details.') return 'Character "%s" has been successfully imported.' % new_pc.fancy_name()
def run(self): """Start the connection-handler thread running. This thread will accept connections, create a Player object for the player logging in, and then add that Player object to the world. """ self.listener.listen(5) self.world.log.debug("Listener started") while 1: try: connection = WebsocketConnection(self.listener.accept(), self.world.log, self.host, self.port) except Exception as e: self.world.log.debug(str(e)) else: new_player = Player(connection) self.world.log.info("Websocket: Client logging in from: %s" % str(connection.addr)) # new_player.conn.setblocking(0) # The player_add function in the world requires access to the player_list, # which the main thread edits quite a bit -- that's why we need a lock # before we add a player self.world.player_list_lock.acquire() self.world.player_add(new_player) self.world.player_list_lock.release()
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER self.area = Area.create({'name': 'foo'})
def test_set_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Set bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name':'bob', 'password':'******'}) # Test setting e-mail Set(bob, 'email [email protected]', 'set').run() self.assertEqual('*****@*****.**', bob.email) # Test setting title Set(bob, 'title is the best EVAR', 'set').run() self.assertEqual('is the best EVAR', bob.title) # Try to set goto_appear and goto_disappear (both should fail # since this player shouldn't have permissions) Set(bob, 'goto_appear Bob pops in from nowhere.', 'set').run() eresult = 'You don\'t have the permissions to set that.' self.assertTrue(eresult in bob.outq) bob.outq = [] Set(bob, 'goto_disappear foo', 'set').run() self.assertTrue(eresult in bob.outq) bob.permissions = bob.permissions | config.BUILDER # Try to set goto_appear and goto_disappear (both should now # succeed now that the player has adequate permissions) Set(bob, 'goto_appear Bob pops in from nowhere.', 'set').run() self.assertEqual('Bob pops in from nowhere.', bob.goto_appear) bob.outq = [] Set(bob, 'goto_disappear foo', 'set').run() self.assertEqual('foo', bob.goto_disappear)
def test_goto_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Goto blarg_area = Area.create({'name': 'blarg'}) foo_area = Area.create({'name': 'foo'}) blarg_room = blarg_area.new_room() foo_room = foo_area.new_room() bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name': 'bob', 'password': '******'}) self.world.player_add(bob) bob.permissions = bob.permissions | config.BUILDER generic_fail = 'Type "help goto" for help with this command.' # We should fail if we only specify a room number when we aren't in # an area Goto(bob, '%s' % foo_room.id, 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(generic_fail in bob.outq) # We should fail if we try to go to a room in an area that doesn't # exist message = 'Area "food" doesn\'t exist.' Goto(bob, '1 food', 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(message in bob.outq) # We should fail if we try to go to a room that doesn't exist (in an # area that does) message = 'Room "4005" doesn\'t exist in area blarg.' Goto(bob, '4005 blarg', 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(message in bob.outq) # We should succeed in going to a room and area that exists Goto(bob, '%s %s' % (foo_room.id, foo_room.area.name), 'goto').run() self.assertEqual(bob.location, foo_room) Goto(bob, '%s %s' % (blarg_room.id, blarg_room.area.name), 'goto').run() self.assertEqual(bob.location, blarg_room) blarg_r2 = blarg_area.new_room() Goto(bob, '%s' % (blarg_r2.id), 'goto').run() self.assertEqual(bob.location, blarg_r2) # We should get a help message if there is only white space given bob.outq = [] Goto(bob, ' ', 'goto').run() fail = 'Type "help goto" for help with this command.' self.assertTrue(fail in bob.outq)
class TestBuildCommands(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) # add a builder from shinymud.data import config from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.commands.build_commands import build_list from shinymud.modes.build_mode import BuildMode self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER def _clean_test_file(self, path): try: os.remove(path) except Exception, e: self.world.log.debug('Error removing test file:' + str(e))
def create_god(world): """Create a god character and save it to this MUD's db.""" from shinymud.models.player import Player save = {'permissions': GOD | PLAYER} player = Player(('foo', 'bar')) save['name'] = '' print "Please choose a name for your character. It should contain \n" +\ "alphanumeric characters (letters and numbers) ONLY." while not save['name']: playername = (raw_input("Name: ")).strip() if not playername.isalpha(): print "That is not a valid name. Please choose another." else: row = player.world.db.select( 'password,dbid FROM player WHERE name=?', [playername]) if row: print "A player with that name already exists. Please choose Another." else: print "You're sure you want your name to be '%s'?" % playername choice = (raw_input("Yes/No: ")).strip() if choice.lower().startswith('y'): save['name'] = playername else: print "Ok, we'll start over. Which name do you REALLY want?" save['password'] = '' while not save['password']: passwd1 = (raw_input(CLEAR + "Choose a password: "******"Re-enter password to confirm: " + CONCEAL)).strip() if passwd1 == passwd2: save['password'] = hashlib.sha1(passwd1).hexdigest() print CLEAR else: print CLEAR + "Your passwords did not match. Please try again." save['gender'] = '' print "What gender shall your character be?" while not save['gender']: print "Choose from: neutral, female, or male." gender = (raw_input('Gender: ')).strip() if len(gender) and gender[0].lower() in ['m', 'f', 'n']: save['gender'] = { 'm': 'male', 'f': 'female', 'n': 'neutral' }[gender[0].lower()] else: print "That's not a valid gender." player.playerize(save) player.save() print 'Your character, %s, has been created.' % player.fancy_name()
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS #"bob" is created so we can tell build mode functions which player called them. #We probably don't need bob since this functionality is only important when permissions #are concerned in build commands. We'll create and pass him in anyways for now. self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'})
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) self.room = self.area.new_room() self.area2 = Area.create({'name': 'SimCity'}) self.area2_script = self.area2.new_script()
def test_goto_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Goto blarg_area = Area.create({'name':'blarg'}) foo_area = Area.create({'name':'foo'}) blarg_room = blarg_area.new_room() foo_room = foo_area.new_room() bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name':'bob', 'password':'******'}) self.world.player_add(bob) bob.permissions = bob.permissions | config.BUILDER generic_fail = 'Type "help goto" for help with this command.' # We should fail if we only specify a room number when we aren't in # an area Goto(bob, '%s' % foo_room.id, 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(generic_fail in bob.outq) # We should fail if we try to go to a room in an area that doesn't # exist message = 'Area "food" doesn\'t exist.' Goto(bob, '1 food', 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(message in bob.outq) # We should fail if we try to go to a room that doesn't exist (in an # area that does) message = 'Room "4005" doesn\'t exist in area blarg.' Goto(bob, '4005 blarg', 'goto').run() self.assertEqual(bob.location, None) bob.world.log.debug(bob.outq) self.assertTrue(message in bob.outq) # We should succeed in going to a room and area that exists Goto(bob, '%s %s' % (foo_room.id, foo_room.area.name), 'goto').run() self.assertEqual(bob.location, foo_room) Goto(bob, '%s %s' % (blarg_room.id, blarg_room.area.name), 'goto').run() self.assertEqual(bob.location, blarg_room) blarg_r2 = blarg_area.new_room() Goto(bob, '%s' % (blarg_r2.id), 'goto').run() self.assertEqual(bob.location, blarg_r2) # We should get a help message if there is only white space given bob.outq = [] Goto(bob, ' ', 'goto').run() fail = 'Type "help goto" for help with this command.' self.assertTrue(fail in bob.outq)
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.bob = Player(("bob", "bar")) self.bob.mode = None self.bob.playerize({"name": "bob"}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER self.area = Area.create({"name": "foo"})
def create_god(world): """Create a god character and save it to this MUD's db.""" from shinymud.models.player import Player save = {'permissions': GOD | PLAYER} player = Player(('foo', 'bar')) save['name'] = '' print "Please choose a name for your character. It should contain \n" +\ "alphanumeric characters (letters and numbers) ONLY." while not save['name']: playername = (raw_input("Name: ")).strip() if not playername.isalpha(): print "That is not a valid name. Please choose another." else: row = player.world.db.select('password,dbid FROM player WHERE name=?', [playername]) if row: print "A player with that name already exists. Please choose Another." else: print "You're sure you want your name to be '%s'?" % playername choice = (raw_input("Yes/No: ")).strip() if choice.lower().startswith('y'): save['name'] = playername else: print "Ok, we'll start over. Which name do you REALLY want?" save['password'] = '' while not save['password']: passwd1 = (raw_input(CLEAR + "Choose a password: "******"Re-enter password to confirm: " + CONCEAL)).strip() if passwd1 == passwd2: save['password'] = hashlib.sha1(passwd1).hexdigest() print CLEAR else: print CLEAR + "Your passwords did not match. Please try again." save['gender'] = '' print "What gender shall your character be?" while not save['gender']: print "Choose from: neutral, female, or male." gender = (raw_input('Gender: ')).strip() if len(gender) and gender[0].lower() in ['m', 'f', 'n']: save['gender'] = {'m':'male', 'f':'female', 'n':'neutral'}[gender[0].lower()] else: print "That's not a valid gender." player.playerize(save) player.save() print 'Your character, %s, has been created.' % player.fancy_name()
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS #"bob" is created so we can tell build mode functions which player called them. #We probably don't need bob since this functionality is only important when permissions #are concerned in build commands. We'll create and pass him in anyways for now. self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'})
def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) self.room = self.area.new_room() self.area2 = Area.create({'name': 'SimCity'}) self.area2_script = self.area2.new_script()
def test_chat_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Chat bob = Player(('bob', 'bar')) alice = Player(('alice', 'bar')) sam = Player(('sam', 'bar')) bob.mode = None bob.playerize({'name':'bob', 'password':'******'}) bob.outq = [] sam.mode = None sam.playerize({'name':'sam', 'password':'******'}) sam.outq = [] self.world.player_add(bob) self.world.player_add(sam) self.world.player_add(alice) Chat(bob, 'lol, hey guys!', 'chat').run() chat = config.chat_color + 'Bob chats, "lol, hey guys!"' + config.clear_fcolor self.assertTrue(chat in sam.outq) self.assertTrue(chat in bob.outq) self.assertFalse(chat in alice.outq) sam.channels['chat'] = False print sam.channels print bob.channels sam.outq = [] bob.outq = [] alice.outq = [] Chat(bob, 'lol, hey guys!', 'chat').run() print sam.channels print sam.outq print bob.channels print bob.outq self.assertFalse(chat in sam.outq) self.assertTrue(chat in bob.outq) self.assertFalse(chat in alice.outq)
class TestNpc(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) self.room = self.area.new_room() self.area2 = Area.create({'name': 'SimCity'}) self.area2_script = self.area2.new_script() def tearDown(self): del self.area del self.area2 del self.bob def test_existance(self): """Test if an NPC can exist within an area properly (unspawned)""" self.npc = self.area.new_npc() self.npc.characterize({'name': 'bobert'}) self.assertTrue(self.npc in self.area.npcs.values()) def test_build_add_remove_events(self): npc = self.area.new_npc() fail_message = 'Type "help events" for help with this command.' message = npc.build_add_event('', self.bob) self.assertEqual(message, fail_message) #test for non-existant scripts message = npc.build_add_event('pc_enter call script 1', self.bob) self.assertEqual(message, "Script 1 doesn't exist.") message = npc.build_add_event("hears 'spam' call script 0", self.bob) self.assertEqual(message, "Script 0 doesn't exist.") message = npc.build_add_event("hears 'spam' call script 602", self.bob) self.assertEqual(message, "Script 602 doesn't exist.") script = self.area.new_script() #Test basic add message = npc.build_add_event('pc_enter call script 1', self.bob) self.assertEqual(message, 'Event added.' ) #Test invalid areas message = npc.build_add_event('pc_enter call script 1 from area AreaDontExist', self.bob) self.assertEqual(message, 'Area "AreaDontExist" doesn\'t exist.') message = npc.build_add_event('pc_enter call script 1 from area AreaDontExist 100', self.bob) self.assertEqual(message, 'Area "AreaDontExist" doesn\'t exist.') #Test invalid probabilities. message = npc.build_add_event('pc_enter call script 1 0', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') message = npc.build_add_event('pc_enter call script 1 101', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') message = npc.build_add_event('pc_enter call script 1 9999', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') #Test different froms of valid adds. message = npc.build_add_event('pc_enter call script 1 50', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event('pc_enter call script 1 from area SimCity', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event('pc_enter call script 1 from area SimCity 75', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event('pc_enter call 1 from SimCity 50', self.bob) self.assertEqual(message, 'Event added.') #Test for trigger 'hears' message = npc.build_add_event("hears 'food' call script 1", self.bob) self.assertEqual(message, 'Event added.' ) #Test for trigger 'emoted' message = npc.build_add_event("emoted 'slap' call script 1", self.bob) self.assertEqual(message, 'Event added.' ) #Technically invalid, but will be left to user responsibility for now. #(it shouldn't ever cause a crash) message = npc.build_add_event("emoted 'emotedontexist' call script 1", self.bob) self.assertEqual(message, 'Event added.' ) #Test for new items self.area.new_item() message = npc.build_add_event("given_item 'item 1' call script 1", self.bob) self.assertEqual(message, 'Event added.' ) #Technically invalid, but will be left to user responsibility for now. #(it shouldn't ever cause a crash) message = npc.build_add_event("given_item 'item 5' call script 1", self.bob) self.assertEqual(message, 'Event added.' ) #we should now have 5 successfully added events in pc_enter self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter -1", self.bob) self.assertEqual(message, 'Try: "remove event <event-trigger> <event-id>" or see "help npc events".' ) self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter 5", self.bob) self.assertEqual(message, "Npc 1 doesn't have the event pc_enter #5." ) self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter 4", self.bob) self.assertEqual(message, 'Event pc_enter, number 4 has been removed.') self.assertEqual(len(npc.events['pc_enter']), 4) message = npc.build_remove_event("given_item 1", self.bob) self.assertEqual(message, 'Event given_item, number 1 has been removed.') self.assertEqual(len(npc.events['pc_enter']), 4) self.assertEqual(len(npc.events['given_item']), 1) def test_build_add_remove_permissions(self): npc = self.area.new_npc() #set npc permissions to nothing. npc.permissions = 0 message = npc.build_add_permission("dm", self.bob) self.assertEqual(message, "You need to be GOD in order to edit an npc's permissions.") #Current permission level needed for messing with npc perms is 'god'. (for when this test was written) #Change as needed! self.bob.permissions = self.bob.permissions | self.PERMS['god'] #Bad input tests message = npc.build_add_permission("", self.bob) self.assertEqual(message, 'Try: "add permission <permission group>". See "help permissions".') message = npc.build_add_permission("monkey", self.bob) self.assertTrue('Valid permissions are: admin, player, builder, dm, god\n' in message) #good input tests message = npc.build_add_permission("god", self.bob) self.assertTrue('Shiny McShinerson now has god permissions.' in message) self.assertTrue(npc.permissions is self.PERMS['god']) message = npc.build_add_permission("dm", self.bob) self.assertTrue('Shiny McShinerson now has dm permissions.' in message) self.assertTrue(npc.permissions is self.PERMS['god'] | self.PERMS['dm']) self.assertTrue(npc.permissions is not self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) message = npc.build_add_permission("admin", self.bob) self.assertTrue('Shiny McShinerson now has admin permissions.' in message) self.assertTrue(npc.permissions is self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) #Removing Permissions #reset bobs permissions for next test self.bob.permissions = 0 message = npc.build_remove_permission("dm", self.bob) self.assertEqual(message, "You need to be GOD in order to edit an npc's permissions.") #Current permission level needed for messing with npc perms is 'god'. (for when this test was written) #Change as needed! self.bob.permissions = self.bob.permissions | self.PERMS['god'] #Bad input tests message = npc.build_remove_permission("", self.bob) self.assertEqual(message, 'Try: "remove permission <permission group>", or see "help permissions".') message = npc.build_remove_permission("monkey", self.bob) self.assertEqual("Shiny McShinerson doesn't have monkey permissions.", message) #Good input tests self.assertTrue(npc.permissions is self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) message = npc.build_remove_permission("god", self.bob) self.assertEqual('Shiny McShinerson no longer has god permissions.', message) self.assertTrue(npc.permissions is self.PERMS['dm'] | self.PERMS['admin']) self.assertTrue(npc.permissions < self.PERMS['god']) message = npc.build_remove_permission("dm", self.bob) self.assertEqual('Shiny McShinerson no longer has dm permissions.', message) self.assertTrue(npc.permissions is self.PERMS['admin']) self.assertTrue(npc.permissions >= self.PERMS['dm']) message = npc.build_remove_permission("admin", self.bob) self.assertEqual('Shiny McShinerson no longer has admin permissions.', message) self.assertTrue(npc.permissions is 0) def test_build_add_remove_ai(self): npc = self.area.new_npc() #Test adding ai pack message = npc.build_add_ai("", self.bob) self.assertEqual('Try: "add ai <ai-pack-name>", or type "help ai packs".', message) message = npc.build_add_ai("doesnotexist", self.bob) self.assertEqual('"doesnotexist" is not a valid ai pack. See "help ai packs".', message) message = npc.build_add_ai("merchant", self.bob) self.assertEqual("This npc (Shiny McShinerson) is now a merchant.", message) message = npc.build_add_ai("merchant", self.bob) self.assertEqual('This npc (Shiny McShinerson) already has that ai pack.', message) #Test basic add behavior for ai pack message = str(npc) self.assertTrue("MERCHANT ATTRIBUTES:" in message) #Test removing ai pack message = npc.build_remove_ai("", self.bob) self.assertEqual('Try: "remove ai <ai-pack-name>", or type "help ai packs".', message) message = npc.build_remove_ai("doesnotexist", self.bob) self.assertEqual('This npc doesn\'t have the "doesnotexist" ai type.', message) message = npc.build_remove_ai("merchant", self.bob) self.assertEqual('Npc 1 (Shiny McShinerson) no longer has merchant ai.', message) message = npc.build_remove_ai("merchant", self.bob) self.assertEqual('This npc doesn\'t have the "merchant" ai type.', message)
def test_chat_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Chat bob = Player(('bob', 'bar')) alice = Player(('alice', 'bar')) sam = Player(('sam', 'bar')) bob.mode = None bob.playerize({'name': 'bob', 'password': '******'}) bob.outq = [] sam.mode = None sam.playerize({'name': 'sam', 'password': '******'}) sam.outq = [] self.world.player_add(bob) self.world.player_add(sam) self.world.player_add(alice) Chat(bob, 'lol, hey guys!', 'chat').run() chat = config.chat_color + 'Bob chats, "lol, hey guys!"' + config.clear_fcolor self.assertTrue(chat in sam.outq) self.assertTrue(chat in bob.outq) self.assertFalse(chat in alice.outq) sam.channels['chat'] = False print sam.channels print bob.channels sam.outq = [] bob.outq = [] alice.outq = [] Chat(bob, 'lol, hey guys!', 'chat').run() print sam.channels print sam.outq print bob.channels print bob.outq self.assertFalse(chat in sam.outq) self.assertTrue(chat in bob.outq) self.assertFalse(chat in alice.outq)
def test_tell_players(self): from shinymud.models.player import Player from shinymud.modes.build_mode import BuildMode from shinymud.modes.init_mode import InitMode from shinymud.data.config import wecho_color, clear_fcolor from shinymud.lib.connection_handlers.shiny_connections import ShinyConnection bob = Player('foo') bob.name = 'bob' alice = Player('foo') alice.name = 'alice' self.world.player_add(bob) self.world.player_add(alice) bob.mode = None bob.outq = [] alice.mode = None alice.outq = [] self.world.tell_players('hello world!') echo = wecho_color + 'hello world!' + clear_fcolor self.assertTrue(echo in bob.outq) self.assertTrue(echo in alice.outq) bob.mode = InitMode(bob) bob.outq = [] alice.outq = [] self.world.tell_players('hello all!') echo = wecho_color + 'hello all!' + clear_fcolor self.assertTrue(echo not in bob.outq) self.assertTrue(echo in alice.outq) bob.mode = BuildMode(bob) bob.outq = [] alice.outq = [] self.world.tell_players('hello!', ['alice']) echo = wecho_color + 'hello!' + clear_fcolor self.assertTrue(echo in bob.outq) self.assertTrue(echo not in alice.outq)
def test_shiny_player_format_containers(self): """Make sure shiny player format still works when player has containers in their inventory. """ from shinymud.lib.sport_plugins.formatters.player_write_shiny_format import format as writeshiny from shinymud.lib.sport_plugins.formatters.player_read_shiny_format import format as readshiny from shinymud.lib.connection_handlers.shiny_connections import ShinyConnection from shinymud.models.player import Player sven = Player(('foo', 'bar')) sven.playerize({'name': 'sven', 'password': '******'}) sven.save() area = self._create_area() item1 = area.new_item() item1.build_set_keywords('item1') item1.build_add_type('container') game1 = item1.load() item2 = area.new_item() item2.build_set_keywords('item2') item2.build_add_type('container') game2 = item2.load() self.assertTrue(game1.item_types['container'].item_add(game2)) item3 = area.new_item() item3.build_set_keywords('item3') game3 = item3.load() self.assertTrue(game2.item_types['container'].item_add(game3)) sven.item_add(game1) txt = writeshiny(sven) self.world.log.debug(txt) sven.destruct() row = self.world.db.select('* from player where name=?', ['sven']) self.assertFalse(row) row = self.world.db.select('* from game_item where owner=?', [sven.dbid]) self.assertFalse(row) result = readshiny(self.world, txt) self.world.log.debug(result) self.assertEqual(result, 'Character "Sven" has been successfully imported.') row = self.world.db.select('* from player where name=?', ['sven'])[0] isven = Player(('foo', 'bar')) isven.playerize(row) self.assertEqual(len(isven.inventory), 1) s1 = isven.inventory[0] self.assertEqual(s1.keywords, ['item1']) s2 = s1.item_types['container'].get_item_by_kw('item2') self.assertEqual(s2.keywords, ['item2']) s3 = s2.item_types['container'].get_item_by_kw('item3') self.assertEqual(s3.keywords, ['item3'])
def test_shiny_player_format(self): from shinymud.lib.sport_plugins.formatters.player_write_shiny_format import format as writeshiny from shinymud.lib.sport_plugins.formatters.player_read_shiny_format import format as readshiny from shinymud.models.player import Player #create a playa sven = Player(('foo', 'bar')) sven.playerize({'name': 'sven', 'password': '******'}) sven.permissions = 17 sven.description = "I'm pretty adorable." sven.title = 'Super Sven' sven.save() area = self._create_area() sven.item_add(area.get_item('1').load()) txt = writeshiny(sven) self.world.log.debug(txt) sven.destruct() # Sven should have been taken out of the database... row = self.world.db.select('* from player where name=?', ['sven']) self.assertFalse(row) row = self.world.db.select('* from game_item where owner=?', [sven.dbid]) self.assertFalse(row) result = readshiny(self.world, txt) self.world.log.debug(result) self.assertEqual(result, 'Character "Sven" has been successfully imported.') # Sven should now be in the database, but not online row = self.world.db.select('* from player where name=?', ['sven'])[0] self.assertTrue(row) self.assertFalse(self.world.get_player('sven')) isven = Player(('foo', 'bar')) isven.playerize(row) row = self.world.db.select('* from game_item where owner=?', [isven.dbid]) self.assertTrue(row) # Make sure that all attributes we set got imported correctly self.assertEqual(sven.password, isven.password) self.assertEqual(sven.description, isven.description) self.assertEqual(sven.name, isven.name) self.assertEqual(sven.title, isven.title) self.assertEqual(sven.permissions, isven.permissions) # Make sure that the inventory was correctly loaded self.assertEqual(len(sven.inventory), len(isven.inventory)) item = isven.inventory[0] self.world.log.debug(item.create_save_dict()) self.world.log.debug(item.item_types) self.assertFalse(sven.inventory[0] is isven.inventory[0]) self.assertEqual(item.name, 'chair') self.assertTrue(item.has_type('furniture')) self.assertEqual(item.item_types['furniture'].capacity, 5)
class TestNpc(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) self.room = self.area.new_room() self.area2 = Area.create({'name': 'SimCity'}) self.area2_script = self.area2.new_script() def tearDown(self): del self.area del self.area2 del self.bob def test_existance(self): """Test if an NPC can exist within an area properly (unspawned)""" self.npc = self.area.new_npc() self.npc.characterize({'name': 'bobert'}) self.assertTrue(self.npc in self.area.npcs.values()) def test_build_add_remove_events(self): npc = self.area.new_npc() fail_message = 'Type "help events" for help with this command.' message = npc.build_add_event('', self.bob) self.assertEqual(message, fail_message) #test for non-existant scripts message = npc.build_add_event('pc_enter call script 1', self.bob) self.assertEqual(message, "Script 1 doesn't exist.") message = npc.build_add_event("hears 'spam' call script 0", self.bob) self.assertEqual(message, "Script 0 doesn't exist.") message = npc.build_add_event("hears 'spam' call script 602", self.bob) self.assertEqual(message, "Script 602 doesn't exist.") script = self.area.new_script() #Test basic add message = npc.build_add_event('pc_enter call script 1', self.bob) self.assertEqual(message, 'Event added.') #Test invalid areas message = npc.build_add_event( 'pc_enter call script 1 from area AreaDontExist', self.bob) self.assertEqual(message, 'Area "AreaDontExist" doesn\'t exist.') message = npc.build_add_event( 'pc_enter call script 1 from area AreaDontExist 100', self.bob) self.assertEqual(message, 'Area "AreaDontExist" doesn\'t exist.') #Test invalid probabilities. message = npc.build_add_event('pc_enter call script 1 0', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') message = npc.build_add_event('pc_enter call script 1 101', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') message = npc.build_add_event('pc_enter call script 1 9999', self.bob) self.assertEqual(message, 'Probability value must be between 1 and 100.') #Test different froms of valid adds. message = npc.build_add_event('pc_enter call script 1 50', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event( 'pc_enter call script 1 from area SimCity', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event( 'pc_enter call script 1 from area SimCity 75', self.bob) self.assertEqual(message, 'Event added.') message = npc.build_add_event('pc_enter call 1 from SimCity 50', self.bob) self.assertEqual(message, 'Event added.') #Test for trigger 'hears' message = npc.build_add_event("hears 'food' call script 1", self.bob) self.assertEqual(message, 'Event added.') #Test for trigger 'emoted' message = npc.build_add_event("emoted 'slap' call script 1", self.bob) self.assertEqual(message, 'Event added.') #Technically invalid, but will be left to user responsibility for now. #(it shouldn't ever cause a crash) message = npc.build_add_event("emoted 'emotedontexist' call script 1", self.bob) self.assertEqual(message, 'Event added.') #Test for new items self.area.new_item() message = npc.build_add_event("given_item 'item 1' call script 1", self.bob) self.assertEqual(message, 'Event added.') #Technically invalid, but will be left to user responsibility for now. #(it shouldn't ever cause a crash) message = npc.build_add_event("given_item 'item 5' call script 1", self.bob) self.assertEqual(message, 'Event added.') #we should now have 5 successfully added events in pc_enter self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter -1", self.bob) self.assertEqual( message, 'Try: "remove event <event-trigger> <event-id>" or see "help npc events".' ) self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter 5", self.bob) self.assertEqual(message, "Npc 1 doesn't have the event pc_enter #5.") self.assertEqual(len(npc.events['pc_enter']), 5) message = npc.build_remove_event("pc_enter 4", self.bob) self.assertEqual(message, 'Event pc_enter, number 4 has been removed.') self.assertEqual(len(npc.events['pc_enter']), 4) message = npc.build_remove_event("given_item 1", self.bob) self.assertEqual(message, 'Event given_item, number 1 has been removed.') self.assertEqual(len(npc.events['pc_enter']), 4) self.assertEqual(len(npc.events['given_item']), 1) def test_build_add_remove_permissions(self): npc = self.area.new_npc() #set npc permissions to nothing. npc.permissions = 0 message = npc.build_add_permission("dm", self.bob) self.assertEqual( message, "You need to be GOD in order to edit an npc's permissions.") #Current permission level needed for messing with npc perms is 'god'. (for when this test was written) #Change as needed! self.bob.permissions = self.bob.permissions | self.PERMS['god'] #Bad input tests message = npc.build_add_permission("", self.bob) self.assertEqual( message, 'Try: "add permission <permission group>". See "help permissions".' ) message = npc.build_add_permission("monkey", self.bob) self.assertTrue( 'Valid permissions are: admin, player, builder, dm, god\n' in message) #good input tests message = npc.build_add_permission("god", self.bob) self.assertTrue( 'Shiny McShinerson now has god permissions.' in message) self.assertTrue(npc.permissions is self.PERMS['god']) message = npc.build_add_permission("dm", self.bob) self.assertTrue('Shiny McShinerson now has dm permissions.' in message) self.assertTrue( npc.permissions is self.PERMS['god'] | self.PERMS['dm']) self.assertTrue(npc.permissions is not self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) message = npc.build_add_permission("admin", self.bob) self.assertTrue( 'Shiny McShinerson now has admin permissions.' in message) self.assertTrue(npc.permissions is self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) #Removing Permissions #reset bobs permissions for next test self.bob.permissions = 0 message = npc.build_remove_permission("dm", self.bob) self.assertEqual( message, "You need to be GOD in order to edit an npc's permissions.") #Current permission level needed for messing with npc perms is 'god'. (for when this test was written) #Change as needed! self.bob.permissions = self.bob.permissions | self.PERMS['god'] #Bad input tests message = npc.build_remove_permission("", self.bob) self.assertEqual( message, 'Try: "remove permission <permission group>", or see "help permissions".' ) message = npc.build_remove_permission("monkey", self.bob) self.assertEqual("Shiny McShinerson doesn't have monkey permissions.", message) #Good input tests self.assertTrue(npc.permissions is self.PERMS['god'] | self.PERMS['dm'] | self.PERMS['admin']) message = npc.build_remove_permission("god", self.bob) self.assertEqual('Shiny McShinerson no longer has god permissions.', message) self.assertTrue( npc.permissions is self.PERMS['dm'] | self.PERMS['admin']) self.assertTrue(npc.permissions < self.PERMS['god']) message = npc.build_remove_permission("dm", self.bob) self.assertEqual('Shiny McShinerson no longer has dm permissions.', message) self.assertTrue(npc.permissions is self.PERMS['admin']) self.assertTrue(npc.permissions >= self.PERMS['dm']) message = npc.build_remove_permission("admin", self.bob) self.assertEqual('Shiny McShinerson no longer has admin permissions.', message) self.assertTrue(npc.permissions is 0) def test_build_add_remove_ai(self): npc = self.area.new_npc() #Test adding ai pack message = npc.build_add_ai("", self.bob) self.assertEqual( 'Try: "add ai <ai-pack-name>", or type "help ai packs".', message) message = npc.build_add_ai("doesnotexist", self.bob) self.assertEqual( '"doesnotexist" is not a valid ai pack. See "help ai packs".', message) message = npc.build_add_ai("merchant", self.bob) self.assertEqual("This npc (Shiny McShinerson) is now a merchant.", message) message = npc.build_add_ai("merchant", self.bob) self.assertEqual( 'This npc (Shiny McShinerson) already has that ai pack.', message) #Test basic add behavior for ai pack message = str(npc) self.assertTrue("MERCHANT ATTRIBUTES:" in message) #Test removing ai pack message = npc.build_remove_ai("", self.bob) self.assertEqual( 'Try: "remove ai <ai-pack-name>", or type "help ai packs".', message) message = npc.build_remove_ai("doesnotexist", self.bob) self.assertEqual('This npc doesn\'t have the "doesnotexist" ai type.', message) message = npc.build_remove_ai("merchant", self.bob) self.assertEqual( 'Npc 1 (Shiny McShinerson) no longer has merchant ai.', message) message = npc.build_remove_ai("merchant", self.bob) self.assertEqual('This npc doesn\'t have the "merchant" ai type.', message)
class TestTextEditMode(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER self.area = Area.create({'name': 'foo'}) def tearDown(self): del self.area def test_help(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() help_msg = " @done - saves your progress and exits the editor.\n" +\ " @cancel - quit the editor without saving changes.\n" +\ " @show - display your progress so far, line by line.\n" +\ " @preview - preview the formatted version of your text.\n" +\ " @clear - clears ALL of your progress, giving you an empty slate.\n" +\ " @delete line# - delete a specific line.\n" +\ " @replace line# new_sentence - replace a line with a new sentence:\n" +\ " e.g. \"@replace 5 My new sentence.\"\n" +\ " @insert line# new_sentence - inserts a sentence at line#:\n" +\ " e.g. \"@insert 1 My new sentence.\"\n" mode = TextEditMode(self.bob, room, 'description', room.description) mode.help() self.assertTrue(help_msg in self.bob.outq) def test_clear(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, 'description', room.description) mode.edit_lines = ['This is a shiny new room!'] mode.clear_description() mode.finish_editing() self.assertEqual(room.description, '') def test_delete_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, 'description', room.description) #Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = [ "This be a shiny room here!", "There be goblins here!", "And a pirate!" ] mode.delete_line(line='2') self.assertEqual(len(mode.edit_lines), 2) mode.finish_editing() self.assertFalse("There be goblins here!" in room.description) #stress testing mode = TextEditMode(self.bob, room, 'description', room.description) mode.delete_line(line='200') self.assertTrue("200 is not a valid line number." in self.bob.outq) #(regular expression parses non-digit input into args instead of line) mode.delete_line(args='YourMother') self.assertTrue( "'YourMother' is not a valid line number." in self.bob.outq) def test_replace_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, 'description', room.description) #Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = [ "This be a shiny room here!", "There be goblins here!", "And a pirate!" ] mode.replace_line(line='2', args='There be spam and eggs here!') self.assertEqual(len(mode.edit_lines), 3) mode.finish_editing() self.assertTrue('There be spam and eggs here!' in room.description) #stress testing mode = TextEditMode(self.bob, room, 'description', room.description) mode.replace_line(line='200') self.assertTrue("200 is not a valid line number." in self.bob.outq) #(regular expression parses non-digit input into args instead of line) mode.replace_line(args='YourMother') self.assertTrue( "'YourMother' is not a valid line number." in self.bob.outq) def test_insert_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, 'description', room.description) #Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = [ "This be a shiny room here!", "There be goblins here!", "And a pirate!" ] mode.insert_line(line='2', args='There be spam and eggs here!') self.assertEqual(len(mode.edit_lines), 4) mode.finish_editing() self.assertTrue('There be spam and eggs here!' in room.description) #stress testing mode = TextEditMode(self.bob, room, 'description', room.description) mode.insert_line(line='200') self.assertTrue("200 is not a valid line number." in self.bob.outq) mode.insert_line(args='YourMother') self.assertTrue( "'YourMother' is not a valid line number." in self.bob.outq) def test_cancel_edit(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, 'description', room.description) mode.edit_lines = [ "This be a shiny room here!", "There be goblins here!", "And a pirate!" ] mode.finish_editing() mode = TextEditMode(self.bob, room, 'description', room.description) mode.insert_line(line='2', args='There be spam and eggs here!') mode.cancel_edit() self.assertFalse('There be spam and eggs here!' in room.description)
class TestTextEditMode(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.bob = Player(("bob", "bar")) self.bob.mode = None self.bob.playerize({"name": "bob"}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | config.BUILDER self.area = Area.create({"name": "foo"}) def tearDown(self): del self.area def test_help(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() help_msg = ( " @done - saves your progress and exits the editor.\n" + " @cancel - quit the editor without saving changes.\n" + " @show - display your progress so far, line by line.\n" + " @preview - preview the formatted version of your text.\n" + " @clear - clears ALL of your progress, giving you an empty slate.\n" + " @delete line# - delete a specific line.\n" + " @replace line# new_sentence - replace a line with a new sentence:\n" + ' e.g. "@replace 5 My new sentence."\n' + " @insert line# new_sentence - inserts a sentence at line#:\n" + ' e.g. "@insert 1 My new sentence."\n' ) mode = TextEditMode(self.bob, room, "description", room.description) mode.help() self.assertTrue(help_msg in self.bob.outq) def test_clear(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, "description", room.description) mode.edit_lines = ["This is a shiny new room!"] mode.clear_description() mode.finish_editing() self.assertEqual(room.description, "") def test_delete_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, "description", room.description) # Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = ["This be a shiny room here!", "There be goblins here!", "And a pirate!"] mode.delete_line(line="2") self.assertEqual(len(mode.edit_lines), 2) mode.finish_editing() self.assertFalse("There be goblins here!" in room.description) # stress testing mode = TextEditMode(self.bob, room, "description", room.description) mode.delete_line(line="200") self.assertTrue("200 is not a valid line number." in self.bob.outq) # (regular expression parses non-digit input into args instead of line) mode.delete_line(args="YourMother") self.assertTrue("'YourMother' is not a valid line number." in self.bob.outq) def test_replace_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, "description", room.description) # Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = ["This be a shiny room here!", "There be goblins here!", "And a pirate!"] mode.replace_line(line="2", args="There be spam and eggs here!") self.assertEqual(len(mode.edit_lines), 3) mode.finish_editing() self.assertTrue("There be spam and eggs here!" in room.description) # stress testing mode = TextEditMode(self.bob, room, "description", room.description) mode.replace_line(line="200") self.assertTrue("200 is not a valid line number." in self.bob.outq) # (regular expression parses non-digit input into args instead of line) mode.replace_line(args="YourMother") self.assertTrue("'YourMother' is not a valid line number." in self.bob.outq) def test_insert_line(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, "description", room.description) # Manually give the room description so we don't depend on the new_room() defaults mode.edit_lines = ["This be a shiny room here!", "There be goblins here!", "And a pirate!"] mode.insert_line(line="2", args="There be spam and eggs here!") self.assertEqual(len(mode.edit_lines), 4) mode.finish_editing() self.assertTrue("There be spam and eggs here!" in room.description) # stress testing mode = TextEditMode(self.bob, room, "description", room.description) mode.insert_line(line="200") self.assertTrue("200 is not a valid line number." in self.bob.outq) mode.insert_line(args="YourMother") self.assertTrue("'YourMother' is not a valid line number." in self.bob.outq) def test_cancel_edit(self): from shinymud.modes.text_edit_mode import TextEditMode room = self.area.new_room() mode = TextEditMode(self.bob, room, "description", room.description) mode.edit_lines = ["This be a shiny room here!", "There be goblins here!", "And a pirate!"] mode.finish_editing() mode = TextEditMode(self.bob, room, "description", room.description) mode.insert_line(line="2", args="There be spam and eggs here!") mode.cancel_edit() self.assertFalse("There be spam and eggs here!" in room.description)
def test_give_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Give area = Area.create({'name': 'blarg'}) room = area.new_room() bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name': 'bob', 'password': '******'}) alice = Player(('alice', 'bar')) alice.mode = None alice.playerize({'name': 'alice', 'password': '******'}) self.world.player_add(bob) self.world.player_add(alice) room.add_char(bob) room.add_char(alice) alice.location = room bob.location = room proto_npc = area.new_npc() npc = proto_npc.load() room.add_char(npc) item = area.new_item() item.build_set_keywords('bauble', bob) item.build_set_name('a bauble', bob) bob.item_add(item.load()) self.assertEqual(len(bob.inventory), 1) Give(bob, 'bauble to alice', 'give').run() self.assertEqual(len(bob.inventory), 0) self.assertEqual(len(alice.inventory), 1) to_alice = 'Bob gives you a bauble.' self.assertTrue(to_alice in alice.outq) to_bob = 'You give a bauble to Alice.' self.assertTrue(to_bob in bob.outq) Give(alice, 'bauble to shiny', 'give').run() self.assertEqual(len(alice.inventory), 0) self.assertEqual(len(npc.inventory), 1) to_alice = 'You give a bauble to %s.' % npc.name alice.world.log.debug(alice.outq) self.assertTrue(to_alice in alice.outq) to_shiny = 'Alice gives you a bauble.' self.assertTrue(to_shiny in npc.actionq) #Test Money bob.currency = 100 com = config.CURRENCY + ' to alice' #Test give one currency unit self.assertEqual(alice.currency, 0) Give(bob, com, 'give').run() self.assertEqual(bob.currency, 99) self.assertEqual(alice.currency, 1) #test give multiple currencies com = '99' + config.CURRENCY + ' to alice' Give(bob, com, 'give').run() self.assertEqual(bob.currency, 0) self.assertEqual(alice.currency, 100) #test give more than bob has com = '1000' + config.CURRENCY + ' to alice' Give(bob, com, 'give').run() self.assertEqual(bob.currency, 0) self.assertEqual(alice.currency, 100)
class TestAiPacks(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS #"bob" is created so we can tell build mode functions which player called them. #We probably don't need bob since this functionality is only important when permissions #are concerned in build commands. We'll create and pass him in anyways for now. self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name': 'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) def tearDown(self): del self.area del self.bob def test_merchant_build_add_remove_item(self): npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] self.area.new_item() #Add items message = ai.build_add_item("", self.bob) self.assertEqual( message, 'Try "add item <item-id> from area <area-name> price <price>" or see "help merchant".' ) message = ai.build_add_item("BLARG", self.bob) self.assertEqual( message, 'Try "add item <item-id> from area <area-name> price <price>" or see "help merchant".' ) message = ai.build_add_item( "1 from area_which_does_not_exist price 20", self.bob) self.assertEqual(message, 'Area "area_which_does_not_exist" doesn\'t exist.') message = ai.build_add_item("2 from foo price 20", self.bob) self.assertEqual(message, "Item 2 doesn't exist.") message = ai.build_add_item("1 from foo price 30", self.bob) self.assertEqual(message, "Merchant now sells New Item.") #remove items message = ai.build_remove_item("", self.bob) self.assertEqual( message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("BLARG", self.bob) self.assertEqual( message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("6203", self.bob) self.assertEqual(message, "That item doesn't exist.") message = ai.build_remove_item("0", self.bob) self.assertEqual(message, "That item doesn't exist.") message = ai.build_remove_item("-1", self.bob) self.assertEqual( message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("1", self.bob) self.assertEqual(message, 'Merchant no longer sells New Item.') #Clean up everything in the area so future tests don't have problems self.area.destroy_npc(1) self.area.destroy_item(1) def test_merchant_build_add_remove_types(self): #We'll need a merchant npc for this test! npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] #Test adding types with good and bad user input. tests = { "": 'Try "add type <item-type>", or see "help merchant".', "BLARG": 'blarg is not a valid item type. See "help merchant" for details.', 'equippable': 'Merchant will now buy items of type equippable from players.', 'plain': 'Merchant will now buy items of type plain from players.' } for (input_m, output_m) in tests.iteritems(): self.assertEqual(ai.build_add_type(input_m, self.bob), output_m) #Test user input for removing types. Note: We test these inputs below with two #input types already added from the tests above. (equippable and plain) tests = { "": 'Try "remove type <item-type>", or see "help merchant".', "BLARG": 'blarg is not a valid item type. See "help merchant" for details.', "equippable": 'Merchant no longer buys items of type equippable.', "plain": 'Merchant no longer buys items of type plain.' } for (input_m, output_m) in tests.iteritems(): self.assertEqual(ai.build_remove_type(input_m, self.bob), output_m) #test trying to remove a vaild item type again, after we already did. message = ai.build_remove_type("equippable", self.bob) self.assertEqual( message, "Merchant already doesn't buy items of type equippable.") #cleanup for additional tests self.area.destroy_npc(1) self.area.destroy_item(1) def test_merchant_volatile_items(self): #Merchants can sell items from different areas, which can be #destroyed or re-imported/recreated at random. Make sure that #Merchants can still keep track of items amidst such chaos! from shinymud.models.area import Area #Create our merchant npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] #Create our area, with which we will have our missing 'dead item' area2 = Area.create({'name': 'bar'}) item = area2.new_item() item.name = 'trucknuts' item.save() #add item to area, make sure it added correctly message = ai.build_add_item('1 from area bar price 2000') self.assertEqual(message, 'Merchant now sells trucknuts.') self.assertEqual(item, ai.sale_items.verify_item(ai.sale_items.live[0])) self.assertEqual([], ai.sale_items.dead) #Destroy the area, with the item we're selling. self.world.destroy_area('bar', self.bob) self.assertFalse(self.world.area_exists('bar')) #ask for a copy of the merch list, make sure the item is not still #trying to be sold (dead) ai.sale_items.merch_list() # updates live,dead lists self.assertEqual([], ai.sale_items.live) self.assertTrue('trucknuts' in ai.sale_items.dead[0].values()) #Recreate the same area and item area2 = Area.create({'name': 'bar'}) item = area2.new_item() item.name = 'trucknuts' item.save() #Update the list. Our item should be resurrected! ai.sale_items.merch_list() self.assertTrue('trucknuts' in ai.sale_items.live[0].values()) self.assertEqual([], ai.sale_items.dead)
def test_give_command(self): from shinymud.models.area import Area from shinymud.data import config from shinymud.models.player import Player from shinymud.commands.commands import Give area = Area.create({'name':'blarg'}) room = area.new_room() bob = Player(('bob', 'bar')) bob.mode = None bob.playerize({'name':'bob', 'password':'******'}) alice = Player(('alice', 'bar')) alice.mode = None alice.playerize({'name':'alice', 'password':'******'}) self.world.player_add(bob) self.world.player_add(alice) room.add_char(bob) room.add_char(alice) alice.location = room bob.location = room proto_npc = area.new_npc() npc = proto_npc.load() room.add_char(npc) item = area.new_item() item.build_set_keywords('bauble', bob) item.build_set_name('a bauble', bob) bob.item_add(item.load()) self.assertEqual(len(bob.inventory), 1) Give(bob, 'bauble to alice', 'give').run() self.assertEqual(len(bob.inventory), 0) self.assertEqual(len(alice.inventory), 1) to_alice = 'Bob gives you a bauble.' self.assertTrue(to_alice in alice.outq) to_bob = 'You give a bauble to Alice.' self.assertTrue(to_bob in bob.outq) Give(alice, 'bauble to shiny', 'give').run() self.assertEqual(len(alice.inventory), 0) self.assertEqual(len(npc.inventory), 1) to_alice = 'You give a bauble to %s.' % npc.name alice.world.log.debug(alice.outq) self.assertTrue(to_alice in alice.outq) to_shiny = 'Alice gives you a bauble.' self.assertTrue(to_shiny in npc.actionq) #Test Money bob.currency = 100 com = config.CURRENCY + ' to alice' #Test give one currency unit self.assertEqual(alice.currency, 0) Give(bob, com, 'give').run() self.assertEqual(bob.currency, 99) self.assertEqual(alice.currency, 1) #test give multiple currencies com = '99' + config.CURRENCY + ' to alice' Give(bob, com, 'give').run() self.assertEqual(bob.currency, 0) self.assertEqual(alice.currency, 100) #test give more than bob has com = '1000' + config.CURRENCY + ' to alice' Give(bob, com, 'give').run() self.assertEqual(bob.currency, 0) self.assertEqual(alice.currency, 100)
class TestAiPacks(ShinyTestCase): def setUp(self): ShinyTestCase.setUp(self) from shinymud.models.player import Player from shinymud.models.npc import Npc from shinymud.models.area import Area from shinymud.models.room import Room from shinymud.modes.build_mode import BuildMode from shinymud.data import config self.PERMS = config.PERMS #"bob" is created so we can tell build mode functions which player called them. #We probably don't need bob since this functionality is only important when permissions #are concerned in build commands. We'll create and pass him in anyways for now. self.bob = Player(('bob', 'bar')) self.bob.mode = None self.bob.playerize({'name':'bob'}) self.world.player_add(self.bob) self.bob.mode = BuildMode(self.bob) self.bob.permissions = self.bob.permissions | self.PERMS['builder'] self.area = Area.create({'name': 'foo'}) def tearDown(self): del self.area del self.bob def test_merchant_build_add_remove_item(self): npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] self.area.new_item() #Add items message = ai.build_add_item("", self.bob) self.assertEqual(message, 'Try "add item <item-id> from area <area-name> price <price>" or see "help merchant".') message = ai.build_add_item("BLARG", self.bob) self.assertEqual(message, 'Try "add item <item-id> from area <area-name> price <price>" or see "help merchant".') message = ai.build_add_item("1 from area_which_does_not_exist price 20", self.bob) self.assertEqual(message, 'Area "area_which_does_not_exist" doesn\'t exist.') message = ai.build_add_item("2 from foo price 20", self.bob) self.assertEqual(message, "Item 2 doesn't exist.") message = ai.build_add_item("1 from foo price 30", self.bob) self.assertEqual(message, "Merchant now sells New Item.") #remove items message = ai.build_remove_item("", self.bob) self.assertEqual(message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("BLARG", self.bob) self.assertEqual(message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("6203", self.bob) self.assertEqual(message, "That item doesn't exist.") message = ai.build_remove_item("0", self.bob) self.assertEqual(message, "That item doesn't exist.") message = ai.build_remove_item("-1", self.bob) self.assertEqual(message, 'Try "remove item <item-id>", or see "help merchant".') message = ai.build_remove_item("1", self.bob) self.assertEqual(message, 'Merchant no longer sells New Item.') #Clean up everything in the area so future tests don't have problems self.area.destroy_npc(1) self.area.destroy_item(1) def test_merchant_build_add_remove_types(self): #We'll need a merchant npc for this test! npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] #Test adding types with good and bad user input. tests = { "": 'Try "add type <item-type>", or see "help merchant".', "BLARG": 'blarg is not a valid item type. See "help merchant" for details.', 'equippable': 'Merchant will now buy items of type equippable from players.', 'plain': 'Merchant will now buy items of type plain from players.' } for (input_m, output_m) in tests.iteritems(): self.assertEqual(ai.build_add_type(input_m, self.bob), output_m) #Test user input for removing types. Note: We test these inputs below with two #input types already added from the tests above. (equippable and plain) tests = { "":'Try "remove type <item-type>", or see "help merchant".', "BLARG":'blarg is not a valid item type. See "help merchant" for details.', "equippable":'Merchant no longer buys items of type equippable.', "plain":'Merchant no longer buys items of type plain.' } for (input_m, output_m) in tests.iteritems(): self.assertEqual(ai.build_remove_type(input_m, self.bob), output_m) #test trying to remove a vaild item type again, after we already did. message = ai.build_remove_type("equippable", self.bob) self.assertEqual(message, "Merchant already doesn't buy items of type equippable.") #cleanup for additional tests self.area.destroy_npc(1) self.area.destroy_item(1) def test_merchant_volatile_items(self): #Merchants can sell items from different areas, which can be #destroyed or re-imported/recreated at random. Make sure that #Merchants can still keep track of items amidst such chaos! from shinymud.models.area import Area #Create our merchant npc = self.area.new_npc() npc.build_add_ai("merchant", self.bob) ai = npc.ai_packs['merchant'] #Create our area, with which we will have our missing 'dead item' area2 = Area.create({'name':'bar'}) item = area2.new_item() item.name = 'trucknuts' item.save() #add item to area, make sure it added correctly message = ai.build_add_item('1 from area bar price 2000') self.assertEqual(message, 'Merchant now sells trucknuts.') self.assertEqual(item, ai.sale_items.verify_item(ai.sale_items.live[0])) self.assertEqual([], ai.sale_items.dead) #Destroy the area, with the item we're selling. self.world.destroy_area('bar', self.bob) self.assertFalse(self.world.area_exists('bar')) #ask for a copy of the merch list, make sure the item is not still #trying to be sold (dead) ai.sale_items.merch_list() # updates live,dead lists self.assertEqual([], ai.sale_items.live) self.assertTrue('trucknuts' in ai.sale_items.dead[0].values()) #Recreate the same area and item area2 = Area.create({'name':'bar'}) item = area2.new_item() item.name = 'trucknuts' item.save() #Update the list. Our item should be resurrected! ai.sale_items.merch_list() self.assertTrue('trucknuts' in ai.sale_items.live[0].values()) self.assertEqual([], ai.sale_items.dead)