Example #1
0
 def test_get_distance_to_body(self):
     map = create_map('Test', 10, 10, 'Floor')
     map.add_object(self.obj, 5, 5)        
     obj = Object('Simple')
     
     # simple
             
     simple = Simple()
     obj.add_component(simple)
     
     for j in range(-2, 5):
         for k in range(-2, 5):
             map.add_object(obj, 5 + j, 5 + k)
             
             self.assertEqual(self.body.get_distance_to_body(simple), int(math.fabs(j) + math.fabs(k)))
             
     # big
     
     big = Big(3)
     obj.add_component(big)
     
     map.add_object(obj, 2, 2)
     self.assertEqual(self.body.get_distance_to_body(big), 2)
     
     map.add_object(obj, 6, 2)
     self.assertEqual(self.body.get_distance_to_body(big), 2)
     
     map.add_object(obj, 2, 6)
     self.assertEqual(self.body.get_distance_to_body(big), 2)
     
     map.add_object(obj, 6, 6)
     self.assertEqual(self.body.get_distance_to_body(big), 2)
     
     map.add_object(obj, 0, 0)
     self.assertEqual(self.body.get_distance_to_body(big), 6)            
Example #2
0
 def test_add_component(self):
     obj = Object('Test')        
     component0 = Body()
     component1 = Body()
     component2 = Inventory()
     component3 = Inventory()
     
     obj.add_component(component0)
     
     self.assertEqual(len(obj.components), 0)
     self.assertEqual(obj.body, component0)
     self.assertNotEqual(obj.body, component1)
     
     obj.add_component(component1)
     
     self.assertEqual(len(obj.components), 0)
     self.assertNotEqual(obj.body, component0)
     self.assertEqual(obj.body, component1)
     
     obj.add_component(component2)
     
     self.assertEqual(len(obj.components), 1)
     self.assertEqual(obj.components['Inventory'], component2)
     self.assertNotEqual(obj.components['Inventory'], component3)
     
     obj.add_component(component3)
     
     self.assertEqual(len(obj.components), 1)
     self.assertNotEqual(obj.components['Inventory'], component2)
     self.assertEqual(obj.components['Inventory'], component3)
Example #3
0
 def setUp(self):
     self.obj = Object('Test')
     self.body = Big(2)
     self.obj.add_component(self.body)
     create_celltype('Floor', False, False)
     create_celltype('Wall', True, False)
     self.map = create_map('Test', 10, 10, 'Floor')
Example #4
0
class SimpleTest(unittest.TestCase):
    
    def setUp(self):
        self.obj = Object('Test')
        self.body = Big(2)
        self.obj.add_component(self.body)
        create_celltype('Floor', False, False)
        create_celltype('Wall', True, False)
        self.map = create_map('Test', 10, 10, 'Floor')
    
    def check(self, x, y):
        self.assertEqual(self.body.x, x)
        self.assertEqual(self.body.y, y)
                
        self.assertEquals(len(self.body.occupied_cells), 4)
        
        for j in range(0, 9):
            for k in range(0, 9):
                cell = self.map.get_cell(j, k)
                if (j is x or j is x + 1) and (k is y or k is y + 1):
                    self.assertTrue(cell in self.body.occupied_cells)
                    self.assertTrue(self.obj in cell.objects)
                else:
                    self.assertFalse(cell in self.body.occupied_cells)
                    self.assertFalse(self.obj in cell.objects)
    
    def test_get_occupied_cells(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        for x in range(0, 9):
            for y in range(0, 9):
                self.body.add_to_map(self.map, x, y)
                cells = self.body.get_occupied_cells()
                
                self.assertEquals(len(cells), 4)
                self.assertTrue(self.map.get_cell(x, y) in cells)
                self.assertTrue(self.map.get_cell(x, y + 1) in cells)
                self.assertTrue(self.map.get_cell(x + 1, y) in cells)
                self.assertTrue(self.map.get_cell(x + 1, y + 1) in cells)
    
    # add
    
    def test_add_to_map(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        # inside
        
        for x in range(0, 9):
            for y in range(0, 9):
                self.assertTrue(self.body.add_to_map(self.map, x, y))
                
                self.check(x, y)
                
        
        # outside
        
        self.assertFalse(self.body.add_to_map(self.map, -1, -1))
        self.assertFalse(self.body.add_to_map(self.map, 9, -1))
        self.assertFalse(self.body.add_to_map(self.map, -1, 9))
        self.assertFalse(self.body.add_to_map(self.map, 9, 9))
        
        self.check(8, 8)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.assertFalse(self.body.add_to_map(self.map, 5, 5))
        self.assertFalse(self.body.add_to_map(self.map, 4, 5))
        self.assertFalse(self.body.add_to_map(self.map, 5, 4))
        self.assertFalse(self.body.add_to_map(self.map, 4, 4))
        
        self.check(8, 8)
    
    def test_map_add_object(self):
        self.map = create_map('Test', 10, 10, 'Floor') 
        
        # inside
        
        for x in range(0, 9):
            for y in range(0, 9):
                self.assertTrue(self.map.add_object(self.obj, x, y))
                
                self.check(x, y)
        
        # outside
        
        self.assertFalse(self.map.add_object(self.obj, -1, 0))
        self.assertFalse(self.map.add_object(self.obj, 0, -1))
        self.assertFalse(self.map.add_object(self.obj, 10, 9))
        self.assertFalse(self.map.add_object(self.obj, 9, 10))
        
        self.check(8, 8)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.assertFalse(self.map.add_object(self.obj, 5, 5))
        self.assertFalse(self.map.add_object(self.obj, 4, 5))
        self.assertFalse(self.map.add_object(self.obj, 5, 4))
        self.assertFalse(self.map.add_object(self.obj, 4, 4))
        
        self.check(8, 8)
    
    # move
    
    def test_move(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        self.map.add_object(self.obj, 0, 0)
        
        # inside
        
        self.assertTrue(self.body.move(1))
        self.check(1, 0)
                
        self.assertTrue(self.body.move(0))
        self.check(1, 1)
        
        self.assertTrue(self.body.move(3))
        self.check(0, 1)
        
        self.assertTrue(self.body.move(2))
        self.check(0, 0)
        
        # outside
        
        self.assertFalse(self.body.move(3))     
        self.check(0, 0)           
        self.assertFalse(self.body.move(2))
        self.check(0, 0)
        
        self.map.add_object(self.obj, 8, 8)
        
        self.assertFalse(self.body.move(1))
        self.check(8, 8)
        self.assertFalse(self.body.move(0))
        self.check(8, 8)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.map.add_object(self.obj, 3, 5)        
        self.assertFalse(self.body.move(1))
        self.check(3, 5)
        
        self.map.add_object(self.obj, 3, 4)        
        self.assertFalse(self.body.move(1))
        self.check(3, 4)
        
        self.map.add_object(self.obj, 6, 5)        
        self.assertFalse(self.body.move(3))
        self.check(6, 5)
        
        self.map.add_object(self.obj, 6, 4)        
        self.assertFalse(self.body.move(3))
        self.check(6, 4)
        
        self.map.add_object(self.obj, 5, 3)        
        self.assertFalse(self.body.move(0))
        self.check(5, 3)
        
        self.map.add_object(self.obj, 4, 3)        
        self.assertFalse(self.body.move(0))
        self.check(4, 3)
        
        self.map.add_object(self.obj, 5, 6)        
        self.assertFalse(self.body.move(2))
        self.check(5, 6)
        
        self.map.add_object(self.obj, 4, 6)        
        self.assertFalse(self.body.move(2))
        self.check(4, 6)
    
    """def test_objects_move(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        self.map.add_object(self.obj, 0, 0)
        
        # inside
        
        self.assertTrue(self.obj.move(1))
        self.check(1, 0)
                
        self.assertTrue(self.obj.move(0))
        self.check(1, 1)
        
        self.assertTrue(self.obj.move(3))
        self.check(0, 1)
        
        self.assertTrue(self.obj.move(2))
        self.check(0, 0)
        
        # outside
        
        self.assertFalse(self.obj.move(3))     
        self.check(0, 0)           
        self.assertFalse(self.obj.move(2))
        self.check(0, 0)
        
        self.map.add_object(self.obj, 8, 8)
        
        self.assertFalse(self.obj.move(1))
        self.check(8, 8)
        self.assertFalse(self.obj.move(0))
        self.check(8, 8)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.map.add_object(self.obj, 3, 5)        
        self.assertFalse(self.obj.move(1))
        self.check(3, 5)
        
        self.map.add_object(self.obj, 3, 4)        
        self.assertFalse(self.obj.move(1))
        self.check(3, 4)
        
        self.map.add_object(self.obj, 6, 5)        
        self.assertFalse(self.obj.move(3))
        self.check(6, 5)
        
        self.map.add_object(self.obj, 6, 4)        
        self.assertFalse(self.obj.move(3))
        self.check(6, 4)
        
        self.map.add_object(self.obj, 5, 3)        
        self.assertFalse(self.obj.move(0))
        self.check(5, 3)
        
        self.map.add_object(self.obj, 4, 3)        
        self.assertFalse(self.obj.move(0))
        self.check(4, 3)
        
        self.map.add_object(self.obj, 5, 6)        
        self.assertFalse(self.obj.move(2))
        self.check(5, 6)
        
        self.map.add_object(self.obj, 4, 6)        
        self.assertFalse(self.obj.move(2))
        self.check(4, 6)"""
    
    # remove
    
    def test_remove_from_map(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        for x in range(0, 9):
            for y in range(0, 9):
                self.body.add_to_map(self.map, x, y)        
                self.body.remove_from_map()
                
                self.assertEqual(self.body.map, None)
                self.assertEqual(self.body.x, None)
                self.assertEqual(self.body.y, None)
                self.assertEquals(len(self.body.occupied_cells), 0)
                
                self.assertFalse(self.obj in self.map.get_cell(x, y).objects)
                self.assertFalse(self.obj in self.map.get_cell(x, y + 1).objects)
                self.assertFalse(self.obj in self.map.get_cell(x + 1, y).objects)
                self.assertFalse(self.obj in self.map.get_cell(x + 1, y + 1).objects)
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.assertFalse(self.obj in self.map.get_cell(x, y).objects)
Example #5
0
 def setUp(self):
     self.obj = Object('Test')
     self.body = Simple()
     self.obj.add_component(self.body)
     create_celltype('Floor', False, False)
     create_celltype('Wall', True, False)
Example #6
0
class SimpleTest(unittest.TestCase):
    
    def setUp(self):
        self.obj = Object('Test')
        self.body = Simple()
        self.obj.add_component(self.body)
        create_celltype('Floor', False, False)
        create_celltype('Wall', True, False)
        
    def check(self, x, y):
        self.assertEqual(self.body.x, x)
        self.assertEqual(self.body.y, y)
        
        self.assertTrue(self.obj in self.map.get_cell(x, y).objects)
        
        for j in range(0, 10):
            for k in range(0, 10):
                cell = self.map.get_cell(j, k)
                if j is not x and k is not y:
                    self.assertFalse(self.obj in cell.objects)     
    
    def test_get_distance_to_body(self):
        map = create_map('Test', 10, 10, 'Floor')
        map.add_object(self.obj, 5, 5)        
        obj = Object('Simple')
        
        # simple
                
        simple = Simple()
        obj.add_component(simple)
        
        for j in range(-2, 5):
            for k in range(-2, 5):
                map.add_object(obj, 5 + j, 5 + k)
                
                self.assertEqual(self.body.get_distance_to_body(simple), int(math.fabs(j) + math.fabs(k)))
                
        # big
        
        big = Big(3)
        obj.add_component(big)
        
        map.add_object(obj, 2, 2)
        self.assertEqual(self.body.get_distance_to_body(big), 2)
        
        map.add_object(obj, 6, 2)
        self.assertEqual(self.body.get_distance_to_body(big), 2)
        
        map.add_object(obj, 2, 6)
        self.assertEqual(self.body.get_distance_to_body(big), 2)
        
        map.add_object(obj, 6, 6)
        self.assertEqual(self.body.get_distance_to_body(big), 2)
        
        map.add_object(obj, 0, 0)
        self.assertEqual(self.body.get_distance_to_body(big), 6)            
    
    def test_get_occupied_cells(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.body.add_to_map(self.map, x, y)
                cells = self.body.get_occupied_cells()
                
                self.assertEquals(len(cells), 1)
                self.assertEquals(cells[0], self.map.get_cell(x, y))
    
    def test_get_size(self):
        self.assertEqual(self.body.get_size(), 1)
    
    def test_get_type(self):
        self.assertEqual(self.body.get_type(), 'Body')
    
    # add
    
    def test_add_to_map(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        # inside
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.assertTrue(self.body.add_to_map(self.map, x, y))
                
                self.check(x, y)
        
        # outside
        
        self.assertFalse(self.body.add_to_map(self.map, -1, 0))
        self.assertFalse(self.body.add_to_map(self.map, 0, -1))
        self.assertFalse(self.body.add_to_map(self.map, 10, 9))        
        self.assertFalse(self.body.add_to_map(self.map, 9, 10))
        
        self.check(9, 9)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        self.assertFalse(self.body.add_to_map(self.map, 5, 5))
        
        self.check(9, 9)
    
    def test_map_add_object(self):
        self.map = create_map('Test', 10, 10, 'Floor') 
        
        # inside
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.assertTrue(self.map.add_object(self.obj, x, y))
                
                self.check(x, y)
        
        # outside
        
        self.assertFalse(self.map.add_object(self.obj, -1, 0))
        self.assertFalse(self.map.add_object(self.obj, 0, -1))
        self.assertFalse(self.map.add_object(self.obj, 10, 9))
        self.assertFalse(self.map.add_object(self.obj, 9, 10))
        
        self.check(9, 9)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        self.assertFalse(self.map.add_object(self.obj, 5, 5))
        
        self.check(9, 9)
    
    # move
    
    def test_move(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        self.map.add_object(self.obj, 0, 0)
        
        # inside
        
        self.assertTrue(self.body.move(1))
        self.check(1, 0)
                
        self.assertTrue(self.body.move(0))
        self.check(1, 1)
        
        self.assertTrue(self.body.move(3))
        self.check(0, 1)
        
        self.assertTrue(self.body.move(2))
        self.check(0, 0)
        
        # outside
        
        self.assertFalse(self.body.move(3))
        self.check(0, 0)                
        self.assertFalse(self.body.move(2))
        self.check(0, 0)
        
        self.map.add_object(self.obj, 9, 9)
        
        self.assertFalse(self.body.move(1))
        self.check(9, 9)        
        self.assertFalse(self.body.move(0))
        self.check(9, 9)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.map.add_object(self.obj, 4, 5)        
        self.assertFalse(self.body.move(1))
        self.check(4, 5)
        
        self.map.add_object(self.obj, 6, 5)        
        self.assertFalse(self.body.move(3))
        self.check(6, 5)
        
        self.map.add_object(self.obj, 5, 4)        
        self.assertFalse(self.body.move(0))
        self.check(5, 4)
        
        self.map.add_object(self.obj, 5, 6)        
        self.check(5, 6)
    
    """def test_objects_move(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        self.map.add_object(self.obj, 0, 0)
        
        # inside
        
        self.assertTrue(self.obj.move(1))
        self.check(1, 0)
                
        self.assertTrue(self.obj.move(0))
        self.check(1, 1)
        
        self.assertTrue(self.obj.move(3))
        self.check(0, 1)
        
        self.assertTrue(self.obj.move(2))
        self.check(0, 0)
        
        # outside
        
        self.assertFalse(self.obj.move(3))
        self.check(0, 0)                
        self.assertFalse(self.obj.move(2))
        self.check(0, 0)
        
        self.map.add_object(self.obj, 9, 9)
        
        self.assertFalse(self.obj.move(1))
        self.check(9, 9)        
        self.assertFalse(self.obj.move(0))
        self.check(9, 9)
        
        # solid
        
        self.map.get_cell(5, 5).celltype = get_celltype('Wall')
        
        self.map.add_object(self.obj, 4, 5)        
        self.assertFalse(self.obj.move(1))
        self.check(4, 5)
        
        self.map.add_object(self.obj, 6, 5)        
        self.assertFalse(self.obj.move(3))
        self.check(6, 5)
        
        self.map.add_object(self.obj, 5, 4)        
        self.assertFalse(self.obj.move(0))
        self.check(5, 4)
        
        self.map.add_object(self.obj, 5, 6)        
        self.check(5, 6)"""
    
    # remove
    
    def test_remove_from_map(self):
        self.map = create_map('Test', 10, 10, 'Floor')
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.body.add_to_map(self.map, x, y)        
                self.body.remove_from_map()
                
                self.assertEqual(self.body.map, None)
                self.assertEqual(self.body.x, None)
                self.assertEqual(self.body.y, None)
                
                cell = self.map.get_cell(x, y)
                
                self.assertFalse(self.obj in cell.objects)
        
        for x in range(0, 10):
            for y in range(0, 10):
                self.assertFalse(self.obj in self.map.get_cell(x, y).objects)
Example #7
0
 def create_object(self):
     obj = Object(self.name + '_' + str(self.count))
 
     for type, data in self.components.iteritems():
         if type == 'Ai':
             obj.add_component(Ai(data['behavior']))
         elif type == 'Armor':
             obj.add_component(Armor(data))
         elif type == 'Body':
             if data['type'] == 'Big':
                 obj.add_component(Big(int(data['size']), data['tile']))
             elif data['type'] == 'Simple':
                 obj.add_component(Simple(data['tile']))
             elif data['type'] == 'Snake':
                 obj.add_component(Snake(int(data['length']), data['head_tile'], data['tail_tile']))
         elif type == 'Character':
             obj.add_component(Character(data))
         elif type == 'Consumable':
             obj.add_component(Consumable(data))
         elif type == 'Description':
             obj.add_component(Description(data))
         elif type == 'Equipment':
             obj.add_component(Equipment(data))
         elif type == 'EquipmentSlots':
             obj.add_component(EquipmentSlots(data))
         elif type == 'Health':
             obj.add_component(Health(data))
         elif type == 'Perception':
             obj.add_component(Perception(data))
         elif type == 'Weapon':
             obj.add_component(Weapon(data))
         elif type == 'Inventory':
             obj.add_component(Inventory())
         else:
             return  
 
     self.count = self.count + 1
     add_object(obj)
     return obj