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))