def test_mortal_chamber(self):
test = Room(RoomType.mortal_chamber, False)
player = Player()
event = test.on_room_enter([], player, [])[0]
self.assertEqual(player.current_room, test)
self.assertTrue(player.dead)
self.assertEqual(RoomEvent(RoomEventType.player_death, player), event)
def test_twin_chamber_no_twin(self):
test = Room(RoomType.twin_chamber, False)
twin = Room(RoomType.twin_chamber, False)
player = Player()
rooms = []
self.assertEqual([], test.on_room_enter(rooms, player, []))
self.assertEqual(player.current_room, test)
def test_dark_chamber(self):
test = Room(RoomType.dark_chamber, False)
player = Player()
event = test.on_room_enter([], player, [])[0]
self.assertEqual(player.current_room, test)
self.assertEqual(player.status, PlayerStatus.blind)
self.assertEqual(RoomEvent(RoomEventType.player_blind, player), event)
def basic_game(tmpdir):
g = Game()
g.gamedir = tmpdir.mkdir("test_game")
with open('{}/gm_passwords.json'.format(g.gamedir), 'w') as outfile:
json.dump({'passwords': ['gmpass1', 'gmpass2']}, outfile)
temp1 = ItemTemplate('backpack', 'Backpack', "It's a backpack", True)
temp2 = ItemTemplate('key', 'Blue Key', 'This is a key', False)
g.player_manager.load_gm_passwords(g.gamedir)
room1 = Room('room1', 'Room #1', 'First room.')
room2 = Room('room2', 'Room #2', 'Second room.')
room3 = Room('room3', 'Room #3', 'Third room.')
room1.adjacent_rooms.add(room2)
room2.adjacent_rooms.add(room1)
room2.adjacent_rooms.add(room3)
room3.adjacent_rooms.add(room2)
room3.adjacent_rooms.add(room1)
char1 = Character('char1', 'First Character', '1234', room1)
char2 = Character('char2', 'Second Character', 'qwerty', room3)
g.room_manager.rooms['room1'] = room1
g.room_manager.rooms['room2'] = room2
g.room_manager.rooms['room3'] = room3
g.char_manager.characters['char1'] = char1
g.char_manager.characters['char2'] = char2
g.item_manager.item_templates[temp1.short_name] = temp1
g.item_manager.item_templates[temp2.short_name] = temp2
backpack1 = g.item_manager.new_item(temp1.short_name)
key1 = g.item_manager.new_item(temp2.short_name)
backpack2 = g.item_manager.new_item(temp1.short_name)
key2 = g.item_manager.new_item(temp2.short_name)
backpack1.add_item(key1)
char1.items.add_item(backpack1)
room1.items.add_item(backpack2)
room1.items.add_item(key2)
return g
def test_two_fully_adjacent_rooms(self):
a, b = Room(width=2, height=2), Room(width=2, height=2)
a.x, a.y, b.x, b.y = 0, 0, 2, 0
turfs = _get_adjacent_turfs(a, b)
self.assertEqual(len(turfs), 2)
self.assertEqual(turfs,
(set([((1, 0), (0, 0)), ((1, 1), (0, 1))]), (1, 0)))
def test_cold_chamber(self):
test = Room(RoomType.cold_chamber, False)
player = Player()
event = test.on_room_enter([], player, [])[0]
self.assertEqual(player.current_room, test)
self.assertEqual(player.status, PlayerStatus.frozen)
self.assertEqual(RoomEvent(RoomEventType.player_frozen, player), event)
def test_room_is_partially_adjacent_to_another_room_from_north(self):
a, b = Room(width=3, height=3), Room(width=3, height=3)
a.x, a.y, b.x, b.y = 1, 3, 0, 0
turfs = _get_adjacent_turfs(a, b)
self.assertEqual(len(turfs), 2)
self.assertEqual(turfs,
(set([((0, 0), (1, 2)), ((1, 0), (2, 2))]), (0, -1)))
def test_room_is_partially_adjacent_to_another_from_the_east(self):
a, b = Room(width=3, height=3), Room(width=3, height=3)
a.x, a.y, b.x, b.y = 0, 0, 3, 1
turfs = _get_adjacent_turfs(a, b)
self.assertEqual(len(turfs), 2)
self.assertEqual(turfs,
(set([((2, 1), (0, 0)), ((2, 2), (0, 1))]), (1, 0)))
def test_twin_chamber_hidden(self):
test = Room(RoomType.twin_chamber, False)
twin = Room(RoomType.twin_chamber)
player = Player()
rooms = [test, Room(RoomType.central_room), twin]
self.assertEqual([], test.on_room_enter(rooms, player, []))
self.assertEqual(player.current_room, test)
def test_add_an_overlapping_room_with_negative_shift(self):
room = Room(width=3, height=3)
room.x, room.y = 3, 3
self.level.add(room)
overlap_room = Room(width=2, height=2)
overlap_room.x, overlap_room.y = 2, 2
with self.assertRaises(Level.RoomOverlap):
self.level.add(overlap_room)
def change_to_room(self, number, level) -> Room:
result = self.room_dict.get(number)
if (result is None):
room_direct = self.get_room_direction(number, level)
room_to_add = Room(game_scale=self.a_scale, direc=room_direct, backgroundX=self.startX, backgroundY=self.startY, this_level=level)
room_to_add.add_entities()
self.room_dict[number] = room_to_add
return self.room_dict.get(number)
def test_acid_bath_multi(self):
test = Room(RoomType.acid_bath, False)
player = Player()
event = test.on_room_enter(
[], player,
[player, Player(), Player(), Player()])
self.assertEqual(player.current_room, test)
self.assertEqual([], event)
def test_prison_cell(self):
test = Room(RoomType.prison_cell, False)
player = Player()
event = test.on_room_enter([], player, [])[0]
self.assertEqual(player.current_room, test)
self.assertEqual(player.status, PlayerStatus.imprisonned)
self.assertEqual(RoomEvent(RoomEventType.player_imprisonned, player),
event)
def test_add_an_overlapping_room_with_matching_coordinates(self):
room = Room(width=1, height=1)
room.x, room.y = 0, 0
self.level.add(room)
overlap_room = Room(width=1, height=1)
overlap_room.x, overlap_room.y = 0, 0
with self.assertRaises(Level.RoomOverlap):
self.level.add(overlap_room)
def test_two_nine_tile_rooms(self):
"""Corridor is chosen randomly out of possible options."""
room_a, room_b = Room(width=3, height=3), Room(width=3, height=3)
room_a.x, room_a.y, room_b.x, room_b.y = 0, 0, 4, 1
self.assertIn(
_get_corridor_coordinates(room_a, room_b),
set([((3, 1), ((2, 1), (0, 0)), (1, 0)),
((3, 2), ((2, 2), (0, 1)), (1, 0))]))
def test_vortex_room(self):
test = Room(RoomType.vortex_room, False)
central = Room(RoomType.central_room)
player = Player()
rooms = [test, Room(RoomType.twin_chamber), central]
self.assertEqual(
RoomEvent(RoomEventType.player_move, player, test, central),
test.on_room_enter(rooms, player, [])[0])
self.assertEqual(player.current_room, central)
def test_flooded_chamber(self):
test = Room(RoomType.flooded_chamber, False)
player = Player()
event = test.on_room_enter([], player, [])[0]
self.assertEqual(player.current_room, test)
self.assertTrue(test.locked)
self.assertEqual(player.status, PlayerStatus.flooded)
self.assertEqual(RoomEvent(RoomEventType.player_flooded, player),
event)
def test_acid_bath_two_same_room(self):
test = Room(RoomType.acid_bath, False)
player = Player()
player2 = Player()
players = [player, Player(), player2, Player()]
test.on_room_enter([], player2, players)
event = test.on_room_enter([], player, players)[0]
self.assertEqual(player.current_room, test)
self.assertEqual(RoomEvent(RoomEventType.player_death, player2), event)
def test_twin_chamber_revealed_another_order(self):
test = Room(RoomType.twin_chamber, False)
twin = Room(RoomType.twin_chamber, False)
player = Player()
rooms = [twin, Room(RoomType.central_room), test]
self.assertEqual(
RoomEvent(RoomEventType.player_move, player, test, twin),
test.on_room_enter(rooms, player, [])[0])
self.assertEqual(player.current_room, twin)
class RoomAddTest(TestCase):
def setUp(self):
self.room = Room(width=1, height=3)
def test_add_turf_without_coordinates(self):
door = Door()
with self.assertRaises(Room.TurfCoordinatesRequired):
self.room.add(door)
def test_add_turf_with_coordinates_in_a_room(self):
door = Door()
door.x, door.y = 0, 1
self.room.add(door)
turfs = self.room.get(x=door.x, y=door.y)
self.assertIn(door, turfs)
self.assertEqual(len(turfs), 2)
self.assertEqual(door.z, 1)
def test_add_turf_with_unadjustable_z_level(self):
floor = Floor()
floor.x, floor.y = 0, 1
with self.assertRaises(Room.TurfZLevelNotAdjustable):
self.room.add(floor)
def test_add_turf_outside_the_room(self):
door = Door()
door.x, door.y = 9, 9
with self.assertRaises(Room.TurfCoordinatesOutsideRoomBoundaries):
self.room.add(door)
def test_two_diagonaly_adjacent_rooms(self):
"""
Rooms are not considered to be adjacent if they touch diagonaly.
"""
for x, y in [(0, 0), (1, 1)]:
room = Room(width=1, height=1)
room.x, room.y = x, y
self.level.add(room)
turf = iter(room.get(x=0, y=0)).next()
self.assertEqual(turf.exits, {})
self.assertEqual(len(self.level.rooms), 2)
def test_level_with_two_fully_adjacent_rooms(self):
"""Exits are added to adjacent turfs."""
a, b = Room(width=1, height=1), Room(width=1, height=1)
a.x, a.y, b.x, b.y = 0, 0, 1, 0
self.level.add(a)
self.level.add(b)
turf_a = iter(a.get(x=0, y=0)).next()
turf_b = iter(b.get(x=0, y=0)).next()
self.assertEqual(len(self.level.rooms), 2)
self.assertEqual(len(turf_a.exits), 1)
self.assertEqual(len(turf_b.exits), 1)
self.assertEqual(turf_a.exits[(1, 0)], turf_b)
self.assertEqual(turf_b.exits[(-1, 0)], turf_a)
def test_level_with_three_adjacent_rooms(self):
a, b, c = Room(width=1, height=1), Room(1, 1), Room(1, 1)
a.x, a.y, b.x, b.y, c.x, c.y = 0, 0, 1, 0, 0, 1
for room in (a, b, c):
self.level.add(room)
turf_a = iter(a.get(x=0, y=0)).next()
turf_b = iter(b.get(x=0, y=0)).next()
turf_c = iter(c.get(x=0, y=0)).next()
self.assertEqual(len(turf_a.exits), 2)
for turf in (turf_b, turf_c):
self.assertEqual(len(turf.exits), 1)
self.assertEqual(turf_a.exits, {(1, 0): turf_b, (0, 1): turf_c})
self.assertEqual(turf_b.exits[(-1, 0)], turf_a)
self.assertEqual(turf_c.exits[(0, -1)], turf_a)
def generate(self):
"""
generate a new map layout.
"""
self.map = [[None for x in range(self.height)]
for y in range(self.width)]
self.__rooms = []
# Init self.map with newly instantiated Room objects
for x in range(self.width):
for y in range(self.height):
if self.rnd.random() > 0.2:
room_type = Room.EMPTY
type_selector = self.rnd.random()
if 0.1 < type_selector < 0.15:
room_type = Room.PIT
elif 0.4 < type_selector < 0.5:
room_type = Room.TREASURE
elif 0.6 < type_selector < 0.65:
room_type = Room.BATS
room = Room(type=room_type)
self.map[x][y] = room
self.__rooms.append(room)
# Add doors
for x in range(1, self.width):
for y in range(1, self.height):
if self.map[x][y] is not None:
if self.rnd.random() >= 0.3:
if self.map[x - 1][y] is not None:
self.map[x][y].add_neighbor(
self.map[x - 1][y], WEST)
if self.rnd.random() >= 0.3:
if self.map[x][y - 1] is not None:
self.map[x][y].add_neighbor(
self.map[x][y - 1], NORTH)
# Remove non connected rooms from map
for x in range(self.width):
for y in range(self.height):
if self.map[x][y] is not None and \
self.map[x][y].get_neighbor(NORTH) is None and \
self.map[x][y].get_neighbor(EAST) is None and \
self.map[x][y].get_neighbor(SOUTH) is None and \
self.map[x][y].get_neighbor(WEST) is None:
self.__rooms.remove(self.map[x][y])
self.map[x][y] = None
# Validate room layout
groups = self.validate_layout()
if len(groups) > 1:
#self.__connect_room_groups(groups=groups)
self.generate()
else:
print("Map generated with {0} rooms.".format(len(self.__rooms)))
async def update_room(self, room: Room):
"""Send room update to all clients"""
if room.is_empty:
self.rooms.remove(room)
await self.delete_room(room)
else:
await self.broadcast('room_update', room.to_dict())
async def test_message_ooc(player_client, valid_character, custom_character):
msg = 'This is a test message.'
ooc_name = 'client one'
data_in = [{'command': 'messageooc', 'message': msg}]
room = valid_character.room
another_room = Room('ic_room', 'IC Room Test', 'For IC testing')
receiving_char = custom_character('ic_char', 'IC Char Test', 'icpass',
room)
another_char = custom_character('ic_char2', 'IC Char Test 2', 'icpass2',
another_room)
client_sender = player_client(valid_character, ooc_name, data_in)
client_receiver = player_client(receiving_char, 'client two', [])
client_unrelated = player_client(another_char, 'client unrelated', [])
data_out = [{
'command': 'messageooc',
'player_name': ooc_name,
'message': msg
}]
client_sender.socket.set_wait_delay(1)
client_receiver.socket.set_wait_delay(1)
client_unrelated.socket.set_wait_delay(1)
await asyncio.gather(client_sender.handle(), client_receiver.handle(),
client_unrelated.handle())
assert client_sender.socket.has_equal_output(data_out)
assert client_receiver.socket.has_equal_output(data_out)
assert client_unrelated.socket.has_equal_output([])
def create_room(room_name):
if rooms.__contains__(room_name):
emit('warn',
"There is a match with this name! Please try another name!",
broadcast=False)
return
rooms[room_name] = Room(room_name=room_name, user=sids[request.sid])
def generate(self, num):
room_w, room_h = 3, 3
dx, dy, px, py = 0, 0, 0, 0
for i in xrange(0, num):
room = Room(width=room_w, height=room_h)
coordinates = _get_surrounding_coordinates(
px, py, room_w, room_h, room_w, room_h)
while True:
dx, dy = sample(coordinates, 1)[0]
room.x, room.y = dx, dy
try:
self.add(room)
break
except self.RoomOverlap:
pass
px, py = dx, dy
def __init__(self, a_scale, backgroundX, backgroundY):
self.a_scale = a_scale
self.startX = backgroundX
self.startY = backgroundY
self.room_dict = {}
self.corner_numbers = {}
starting_room = Room(game_scale=a_scale, direc=None, backgroundX=self.startX, backgroundY=self.startY, this_level=0)
num = random.randint(0, 3)
if (num == 0):
level_up = Door(game_scale=a_scale, direct=Direction.NORTH, backgroundX=self.startX, backgroundY=self.startY)
level_up.make_golden()
starting_room.entities.append(level_up)
elif (num == 1):
level_up = Door(game_scale=a_scale, direct=Direction.EAST, backgroundX=self.startX, backgroundY=self.startY)
level_up.make_golden()
starting_room.entities.append(level_up)
elif (num == 2):
level_up = Door(game_scale=a_scale, direct=Direction.SOUTH, backgroundX=self.startX, backgroundY=self.startY)
level_up.make_golden()
starting_room.entities.append(level_up)
else:
level_up = Door(game_scale=a_scale, direct=Direction.WEST, backgroundX=self.startX, backgroundY=self.startY)
level_up.make_golden()
starting_room.entities.append(level_up)
self.room_dict[0] = starting_room
self.corner_numbers[0] = None
def __init__(self, wsclient):
self.wsclient = wsclient
self.id = 1
self.name = "Bernd"
self.room = Room.get_room_by_id(1)
self.room.player.append(self)
self.lang = "en"
self.admin_for_area = [3]
def load_rooms(self, gamedir, item_manager):
data = json.load(open("{}/rooms.json".format(gamedir)))
for room in data:
r = Room(room['short_name'], room['long_name'], room['description'])
for item in item_manager.construct_loaded_items(room['items']):
r.items.add_item(item)
self.rooms[room['short_name']] = r
for room in data:
for adj in room['adjacent']:
self.rooms[room['short_name']].adjacent_rooms.add(self.rooms[adj])
def test_get_neighbor_returns_correct_room_reference_after_add_neighbor(self):
first = Room()
second = Room()
first.add_neighbor(second, Room.SOUTH)
room_a = first.get_neighbor(Room.SOUTH)
room_b = second.get_neighbor(Room.NORTH)
self.assertIsNotNone(room_a, "First's neighbor is None")
self.assertIsNotNone(room_b, "Second's neighbor is None")
self.assertEqual(second, room_a, "First's neighbor is not equal to second's reference.")
self.assertEqual(first, room_b, "Second's neighbor is not equal to first's reference.")
def test_level_with_two_partially_adjacent_rooms(self):
"""Non-adjacent turfs do not become exits."""
a, b = Room(width=3, height=3), Room(width=3, height=3)
a.x, a.y, b.x, b.y = 3, 1, 0, 0
self.level.add(a)
self.level.add(b)
exits = set([((0, 0), (2, 1)), ((0, 1), (2, 2))])
for ((a_x, a_y), (b_x, b_y)) in exits:
turf_a = iter(a.get(x=a_x, y=a_y)).next()
turf_b = iter(b.get(x=b_x, y=b_y)).next()
self.assertEqual(len(turf_a.exits), 1)
self.assertEqual(len(turf_b.exits), 1)
self.assertEqual(turf_a.exits[(-1, 0)], turf_b)
self.assertEqual(turf_b.exits[(1, 0)], turf_a)
no_exits = {
a: set([(0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]),
b: set([(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0)])}
for room, coordinates in no_exits.items():
for (x, y) in coordinates:
turf = iter(room.get(x=x, y=y)).next()
self.assertEqual(len(turf.exits), 0)
class RoomGetTest(TestCase):
def setUp(self):
self.room = Room(width=2, height=2)
def test_get_all_turfs_in_a_room(self):
self.assertEqual(self.room.get(), set(self.room.objects))
def test_get_one_specific_turf(self):
turfs = self.room.get(x=0, y=0)
self.assertEqual(len(turfs), 1)
turf = iter(turfs).next()
self.assertEqual((turf.x, turf.y), (0, 0))
def test_get_a_set_of_turfs(self):
turfs = self.room.get(x=0)
self.assertEqual(len(turfs), 2)
for turf in turfs:
self.assertEqual(turf.x, 0)
def test_get_with_nonexistent_kwargs(self):
self.assertEqual(self.room.get(x=0, invalid_kwarg=True), set())
def get_room(roomid):
filename = Config.workingpath + "/rooms/" + str(roomid) + ".json"
if not os.path.exists(filename):
log.error("Serializer: room does not exists: id: " + str(roomid) +
" " + filename)
from game.room import Room
return Room(roomid)
roomfile = open(filename, 'r')
filecontent = roomfile.read()
try:
jsonobj = json.loads(filecontent)
except:
log.error("Serializer: JSON error: id: " + str(roomid) + " " +
filename)
jsonobj = False
log.debug("Serializer: loading room: id: " + str(roomid) + " " +
str(jsonobj))
from game.room import Room
room = Room(roomid)
if not jsonobj == False:
room.fromJSON(jsonobj)
return room
def construct_room(short_name,
long_name,
description='N/A',
adjacent_rooms=set(),
both_ways=True):
r = Room(short_name, long_name, description)
for room in adjacent_rooms:
target_room = basic_game.room_manager[room]
r.adjacent_rooms.add(target_room)
if both_ways:
target_room.adjacent_rooms.add(r)
basic_game.room_manager.rooms[r.short_name] = r
return r
def _run_pairing(self):
self._remove_offline_free_players()
players = list(self._free_players)
random.shuffle(players)
for i in range(int(len(players) / 2)):
p1 = players[i * 2]
p2 = players[i * 2 + 1]
room = Room(self, p1, p2)
self._free_players.remove(p1)
self._free_players.remove(p2)
self._playing_players.append(p1)
self._playing_players.append(p2)
p1.send_json({"event": "starting_game", "against": p2.username})
p2.send_json({"event": "starting_game", "against": p1.username})
self._rooms.append(room)
room.run_game()
def test_add_neighbor_raises_neighbor_exists_error_when_adding_to_occupied_direction(self):
first = Room()
second = Room()
third = Room()
first.add_neighbor(room=second, direction=Room.EAST)
first.add_neighbor(room=third, direction=Room.NORTH)
self.assertRaises(NeighborExistsError, first.add_neighbor, room=third, direction=Room.EAST)
def test_item_transfer():
bp_t = ItemTemplate('backpack', 'A backpack', 'N/A', True)
bp2_t = ItemTemplate('backpack2', 'Another backpack', 'N/A', True)
k_t = ItemTemplate('key', 'A key', 'N/A', False)
# create a backpack (1) with a key (1) in it
bp_1 = ItemContainer(bp_t)
k_1 = Item(k_t)
bp_1.add_item(k_1)
# create another backpack (2)
bp_2 = ItemContainer(bp_t)
# create another backpack (3) with another key (2) in it
bp_3 = ItemContainer(bp2_t)
k_2 = Item(k_t)
bp_3.add_item(k_2)
# create a room
r_1 = Room('room', 'room')
# create a character and give him backpacks (1) and (3)
c_1 = Character('transferer', '', '', r_1)
c_1.items.add_item(bp_1)
c_1.items.add_item(bp_3)
# create a character and give him backpack (2)
c_2 = Character('transferee', '', '', r_1)
c_2.items.add_item(bp_2)
# move backpack (1) with key (1) to other character
assert bp_1 in c_1.items
assert bp_1 not in c_2.items
c_1.items.transfer_item(bp_1.get_short_name(), c_2.items)
assert bp_1 not in c_1.items
assert bp_1 in c_2.items
# indirectly move key (2) from character's backpack (3) to other character
assert k_2 in bp_3
assert k_2 not in c_2.items
c_1.items.transfer_item(k_2.get_short_name(), c_2.items)
assert k_2 not in bp_3
assert k_2 in c_2.items
def enter_room(self, roomaction):
roomid = roomaction['roomid']
newroom = Room.get_room_by_id(roomid)
if self in self.room.player:
self.room.player.remove(self)
for p in self.room.player:
p.send_text(
i18n(
p.lang, {
"en":
"" + self.name + " leaves the room..." +
i18n(self.lang, roomaction['command'])
}))
# enter the room, first notification then enter
enteraction = None
for a in newroom.actions:
if 'roomid' in a and a['roomid'] == self.room.roomid:
enteraction = a
if enteraction is None:
for p in newroom.player:
p.send_text(
i18n(
p.lang, {
"en":
"" + self.name +
" enters the room with a puff of smoke..."
}))
else:
for p in newroom.player:
p.send_text(
i18n(
p.lang, {
"en":
"" + self.name + " enters the room..." +
i18n(self.lang, enteraction['command'])
}))
newroom.player.append(self)
self.send_room_actions(newroom)
self.room = newroom
self.send_player_new_command_list()
self.send_other_players_in_room(self.room)
self.send_is_room_admin()
def prepare_level(self, level_num):
num_rooms = 8 * level_num
rand_num = random.randint(1, num_rooms)
rand_room_num = rand_num + (8 * (level_num - 1))
num_rooms_per_side_previous = 1 + ((level_num - 1) * 2)
num_rooms_per_side_current = 1 + (level_num * 2)
curr_NW_number = num_rooms_per_side_previous**2
corners = [curr_NW_number, curr_NW_number + (num_rooms_per_side_current - 1), curr_NW_number + (2 * (num_rooms_per_side_current - 1)), curr_NW_number + (3 * (num_rooms_per_side_current - 1))]
self.corner_numbers[level_num] = corners
rand_room_direct = self.get_room_direction(number=rand_room_num, level=level_num)
room_to_add = Room(game_scale=self.a_scale, direc=rand_room_direct, backgroundX=self.startX, backgroundY=self.startY, this_level=level_num)
room_to_add.make_level_up()
room_to_add.add_entities()
self.room_dict[rand_room_num] = room_to_add
def add_room(self):
"""
Добавить комнату в игру
:param game_manager_ref: ссылка на менеджер игр
:return: объект комнаты
"""
new_room_id = self.find_first_not_busy_id_for_room()
if new_room_id is None:
return None
self.rooms.append(
Room(id_room=new_room_id,
type_room=self.rooms_type,
game_manager_ref=self.game_manager_ref))
added_room = self.rooms[-1]
return added_room
def generate_rooms(self):
room_types = []
room_types_iter = RoomTypes.__iter__()
for i in range(self.nb_rooms):
room_types.append(room_types_iter.__next__())
random.shuffle(room_types)
room_width = int(math.sqrt(len(room_types)))
room_height = math.ceil(len(room_types) / room_width)
for i in range(room_height):
for j in range(room_width):
if room_width * i + j >= len(room_types):
break
bottom_room = None
if i > 0:
bottom_room = self.rooms[room_width * (i - 1) + j]
left_room = None
if j > 0:
left_room = self.rooms[room_width * i + j - 1]
room_type = room_types[room_width * i + j]
room = Room(room_type)
if room_type is self.__class__.START_ROOM:
self.start_room = room
if bottom_room is not None:
room.add_neighbour_room(bottom_room, Directions.BOTTOM)
if left_room is not None:
room.add_neighbour_room(left_room, Directions.LEFT)
self.rooms.append(room)
def test_level_with_one_room(self):
room = Room(width=1, height=1)
room.x, room.y = 0, 0
self.level.add(room)
self.assertEqual(self.level.rooms, set([room]))
def setUp(self):
self.room = Room(width=1, height=3)
def main():
#test variables
#curses.initscr();
one = Player("DakotaJAlton")
Item1 = Item("axe", "weapon", 2, 10)
Item2 = Item("sword", "weapon", 2, 10)
Item3 = Item("helm", "helmet", 2, 10)
Monster1 = Monster("goblin", "goblin")
currentRoom = None
Room1 = Room("Start", "dank hallway")
Room2 = Room("Second", "dank Locker")
Room2.addMonster(Monster1)
Room2.addItem(Item1)
Room2.addItem(Item2)
Room2.addItem(Item3)
Room1.setExit("north", Room2)
Room2.setExit("south", Room1)
currentRoom = Room1
print "Welcome to the Multiplayer Text Adventure! \nWritten by Dakota Alton and Cole Severson!"
#termination while loop
while True:
user_input = map(lambda s: str.lower(s), str.split(raw_input('--> ')))
if user_input[0] == "info":
currentRoom.printInfo()
elif user_input[0] == "quit":
break
elif user_input[0] == "go":
if currentRoom.checkExit(user_input[1]):
currentRoom = currentRoom.getExit(user_input[1])
currentRoom.printInfo()
else:
print "Exit spelled wrong or non-existing"
elif user_input[0] == "inventory":
one.backpack()
elif user_input[0] == "grab":
if currentRoom.hasItem(user_input[1]):
one.pickup(currentRoom.snatchItem(user_input[1]))
else:
print "no such item here... scrub"
elif user_input[0] == "status":
one.getStats()
elif user_input[0] == "equip":
one.equipWeapon(user_input[1])
elif user_input[0] == "equipped":
one.getEquipped()
elif user_input[0] == "attack":
marker = False
for m in currentRoom.monsters:
if m.name == user_input[1]:
m.damageMonster(one.getDamage())
marker = True
#TODO add flavor text attack statement
if marker == False:
print "there is no monster with this name here..."
else:
print "invalid selection"
print termcolor.colored("-------------------", 'green')
#end of the main running loop
print "Thank you for playing..."
def setUp(self):
self.room = Room(width=2, height=2)
def test_rooms_are_too_far_away(self):
room_a, room_b = Room(width=1, height=1), Room(width=1, height=1)
room_a.x, room_a.y, room_b.x, room_b.y = 0, 0, 9, 9
self.assertEqual(_get_corridor_coordinates(room_a, room_b),
(None, (None, None), None))
def test_two_non_overlapping_rooms(self):
a, b = Room(width=1, height=1), Room(width=1, height=1)
coordinates = [(0, 0, 1, 0), (2, 2, 5, 5), (0, 0, 1, 1)]
for coordinate_set in coordinates:
a.x, a.y, b.x, b.y = coordinate_set
self.assertFalse(_rooms_overlap(a, b))
def test_two_one_tile_rooms_from_north(self):
room_a, room_b = Room(width=1, height=1), Room(width=1, height=1)
room_a.x, room_a.y, room_b.x, room_b.y = 0, 2, 0, 0
self.assertEqual(_get_corridor_coordinates(room_a, room_b),
((0, -1), ((0, 0), (0, 0)), (0, -1)))
def test_two_unadjacent_rooms(self):
a, b = Room(width=1, height=1), Room(width=1, height=1)
a.x, a.y, b.x, b.y = 0, 0, 2, 2
self.assertEqual(_get_adjacent_turfs(a, b), (set(), (None, None)))
def test_level_with_two_non_adjacent_rooms(self):
for x, y in [(0, 0), (3, 3)]:
room = Room(width=1, height=1)
room.x, room.y = x, y
self.level.add(room)
self.assertEqual(len(self.level.rooms), 2)
def test_one_room_within_another(self):
a, b = Room(width=3, height=3), Room(width=1, height=1)
a.x, a.y, b.x, b.y = 0, 0, 1, 1
self.assertTrue(_rooms_overlap(a, b))
def test_two_unadjacent_rooms(self):
a, b = Room(width=1, height=1), Room(width=1, height=1)
coordinates = [(0, 0, 1, 1), (1, 1, 0, 0), (0, 0, 4, 4)]
for coordinate_set in coordinates:
a.x, a.y, b.x, b.y = coordinate_set
self.assertFalse(_rooms_adjacent(a, b))
def test_two_adjacent_rooms(self):
a, b = Room(width=2, height=2), Room(width=2, height=2)
coordinates = [(0, 0, 2, 0), (0, 2, 0, 0), (0, 0, 1, 2)]
for coordinate_set in coordinates:
a.x, a.y, b.x, b.y = coordinate_set
self.assertTrue(_rooms_adjacent(a, b))
def test_two_overlapping_rooms(self):
a, b = Room(width=2, height=2), Room(width=2, height=2)
coordinates = [(0, 0, 1, 1), (2, 2, 1, 1), (0, 0, 0, 1)]
for coordinate_set in coordinates:
a.x, a.y, b.x, b.y = coordinate_set
self.assertFalse(_rooms_adjacent(a, b))