def new_game():
"""
===========================================================================
Resets the state of the game.
===========================================================================
"""
Entity.health_bars.clear()
Entity.enemy_list.clear()
Projectile.attackSprites.clear()
Player.Player.is_dead = False
Player.Player.playerInstances = 0
Player.Player.playerInstance = Player.Player()
Player.Player.currentLane = 0
global current_player_level
current_player_level = 1
Room.rooms_list.clear()
Room.reset_room()
first_room = Room()
second_room = Room()
Room.current_room = first_room
Room.next_room = second_room
Helper.LANES['left'][1] = False
Helper.LANES['middle'][1] = False
Helper.LANES['right'][1] = False
populate_current_room()
def initMap():
intMap = [
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0],
[0,1,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0],
[0,1,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0],
[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
[0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0],
[0,1,1,1,1,1,0,1,0,0,0,0,0,0,0,1,0,1,1,1,1,1,0],
[0,0,0,0,0,1,0,1,1,1,1,0,1,1,1,1,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
[0,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],
[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0],
[0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],
[0,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0],
[0,1,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0],
[0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0],
[0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0],
[0,1,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,1,0],
[0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0],
[0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0],
[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],]
newDict = {}
for x in range(len(intMap)):
for y in range(len(intMap[x])):
if intMap[x][y] == 0:
newDict[(x,y)] = Room(Point(x,y), "SOLID")
if intMap[x][y] == 1:
newDict[(x,y)] = Room(Point(x,y), "EMPTY")
return newDict
def __init__(self,
name,
theme,
next,
width,
height,
room_str=None,
id=None):
if id:
self.id = id
else:
self.id = unique_id()
self.name = name
self.theme = theme
self.next = next
self.width = width
self.height = height
self.roomlist = []
for y in range(0, height):
room_row = []
for x in range(0, width):
if room_str:
room_row.append(Room(x, y, room_str.pop(0)))
else:
room_row.append(Room(x, y))
self.roomlist.append(room_row)
def fill_rooms(data_base,letters,cruise_answer,r_type):
"""
Regresa una lista con objetos tipo room
cruise_answer representa el crucero seleccionado
r_type representa el tipo de habitacion
letters representa la letra del pasillo
"""
rooms = []
for r_letter in range(0,data_base[cruise_answer-1]["rooms"][r_type][0]):
for r_number in range(1,data_base[cruise_answer-1]["rooms"][r_type][1]+1):
if r_type == "simple":
room = Room(letters[r_letter],r_number,data_base[cruise_answer-1]["capacity"][r_type],"Sencilla","Disponible",f"S{letters[r_letter]}{r_number}")
elif r_type == "premium":
room = Room(letters[r_letter],r_number,data_base[cruise_answer-1]["capacity"][r_type],"Premium","Disponible",f"P{letters[r_letter]}{r_number}")
else:
room = Room(letters[r_letter],r_number,data_base[cruise_answer-1]["capacity"][r_type],"VIP","Disponible",f"V{letters[r_letter]}{r_number}")
rooms.append(room)
return rooms
def setRooms(self):
positions_room_out = []
positions_room_out.append((self.doors[0].x, self.doors[0].y)) #I understand that door 1 is out of the laboratory
self.roomOut = Room(positions_room_out)
positions_room1 = []
for x in range(1,7):
for y in range(1,3):
pos = (x, y)
positions_room1.append(pos)
room1 = Room(positions_room1)
positions_room2 = []
for x in range(1,7):
for y in range(4,17):
pos = (x, y)
positions_room2.append(pos)
positions_room2.append((self.doors[1].x, self.doors[1].y))
room2 = Room(positions_room2)
positions_room3 = []
for x in range(8,14):
for y in range(4,10):
pos = (x, y)
positions_room3.append(pos)
positions_room2.append((self.doors[2].x, self.doors[2].y))
room3 = Room(positions_room3)
positions_room4 = []
for x in range(8,14):
for y in range(11,17):
pos = (x, y)
positions_room4.append(pos)
positions_room2.append((self.doors[3].x, self.doors[3].y))
room4 = Room(positions_room4)
self.rooms = [room1, room2, room3, room4, self.roomOut]
def createRoom(self):
self.rooms = [
Room(0),
Room(1),
Room(2),
Room(3),
Room(4),
Room(5),
Room(6),
Room(7),
Room(8),
Room(9)
]
passages = [{1, 4}, {0, 2}, {1, 3}, {2, 7}, {0, 5, 8}, {4, 6}, {5, 7},
{3, 6, 9}, {4, 9}, {7, 8}]
pass_ext = [{1, 4}, {0, 2, 5, 7}, {1, 3, 6}, {2, 7}, {0, 5, 8, 9},
{4, 6, 1, 8}, {5, 7, 2, 9}, {3, 6, 9, 1}, {4, 9, 5},
{7, 8, 4, 6}]
for index, room in enumerate(self.rooms):
for otherRoom in passages[index]:
room.addRoom(self.rooms[otherRoom])
for otherRoom in pass_ext[index]:
room.addExtendedRoom(self.rooms[otherRoom])
def add_edge(self, start, end, distance, edge_type='d'):
if start not in self.rooms.keys():
room = Room(start)
self.rooms[start] = room
if end not in self.rooms.keys():
room = Room(end)
self.rooms[end] = room
self.rooms[start].add_neighbor(self.rooms[end], distance)
if edge_type == 'u':
self.rooms[end].add_neighbor(self.rooms[start], distance)
def __gameSetup__(self): #Sets up all the rooms for the game
#(6,[(0,3),(2,6),(3,3),(3,4),(3,5),(4,3)])
rooms = [
Room(1, Grid.map1, self.roomResolution),
Room(2, Grid.map2, self.roomResolution),
Room(3, Grid.map3, self.roomResolution),
Room(4, Grid.map4, self.roomResolution),
Room(5, Grid.map5, self.roomResolution)
]
return rooms
def __init__(self, numSingles, numDoubles, name):
self.numSingles_ = numSingles
self.numDoubles_ = numDoubles
self.listRooms_ = []
for i in range(numSingles):
self.listRooms_.append(Room(1, [], name, i))
for i in range(numDoubles):
self.listRooms_.append(Room(2, [], name, i + numSingles))
self.numRooms_ = len(self.listRooms_)
self.name_ = name
def InstantiateRooms():
global roomDictionary
global currentRoom
#Assign the dictionary of rooms its rooms' info.
roomDictionary["room1"] = Room(
"This is our first test room",
[Exit("n", "room2"), Exit("e", "room3")])
roomDictionary["room2"] = Room("You have made it to the second room.",
[Exit("s", "room1")])
roomDictionary["room3"] = Room("Third room lads lads lads lads",
[Exit("w", "room1")])
#Assign the starting room to be the current room
currentRoom = roomDictionary['room1']
def __init__(self, game, size):
"""__init__ method for Dungeon class
Args:
game (<class 'Integrate.Game'>): Integrate.Game class object.
size (<class 'tuple'>): the size of dungeon in a 2 point tuple.
"""
self.game = game
self.size = pygame.math.Vector2(size)
w = int(self.size.x)
h = int(self.size.y)
self.room_matrix = [[None for i in range(w)]
for j in range(h)] # Initializing empty rooms 2D
self.room_list = [] # Initializing empty rooms 1D
self.current_room_index = [h // 2,
w // 2] # Starting room set to middle one
# beginnning room contains doors in all directions
room_start = Room(self.game, 'NSWE', 'start')
room_start.pos = [
self.current_room_index[0], self.current_room_index[1]
]
self.room_matrix[self.current_room_index[0]][
self.current_room_index[1]] = room_start
self.room_list.append(room_start)
self.room_current = self.room_matrix[self.current_room_index[0]][
self.current_room_index[1]]
# variables for animation
self.last_update = 0
self.current_frame = 0
self.tileset = random.choice(self.game.imageLoader.tileset_file)
def set_room(info_rooms):
"""Con la información del diccionario, sacada de la API instancia la habitación y los direrentes objetos
Args:
[Player]: información del juegador
Returns:
[Objeto clase Room]: biblioteca
[Objeto clase Object]: mueble_libros, mueble_sentarse, mueble_gabetas
"""
info_rooms = info_API()
biblioteca = Room(info_rooms[1]["name"])
mueble_libros = Object(info_rooms[1]["objects"][0]["name"].title())
mueble_libros.set_position(info_rooms[1]["objects"][0]["position"])
mueble_libros.set_game(info_rooms[1]["objects"][0]["game"])
mueble_sentarse = Object(info_rooms[1]["objects"][1]["name"].title())
mueble_sentarse.set_position(info_rooms[1]["objects"][1]["position"])
mueble_sentarse.set_game(info_rooms[1]["objects"][1]["game"])
mueble_gabetas = Object(info_rooms[1]["objects"][2]["name"].title())
mueble_gabetas.set_position(info_rooms[1]["objects"][2]["position"])
mueble_gabetas.set_game(info_rooms[1]["objects"][2]["game"])
biblioteca.add_object(mueble_libros)
biblioteca.add_object(mueble_sentarse)
biblioteca.add_object(mueble_gabetas)
biblioteca.set_design(designs_room.biblioteca_design())
return biblioteca, mueble_libros, mueble_sentarse, mueble_gabetas
def test_init(self):
"""
This test checks if the room is empty initially
"""
room = Room()
self.assertEqual("* * *\n* * *\n* * *\n", room.__str__(),
"Room should be empty but is not")
def __init__(self, key, room=None):
if room is None:
self.rooms = []
else:
self.rooms = [Room(room)]
self.key = key
self.children = []
def set_room(info_rooms):
"""Con la información del diccionario, sacada de la API instancia la habitación y los direrentes objetos
Args:
[Player]: información del juegador
Returns:
[Objeto clase Room]: plaza_rectorado
[Objeto clase Object]: saman, banco_1, banco_2
"""
plaza_rectorado = Room(info_rooms[2]["name"])
saman = Object(info_rooms[2]["objects"][0]["name"].title())
saman.set_position(info_rooms[2]["objects"][0]["position"])
saman.set_game(info_rooms[2]["objects"][0]["game"])
banco_1 = Object(info_rooms[2]["objects"][1]["name"].title())
banco_1.set_position(info_rooms[2]["objects"][1]["position"])
banco_1.set_game(info_rooms[2]["objects"][1]["game"])
banco_2 = Object(info_rooms[2]["objects"][2]["name"].title())
banco_2.set_position(info_rooms[2]["objects"][2]["position"])
banco_2.set_game(info_rooms[2]["objects"][2]["game"])
plaza_rectorado.add_object(saman)
plaza_rectorado.add_object(banco_1)
plaza_rectorado.add_object(banco_2)
plaza_rectorado.set_design(designs_room.saman_design())
return plaza_rectorado, saman, banco_1, banco_2
def _check_room_continuity(self, rid, plan):
""" Check whether the xys in given room are still continuous. If yes,
keep it, else, split it into new rooms and set it to None.
Args:
rid (int): the rid of room to check
plan (Plan): the plan contains this given room
"""
groups = self._group_xys_by_adjacency(plan.rooms[rid].xys)
if len(groups) == 1:
if not self.silent:
print("Room %d is still a whole piece" % rid)
else:
if not self.silent:
print("Room %d is divided into %d pieces" % (rid, len(groups)))
# create new rooms and set old room to None
for group in groups:
# add new room to self.rooms
room_new = Room(
function=plan.rooms[rid].function,
rid=plan.room_count,
xys=group
)
plan.rooms.append(room_new)
if not self.silent:
print("Room %d is split out" % room_new.rid)
# update the rid of xys
for xy in group:
plan.grids[xy].rid = plan.room_count
plan.room_count += 1
plan.rooms[rid] = None
if not self.silent:
print("Room %d is reset to None" % rid)
def createRoom(self, user, msg):
# Test if the input is long enough
if len(msg.split()) >= 2:
# Parse the room name
roomName = self.parseRoomName(msg)
# Checks if the room is already in the existing rooms
if not roomName in self.rooms:
# If the user is already in a room
if user.name in self.roomUserMap:
# Get old room and remove user from old room
oldRoom = self.roomUserMap[user.name]
self.rooms[oldRoom].removeUser(user)
# Create a new room and assign the user to the room
newRoom = Room(roomName)
self.rooms[roomName] = newRoom
self.addToRoom(user, roomName)
# If user tries to create a room that already exists
else:
# Send error message to client and print all the rooms
user.socket.sendall(
b"The " + roomName.encode() +
b" already exists. Join the following rooms or create a new room.\n"
)
self.listRooms(user)
else:
user.socket.sendall(self.commands)
def _parse_init_state(self, init_state):
""" Parse the given initial state into rooms and grids.
Args:
init_state (dict): initial state encoded as a dictionary.
"""
self.room_count = 0
self.grids = {}
self.rooms = []
self.xys = []
# for each room state namely each function:grid_coords pair in init_state
for function, grid_coords in init_state.items():
# instantialize this room and add it to self.rooms
room = Room(rid=self.room_count,
function=function,
xys=grid_coords)
self.rooms.append(room)
# instantialize the grids from this group of grid coordinates
for xy in grid_coords:
self.grids[xy] = Grid(xy=xy, rid=self.room_count)
self.room_count += 1
self.xys += grid_coords
def __load_dungeon(self):
currentX = 0
currentY = 0
if os.path.exists(MAP_PATH + self.id):
dgnFile = open(MAP_PATH + self.id, 'r')
d_dict = do_load(dgnFile)
dgnFile.close()
else:
d_dict = load_dungeon_by_id(self.id)
self.sizeX = d_dict['x']
self.sizeY = d_dict['y']
self.theme = d_dict['theme']
self.name = d_dict['name']
self.next = d_dict['next']
for line in d_dict['roomstr']:
the_room = Room(currentX, currentY, line)
self.rooms[(currentX, currentY)] = the_room
if the_room.is_entrance():
self.start = (currentX, currentY)
currentX += 1
if currentX == self.sizeX:
currentY += 1
currentX = 0
if currentY > self.sizeY:
break
def set_room(info_rooms):
"""Con la información del diccionario, sacada de la API instancia la habitación y los direrentes objetos
Args:
[Player]: información del juegador
Returns:
[Objeto clase Room]: cuarto_servidores
[Objeto clase Object]: puerta, rack, papelera
"""
cuarto_servidores = Room(info_rooms[2]["name"])
puerta = Object(info_rooms[4]["objects"][0]["name"].title())
puerta.set_position(info_rooms[4]["objects"][0]["position"])
puerta.set_game(info_rooms[4]["objects"][0]["game"])
rack = Object(info_rooms[4]["objects"][1]["name"].title())
rack.set_position(info_rooms[4]["objects"][1]["position"])
rack.set_game(info_rooms[4]["objects"][1]["game"])
papelera = Object(info_rooms[4]["objects"][2]["name"].title())
papelera.set_position(info_rooms[4]["objects"][2]["position"])
papelera.set_game(info_rooms[4]["objects"][2]["game"])
cuarto_servidores.add_object(puerta)
cuarto_servidores.add_object(rack)
cuarto_servidores.add_object(papelera)
cuarto_servidores.set_design(designs_room.server_design())
return cuarto_servidores, puerta, rack, papelera
def createRoom(self, noOfLight, noOfMotion, noOfSound, noOfLamps,
noOfCurtains, roomName): # creates a room object
lightSensors, motionSensors, soundSensors = self.createSensors(
noOfLight, noOfMotion, noOfSound) # creates
# local arrays to store sensors, and calls the create sensors method
lamps, curtainss = self.createDevices(
noOfLamps,
noOfCurtains) # does same thing as above except for devices
for lS in lightSensors: # gives the light sensors a value and a location
lS.setValue(randint(500, 1000))
lS.setLocation(roomName)
for mS in motionSensors: # same as above except for motion
mS.setValue(randint(0, 100))
mS.setLocation(roomName)
for sS in soundSensors: # ^^
sS.setValue(randint(30, 100))
sS.setLocation(roomName)
self.rooms.append(
Room(roomName, lamps, curtainss, lightSensors, soundSensors,
motionSensors)) # Creates a
# room and appends it to the room array
counter = 1
for room in self.rooms:
self.populateWorksheet(room, counter)
return self.rooms # Returns rooms
def __arrangerooms(self):
rooms = self.__doc.getElementsByTagName("rooms")
room = rooms[0].getElementsByTagName("room")
output = []
for x in room:
idaux = int(x.getAttribute("id"), 10)
capaux = int(x.getAttribute("capacity"), 10)
travelaux = {}
unavailables = []
travel = x.getElementsByTagName("travel")
unava = x.getElementsByTagName("unavailable")
times = []
if (travel != []):
for traveltime in travel:
travelaux[traveltime.getAttribute("room")] = int(
traveltime.getAttribute("value"), 10)
if (unava != []):
for unavailable in unava:
daysaux = unavailable.getAttribute("days")
startaux = int(unavailable.getAttribute("start"), 10)
lenaux = int(unavailable.getAttribute("length"), 10)
weekaux = unavailable.getAttribute("weeks")
unavailables.append(
Unavailable(daysaux, startaux, lenaux, weekaux))
output.append(Room(idaux, capaux, travelaux, unavailables))
return output
def set_room(info_rooms):
"""Con la información del diccionario, sacada de la API instancia la habitación y los direrentes objetos
Args:
[Player]: información del juegador
Returns:
[Objeto clase Room]: laboratorio_sl001
[Objeto clase Object]: pizarra, compu_1, compu_2
"""
info_rooms = info_API()
laboratorio_sl001 = Room(info_rooms[0]["name"])
pizarra = Object(info_rooms[0]["objects"][0]["name"].title())
pizarra.set_position(info_rooms[0]["objects"][0]["position"])
pizarra.set_game(info_rooms[0]["objects"][0]["game"])
compu_1 = Object(info_rooms[0]["objects"][1]["name"].title())
compu_1.set_position(info_rooms[0]["objects"][1]["position"])
compu_1.set_game(info_rooms[0]["objects"][1]["game"])
compu_2 = Object(info_rooms[0]["objects"][2]["name"].title())
compu_2.set_position(info_rooms[0]["objects"][2]["position"])
compu_2.set_game(info_rooms[0]["objects"][2]["game"])
laboratorio_sl001.add_object(pizarra)
laboratorio_sl001.add_object(compu_1)
laboratorio_sl001.add_object(compu_2)
laboratorio_sl001.set_design(designs_room.laboratorio_design())
laboratorio_sl001.set_design(designs_room.laboratorio_design())
return laboratorio_sl001, pizarra, compu_1, compu_2
def finish(self, last_command):
for item in self.player.room.inventory:
try:
if not item.locked and item.name == "trapdoor":
self.player.room.inventory.remove(item)
backpack = CarrierItem("backpack",
2,
self.player,
capacity=6)
basement = Room("basement",
inventory=[backpack],
connections=[self.player.room])
self.player.room.connections.append(basement)
trapdoor = StairsItem("trapdoor",
100,
self.player,
access_to=[basement])
self.player.room.inventory.append(trapdoor)
except AttributeError:
pass
if self.player.room.name == "basement":
print("I made it!")
self.complete = True
self.player.objective = None
self.player.completed_objectives.append("OpenBasement")
def find_north_pole_storage(self, room_file):
for line in room_file:
room_name = line[:-1]
room = Room(room_name)
if room.is_valid():
decrypted_name = room.get_decrypted_name()
if 'north' in decrypted_name:
print('Potential match: room {:d}, "{:s}"'.format(room.sector_id, decrypted_name))
def get_real_rooms_sector_id_sum(self, room_file):
valid_sector_id_sum = 0
for line in room_file:
room_name = line[:-1]
room = Room(room_name)
if room.is_valid():
valid_sector_id_sum += room.sector_id
return valid_sector_id_sum
def add_room(self, source_room, direction):
newx, newy = source_room.translate(direction)
new_room = Room(newx, newy, self.rh)
source_room.exits[direction] = new_room
source_room.bombs[direction] = False
new_room.exits[mirror(direction)] = source_room
self.rooms.append(new_room)
return new_room
def resetAllRooms(self):
self.rooms = set()
self.occupiedRooms = set()
self.emptyRooms = set()
self.roomCoordinates = set()
self.spawnRoom = Room("Spawn Area")
self.addRoomConnection(self.spawnRoom, None, None)
def fill_objects(self, rooms, meeting_times, docents):
for i in range(0, len(rooms)):
self._rooms.append(Room(rooms[i][0], rooms[i][1]))
for i in range(0, len(meeting_times)):
self._meeting_times.append(
MeetingTime(meeting_times[i][0], meeting_times[i][1]))
for i in range(0, len(docents)):
self._docents.append(Docent(docents[i][0], docents[i][1]))
def Init(self):
print(
"You've decided to go on an adventure. \n "
"Luckily, first dungeon was nearby, which wasn't looking as dangerous as others were talking about. \n "
"So, there you are, at the entrance to a pyramid-like dungeon! \n")
self.room["1-entrance"] = Room(
"1-entrance",
"There is a sign reading - DO NOT ENTER - What's your next move? \n",
"1-hall", "", "", "")
self.room["1-hall"] = Room(
"1-hall",
"You've entered the dungeon. but suddenly, as soon as you've entered it, the doors behind you closed. \n What is you next move? \n",
"1-northHallway", "", "", "")
self.room["1-northHallway"] = Room(
"1-northHallway",
"In front of you is a narrow corridor going only forwards \n ",
"1-branching", "", "", "")
self.room["1-branching"] = Room(
"1-branching",
"You've encountered different ways to go. What is your next move? \n ",
"1-branchingN", "1-branchingE", "1-northHallway", "1-branchingW")
self.room["1-branchingN"] = Room("1-branchingN", "", "", "", "", "")
self.room["1-branchingE"] = Room("1-branchingE", "", "", "", "", "")
self.room["1-branchingW"] = Room("1-branchingW", "", "", "", "", "")
self.currentRoom = "1-entrance"
