class SimpleBody_can_move_Test(unittest.TestCase):

    def setUp(self):
        self.type0 = CellType('Test', False, 'Test')
        self.type1 = CellType('Test', True, 'Test')
        self.map = Map()
        self.map.create(4, 4, self.type0)    
    
    def test_invalid_direction(self): 
        body = SimpleBody(None)  
        body.add_to_map(self.map, 0, 0)   
          
        self.assertFalse(body.can_move(4))  
        self.assertFalse(body.can_move(-1))
        self.assertFalse(body.can_move(None)) 
    
    def test_without_map(self):
        body = SimpleBody(None)     
           
        self.assertFalse(body.can_move(0))
        self.assertFalse(body.can_move(1))
        self.assertFalse(body.can_move(2))
        self.assertFalse(body.can_move(3))
    
    def test_can_move(self):
        body = SimpleBody(None)  
        body.add_to_map(self.map, 1, 1)  
        
        self.assertTrue(body.can_move(0))          
        self.assertTrue(body.can_move(1))  
        self.assertTrue(body.can_move(2))  
        self.assertTrue(body.can_move(3))                 
        
    def test_border(self): 
        body = SimpleBody(None)  
        body.add_to_map(self.map, 0, 0)
        
        self.assertFalse(body.can_move(2))  
        self.assertFalse(body.can_move(3))  
        
        body.add_to_map(self.map, 3, 3)  
        
        self.assertFalse(body.can_move(0))  
        self.assertFalse(body.can_move(1))  
        
    def test_solid_cell(self): 
        body = SimpleBody(None)         
        self.map.get_cell(1, 1).type = self.type1
        
        body.add_to_map(self.map, 1, 0) 
        self.assertFalse(body.can_move(0))  
        
        body.add_to_map(self.map, 0, 1) 
        self.assertFalse(body.can_move(1))
        
        body.add_to_map(self.map, 1, 2) 
        self.assertFalse(body.can_move(2))
        
        body.add_to_map(self.map, 2, 1) 
        self.assertFalse(body.can_move(3))       
class SimpleBody_add_to_map_Test(unittest.TestCase):

    def setUp(self):
        self.type0 = CellType('Test', False, 'Test')
        self.type1 = CellType('Test', True, 'Test')
        self.map = Map()
        self.map.create(4, 4, self.type0) 
    
    def test_add_to_map(self):   
        body = SimpleBody(None)
        self.assertTrue(body.add_to_map(self.map, 1, 2))
        self.assertEqual(body.x, 1)  
        self.assertEqual(body.y, 2)  
        self.assertEqual(body.map, self.map)  
    
    def test_occupied(self):
        body0 = SimpleBody(None)
        body0.object = 1
        body0.add_to_map(self.map, 1, 2)
        
        body1 = SimpleBody(None)
        body1.object = 2
        
        self.assertFalse(body1.add_to_map(self.map, 1, 2))
        self.assertEqual(body1.x, None)  
        self.assertEqual(body1.y, None)  
        self.assertEqual(body1.map, None)  
        self.assertEqual(self.map.get_cell(1, 2).creature, 1) 
     
    def test_invalid_cell(self):   
        body = SimpleBody(None)
        self.assertFalse(body.add_to_map(self.map, -1, 0))
        self.assertEqual(body.x, None)  
        self.assertEqual(body.y, None)  
        self.assertEqual(body.map, None)  
    
    def test_solid_cell(self):           
        self.map.get_cell(0, 0).type = self.type1
        
        body = SimpleBody(None)
        self.assertFalse(body.add_to_map(self.map, 0, 0)) 
        self.assertEqual(body.x, None)  
        self.assertEqual(body.y, None)  
        self.assertEqual(body.map, None) 
        self.assertEqual(self.map.get_cell(0, 0).creature, None)         
Esempio n. 3
0
class Map_Test(unittest.TestCase):

    def setUp(self):
        self.type = CellType('Test', False, 'Test')
        self.map = Map()
        self.map.create(2, 4, self.type)          
    
    def test_create(self):
        self.assertEqual(self.map.width, 2)
        self.assertEqual(self.map.height, 4)
        
        for x in range(0, 2):
            for y in range(0, 4):
                cell = self.map.cells[(x,y)]
                self.assertEqual(cell.x, x)
                self.assertEqual(cell.y, y)
                self.assertEqual(cell.type, self.type)

    def test_get_cell(self):
        for x in range(0, 2):
            for y in range(0, 4):
                self.assertEqual(self.map.get_cell(x,y), self.map.cells[(x,y)])  
        
        self.assertEqual(self.map.get_cell(-1,0), None)   
        self.assertEqual(self.map.get_cell(0,-1), None)   
        self.assertEqual(self.map.get_cell(100,0), None)   
        self.assertEqual(self.map.get_cell(0,100), None)   
        self.assertEqual(self.map.get_cell(0,None), None)   
        self.assertEqual(self.map.get_cell(None,0), None)                         
 def setUp(self):
     self.type0 = CellType('Test', False, 'Test')
     self.type1 = CellType('Test', True, 'Test')
     self.map = Map()
     self.map.create(4, 4, self.type0)    
Esempio n. 5
0
class SimpleBody_move_Test(unittest.TestCase):

    def setUp(self):
        self.type0 = CellType('Test', False, 'Test')
        self.type1 = CellType('Test', True, 'Test')
        self.map = Map()
        self.map.create(4, 4, self.type0)    
    
    def test_without_map(self):
        body = SimpleBody(None)        
        self.assertFalse(body.move(0))
        self.assertFalse(body.move(1))
        self.assertFalse(body.move(2))
        self.assertFalse(body.move(3))
    
    def test_occupied(self):
        body0 = SimpleBody(None)   
        body0.object = 1 
        body0.add_to_map(self.map, 1, 1)  
        
        body1 = SimpleBody(None) 
        body1.object = 2              
        body1.add_to_map(self.map, 1, 0) 
        
        self.assertFalse(body1.move(0))   
        self.assertEqual(body1.x, 1)  
        self.assertEqual(body1.y, 0)  
        self.assertEqual(self.map.get_cell(1, 0).creature, 2) 
        
        self.assertEqual(body0.x, 1)  
        self.assertEqual(body0.y, 1)  
        self.assertEqual(self.map.get_cell(1, 1).creature, 1) 
    
    def test_move(self):
        body = SimpleBody(None)  
        body.add_to_map(self.map, 0, 0)  
        
        self.assertTrue(body.move(0))  
        self.assertEqual(body.x, 0)  
        self.assertEqual(body.y, 1)  
        self.assertEqual(body.map, self.map) 
        
        self.assertTrue(body.move(1))  
        self.assertEqual(body.x, 1)  
        self.assertEqual(body.y, 1)  
        self.assertEqual(body.map, self.map) 
        
        self.assertTrue(body.move(2))  
        self.assertEqual(body.x, 1)  
        self.assertEqual(body.y, 0)  
        self.assertEqual(body.map, self.map)      
        
        self.assertTrue(body.move(3))  
        self.assertEqual(body.x, 0)  
        self.assertEqual(body.y, 0)  
        self.assertEqual(body.map, self.map) 
                
    def test_invalid_direction(self): 
        body = SimpleBody(None)  
        body.add_to_map(self.map, 0, 0)   
          
        self.assertFalse(body.move(4))  
        self.assertEqual(body.x, 0)  
        self.assertEqual(body.y, 0)  
        self.assertEqual(body.map, self.map) 
        
    def test_border(self): 
        body = SimpleBody(None)  
        body.add_to_map(self.map, 0, 0)
        
        self.assertFalse(body.move(2))  
        self.assertEqual(body.x, 0)  
        self.assertEqual(body.y, 0)  
        self.assertEqual(body.map, self.map)      
        
    def test_solid_cell(self): 
        body = SimpleBody(None)         
        self.map.get_cell(1, 1).type = self.type1
        
        body.add_to_map(self.map, 1, 0) 
        self.assertFalse(body.move(0))   
        self.assertEqual(body.x, 1)  
        self.assertEqual(body.y, 0)          
Esempio n. 6
0
    def build_map():
        row = math.floor(
            (GRID_HEIGHT - MARGIN_TOP - MARGIN_BOTTOM) / CUBE_SIZE)
        col = math.floor((GRID_WITH - MARGIN_LEFT - MARGIN_RIGHT) / CUBE_SIZE)

        return Map(row, col)
Esempio n. 7
0

if __name__ == '__main__':
    window = pyglet.window.Window(800, 600, 'PyArena 0.03')   
    
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    
    init_tiles()
    
    create_color_tile('Grass', 0, 255, 0)
    create_color_tile('Stone', 200, 200, 200) 
    create_image_tile('Fey', 'fey.png')
    create_image_tile('Demon', 'demon.png')    
    
    map = Map()
    map.create(32, 24, CellType('Test', False, 'Grass'))     
    map.get_cell(5, 10).type = CellType('Test', True, 'Stone')
    
    fey = Creature(SimpleBody('Fey'), Player())    
    map.add_creature(fey, 2, 5)
    
    demon = Creature(SimpleBody('Demon'))    
    map.add_creature(demon, 4, 5)
    
    @window.event
    def on_draw():
        fey.controller.execute()
        window.clear()
        map.draw()
    
Esempio n. 8
0
 def setUp(self):
     self.type = CellType('Test', False, 'Test')
     self.map = Map()
     self.map.create(2, 4, self.type)