def test_get_rows_asym_bottom(self):
"""testing making rows unevenly, edge"""
x_dimension = 5
y_dimension = 7
test_array = self.numpy_it(y_dimension, x_dimension)
increment = 2
position = y_dimension - (y_dimension % increment)
base = 0
step = 1
self.assertEqual(Tile.get_rows(test_array, position, y_dimension, increment, base, step)[2].tolist(),
[[30, 31, 32, 33, 34]])
self.assertEqual((Tile.get_rows(test_array, position, y_dimension, increment, base, step)[0],
Tile.get_rows(test_array, position, y_dimension, increment, base, step)[1]),
(6, 7))
def test_get_tiles_asym_bottom(self):
"""testing making rows unevenly, edge"""
x_dimension = 5
increment = 2
position = x_dimension - (x_dimension % increment)
base = 0
step = 1
# this function call is different because I am testing the uneven edge | uneven edge
test_array = self.numpy_row_it(position, 1, x_dimension)
self.assertEqual(Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[2].tolist(),
[[24]])
self.assertEqual((Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[0],
Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[1]),
(4, 5))
def test_get_tiles_asym_top(self):
"""testing making rows unevenly, normal"""
x_dimension = 5
increment = 2
position = 0
base = 0
step = 1
test_array = self.numpy_row_it(position, increment, x_dimension)
self.assertEqual(Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[2].tolist(),
[[0, 1],
[5, 6]])
self.assertEqual((Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[0],
Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[1]),
(0, 2))
def test_get_tiles_square_top(self):
"""testing making rows from square, top"""
x_dimension = 9
increment = 3
position = 0
base = 0
step = 1
test_array = self.numpy_row_it(position, increment, x_dimension)
self.assertEqual(Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[2].tolist(),
[[0, 1, 2],
[9, 10, 11],
[18, 19, 20]])
self.assertEqual((Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[0],
Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[1]),
(0, 3))
def test_get_rows_asym_top(self):
"""testing making rows unevenly, normal"""
x_dimension = 5
y_dimension = 7
test_array = self.numpy_it(y_dimension, x_dimension)
increment = 2
position = 0
base = 0
step = 1
self.assertEqual(Tile.get_rows(test_array, position, y_dimension, increment, base, step)[2].tolist(),
[[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
self.assertEqual((Tile.get_rows(test_array, position, y_dimension, increment, base, step)[0],
Tile.get_rows(test_array, position, y_dimension, increment, base, step)[1]),
(0, 2))
def test_get_rows_square_bottom(self):
"""testing making rows from square, bottom"""
y_dimension = 9
test_array = self.numpy_it(y_dimension, y_dimension)
increment = 3
position = y_dimension - increment
base = 0
step = 1
self.assertEqual(Tile.get_rows(test_array, position, y_dimension, increment, base, step)[2].tolist(),
[[54, 55, 56, 57, 58, 59, 60, 61, 62],
[63, 64, 65, 66, 67, 68, 69, 70, 71],
[72, 73, 74, 75, 76, 77, 78, 79, 80]])
self.assertEqual((Tile.get_rows(test_array, position, y_dimension, increment, base, step)[0],
Tile.get_rows(test_array, position, y_dimension, increment, base, step)[1]),
(6, 9))
def test_get_rows_square_top(self):
"""testing making rows from square, top"""
y_dimension = 9
test_array = self.numpy_it(y_dimension, y_dimension)
increment = 3
position = 0
base = 0
step = 1
self.assertEqual(Tile.get_rows(test_array, position, y_dimension, increment, base, step)[2].tolist(),
[[0, 1, 2, 3, 4, 5, 6, 7, 8],
[9, 10, 11, 12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23, 24, 25, 26]])
self.assertEqual((Tile.get_rows(test_array, position, y_dimension, increment, base, step)[0],
Tile.get_rows(test_array, position, y_dimension, increment, base, step)[1]),
(0, 3))
def test_get_tiles_square_bottom(self):
"""testing making rows from square, bottom"""
x_dimension = 9
increment = 3
position = x_dimension - increment
base = 0
step = 1
test_array = self.numpy_row_it(position, increment, x_dimension)
self.assertEqual(Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[2].tolist(),
[[60, 61, 62],
[69, 70, 71],
[78, 79, 80]])
self.assertEqual((Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[0],
Tile.get_tiles(test_array, position, x_dimension, increment, base, step)[1]),
(6, 9))
def get(self):
db.delete(Tile.all())
db.delete(Avatar.all())
cleared = make_maze(20, 20)
for t in cleared:
view = []
for vy in range(t[1] - view_radius, t[1] + view_radius + 1):
for vx in range(t[0] - view_radius, t[0] + view_radius + 1):
if (vx, vy) in cleared:
shape = get_shape(vx, vy, cleared)
view.append({'x': vx, 'y': vy, 'shape': shape})
shape = get_shape(t[0], t[1], cleared)
key = db.Key.from_path(
'Maze', 'bogart',
'Tile', '%d-%d' % (t[0], t[1])
)
Tile(
key=key,
x=t[0],
y=t[1],
shape=shape,
view_blob=json.dumps(view)
).put()
Avatar(x=0, y=0, name='jack').put()
self.response.out.write('Generator %s' % cleared)
def set_board(self):
# Initialize board with empty tiles
for row in range(Minesweeper.ROWS):
row_list = list()
for column in range(Minesweeper.COLS):
row_list.append(Tile(row * Minesweeper.COLS + column))
self.data.append(row_list)
def get(self):
width = 20
height = 20
paths = Tile.all()
maze_tiles = {}
for path in paths:
maze_tiles[(path.x, path.y)] = ' '
lines = []
tenline = [' *']
unitline = [' *']
for ten in range(0,width,10):
tenline.append(str(ten)[0]*10)
unitline.append(''.join(map(str,range(10))))
lines.append(''.join(tenline))
lines.append(''.join(unitline))
lines.append('***'+'*'*width)
for y in range(height):
line = []
line.append('%02d*'%y)
for x in range(width):
line.append(maze_tiles.get((x,y), '#'))
line.append('*')
lines.append(''.join(line))
lines.append(' '+'*'*width)
self.response.headers['Content-type'] = 'text/plain'
self.response.out.write('\n'.join(lines))
def setup_board(self):
# Shuffle up the list to get random
random_num_list = number_list.copy()
random_res_list = resource_list.copy()
random.shuffle(random_num_list)
random.shuffle(random_res_list)
ctr = 0
for i in range(1, 18):
self.tilePool.append(
Tile(resource_dependencies[i], random_num_list[i],
resource_dependencies[i]))
def get(self):
db.delete(Tile.all())
db.delete(Avatar.all())
cleared = make_maze(20,20)
for t in cleared:
view = []
for vy in range(t[1]-view_radius,t[1]+view_radius+1):
for vx in range(t[0]-view_radius,t[0]+view_radius+1):
if (vx,vy) in cleared:
view.append({'x':vx, 'y':vy})
Tile(x=t[0], y=t[1], view_blob=pickle.dumps(view, 2)).put()
Avatar(x=0,y=0,name='jack').put()
self.response.out.write('Generator %s'%cleared)
def testInsertEntity(self):
t = Tile(x=0, y=1, shape=0, view_blob='blob')
t.put()
self.assertEqual(1, len(Tile.all().fetch(2)))
from data import bay_data, BAY
from model import connect_to_db, db
from server import app
from model import Tile
from model import Point
if __name__ == "__main__":
connect_to_db(app)
# In case tables haven't been created, create them
connect_to_db(app)
print "Connected to DB."
db.create_all()
print "tables created"
# Calling main load function with variables in correct order, be careful of order
Tile.load_tiles(bay_data, BAY['incr'], BAY['steps_x'], BAY['steps_y'],
BAY['N'], BAY['W'], BAY['S'], BAY['E'])
print "tiles loaded"
