def test_delete(self):
for m in range(rlfl.MAX_MAPS):
rlfl.create_map(20, 20)
rlfl.delete_all_maps()
self.assertEqual(0, rlfl.create_map(20, 20))
self.assertTrue(rlfl.delete_map(0))
self.assertEqual(0, rlfl.create_map(20, 20))
self.assertTrue(rlfl.delete_map(0))
self.assertFalse(rlfl.delete_map(0))
self.assertFalse(rlfl.delete_map(-1))
def test_delete(self):
for m in range(rlfl.MAX_MAPS):
rlfl.create_map(20, 20)
rlfl.delete_all_maps()
self.assertEqual(0, rlfl.create_map(20, 20))
self.assertTrue(rlfl.delete_map(0))
self.assertEqual(0, rlfl.create_map(20, 20))
self.assertTrue(rlfl.delete_map(0))
self.assertFalse(rlfl.delete_map(0))
self.assertFalse(rlfl.delete_map(-1))
def init_fov(self):
if self.current.fov_map0 is None:
self.current.fov_map0 = rlfl.create_map(self.current.width, self.current.height)
# self.current.fov_map = libtcod.map_new(self.current.width, self.current.height)
for y in xrange(self.current.height):
for x in xrange(self.current.width):
self.update_fov_for(x, y)
def show(self):
# Start by creating a map on which to work
# We shall import a dummy map to use
# Import the map
import tmap
self.map, self.origos = tmap.MAP
p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 = self.origos
# Create the RLFL internal map
width = len(self.map)
height = len(self.map[0])
self.map_number = rlfl.create_map(width, height)
# We now have a map number representing the
# internal map in rlfl
# initialize the map
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open and seen
rlfl.set_flag(self.map_number, p, rlfl.CELL_SEEN)
rlfl.set_flag(self.map_number, p, rlfl.CELL_OPEN)
# we now have a map to work on
# LOS between 1 and 4 on the map above
have_los = rlfl.los(self.map_number, p1, p2)
assert (have_los == False)
# LOS between 2 and 3
have_los = rlfl.los(self.map_number, p2, p3)
assert (have_los == True)
# Measure distance
dist = rlfl.distance(p1, p4)
# Plot simple paths
flags = 0
# range (-1 for max range)
r = -1
path = rlfl.path(self.map_number, p1, p2, rlfl.PATH_BASIC, r, flags,
0.0)
# Or real path A*
path = rlfl.path(self.map_number, p1, p2, rlfl.PATH_ASTAR, r, flags,
7.0)
# Lets calculate FOV from 3 using recursive shadowcasting
# with a light source radius of 6
rlfl.fov(self.map_number, p3, rlfl.FOV_SHADOW, 6)
self.print_map(p3)
# Use the scatter function to find a random spot (summon, teleport)
# Here we want an open cell within range 16 from p
require_los = False
ps = rlfl.scatter(self.map_number, p0, 16, rlfl.CELL_OPEN, require_los)
super(Full_example, self).print_map([], p0, ps)
def init_fov(self):
if self.current.fov_map0 is None:
self.current.fov_map0 = rlfl.create_map(self.current.width,
self.current.height)
# self.current.fov_map = libtcod.map_new(self.current.width, self.current.height)
for y in xrange(self.current.height):
for x in xrange(self.current.width):
self.update_fov_for(x, y)
def show(self):
# Start by creating a map on which to work
# We shall import a dummy map to use
# Import the map
import tmap
self.map, self.origos = tmap.MAP
p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 = self.origos
# Create the RLFL internal map
width = len(self.map)
height = len(self.map[0])
self.map_number = rlfl.create_map(width, height)
# We now have a map number representing the
# internal map in rlfl
# initialize the map
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open and seen
rlfl.set_flag(self.map_number, p, rlfl.CELL_SEEN)
rlfl.set_flag(self.map_number, p, rlfl.CELL_OPEN)
# we now have a map to work on
# LOS between 1 and 4 on the map above
have_los = rlfl.los(self.map_number, p1, p2)
assert(have_los == False)
# LOS between 2 and 3
have_los = rlfl.los(self.map_number, p2, p3)
assert(have_los == True)
# Measure distance
dist = rlfl.distance(p1, p4)
# Plot simple paths
flags = 0
# range (-1 for max range)
r = -1
path = rlfl.path(self.map_number, p1, p2, rlfl.PATH_BASIC, r, flags, 0.0)
# Or real path A*
path = rlfl.path(self.map_number, p1, p2, rlfl.PATH_ASTAR, r, flags, 7.0)
# Lets calculate FOV from 3 using recursive shadowcasting
# with a light source radius of 6
rlfl.fov(self.map_number, p3, rlfl.FOV_SHADOW, 6)
self.print_map(p3)
# Use the scatter function to find a random spot (summon, teleport)
# Here we want an open cell within range 16 from p
require_los = False
ps = rlfl.scatter(self.map_number, p0, 16, rlfl.CELL_OPEN, require_los)
super(Full_example, self).print_map([], p0, ps)
def setUp(self):
rlfl.delete_all_maps()
self.map = rlfl.create_map(len(TMAP), len(TMAP[0]))
for row in range(len(TMAP)):
for col in range(len(TMAP[row])):
if TMAP[row][col] != '#':
p = (row, col)
rlfl.set_flag(self.map, p, rlfl.CELL_SEEN)
rlfl.set_flag(self.map, p, rlfl.CELL_OPEN)
def setUp(self):
rlfl.delete_all_maps()
self.map = rlfl.create_map(len(MAP), len(MAP[0]))
for row in range(len(MAP)):
for col in range(len(MAP[row])):
if MAP[row][col] != '#':
p = (row, col)
rlfl.set_flag(self.map, p, rlfl.CELL_SEEN)
rlfl.set_flag(self.map, p, rlfl.CELL_OPEN)
def test_create(self):
for m in range(rlfl.MAX_MAPS):
self.assertEqual(m, rlfl.create_map(20, 20))
try:
m = rlfl.create_map(20, 20)
except Exception as e:
self.assertEqual(str(e), 'Too many maps')
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception')
rlfl.delete_all_maps()
try:
rlfl.create_map(-1, -1)
except Exception as e:
self.assertEqual(str(e), 'Invalid map size')
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception')
def test_create(self):
for m in range(rlfl.MAX_MAPS):
self.assertEqual(m, rlfl.create_map(20, 20))
try:
m = rlfl.create_map(20, 20)
except Exception as e:
self.assertEqual(str(e), 'Too many maps')
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception')
rlfl.delete_all_maps()
try:
rlfl.create_map(-1, -1)
except Exception as e:
self.assertEqual(str(e), 'Invalid map size')
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception')
def create_map(self, m):
# Import the map
imap = __import__(m)
self.map, self.origos = imap.MAP
# Create the RLFL internal map
self.mapnum = rlfl.create_map(len(self.map), len(self.map[0]))
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open
rlfl.set_flag(self.mapnum, p, rlfl.CELL_OPEN)
def create_map(self, m):
# Import the map
imap = __import__(m)
self.map, self.origos = imap.MAP
# Create the RLFL internal map
self.mapnum = rlfl.create_map(len(self.map), len(self.map[0]))
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open
rlfl.set_flag(self.mapnum, p, rlfl.CELL_OPEN)
def test_gf(self):
m = rlfl.create_map(20, 20)
rlfl.set_flag(m, (10, 10), rlfl.CELL_OPEN)
self.assertTrue(rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN))
rlfl.set_flag(m, (10, 10), rlfl.CELL_WALK)
self.assertTrue(rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN|rlfl.CELL_WALK))
rlfl.clear_flag(m, (10, 10), rlfl.CELL_WALK)
self.assertTrue(rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN|rlfl.CELL_WALK))
rlfl.clear_flag(m, (10, 10), rlfl.CELL_OPEN)
self.assertFalse(rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN|rlfl.CELL_WALK))
for i in range(0, 20):
self.assertTrue(rlfl.has_flag(m, (0, i), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (19, i), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (i, 0), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (i, 19), rlfl.CELL_PERM))
def test_gf(self):
m = rlfl.create_map(20, 20)
rlfl.set_flag(m, (10, 10), rlfl.CELL_OPEN)
self.assertTrue(rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN))
rlfl.set_flag(m, (10, 10), rlfl.CELL_WALK)
self.assertTrue(
rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN | rlfl.CELL_WALK))
rlfl.clear_flag(m, (10, 10), rlfl.CELL_WALK)
self.assertTrue(
rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN | rlfl.CELL_WALK))
rlfl.clear_flag(m, (10, 10), rlfl.CELL_OPEN)
self.assertFalse(
rlfl.has_flag(m, (10, 10), rlfl.CELL_OPEN | rlfl.CELL_WALK))
for i in range(0, 20):
self.assertTrue(rlfl.has_flag(m, (0, i), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (19, i), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (i, 0), rlfl.CELL_PERM))
self.assertTrue(rlfl.has_flag(m, (i, 19), rlfl.CELL_PERM))
def test_flags(self):
m = rlfl.create_map(20, 20)
test = (
{
'p': (10, 10),
'm': -1,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'p': (-1, -1),
'm': m,
's': 'Location out of bounds',
'f': rlfl.CELL_OPEN
},
{
'p': (1, 1),
'm': m,
's': 'Invalid flag used',
'f': -1
},
)
for func in ['has_flag', 'set_flag', 'clear_flag']:
for i in test:
try:
getattr(rlfl, func)(i['m'], i['p'], i['f'])
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' %
(func, i['s']))
for i in test[0:2]:
try:
f = rlfl.get_flags(i['m'], i['p'])
self.assertEqual(f, 0)
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' %
('get_flags', i['s']))
def test_flags(self):
m = rlfl.create_map(20, 20)
test = (
{
'p': (10, 10),
'm': -1,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'p': (-1, -1),
'm': m,
's': 'Location out of bounds',
'f': rlfl.CELL_OPEN
},
{
'p': (1, 1),
'm': m,
's': 'Invalid flag used',
'f': -1
},
)
for func in ['has_flag', 'set_flag', 'clear_flag']:
for i in test:
try:
getattr(rlfl, func)(i['m'], i['p'], i['f'])
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' % (func, i['s']))
for i in test[0:2]:
try:
f = rlfl.get_flags(i['m'], i['p'])
self.assertEqual(f, 0)
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' % ('get_flags', i['s']))
def show_path_away(self, p1, p2, type, m, r=30, flags=0, diagonal=1.0):
# Import the map
imap = __import__(m)
self.map, origos = imap.MAP
# Create the RLFL internal map
mapnum = rlfl.create_map(len(self.map), len(self.map[0]))
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open and seen
rlfl.set_flag(mapnum, p, rlfl.CELL_SEEN)
rlfl.set_flag(mapnum, p, rlfl.CELL_OPEN)
# Fetch points to path
p1, p2 = (origos[p1], origos[p2])
# Create the path
path = rlfl.path_away(mapnum, p1, p2, type, r, flags, diagonal)
# Print the path
self.print_map(path, p1, p2)
def show_path_away(self, p1, p2, type, m, r=30, flags=0, diagonal=1.0):
# Import the map
imap = __import__(m)
self.map, origos = imap.MAP
# Create the RLFL internal map
mapnum = rlfl.create_map(len(self.map), len(self.map[0]))
for row in range(len(self.map)):
for col in range(len(self.map[row])):
if self.map[row][col] != '#':
p = (row, col)
# Set non-wall grids as open and seen
rlfl.set_flag(mapnum, p, rlfl.CELL_SEEN)
rlfl.set_flag(mapnum, p, rlfl.CELL_OPEN)
# Fetch points to path
p1, p2 = (origos[p1], origos[p2])
# Create the path
path = rlfl.path_away(mapnum, p1, p2, type, r, flags, diagonal)
# Print the path
self.print_map(path, p1, p2)
def test_map(self):
m = rlfl.create_map(20, 20)
rlfl.fill_map(m, rlfl.CELL_SEEN)
for i in range(20):
for j in range(20):
self.assertTrue(rlfl.has_flag(m, (i, j), rlfl.CELL_SEEN))
rlfl.clear_map(m)
for i in range(20):
for j in range(20):
self.assertFalse(rlfl.has_flag(m, (i, j), rlfl.CELL_SEEN))
test = (
{
'm': -1,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'm': 3,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'm': m,
's': 'Invalid flag used',
'f': -1
},
)
for func in ['fill_map', 'clear_map']:
for i in test:
try:
getattr(rlfl, func)(i['m'], i['f'])
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' %
(func, i['s']))
def test_map(self):
m = rlfl.create_map(20, 20)
rlfl.fill_map(m, rlfl.CELL_SEEN)
for i in range(20):
for j in range(20):
self.assertTrue(rlfl.has_flag(m, (i, j), rlfl.CELL_SEEN))
rlfl.clear_map(m)
for i in range(20):
for j in range(20):
self.assertFalse(rlfl.has_flag(m, (i, j), rlfl.CELL_SEEN))
test = (
{
'm': -1,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'm': 3,
's': 'Map not initialized',
'f': rlfl.CELL_OPEN
},
{
'm': m,
's': 'Invalid flag used',
'f': -1
},
)
for func in ['fill_map', 'clear_map']:
for i in test:
try:
getattr(rlfl, func)(i['m'], i['f'])
except Exception as e:
self.assertEqual(str(e), i['s'])
self.assertEqual(str(e.__class__), "<class 'rlfl.Error'>")
else:
self.fail('Expected Exception: func: %s, %s' % (func, i['s']))