def CreateRoom4(roomSimple, map):
roomSimple.BuildRoom(12, 12, 1, 6)
# East Door
portal = Room.Portal()
portal.startPosition = 5
portal.size = 2
portal.destination = (0, 2, 11, 3)
roomSimple.wall[1].portalList = [portal]
roomSimple.wall[1].UpdatePortalRange()
# North door
portal = Room.Portal()
portal.startPosition = 5
portal.size = 2
portal.destination = (0, 3, 0, -11)
roomSimple.wall[0].portalList = [portal]
roomSimple.wall[0].UpdatePortalRange()
roomSimple.SetRoomID(4, map)
#Add a Rug
rug = RoomFeature.Feature()
rug.CreateRug(1)
rug.SetPosition(2, 3)
roomSimple.AddFeature(rug)
def test_room_paths():
center = Room("Center", "Test room is the center.")
north = Room("South", "Test room in the north.")
south = Room("South", "Test room in the south.")
center.add_paths({'north':north, 'south':south})
assert_equal(center.go('north'), north)
assert_equal(center.go('south', south))
def CreateRoom2(roomSimple, map):
roomSimple.BuildRoom(10,7,4,16)
portal = Room.Portal()
portal.startPosition = 2
portal.size = 2
portal.destination = (0,4,-11,-3)
roomSimple.wall[3].portalList = [portal]
roomSimple.wall[3].UpdatePortalRange()
roomSimple.SetRoomID(2,map)
portal = Room.Portal()
portal.startPosition = 2
portal.size = 2
portal.destination = (0,5,9,-3)
roomSimple.wall[1].portalList = [portal]
roomSimple.wall[1].UpdatePortalRange()
#Add a staircase
stairs = RoomFeature.Feature()
stairs.CreateStaircase(0)
stairs.SetPosition(2,3)
stairs.FeatureBlocks[2].EffectData = (1,2,1) # Room, OffsetX, offsety
stairs.FeatureBlocks[5].EffectData = (1,2,1) # Room, OffsetX, offsety
roomSimple.AddFeature(stairs)
def get_current_room(self):
room_path = self.world_folder + "/rooms/room_{}_{}.json".format(
int(self.current_room.x), int(self.current_room.y))
if not os.path.isfile(room_path):
Room.ScreenGenerator(self.current_room.copy(), self)
room_file = open(room_path, "rb")
room_json = room_file.read()
room_file.close()
room_data = json.loads(room_json)
room_map = room_data["map"]
room_objects = room_data["objects"]
room_connections = room_data["connections"]
new_room_objects = []
for obj in range(0, len(room_objects)):
obj_to_add = ObjectUnpacker.unpack(room_objects[obj], self.camera)
if isinstance(obj_to_add, Object):
new_room_objects.append(obj_to_add)
room_objects = new_room_objects
room_renderer = Room.RoomRenderer(room_map,
"game_data/tileset/tileset1",
objects=room_objects,
camera=self.camera,
connections=room_connections)
room_renderer.fix()
room_renderer.render()
self.save_room()
self.current_room_obj = room_renderer
return room_renderer
def __init__(self, cam_resolution, camera_number, horizontal_sect,
vertical_sect, white_level, person_ammount, new_person_tresh,
sleep_period_value):
print " analysis"
#podzial sceny na sektory
self.note_file_url = "results/results"
self.cam_resolution = cam_resolution
self.camera_number = camera_number
self.white_level = white_level
self.person_ammount = person_ammount
self.sectors = []
self.sleep_period_value = sleep_period_value
row = []
self.persons = []
miny_x = range(0, cam_resolution[0],
cam_resolution[0] / horizontal_sect)
maksy_x = range(cam_resolution[0] / horizontal_sect,
(cam_resolution[0] / horizontal_sect *
(horizontal_sect + 1)),
cam_resolution[0] / horizontal_sect)
miny_y = range(0, cam_resolution[1], cam_resolution[1] / vertical_sect)
maksy_y = range(cam_resolution[1] / vertical_sect,
(cam_resolution[1] / vertical_sect *
(vertical_sect + 1)),
cam_resolution[1] / vertical_sect)
for i in range(vertical_sect):
miny, maksy = miny_y[i], maksy_y[i]
for column in range(horizontal_sect):
minx, maksx = miny_x[column], maksy_x[column]
row.append((minx, miny, maksx, maksy))
self.sectors.append(row)
self.room = Room(person_ammount, new_person_tresh)
f = open(self.note_file_url, "w")
f.close()
def BSP(ws: np.mat) -> None:
# print("BSP : ", ws.shape)
height, width = ws.shape
bsp = tcod.bsp.BSP(x=2, y=2, width=width - 4, height=height - 4)
bsp.split_recursive(
# depth=randint(10, 15)
depth=6,
min_width=1,
min_height=1,
max_horizontal_ratio=1.5,
max_vertical_ratio=1.5,
)
# In pre-order, leaf nodes are visited before the nodes that connect them
for node in bsp.pre_order():
if node.children:
node1, node2 = node.children
Room.connect_rooms(ws, node1, node2)
else:
# Room Too Big, Split Further
limit = 6
if node.width > width//limit and node.height > height//limit and node.width > 3 and node.height > 3:
BSP(ws[node.y + 1:node.y + node.height - 1, node.x + 1: node.x + node.width - 1])
else: # Dig out room
Room.create_room(ws, node)
def test_room_paths():
center = Room("Center", "Test room in the center.")
north = Room("North", "Test room in the north.")
south = Room("South", "Test room in the south.")
cent.add_paths({'north': north, 'south': south})
assert_equal(center.go('north'), north)
assert_equal(center.go('south'), south)
def switchRoom(d):
oldRoom = d["currentRoom"]
player = Room.getPlayer(oldRoom)
x, y = Entity.getPosition(player)
if x < 2 or x > 77 or y < 1 or y > 38:
Room.removeEntity(oldRoom, player)
if x < 2:
setCurrentRoom(d, Room.getLeftRoom(oldRoom))
x = 77
if x > 77: # Taille max en x des salles
setCurrentRoom(d, Room.getRightRoom(oldRoom))
x = 2
if y < 1:
setCurrentRoom(d, Room.getUpRoom(oldRoom))
y = 38
if y > 38: # Taille max en y des salles
setCurrentRoom(d, Room.getDownRoom(oldRoom))
y = 1
Entity.setPosition(player, x, y)
Room.addEntity(d["currentRoom"], player)
def __init__(self, agent):
'''
Constructor
'''
self.r1 = Room.Room('A', 'dirty')
self.r2 = Room.Room('B', 'dirty')
self.agent = agent
self.currentRoom = self.r1
self.delay = 1000
self.step = 1
self.action = ""
def __init__(self, radius):
self.radius = radius
self.room_grid = [[0 for i in range(radius * 2 - 1)]
for j in range(radius * 2 - 1)]
self.doorgrid = [[[0, 0, 0, 0] for i in range(radius * 2 - 1)]
for j in range(radius * 2 - 1)]
diam = radius * 2 - 1
for i in range(-radius + 1, radius):
for j in range(-radius + 1, radius):
value = ((i)**2 + (j)**2)**(1 / 2)
if value <= radius - 1:
self.room_grid[i + radius - 1][j + radius - 1] = Room(
i + radius - 1, j + radius - 1, [])
room_starter = self.room_grid[radius - 1][radius - 1]
for i in range(diam):
for j in range(diam):
temp = self.room_grid[i][j]
if type(temp) == type(Room(None, None, [])):
temp_right = None
temp_down = None
try:
if i + 1 < diam or i + 1 >= 0:
temp2 = self.room_grid[i + 1][j]
except Exception:
continue
try:
if j + 1 < diam or j + 1 >= 0:
temp3 = self.room_grid[i][j + 1]
except Exception:
continue
if type(temp2) == type(Room(None, None,
[])) and random() > 0.2:
location = 1 + int(random() * 13)
temp.addDoor([3, location])
temp2.addDoor([2, location])
if type(temp3) == type(Room(None, None,
[])) and random() > 0.2:
location = 1 + int(random() * 18)
temp.addDoor([1, location])
temp3.addDoor([0, location])
self.connect_rooms()
self.clear_unconnected()
self.setRoomTypes()
self.buildChests()
class EnemyTests(unittest.TestCase):
def setUp(self):
self.player = Player("Obi")
self.room = Room(self.player)
def test_enemy_count(self):
self.assertEqual(True, self.room.number_of_enemies > 0)
def test_enemies(self):
self.room.generate_enemies()
self.assertEqual([], self.room.enemies)
def test_room_knows_player_name(self):
self.assertEqual("Obi", self.room.player.name)
def test_treasure_chest_starts_with_0(self):
self.assertEqual(0, self.room.treasure_chest)
def test_add_gold_to_chest(self):
self.room.add_gold_to_treasure_chest()
self.room.add_gold_to_treasure_chest()
self.assertEqual(True, self.room.treasure_chest >= 20)
def test_treasure_chest_looting(self):
self.room.add_gold_to_treasure_chest()
self.room.loot_treasure_chest()
self.assertEqual(True, self.room.player.goldPouch > 9)
self.assertEqual(0, self.room.treasure_chest)
def room_4_state_5():
''' room 4 state 5 '''
Game1.introduction()
print(Room.load_room_4_description_2())
print(room_ascii.room_4_state_4())
print(Room.load_room_4_description_3())
command = prompt()
if command == "q" or command == "quit":
print("Quitting the game, hope you had fun!")
Game1.emptyInventory()
sys.exit()
elif command == "h" or command == "help":
Game1.help_choice()
print()
print("______________________________________________")
room_4_state_5()
elif command == "inv" or command == "inventory":
Game1.inv()
room_4_state_5()
elif command == "fw" or command == "forward" or command == "cheat" or command == "ready":
print("The fairy snaps her fingers and casts her spell")
print("______________________________________________")
room_5_state_0()
elif command == "bw" or command == "backwards":
print("Taking one step back...")
print("______________________________________________")
Game4.backwards()
Game1.addItem("boots")
room_4_state_4()
elif command in Game1.always_available_options()[:]:
print(Game4.respond_options_state_5(command))
print()
print("______________________________________________")
room_4_state_5()
elif command.split(' ', 1)[0] in Game1.object_options()[:]:
try:
Game4.respond_object_options_state_5(command)
print()
print("______________________________________________")
room_4_state_5()
except IndexError:
print("This command needs to be used with an object")
print("______________________________________________")
room_4_state_5()
elif command not in Game1.always_available_options(
)[:] or command not in Game1.object_options()[:]:
print("Thats not a valid choice")
print()
print("______________________________________________")
room_4_state_5()
def setRoomTypes(self):
maxDist = 0
mdi = -1
mdj = -1
for i in range(len(self.room_grid)):
for j in range(len(self.room_grid)):
if type(self.room_grid[i][j]) == type(Room(None, 0, 0)):
if (i == self.radius - 1 and j == self.radius - 1):
self.room_grid[i][j].setRoomType("Base")
elif (i == 0 or j == 0 or i == self.radius * 2 - 2
or j == self.radius * 2 - 2):
self.room_grid[i][j].setRoomType("Boss")
elif random() > 0.3:
self.room_grid[i][j].setRoomType("Enemy")
temp_dist = self.room_grid[i][j].getDist()
if temp_dist > maxDist:
maxDist = temp_dist
mdj = i
mdi = j
self.room_grid[mdj][mdi].setRoomType("Exit")
def generate(self):
last = -1
def opp(dir):
if dir == 0:
return 2
if dir == 2:
return 0
if dir == 1:
return 3
if dir == 3:
return 1
for i in range(self.noOfRooms - 1):
direction = random.randrange(0, 4)
while (last == opp(direction)):
direction = random.randrange(0, 4)
if (direction == 0):
self.roomConnections[i] = [
i, i + 1, 0
] # 0 -> bottom to top 1 -> left to right
elif (direction == 1):
self.roomConnections[i] = [i, i + 1, 1]
elif (direction == 2):
self.roomConnections[i] = [i + 1, i, 0]
elif (direction == 3):
self.roomConnections[i] = [i + 1, i, 1]
last = direction
for i in range(self.noOfRooms):
self.rooms[i] = Room(i, random.randrange(0, len(RoomTypes)),
self.lvl)
self.rooms[i].generate()
def __init__(self, width, height, mapSize, roomNum):
self.width = width
self.height = height
#iterate over the map and fill it with wall tiles
# self._map = ["-" for i in xrange(0, width * height)]
# self._map = ["◊" for i in xrange(0, width * height)]
self._map = [" " for i in xrange(0, width * height)]
self.mapSize = mapSize
hallwayDist = MAX_DIST_FOR_HALLWAYS.get(self.mapSize, 40)
# self.roomNum = roomNum
# roomDims = DimRange(roomMin, roomMin, roomMax, roomMax)
# self.roomDims = roomDims
self.rooms = [Room(self, ROOM_DIMS)] * roomNum
for i in xrange(0, roomNum):
self.rooms[i].myIndex = i
#print "Testing to see if room: %d intersects with another room" %i
while (self.isRoomIntersectingAnotherRoom(i)):
self.rooms[i] = self.RollRoom(i)
self.proximities = []
self.buildAndSortProximities()
self.hallways = []
self.makeHallways(hallwayDist)
def __init__(self):
self.lifes = 3
self.hungover = True
self.key = False
self.earring = False
self.map = False
self.location = Room.Cabin()
def __init__(self):
Room.__init__(self)
walls = [[0, 0, 20, 250, RED],
[0, 350, 20, 250, RED],
[780, 0, 20, 250, RED],
[780, 350, 20, 250, RED],
[20, 0, 760, 20, RED],
[20, 580, 760, 20, RED],
[190, 50, 20, 500, GREEN],
[590, 50, 20, 500, GREEN]
]
for item in walls:
wall = Wall(item[0], item[1], item[2], item[3], item[4])
self.wall_list.add(wall)
def select_rooms(self):
self._c.execute("SELECT * FROM room")
rooms = self._c.fetchall()
returnRooms = []
for i in range(0, len(rooms)):
returnRooms.append(Room.Room(rooms[i][0], rooms[i][1]))
return returnRooms
def clear_unconnected(self):
for i in range(len(self.room_grid)):
for j in range(len(self.room_grid)):
if type(self.room_grid[i][j]) == type(
Room(None, None,
[])) and not self.room_grid[i][j].connected:
self.room_grid[i][j] = 0
def init_room(data):
"""
Returns a room built with the room json data.
args:
data (dict): structure that contains all room data
"""
name = data['room_name']
long_intro = data['long_intro']
short_intro = data['short_intro']
long_exit = data['long_exit']
north = data['north']
south = data['south']
east = data['east']
west = data['west']
features = init_room_features(name, data)
objects = init_room_objects(data)
north_exits = init_list(data['north_exits'])
south_exits = init_list(data['south_exits'])
east_exits = init_list(data['east_exits'])
west_exits = init_list(data['west_exits'])
room_type = data['room_type']
restricted = data['restricted']
room = Room(name, long_intro, short_intro, long_exit, north, south, east,
west, features, objects, north_exits, south_exits, east_exits,
west_exits, room_type, restricted)
return room
def __init__(self,cam_resolution, camera_number, horizontal_sect, vertical_sect, white_level, person_ammount, new_person_tresh, sleep_period_value):
print " analysis"
#podzial sceny na sektory
self.note_file_url = "results/results"
self.cam_resolution = cam_resolution
self.camera_number = camera_number
self.white_level = white_level
self.person_ammount = person_ammount
self.sectors = []
self.sleep_period_value =sleep_period_value
row =[]
self.persons =[]
miny_x = range(0, cam_resolution[0], cam_resolution[0]/horizontal_sect)
maksy_x = range(cam_resolution[0]/horizontal_sect, (cam_resolution[0]/horizontal_sect*(horizontal_sect+1)), cam_resolution[0]/horizontal_sect)
miny_y = range(0,cam_resolution[1] , cam_resolution[1] /vertical_sect)
maksy_y = range(cam_resolution[1]/vertical_sect, (cam_resolution[1]/vertical_sect*(vertical_sect+1)), cam_resolution[1]/vertical_sect )
for i in range(vertical_sect):
miny, maksy= miny_y[i], maksy_y[i]
for column in range(horizontal_sect):
minx, maksx = miny_x[column], maksy_x[column]
row.append((minx, miny, maksx, maksy))
self.sectors.append(row)
self.room = Room(person_ammount, new_person_tresh)
f= open(self.note_file_url, "w")
f.close()
def test():
import Room
### remove the monotany of recreating player name every time
# link = create_player()
link = Hero("linko")
enemy = Room.create_opponent()
zelda_battle(link, enemy)
def room_5_state_0():
''' POOF state room 5 '''
print(room_ascii.room_5_state_1())
time.sleep(2)
Game1.addItem("ring")
print(Room.load_room_5_description_2())
room_5_state_1()
def __init__(self, width, height):
self.username = "******"
self.rooms = []
self.player = Player()
self.rooms.append(Room(width, height, self.player))
self.currentRoom = self.rooms[0]
def __init__(self, wielkosc_mapygen=None):
global ile_map
global wybrana
# tworzenie mapy gry
if wielkosc_mapygen is not None:
wielkosc_mapy = [0] * wielkosc_mapygen.get()
else:
wielkosc_mapy = [0] * random.randint(7, 14)
wybrana = wielkosc_mapy
self.mapa = [] # ATR: MAPA
for i in range(len(wielkosc_mapy)):
self.mapa.append(wielkosc_mapy[:])
self.list_of_item_pokoi = [
Room.Pokoj() for i in range(len(wielkosc_mapy)**2)
] # ATR: list_of_item_POKOI
k = 0
for i in range(len(wielkosc_mapy)):
for j in range(len(wielkosc_mapy)):
self.mapa[i][j] = self.list_of_item_pokoi[k]
if random.choice(prawda_falsz):
self.mapa[i][j].otwarty = True
if random.choice(prawda_falsz):
self.mapa[i][j].event = True
else:
self.mapa[i][j].otwarty = False
k += 1
self.mapa[len(wielkosc_mapy) - 1][len(wielkosc_mapy) -
1].otwarty = True
def testSetRoomName(self):
"""
Prueba unitaria para setRoomName.
"""
self.room = Room.Room("Nueva", "Teresa")
self.assertEqual("Nueva", self.room.getRoomName())
self.room.setRoomName("Prueba")
self.assertEqual("Prueba", self.room.getRoomName())
def testGetUsersInRoom(self):
"""
Prueba unitaria para getUsersInRoom.
"""
self.room6 = Room.Room("Nueva", "Marco")
self.assertEqual([], self.room6.getUsersInRoom())
self.room6.addUsersInRoom("Daniel")
self.assertEqual(["Daniel"], self.room6.getUsersInRoom())
def testAddUsersInRoom(self):
"""
Prueba unitaria para addUsersInRoom.
"""
self.room4 = Room.Room("Nueva", "Luci")
self.assertEqual([], self.room4.getUsersInRoom())
self.room4.addUsersInRoom("Enrique")
self.assertEqual(["Enrique"], self.room4.getUsersInRoom())
def testGetRoomName(self):
"""
Prueba unitaria para getRoomName.
"""
self.room1 = Room.Room("Nueva1", "Carmen")
self.assertEqual("Nueva1", self.room1.getRoomName())
self.room1.setRoomName("Prueba1")
self.assertEqual("Prueba1", self.room1.getRoomName())
def __init__(self):
self.room_class = r.Room()
self.map = [[self.room_class.all_rooms.get("Vestibule")]]
self.main_room = (0, 0)
self.difficulty_level = d.All_Difficulties().difficulties.get("Normal") # random diff for now
self.player_list = [h.HeroesCards.aelfric, h.HeroesCards.cecilia, h.HeroesCards.tetemeko] # random players for now
self.current_player = self.player_list[0]
self.map[0][0].players = self.player_list
def changeroom(self, nextroom):
print(nextroom + " test1")
if nextroom == 'káeta':
self.location = Room.Cabin()
return self.location.whereami()
elif nextroom == 'bar':
self.location = Room.Bar()
return self.location.whereami()
elif nextroom == 'strönd':
self.location = Room.Beach()
return self.location.whereami()
elif nextroom == 'skógur':
if self.map:
self.location = Room.Forrest()
return self.location.whereami()
else:
return 'Þetta er ekki lögleg staðseting'
def CreateRoom5(roomSimple, map):
roomSimple.BuildRoom(9, 9, 2, 7)
roomSimple.SetRoomID(5, map)
portal = Room.Portal()
portal.startPosition = 5
portal.size = 2
portal.destination = (0, 2, -9, 3)
roomSimple.wall[3].portalList = [portal]
roomSimple.wall[3].UpdatePortalRange()
portal = Room.Portal()
portal.startPosition = 4
portal.size = 2
portal.destination = (0, 6, 0, -10)
roomSimple.wall[0].portalList = [portal]
roomSimple.wall[0].UpdatePortalRange()
def Room2D():
global totRooms
from gpiozero import LED
LED(12).on()
totRooms += 1
intStations = [0]
points2D = 360
with open('outfile.json') as json_file:
data = json.load(json_file)
for area in data['areas']:
if area['id'] == 'R' + str(totRooms):
roomname = area['room']
stationname = area['stations']
note = area['notes']
activeroomtxt.configure(text='Active Room: ' + roomname)
stationlabel.configure(text='Station: ' + stationname)
stationnotes.configure(text='Note: ' + note)
window.update()
room = Room(roomname, totRooms, intStations)
room.room2DScan(points2D)
if activeStation >= 0:
xoff = stations[activeStation].x * -1
yoff = stations[activeStation].y * -1
room.rotate2Ddata(stations[activeStation].quatw,
stations[activeStation].quatx,
stations[activeStation].quaty,
stations[activeStation].quatz)
else:
xoff = 0
yoff = 0
print(len(room.x2d))
room.addOffset2D(xoff, yoff)
room.showRoom(rooms)
rooms.append(room)
with open('outfile.json') as out_file:
data = json.load(out_file)
for area in data['areas']:
if area['id'] == 'R' + str(totRooms):
area['x2d'] = room.x2d
area['y2d'] = room.y2d
window.update()
os.remove('outfile.json')
with open('outfile.json', 'w') as out_file:
json.dump(data, out_file, indent=4)
print(rooms)
LED(12).off()
def __init__(self):
Room.__init__(self)
# Make the walls. (x_pos, y_pos, width, height)
# This is a list of walls. Each is in the form [x, y, width, height]
walls = [[0, 0, 20, 250, WHITE],
[0, 350, 20, 250, WHITE],
[780, 0, 20, 250, WHITE],
[780, 350, 20, 250, WHITE],
[20, 0, 760, 20, WHITE],
[20, 580, 760, 20, WHITE],
[390, 50, 20, 500, BLUE]
]
# Loop through the list. Create the wall, add it to the list
for item in walls:
wall = MyWall(item[0], item[1], item[2], item[3], item[4])
self.wall_list.add(wall)
def test_room_paths():
center = Room("Center", "Test room in the center")
north = Room("North", "Test room in the north")
south = Room("South", "Test room in the south")
center.add_paths({'north': north, 'south': south})
assert_equal(center.go('north', north)
assert_equal(center.go('south', south)
def test_map():
start = Room("Start", "You can go west and down a hole.")
west = Room("Trees", "There are trees here, you can go east.")
down = Room("Dungeon", "It's dark down here, you can go up.")
start.add_paths({'west': west, 'down': down})
west.add_paths({'east': start})
down.add_paths({'up': start})
assert_equal(start.go('west'), west)
assert_equal(start.go('west').go('east'), start)
assert_equal(start.go('west'),go('up'), start)
def __init__(self):
Room.__init__(self)
walls = [[0, 0, 20, 250, PURPLE],
[0, 350, 20, 250, PURPLE],
[780, 0, 20, 250, PURPLE],
[780, 350, 20, 250, PURPLE],
[20, 0, 760, 20, PURPLE],
[20, 580, 760, 20, PURPLE]
]
for item in walls:
wall = MyWall(item[0], item[1], item[2], item[3], item[4])
self.wall_list.add(wall)
for x in range(100, 800, 100):
for y in range(50, 451, 300):
wall = MyWall(x, y, 20, 200, RED)
self.wall_list.add(wall)
for x in range(150, 700, 100):
wall = MyWall(x, 200, 20, 200, WHITE)
self.wall_list.add(wall)
def initUI(self,name, parent, tracker):
#parsePlantXML(name)
#FOR TESTING PURPOSES ONLY!!!!!
roomList = []
if (name == "Floor 1"):
roomList = ["Room 1","Room 2","Room 3"]
elif (name == "Floor 2"):
roomList = ["Room 4","Room 5","Room 6"]
else:
roomList = ["Room 7","Room 8","Room 9"]
grid = QtGui.QGridLayout()
grid.setSpacing(10)
grid.setVerticalSpacing(20)
#floorList is returned by xml parser --> ["Floor 1","Floor 2",...]
#create instances of FloorButton (extends AbstractButton) from floorList
for i in range(len(roomList)):
theRoom = Room(roomList[i],self,self.tracker)#QtGui.QGroupBox(roomList[i]) #should be Room()
theRoomButton = RoomButton(roomList[i], self, theRoom)
theRoom.addButton(theRoomButton)
self.roomButtonList.append(theRoomButton) #abstract button --> FloorButton
self.roomObjectList.append(theRoom)
for k in range(len(self.roomButtonList)):
grid.addWidget(self.roomButtonList[k], 0, k)
#Comment after testing!!!!!
for k in range(len(self.roomObjectList)):
grid.addWidget(self.roomObjectList[k], 1, 0, 1, len(self.roomButtonList))
self.setLayout(grid)
# self.setGeometry(300, 300, 350, 300)
# self.show()
self.setStyleSheet(""".Floor { background-color: white; font-size: 10px; border-radius: 6px}
.Floor::title { color: transparent; background-color: transparent; padding-top: 5px; padding-left: 5px; }""")
def load_game_world(self):
stairwell = Room("../data/mod/jcmbstairs.egg")
stairwell.add_all_visibles_and_collidables(render, self.bullet_world)
def __init__(self):
yaml_path = 'config/airplane_1_alpha.yaml'
self.rooms = {}
self.abilities = []
self.ability_dict = {}
self.enemies = {}
room_data = yaml.load_all( open(yaml_path, 'r') )
### Load map data
print "Loading map file..."
for d in room_data:
newroom = Room()
newroom.setDescription(d['description'])
directional_descs = [d['look_north'], d['look_south'], d['look_east'], d['look_west']]
newroom.setDirectionalDescriptions(directional_descs)
## Check for alt descriptions
if 'look_alt_north' in d.keys():
newroom.setAltDesc('north', d['look_alt_north'])
newroom.setAltDescBool('north', False)
if 'look_alt_south' in d.keys():
newroom.setAltDesc('south', d['look_alt_south'])
newroom.setAltDescBool('south', False)
if 'look_alt_east' in d.keys():
newroom.setAltDesc('east', d['look_alt_east'])
newroom.setAltDescBool('east', False)
if 'look_alt_west' in d.keys():
newroom.setAltDesc('west', d['look_alt_west'])
newroom.setAltDescBool('west', False)
moves = [d['north'], d['south'], d['east'], d['west']]
newroom.setDirectionalMoves(moves)
self.rooms[(d['x'],d['y'])] = newroom
room_items = []
for item in d['items']:
new_obj = InteractiveObject()
new_obj.setName(item['name'])
new_obj.setItems(item['item_list'])
new_obj.setUnlockItems(item['unlock_item'])
if len(new_obj.getUnlockItems()) > 0:
new_obj.setUnlockText(item['unlock_text'])
new_obj.setKeywords(item['keyword'])
new_obj.setDirectionToChange(item['map_side_to_change'])
new_obj.setExamineText(item['examine_text'])
new_obj.setEquippable(item['equippable'])
if new_obj.getEquippable():
new_obj.setStrength(item['strength'])
new_obj.setIntellect(item['intellect'])
# Alt text to change
if 'alt_text_dir' in item.keys():
new_obj.setAltDescDirection(item['alt_text_dir'])
## Droppable items, if any
d_items = []
for d_item in item['droppable_items']:
d_obj = InteractiveObject()
d_obj.setName(d_item['name'])
d_obj.setItems(d_item['item_list'])
d_obj.setUnlockItems(d_item['unlock_item'])
if len(d_obj.getUnlockItems()) > 0:
d_obj.setUnlockText(d_item['unlock_text'])
d_obj.setKeywords(d_item['keyword'])
d_obj.setDirectionToChange(d_item['map_side_to_change'])
d_obj.setExamineText(d_item['examine_text'])
d_obj.setEquippable(d_item['equippable'])
if d_obj.getEquippable():
d_obj.setStrength(d_item['strength'])
d_obj.setIntellect(d_item['intellect'])
d_items.append(d_obj)
new_obj.setDroppableItems(d_items)
room_items.append(new_obj)
newroom.setItems(room_items)
newroom.setEnemies(d['enemies'])
print "Map file loaded!"
### Load ability data
ability_yaml_path = 'config/ability_bank.yaml'
ability_data = yaml.load_all( open(ability_yaml_path, 'r') )
for a in ability_data:
new_a = Ability()
new_a.setName(a['name'])
new_a.setLevelReq(a['level_req'])
new_a.setDamage(a['damage'])
new_a.setForPlayer(a['for_player'])
self.ability_dict[a['id']] = new_a
#self.abilities.append(new_a)
### Load enemy data
enemy_yaml = 'config/enemies.yaml'
enemy_data = yaml.load_all( open(enemy_yaml, 'r') )
for e in enemy_data:
new_e = Enemy()
id = e['id']
#new_e.setPos((e['x'], e['y']))
new_e.setName(e['name'])
new_e.setHP(e['hp'])
new_e.setMP(e['mp'])
new_e.setXP(e['xp'])
for a_id in e['abilities']:
new_e.addAbility(self.ability_dict[a_id])
self.enemies[id] = new_e
import Room
central_corridor = Room("Central Corridor",
"""
The Gothons of Planet Percal #25 have invaded your ship and destroyed
your entire crew. You are the last surviving member and your last
mission is to get the neutron destruct bomb from the Weapons Armory,
put it in the bridge, and blow the ship up after getting into an
escape pod.
You're running down the central corridor to the Weapons Armory when
a Gothon jumps out, red scaly skin, dark grimy teeth, and evil clown costume
flowing around his hate filled body. He's blocking the door to the
Armory and about to pull a weapon to blast you.
""")
laser_weapon_armory = Room("Laser Weapon Armory",
"""
Lucky for you they made you learn Gothon insults in the academy.
You tell the one Gothon joke you know:
Lbhe zbgure vf fb sng, jura fur fvgf nebhaq gur ubhfr, fur fvgf nebhaq gur ubhfr.
The Gothon stops, tries not to laugh, then busts out laughing and can't move.
While he's laughing you run up and shoot him square in the head
putting him down, then jump through the Weapon Armory door.
You do a dive roll into the Weapon Armory, crouch and scan the room
for more Gothons that might be hiding. It's dead quiet, too quiet.
You stand up and run to the far side of the room and find the
neutron bomb in its container. There's a keypad lock on the box
and you need the code to get the bomb out. If you get the code
def createWorld(self):
# Criando as salas...
salaMisteriosa = Room(
"sala misteriosa",
"Você abre os olhos devagar, sua visão ainda embaçada consegue identificar que"
+ " você encontra-se em um salão tão brilhante quanto ouro. Ao seu lado você percebe uma silhueta de um homem vestido em uma"
+ " armadura e segurando o que parece ser uma lança... Ele dirigi-se à você...",
)
cabana = Room(
"cabana",
"Você acorda assustado e suando. Olha ao redor e encontra suas roupas penduradas na parede, sua cama"
+ " e seu machado e escudo pendurados na parde de madeira, logo ao lado uma porta... Você então se dá conta de que"
+ " está em sua cabana e que tudo não passou de um sonho.",
)
cozinha = Room(
"cozinha",
"Entrando na cozinha, você já está familiarizado com sua velha dispensa, sua pequena mesa e sobre ela o"
+ " que restou da caça de ontem e uma pequena runa. Além disso, a parte mais importante, seu trófeu da primeira caçada ao lado"
+ " de seu pai.",
)
dispensa = Room("dispensa", "um armário antigo com algumas frutas")
cama = Room("cama", "cama de feno e pedaços de pele de animais. Muito usada nesses tempos...")
arredoresDeSiegheim1 = Room(
"arredores de Siegheim",
" ao sair da sua cabana, você se encontra nas florestas que rodeiam as ruinas de"
+ " Siegheim(nome da cidade principal dos dominios do rei ragnar)",
)
arredoresDeSiegheim2 = Room(
"arredores de Siegheim",
" andando pelo caminho, você lembra dos passeios com seu pai por essas mesmas florestas."
+ " Olhando ao redor você observa alguns cogumelos e lembra dos ensinamentos de seu pai, explicando os efeitos de cada planta nas florestas.",
)
arredoresDeSiegheim3 = Room(
"arredores de Siegheim",
" seguindo frente você se depara com uma bifurcação no caminho. Você acha estranho,"
+ " pois o caminho havia se alterado repentinamente.",
)
arredoresDeSiegheim4 = Room(
"arredores de Siegheim",
" você anda com desconfiança pela floresta desconhecida. Ao longe observa-se uma slhueta de uma pessoa.",
)
eremita = Room(
"velho eremita misterioso",
"Aproximando-se, a silhueta toma a forma de um senhor de idade. Enquanto você passa ele joga pragas"
+ " aos ventos. No momento em que ele o vê, os olhos do eremita se enchem de raiva. O senhor começa a esbravejar insunuações sobre o seu pai ter"
+ " sido a ruína dos bárbaros. Logo após ele corre em direção a mata dansa e nebulosa.",
)
arredoresDeSiegheim5 = Room(
"arredores de Siegheim",
" com o tempo você começa a reconhecer o caminho. Lembra que havia uma cicatriz naquela árvore."
+ " a partir desse momento você se dá conta de que se aproxima das ruínas do palácio.",
)
# Adicionando as segundas descrições
cabana.setDescription2(" seu quarto, nele você pode ver sua cama e algumas coisas comuns")
cozinha.setDescription2(" sua cozinha. Você pode ver sua dispensa e mesa.")
dispensa.setDescription2(" armário antigo")
cama.setDescription2(" sua cama")
arredoresDeSiegheim1.setDescription2(" arredores de sigheim, próxima a sua cabana.")
arredoresDeSiegheim2.setDescription2(" arredores de Siegheim, essa área possui várias plantas medicinais.")
arredoresDeSiegheim3.setDescription2(" arredores de Siegheim, você se encontra na bifurcação estranha.")
arredoresDeSiegheim4.setDescription2(" arredores de Siegheim, local próximo ao seu encontro com o eremita.")
arredoresDeSiegheim5.setDescription2(" arredores de Siegheim, você está mais próximo das ruínas.")
eremita.setDescription2(" arredores de Siegheim, local exato onde você encontrou o eremita.")
# Adicionando saídas as salas
salaMisteriosa.setExits("correr", cabana)
cabana.setExits("porta", cozinha)
cabana.setExits("cama", cama)
cozinha.setExits("porta", cabana)
cozinha.setExits("dispensa", dispensa)
cozinha.setExits("fora da cabana", arredoresDeSiegheim1)
dispensa.setExits("cozinha", cozinha)
cama.setExits("quarto", cabana)
arredoresDeSiegheim1.setExits("cabana", cozinha)
arredoresDeSiegheim1.setExits("continuar andando", arredoresDeSiegheim2)
arredoresDeSiegheim2.setExits("voltar", arredoresDeSiegheim1)
arredoresDeSiegheim2.setExits("seguir em frente", arredoresDeSiegheim3)
arredoresDeSiegheim3.setExits("voltar", arredoresDeSiegheim2)
arredoresDeSiegheim3.setExits("esquerda", arredoresDeSiegheim4)
arredoresDeSiegheim3.setExits("direita", arredoresDeSiegheim5)
arredoresDeSiegheim4.setExits("voltar", arredoresDeSiegheim3)
arredoresDeSiegheim4.setExits("se aproximar da silhueta", eremita)
arredoresDeSiegheim5.setExits("voltar", arredoresDeSiegheim3)
# Criando itens
bilhete = Item("bilhete", ' "Encontre-me nas ruinas do antigo rei,\nDe: Seu amigo\nPara: Sieg"')
roupas = Item("roupas", "Roupas de couro de animais das redondezas, protegem bastante contra o frio")
machado = Item("machado", "Um machado comum")
escudo = Item("escudo", "Escudo de madeira feito pelo seu pai.")
frutas = Item("frutas", "algumas frutas que sobraram antes do início do inverno.")
simboloDeCaçada = Item(
"Troféu",
"A cabeça de um javali morto na sua primeira caçada com seu pai. Olhar ela lhe traz lembranças de sua infância..."
+ " De quando você ainda estava aprendendo a segurar seu escudo.",
)
cogumelosVerdes = Item("cogumelo verde", "Cogumelo com capacidades curativas")
# Adicionando itens as salas
cabana.addItem(roupas)
cabana.addItem(machado)
cabana.addItem(escudo)
cozinha.addItem(simboloDeCaçada)
cozinha.addItem(bilhete)
dispensa.addItem(frutas)
arredoresDeSiegheim2.addItem(cogumelosVerdes)
# Atribuindo a sala inicial
self.actualRoom = salaMisteriosa
def load(self, filename):
start_room = None
first_room = None
new_room = None
new_command = None
cur_room_name = None
file_stream = file(filename)
for line in file_stream:
line = string.translate(string.strip(line), \
string.maketrans('\\', '\n'))
if line.find("=") != -1:
keyword, params = line.split("=", 1)
else:
keyword = line
params = None
if keyword == "TITLE":
self.title = params[:]
elif keyword == "START_ROOM":
start_room = params[:]
elif keyword == "INVENTORY_LIMIT":
self.player.item_limit = string.atoi(params)
elif keyword == "ROOM":
new_room = Room()
new_room.name = params[:]
self.rooms[new_room.name] = new_room
if first_room == None:
first_room = new_room
cur_room_name = new_room.name
new_command = None
elif keyword == "LOCAL":
cur_room_name = params[:]
new_room = None
new_command = None
elif keyword == "GLOBAL":
cur_room_name = None
new_room = None
new_command = None
elif keyword == "COMMAND":
new_command = Command()
self.commands.append(new_command)
if cur_room_name != None:
new_command.location = cur_room_name[:]
if params[0] == "+":
new_command.condition = params[1:]
elif params[0] == "-":
new_command.condition = params[:]
else:
pos = params.find(":")
if pos != -1:
if params[pos + 1] == "+":
new_command.condition = params[pos + 2:]
else:
new_command.condition = params[pos + 1:]
new_command.commands = params[:pos].split(",")
else:
new_command.commands = params.split(",")
elif keyword == "ACTION":
# If there is no current command, make one.
if new_command == None:
new_command = Command()
self.commands.append(new_command)
if cur_room_name != None:
new_command.location = cur_room_name[:]
for action in params.split(";"):
new_command.add_action(action)
#new_command.actions.append(action)
elif keyword == "DESC":
if new_room != None:
new_room.desc = params[:]
elif keyword == "ALT_DESC":
if new_room != None:
new_room.desc_alt = params[:]
elif keyword == "DESC_CONTROL":
if new_room != None:
new_room.desc_ctrl = params[:]
elif keyword == "CONTENTS":
if new_room != None:
new_room.items = params.split(",")
elif keyword == "NORTH":
if new_room != None:
new_room.init_neighbor("N", params[:])
elif keyword == "SOUTH":
if new_room != None:
new_room.init_neighbor("S", params[:])
elif keyword == "EAST":
if new_room != None:
new_room.init_neighbor("E", params[:])
elif keyword == "WEST":
if new_room != None:
new_room.init_neighbor("W", params[:])
elif keyword == "UP":
if new_room != None:
new_room.init_neighbor("U", params[:])
elif keyword == "DOWN":
if new_room != None:
new_room.init_neighbor("D", params[:])
if self.rooms.has_key(start_room):
self.player.current_room = self.rooms[start_room]
elif first_room != None:
self.player.current_room = first_room
else:
self.player.current_room = Room()
self.player.current_room.name = "limbo"
self.player.current_room.desc = \
"This adventure has no rooms. You are in limbo!"
file_stream.close()
class Analysis:
def __init__(self,cam_resolution, camera_number, horizontal_sect, vertical_sect, white_level, person_ammount, new_person_tresh, sleep_period_value):
print " analysis"
#podzial sceny na sektory
self.note_file_url = "results/results"
self.cam_resolution = cam_resolution
self.camera_number = camera_number
self.white_level = white_level
self.person_ammount = person_ammount
self.sectors = []
self.sleep_period_value =sleep_period_value
row =[]
self.persons =[]
miny_x = range(0, cam_resolution[0], cam_resolution[0]/horizontal_sect)
maksy_x = range(cam_resolution[0]/horizontal_sect, (cam_resolution[0]/horizontal_sect*(horizontal_sect+1)), cam_resolution[0]/horizontal_sect)
miny_y = range(0,cam_resolution[1] , cam_resolution[1] /vertical_sect)
maksy_y = range(cam_resolution[1]/vertical_sect, (cam_resolution[1]/vertical_sect*(vertical_sect+1)), cam_resolution[1]/vertical_sect )
for i in range(vertical_sect):
miny, maksy= miny_y[i], maksy_y[i]
for column in range(horizontal_sect):
minx, maksx = miny_x[column], maksy_x[column]
row.append((minx, miny, maksx, maksy))
self.sectors.append(row)
self.room = Room(person_ammount, new_person_tresh)
f= open(self.note_file_url, "w")
f.close()
def stop(self):
self.run_the_analysis =False
def run_analysis(self):
self.run_the_analysis= True
print "run analysis"
while self.run_the_analysis:
images_data_file = open("images_data")
face_number=0
face_data =[]
#wyszukuje linii definiujacych osobe
for line in images_data_file:
if(line.find("face")!=-1):
try:
face_number = eval(line[4:5].strip()) # zamienic na TRY bo sie czasem pierdoli
f_rect = eval(line.split(":")[1].strip())
face_data.append(face_number)
face_data.append(f_rect)
except:
break
if(line.find("NOSE:")!=-1):
try:
nose_rect = eval(line.split(":")[1].strip())
face_data.append(nose_rect)
except:
break
if(line.find("POINTS:")!=-1):
try:
points_rect = eval(line.split(":")[1].strip())
face_data.append(points_rect)
except:
break
new_person = Person(face_data, self.sectors, self.white_level, self.note_file_url)
face_data =[]
#jak nadaje sie do analizy to tworze nowa osobe
if new_person.is_person_created():
print "twarz ", face_number, " nadaje sie do analizy"
person_class = self.is_a_new_person(new_person)
if person_class[0]:
print "to byla nowa osoba, dodalem ja"
else:
print "juz widzialem ta osobe, to byla osoba", person_class[1]," updatuje ja"
self.room.people_list[person_class[1]]=new_person
else:
print "osoba nie stworzona"
images_data_file.close()
time.sleep(self.sleep_period_value)
def is_a_new_person(self, person):
return self.room.check_and_add_if_new(person)
#return False
def extract_face_information(self):
return [0, 0, 3, 2, 0]
def detect_faces_with_threshold(self, original, face_certanity):
detected = cv.HaarDetectObjects(original, self.haar_face, self.storage)
#wybieram tylko te pewne twarze
certain_faces= []
for cvmatrix in detected:
if cvmatrix[1]> face_certanity: certain_faces.append(cvmatrix)
return certain_faces
from nose.tools import *
import ex47.game import Room
def test_room():
gold = Room("GoldRoom",
"""This room has gold init you can grab. There's a
door to the north.""")
assert_equal(gold.name, "GoldRoom")
assert_equal(gold.paths, {})
def test_room_paths():
center = Room("Center", "Test room in the center.")
north = Room("North", "Test room in the north.")
south = Room("South", "Test room in the south.")
center.add_paths({'north': north, 'south': south})
assert_equal(center.go('north'), north)
assert_equal(center.go('south'), south)
def test_map():
start = Room("Start", "You can go west and down a hole.")
west = Room("Trees", "There are trees here, you can go east.")
down = Room("Dungeon", "It's dark down here, you can go up.")
start.add_paths({'west': west, 'down': down})
west.add_paths({'east': start})
down.add_paths({'up': start})
assert_equal(start.go('west'), west)
assert_equal(start.go('west').go('east'), start)
assert_equal(start.go('down').go('up'), start)
def test_map():
start = Room("Start", "You can go west and down a hole.")
west = Room("Trees", "There are trees here, you can go east.")
down = Room("Dungeon", "It's dark down here, you can go up.")
start.add_paths({'west': west, 'down': down})
west.add_paths({'east': start})
down.add_paths({'up': start})
assert_equal(start.go('west'), west)
assert_equal(start.go('west').go('east'), start)
assert_equal(start.go('down').go('up'), start)
def test_map():
start = Room("Start", "You can go west and down a hole.")
west = Room("Trees", "There are trees here, you can go east.")
down = Room("Dungeon", "It's dark down here, you can go up.")
start.add_paths({'west': west, 'down': down})
west.add_paths({'east': start})
down.add_paths({'up': start})
assert_equal(start.go('west'), west)
assert_equal(start.go('west').go('east'), start)
assert_equal(start.go('down').go('up'), start)
# def setup():
# print "SETUP!"
#
# def teardown():
# print "TEAR DOWN!"
#
# def test_basic():
# print "I RAN!"
