def test_room_equality(self):
# Equality is true
r2 = Room(self.polygon1.clone(), [t.clone() for t in self.room1.texts])
r3 = Room(self.polygon1.clone(),
[t.clone() for t in self.room1.texts[1:]])
# Equality is false
d = Room(self.polygon1.clone().traslate(1, 0),
[t.clone() for t in self.room1.texts])
self.assertEqual(self.room1, r2)
self.assertEqual(self.room1, r3)
self.assertNotEqual(self.room1, d)
def loadRooms(self):
roomLoaded = filesUtils.loadFromFile('model/roomsOriginal.txt')
if roomLoaded == None or len(roomLoaded) == 0:
rooms = {}
rooms['Geral'] = Room('Geral', None, [], {})
else:
rooms = {}
for name, dic in roomLoaded.items():
admin = dic['admin']
bans = list(dic['bans'])
timeouts = dic['timeouts']
rooms[name.strip()] = Room(
name.strip(), admin if admin == None else admin.strip(),
bans, timeouts)
return rooms
def test_show_all_rooms(self):
room_name = "lalala"
new_room = Room(name=room_name)
db.session.add(new_room)
db.session.commit()
result = self.client.get('/api/rooms')
self.assertIn(result.data, '"name": "{}",'.format(room_name))
def main():
if len(sys.argv) == 2:
map_name = sys.argv[1]
else:
exit(1)
map_file = open(map_name, 'r')
# ввод данных
map_data = map_file.read()
links = re.findall('\w+-\w+', map_data)
rooms = re.findall('\w+ \d+ \d+', map_data)
paths = re.findall('(L.*?)\n', map_data)
print(paths)
# парсинг данных на узлы, ребра и перемещения за каждый шаг
rooms_dict = {}
links_list = []
for room in rooms:
buf = room.split(' ')
rooms_dict[buf[0]] = (Room(buf[0],
int(buf[1]) * ZOOM,
int(buf[2]) * ZOOM, NODE_SIZE))
print(buf[0], buf[1], buf[2])
for link in links:
buf = link.split('-')
if not buf[0].startswith('L'):
line = Link(None, None)
for room in rooms_dict:
room = rooms_dict[room]
if room.name == buf[0]:
line.start = room
elif room.name == buf[1]:
line.end = room
links_list.append(line)
start_room = re.findall('##start\n(\w+)', map_data)[0].split('\n')[0]
moves_list = []
moved_ants = set()
for path in paths:
move_per_ant = ' ' + path
move_per_ant = move_per_ant.split(' L')
moves = {}
for ant_move in move_per_ant:
if ant_move != '':
ant_move = ant_move.split('-')
if not ant_move[0] in moved_ants:
moved_ants.add(ant_move[0])
moves[ant_move[0]] = Move(rooms_dict[start_room],
rooms_dict[ant_move[1]],
ant_move[0])
else:
previous_ant_move = moves_list[-1][ant_move[0]]
moves[ant_move[0]] = Move(previous_ant_move.end,
rooms_dict[ant_move[1]],
ant_move[0])
moves_list.append(moves)
game = Game(links_list, moves_list)
game.run()
def test_show_room_users(self):
'''Test GET server.show_room_users'''
with self.client as test_client:
room_name = "tesseract"
user_name = 'Penny Penguin'
# Create a room
new_room = Room(name=room_name)
db.session.add(new_room)
db.session.commit()
# Create a user
penny_penguin = User(user_name)
db.session.add(penny_penguin)
db.session.commit()
# Add the user to the room
new_room = Room.query.filter(Room.name == room_name).first()
penny_penguin = User.query.filter(User.name == user_name).first()
balloonicorn = User.query.get(1)
anonymouse = User.query.get(2)
# print type(balloonicorn), balloonicorn, balloonicorn.user_id
# print type(anonymouse), anonymouse, anonymouse.user_id
# db.session.add(main_room.join_room(anonymouse))
db.session.add(new_room.join_room(penny_penguin))
db.session.add(new_room.join_room(balloonicorn))
db.session.add(new_room.join_room(anonymouse))
db.session.commit()
result = test_client.get('/api/rooms/{}/users'.format(
int(new_room.room_id)))
# print "rooms and users:\n", result.data
self.assertIn('"name": "{}",'.format(penny_penguin.name),
result.data)
def check_if_db(room_id: Optional[int] = None, return_exits: bool = False) -> Tuple[int, List[str]]:
""" checks if the current room you're in is in the database.
if not, adds it.
to be helpful, returns current room id
if given an int, it will check that room. not not, it will initialize.
"""
sess = Session(bind=engine)
if not room_id:
i = init()
sleep(i['cooldown'])
room_id = i['room_id']
room_ = sess.query(Room).filter(Room.room_id==room_id)
if not room_.all():
i = init()
sleep(i['cooldown'])
room = Room(room_id=room_id, title=i['title'])
print('ADDING NEW ROOM ', end='')
sess.add(room)
sess.commit()
if return_exits:
try:
return room_id, i['exits']
except NameError as e:
i = init()
sleep(i['cooldown'])
return room_id, i['exits']
else:
return room_id, []
def test_create_room_users(self):
'''Test POST server.show_room_users'''
with self.client as test_client:
room_name = "tesseract"
user_name = 'Penny Penguin'
# Create a room
new_room = Room(name=room_name)
db.session.add(new_room)
db.session.commit()
# Create a user
penny_penguin = User(user_name)
db.session.add(penny_penguin)
db.session.commit()
# Add the user to the room
new_room = Room.query.filter(Room.name == room_name).first()
penny_penguin = User.query.filter(User.name == user_name).first()
result_post_1 = test_client.post(
'/api/rooms/{}/users'.format(int(new_room.room_id)),
data={'user_id': penny_penguin.user_id})
# print "result_post_1:\n", result_post_1.data
penny_penguin
self.assertIn('"name": "{}",'.format(penny_penguin.name),
result_post_1.data)
def insert():
name = ["John","Haifen","Dan","Morres","Issac","Vikas","Bill","Ross","Chandler"]
team = ["API","Finance"]
for i in xrange(1,37):
seat = Seats()
if i in [1,5]:
seat.user = random.choice(name)
seat.status = "Allocated"
seat.teamname = team[0]
if i in [10]:
seat.user = random.choice(name)
seat.status = "Allocated"
seat.teamname = team[1]
seat.building = 1
seat.floor = 1
seat.seatnum = i
seat.row = i/9 if i%9==0 else i/9+1
seat.save()
for i in xrange(1,7):
room = Room()
room.building = 1
room.floor = 1
room.roomnum = i
room.save()
return "done"
def get_room(self, name):
try:
room = self.conference.rooms[name]
except KeyError:
room = Room(name)
self.conference.rooms[name] = room
return room
def create_room(room_name):
room = Room(room_name=room_name)
db.session.add(room)
db.session.commit()
return room
def create_room(arg):
game_info = Game.get(arg['game']['id'])
room = Room(name=arg['name'],
capacity=arg['capacity'],
game=game_info,
difficulty=arg['game']['difficulty'])
room.put()
return room
def __init__(self, cfg):
self.name = cfg.get("class", "Unknown Class")
self.assigned = {}
self.allowed_rows = {}
self.disallowed_rows = {}
self.allowed_columns = {}
self.disallowed_columns = {}
self.separate = []
self.keep_near = []
self.counter = Counter()
for kid in cfg["kids"]:
name = kid["name"]
self.counter[name] = 0
for k in kid.get("keep_away_from", []):
ka = set([k, name])
self.counter[name] += 1
if ka not in self.separate:
self.separate.append(ka)
for k in kid.get("keep_near", []):
self.counter[name] += 1
sn = set([k, name])
if sn not in self.keep_near:
self.keep_near.append(sn)
if "assigned" in kid:
self.counter[name] += 1
self.assigned[name] = [x - 1 for x in kid["assigned"]]
else:
if "allowed_rows" in kid:
self.counter[name] += len(kid["allowed_rows"])
self.allowed_rows[name] = [
x - 1 for x in kid["allowed_rows"]
]
if "disallowed_rows" in kid:
self.counter[name] += len(kid["disallowed_rows"])
self.disallowed_rows[name] = [
x - 1 for x in kid["disallowed_rows"]
]
if "allowed_columns" in kid:
self.counter[name] += len(kid["allowed_columns"])
self.allowed_columns[name] = [
x - 1 for x in kid["allowed_columns"]
]
if "disallowed_columns" in kid:
self.counter[name] += len(kid["disallowed_columns"])
self.disallowed_columns[name] = [
x - 1 for x in kid["disallowed_columns"]
]
self.kids = [k[0] for k in self.counter.most_common()]
self.room = Room(width=cfg["columns"], height=cfg["rows"])
def create_room(data):
name = data['name']
if name in rooms:
status = "There is already a room with that name"
emit('failure', status, broadcast=False)
else:
room = Room(title=name, made_by=session['name'])
rooms[name] = room
room = room.__dict__
emit('show rooms', room, broadcast=True)
def test_floor_room_addition(self):
self.f.add_room(self.room1)
self.assertEqual(self.f.rooms[0], self.room1)
p2 = Polygon.from_absolute_coordinates( [(4, 4), (22, 14), (53, 53)] )
r2 = Room(p2)
self.f.add_room(r2)
self.assertEqual(len(self.f.rooms), 2)
self.assertTrue( r2 in self.f.rooms )
def test_floor_encoding_and_decoding(self):
p2 = Polygon.from_absolute_coordinates([(12,0),(22,0),(22,10),(12,10)])
r2 = Room(p2)
f1 = Floor("Building cool name","Floor cool name", [self.room1,r2])
f_dump = json.dumps(f1.to_serializable())
f_load = json.loads(f_dump)
f2 = Floor.from_serializable(f_load)
self.assertEqual(f1,f2)
def test_show_room(self):
'''Test server.show_room(room_id)'''
room_name = "lalala"
new_room = Room(name=room_name)
db.session.add(new_room)
db.session.commit()
new_room = Room.query.filter(Room.name == room_name).first()
result = self.client.get('/api/rooms/{}'.format(int(new_room.room_id)))
self.assertIn('"name": "{}",'.format(new_room.name), result.data)
self.assertIn('"room_id": {}'.format(new_room.room_id), result.data)
def setUp(self):
# 10x10 square beginning on origin
self.polygon1 = Polygon.from_absolute_coordinates([(0, 0), (10, 0),
(10, 10), (0, 10)])
self.room1 = Room(self.polygon1, [
Text("1234", Point(3, 3)),
Text("Super Cool", Point(4, 7)),
Text("Corner Text!", Point(1, 10))
])
# 10x10 diamond shape centered at origin
self.polygon2 = Polygon.from_absolute_coordinates([(10, 0), (0, 10),
(-10, 0), (0, -10)])
self.room2 = Room(self.polygon2)
# L-shaped room
self.polygon3 = Polygon.from_absolute_coordinates([(0, 0), (10, 0),
(10, 5), (5, 5),
(5, 10), (0, 10)])
self.room3 = Room(self.polygon3)
def test_calculate_scale_amount_and_trasform(self):
polygon = Polygon.from_absolute_coordinates(
[(0,0),(1024,0),(1024,1024),(2048,1024),(2048,2048),(0,2048)]
)
room = Room(polygon)
f = Floor("Pippo", "disneyland", [room])
self.assertEqual(f.max_output_size / 2048, f.calculate_scale_amount())
f.normalize()
for point in f.rooms[0].polygon.points:
self.assertTrue(point.x <= f.max_output_size)
self.assertTrue(point.y <= f.max_output_size)
def test_floor_equal(self):
p2 = Polygon.from_absolute_coordinates([(12,0),(22,0),(22,10),(12,10)])
r2 = Room(p2)
floor = Floor("Building 1", "Floor1", [self.room1,r2])
floor2 = Floor("Building 1", "Floor1",[self.room1,r2])
self.assertEqual(floor,floor2)
floor3 = Floor("Building 1", "Floor", [self.room1,r2])
self.assertNotEqual(floor, floor3)
floor3 = Floor("Building", "Floor1", [self.room1,r2])
self.assertNotEqual(floor, floor3)
floor3 = Floor("Building 1", "Floor1", [self.room1])
self.assertNotEqual(floor, floor3)
def main():
r1 = Room(id_=1)
r2 = Room(id_=2)
r3 = Room(id_=3)
r4 = Room(id_=4)
r5 = Room(id_=5)
r6 = Room(id_=6)
m1 = Monster()
m2 = Monster()
t = Treasure(prize=100)
r1.add_choice(r2)
r1.add_choice(r4)
r2.add_choice(r3)
r2.add_choice(r6)
r3.add_choice(r4)
r3.add_choice(m1)
m1.set_treasure(t)
r3.add_choice(t)
r4.add_choice(r5)
r5.add_choice(m2)
r6.add_choice(t)
game = MonsterMazeGame(start=r1)
game.play_game()
def test_floor_to_serializable(self):
p2 = Polygon.from_absolute_coordinates([(12,0),(22,0),(22,10),(12,10)])
r2 = Room(p2)
f = Floor("Building cool name","Floor cool name", [self.room1, r2])
self.assertEqual( f.to_serializable() ,
{
"walls" : [],
"windows" : [],
"b_id" : f.b_id,
"f_id" : f.f_id,
"rooms" : [self.room1.to_serializable(), r2.to_serializable()]
})
def post(self):
data = request.get_json()
# pre-validation
data = marshal(data, room_resource_fields)
if data not in marshal(DB['room'], room_resource_fields) and any(
list(data.values())):
data = dict(data)
data = Room(**data)
DB['room'].append(data)
return "object is added", 200
return "object is empty or already in DB", 200
def test_room_encoding_and_decoding(self):
r = Room([(1,2), (3, 4), (5, 6)])
self.room1.add_text(Text("Encoded cool text", Point([1,1])))
s1 = json.dumps(self.room1.to_serializable(), indent = 3)
d1 = json.loads(s1)
r2 = Room.from_serializable(d1)
self.assertEqual(self.room1.polygon.points, r2.polygon.points)
self.assertEqual(self.room1.texts, r2.texts)
s2 = json.dumps(self.room1.to_serializable(), indent = 4)
d2 = json.loads(s2)
self.assertEqual(d1, d2)
def test_associate_text_to_rooms(self):
p2 = Polygon.from_absolute_coordinates([(12,0),(22,0),(22,10),(12,10)])
r2 = Room(p2)
t1 = Text("Text room 1", Point(5,5))
t2 = Text("Text room 2", Point(15,8))
t3 = Text("Text outside",Point(11,5))
floor = Floor("Building 1", "Floor1",[self.room1, r2])
floor.associate_room_texts([t1,t2,t3])
self.assertEqual( len(self.room1.texts), 1 )
self.assertTrue( len(r2.texts) == 1 )
self.assertTrue( t1 in self.room1.texts )
self.assertTrue( t2 in r2.texts )
def create_room(arg):
assert arg['game'].has_key(
'map_size'), 'Required argument is missing: "game.map_size".'
player = arg['sender']
game_info = Game.get(arg['game']['id'])
room = Room(name=arg['name'],
capacity=arg['capacity'],
game=game_info,
map_size=arg['game']['map_size'])
room.put()
player.room = room
player.is_ready = True
player.put()
return {'room': str(player.room.key())}
def load_Room():
"""Load room numbers from room.csv into database."""
print "rooms"
Room.query.delete()
for row in open("seed_data/room"):
row = row.strip()
items = row.split(",")
room = Room(room_loc=items[0], capacity=items[1])
db.session.add(room)
db.session.commit()
def enterRoom(self, user, msg):
try:
roomName = msg.split()[1]
self.checkRoomAssocioate(user)
if not roomName in self.rooms:
room = Room(roomName, user.name, [], {})
self.rooms[roomName] = room
self.userRooms[user].append(roomName)
self.rooms[roomName].enterUser(user)
self.saveRooms()
elif not roomName in self.userRooms[user]:
room = self.rooms[roomName]
self.userRooms[user].append(roomName)
room.enterUser(user)
except IndexError:
user.socket.sendall(
JsonHandler.encode('#msg',
'tem que indicar o nome da sala').encode())
def _extract_entities(self):
self._rooms = []
self._texts = []
self._wall_lines = []
self._window_lines = []
for ent in self._grabber.entities:
if self._is_valid_room(ent):
points = [(p[0], -p[1]) for p in ent.points]
polygon = Polygon.from_absolute_coordinates(points)
polygon.ensure_is_closed(tollerance=0.8)
polygon.simplify_close_points(tollerance=0.8)
if polygon.is_self_crossing():
Logger.warning("Self crossing room is not valid: " +
str(polygon))
continue
self._rooms.append(Room(polygon))
elif self._is_valid_text(ent):
self._texts.append(
Text(ent.plain_text().strip(),
Point(ent.insert[0], -ent.insert[1])))
elif self._is_valid_wall_line(ent):
start = Point(ent.start[0], -ent.start[1])
end = Point(ent.end[0], -ent.end[1])
line = Segment(start, end)
self._wall_lines.append(line)
elif self._is_valid_wall_polyline(ent):
points = [(p[0], -p[1]) for p in ent.points]
polygon = Polygon.from_relative_coordinates((0, 0), points)
polygon.ensure_is_closed(tollerance=1)
polygon.simplify_close_points(tollerance=1)
self._wall_lines.extend(polygon.as_segment_list())
elif self._is_valid_window_line(ent):
start = Point(ent.start[0], -ent.start[1])
end = Point(ent.end[0], -ent.end[1])
line = Segment(start, end)
self._window_lines.append(line)
def create_room():
username = request.form['username']
cookie = request.form['cookie']
chatroom_name = request.form['chatroom_name']
if not authenticate_user(username, cookie):
return 'authentication failed'
room_exist = db.session.query(Room).filter_by(
name=chatroom_name).first() != None
if room_exist:
return 'failed'
user = db.session.query(Account).filter_by(name=username).first()
new_room = Room(chatroom_name)
b = Belong(user, new_room)
db.session.add_all([new_room, b])
db.session.commit()
return 'successful'
def test_associate_text_to_rooms2(self):
p2 = Polygon.from_absolute_coordinates([(6,0),(12,0),(12,10),(11,10),(11,4),(6,4)])
r2 = Room(p2)
t1_1 = Text("Text room 1",Point(2,2))
t1_2 = Text("Text room 1",Point(8,8))
t2_1 = Text("Text room 2",Point(7,2))
t2_2 = Text("Text room 2",Point(11,8))
t_none = Text("Text none",Point(5,12))
floor = Floor("Building 1", "Floor1",[ self.room1,r2])
floor.associate_room_texts([t1_1,t1_2,t2_1,t2_2,t_none])
self.assertTrue( len(self.room1.texts) == 2 )
self.assertTrue( len(r2.texts) == 2 )
self.assertTrue( t1_1 in self.room1.texts )
self.assertTrue( t1_2 in self.room1.texts )
self.assertTrue( t2_1 in r2.texts )
self.assertTrue( t2_2 in r2.texts )
self.assertTrue( t1_1 in self.room1.texts )
self.assertTrue( t_none not in self.room1.texts )
