def __init__(self):
# Initialize pygame for the game class, as well as initializing the font.
pygame.init()
pygame.font.init()
# Set the display accordingly (x,y) and set the title for the game.
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Game")
# Initialize the classes
self.player = Node(0, 580, 3.5)
self.key = Key(600, 0)
self.door = Door(760, 550)
#Current floor values are probably going to be level 1
self.floors = [
Floor(300, 0, 20, 50),
Floor(500, 1, 20, 50),
Floor(100, 2, 20, 50),
Floor(200, 3, 20, 50),
Floor(400, 4, 20, 50),
Floor(250, 5, 20, 50),
Floor(50, 6, 20, 50),
Floor(150, 7, 20, 50),
Floor(550, 8, 20, 50),
Floor(450, 9, 20, 50)
]
self.counter = Counter(675, 10)
self.RUN = True
self.playerFoundKey = False
self.gameOver = False
def create(self, cruise, room_type):
#el día que esta función se ejecutó sin errores fue el día más feliz de mi trimestre no joke
room_list = []
rooms_per_floor = Floor.create(Floor, cruise)[room_type - 1].quantity_of_rooms_per_hall * Floor.create(Floor, cruise)[room_type - 1].quantity_of_halls
for n in range(rooms_per_floor):
for rt, price in Cruise.api_saman_caribbean()[cruise].cost.items():
if room_type == 1:
self.cost = Cruise.api_saman_caribbean()[cruise].cost['simple']
self.classification = 'simple'
self.extra_info = 'Room service'
elif room_type == 2:
self.cost = Cruise.api_saman_caribbean()[cruise].cost['premium']
self.classification = 'premium'
self.extra_info = 'Vista al mar'
elif room_type == 3:
self.cost = Cruise.api_saman_caribbean()[cruise].cost['vip']
self.classification = 'vip'
self.extra_info = 'Se pueden realizar fiestas'
self.capacity = self.room_capacity(cruise, room_type)
self.reference = '-'
self.hall_letter = self.assing_hall_letter(Floor.create(Floor, cruise)[room_type - 1].quantity_of_halls, Floor.create(Floor, cruise)[room_type - 1].quantity_of_rooms_per_hall)[n]
self.number = n + 1
room = Room(self.cost, self.classification, self.capacity, self.hall_letter, self.number, self.reference, self.extra_info)
room_list.append(room)
return room_list
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)),
(0, 0))
self.screen.blit(
FONT.render("Remember - patience is a virtue.", True,
(255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles(
)
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles,
self.characters, self.items, self.bullets,
self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen,
x=0,
y=0,
obstaclemap=self.obstacles,
**temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
self.show_fps = True
def toFloor(self) :
f=Floor()
f.name=self.name+'floor'
n=self.normal
deep=self.thickness
lines=self.curve.lines
f.curve.lines.clear()
newlines1=[]
newlines1.clear()
newlines2=[]
newlines2.clear()
if n.z!=0:
f.curve.lines=copy.deepcopy(lines)
f.thickness=deep
else:
min=self.minV()
dz=self.dR().z
for l in lines:
if l.start.z==min.z and l.end.z==min.z:
newlines1.append(l)
newlines2.append(l.translate(n,deep))
start1=newlines1[len(newlines1)-1].end
end1=newlines2[len(newlines1)-1].end
start2=newlines1[0].start
end2=newlines2[0].start
newlines1.append(Line(start1,end1))
newlines1.extend(newlines2)
newlines1.append(Line(start2,end2))
f.curve.lines.extend(newlines1)
f.thickness=dz
return f
def main():
global CLOCK, SCREEN, bird, floor, point, last_pipe, point_sound
pygame.init() # 初始化pygame
pygame.mixer.init()
point_sound = ResourceLoader.get_sound("point.wav")
wing_sound = ResourceLoader.get_sound("wing.wav")
die_sound = ResourceLoader.get_sound("die.wav")
CLOCK = pygame.time.Clock()
SCREEN = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT]) # 初始化一个用于显示的窗口
pygame.display.set_caption('flappyBird') # 设置窗口标题.
bird = Bird(window_size, wing_sound, die_sound)
floor = Floor(window_size)
background = ResourceLoader.get_image("background-day.png")
message = ResourceLoader.get_image("message.png")
message_rect = (message.get_rect(centerx=SCREEN_WIDTH / 2, centery=SCREEN_HEIGHT / 2))
reset()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_SPACE or event.key == K_UP:
if not bird.isDie:
bird.fly()
else:
reset()
if not bird.isDie:
bird.update()
floor.update()
SCREEN.blit(background, (0, 0))
if not bird.begin_fly and not bird.isDie:
SCREEN.blit(message, (message_rect.x, message_rect.y))
else:
for i in range(COUNT):
center_y = make_center_y()
pipe_top = pipes_top[i]
pipe_botom = pipes_botom[i]
if not bird.isDie:
pipe_top.update(center_y)
pipe_botom.update(center_y)
SCREEN.blit(pipe_top.image, (pipe_top.rect.x, pipe_top.rect.y))
SCREEN.blit(pipe_botom.image, (pipe_botom.rect.x, pipe_botom.rect.y))
SCREEN.blit(floor.image, (floor.rect.x, floor.rect.y))
SCREEN.blit(bird.get_bird_image(), (bird.rect.x, bird.rect.y))
if bird.isDie:
game_over = ResourceLoader.get_image("gameover.png")
SCREEN.blit(game_over, (
(SCREEN_WIDTH - game_over.get_rect().width) / 2, (SCREEN_HEIGHT - game_over.get_rect().height) / 2))
if bird.begin_fly:
show_point()
if check_conlision():
bird.die()
pygame.display.flip()
CLOCK.tick(FPS)
def show(cruise, room_type):
#guardo en una variable la lista que devuelve la función create
rl = Room.create(Room, cruise, room_type)
l1 = []
for n in range(len(rl)):
#en una lista vacía appendeo la información de las habitaciones que necesito
l1.append(f'{rl[n].number}{rl[n].hall_letter}')
#le paso la lista a la función que va a mostrar la matriz
Floor.show(Floor.create(Floor, cruise), room_type, l1)
def create_level(self, num_iter):
"""Сборная солянка из функций."""
floor = [[
Tile("wall#", "white", True) for _ in range(self.floor_size)
] for _ in range(self.floor_size)]
start = self.create_start()
start.dig_me(floor)
first_room = self.create_first_room(start, floor)
rooms = [first_room]
tonels = []
self.create_main(rooms, tonels, floor, num_iter)
rooms.remove(first_room)
if num_iter == self.max_floor_num - 1:
end = Rect(-1, -1, 0, 0)
else:
end = self.create_end(rooms, floor)
rooms.append(first_room)
floor[end.x1][end.y1] = Tile("eXit", "blue", False)
floor[start.x1][start.y1] = Tile("Enter", "blue", False)
self.floors.append(
Floor(floor, start, end, rooms, self.floor_size, self.min_level))
def runWarehouse():
env = simpy.Environment()
# Test Instances of Areas
floor = Floor(env)
inventory = Inventory(env)
robotScheduler = RobotScheduler(env, floor)
orderControl = OrderControl(env)
# Place items into shelves within ShelfAreas
shelveStock()
orders_to_complete = orderControl.allOrders
order_one = orders_to_complete[0]
processOrder(floor, inventory, order)
floor.printMap()
def __init__(self, numberOfPeople, numOfFloors, numOfElevators):
self.numberOfPeople = numberOfPeople
self.numberOfFloors = numOfFloors
self.floors = {}
self.elevators = []
i = 0
peopleInFloor = int(numberOfPeople / numOfFloors)
"""need to fix"""
# peopleInFloor = int(numberOfPeople / numOfFloors)
# if peopleInFloor < 1:
# while floorNum < numOfFloors + 1:
# randPerson = random.randint(0, 1)
# if i < numberOfPeople:
# if randPerson == 1:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
# i = i + 1
# else:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
for floorNum in range(1, numOfFloors + 1):
self.floors[floorNum] = Floor(floorNum, peopleInFloor, numOfFloors)
for i in range(0, numOfElevators):
self.elevators.append(Elevator(i, numOfFloors))
def __init__(self, floor_count, lift_count):
self.floors = [Floor(floor_num=i) for i in range(floor_count)]
self.lifts = [
Lift(max_weight=1000, current_floor=0) for _ in range(lift_count)
]
self.floor_exit_counts = [
[1 for _ in range(Building.max_people_count)] * floor_count
]
def __init__(self, env):
random.seed(5)
self.clock = env
# Create Instances of main components
self.floor = Floor(env)
self.inventory = Inventory(env, self.floor)
self.robot_scheduler = RobotScheduler(env, self.floor)
self.order_control = OrderControl(env, self.inventory)
def loadFromID(self, id):
result = Query.getOneResult("select * from " + Query.getDBName() +".BUILDINGS where ID = '" + id + "'")
if result is None:
return
self.loadFromResult(result)
#floorPlans = []
floors = Floor.getAllForBuilding(id)
for floor in floors:
self.floorPlans.append(floor.floor_map)
return self
def __init__(self, env):
# Seed in which the randomness of the simulation pans out
# Change the number to see different Order schedules
random.seed(5)
# env is the SimPy simulation environment. It works as our world clock for this simulation
# env is created and can be adjusted at the bottom of Warehouse.py
self.clock = env
# Create Instances of main components
self.floor = Floor(env)
self.inventory = Inventory(env, self.floor)
self.robot_scheduler = RobotScheduler(env, self.floor)
self.order_control = OrderControl(env, self.inventory)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.networks = []
if computer_playing:
self.computer_player = Neat_O_Player()
for i in range(self.computer_player.num_per_gen):
self.birds.append(Bird())
self.networks = self.computer_player.increment_gen()
self.scores = [0] * self.computer_player.num_per_gen
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
self.play_game()
def getBuildingInfo(building_id):
building = Building()
building.loadFromID(building_id)
#Find all floor plans for our end place
floorPlans = []
floors = Floor.getAllForBuilding(building_id)
for floor in floors:
floorPlans.append(floor.floor_map)
buildingInfo = BuildingWithFloor()
buildingInfo.loadUp(building.__dict__, floorPlans)
return buildingInfo.__dict__
def initObject(self, id1, id2, dbIndex): # 物件初始化
self.id1 = id1
self.id2 = id2
self.dbIndex = dbIndex
self.ballList = [Ball(1, 100, 200), Ball(2, 858, 200)]
# self.ballList = [Ball(2, 858, 200)]
self.floorList = [Floor(106, 560), Floor(412, 560), Floor(718, 560)]
# self.floorList = [Floor(0, 560), Floor(100, 560), Floor(300, 560), Floor(500, 560), Floor(700, 560), Floor(900, 560)]
self.playerList = [Player(self.id1, 100, 460, True), Player(self.id2, 824, 460, False)]
self.ballGroup = pygame.sprite.Group()
self.floorGroup = pygame.sprite.Group()
self.playerGroup = pygame.sprite.Group()
self.ballGroup.add(self.ballList)
self.floorGroup.add(self.floorList)
self.playerGroup.add(self.playerList)
self.startTime = time.time()
self.passTime = time.time()
self.bestTime = self.readBestTime()
self.isOver = -1
self.startCounting = False
self.startCountingTime = 0
self.initFloorMove() # 依難度決定地板的移動方向
def create_tile_map(self):
for i, row in enumerate(self.map_array):
row.remove("\n")
for j, tile in enumerate(row):
tile_type = tile[0]
if tile not in self.seen_tiles:
image = self.img_loader.load_image(ALL_IMAGES[tile])
self.seen_tiles[tile] = image
image = self.seen_tiles[tile]
if tile_type == "F":
self.tile_map[j, i] = Floor(image, j, i)
elif tile_type == "W":
self.tile_map[j, i] = Wall(image, j, i)
def __init__(self, width, height):
self.delay = 0.0000005
self.screen = [width, height]
self.wn = turtle.Screen()
self.wn.title("Jump Man Game")
self.wn.bgcolor("black")
self.wn.setup(width=width, height=height)
self.wn.tracer(0)
self.roof = Roof(width, height)
self.floor = Floor(width, height, self.roof.point)
gen = Gen(0, 30, 20)
# self.jump_man = JumpMan(screen=self.screen, dna=gen, point=self.floor.point)
self.population = Population(screen=self.screen, point=self.floor.point)
def __init__(self):
self.objects = []
self.faces = []
self.colors = []
for i in range(-5, 6):
for j in range(-5, 5):
self.objects.append(Floor(i, 0, j, 1, 'black'))
self.objects.append(Cube(-3, 0, 0, 1, 'pink'))
self.objects.append(Slope(-1, 0, 0, 1, 'purple'))
self.objects.append(Stairs(1, 0, 0, 1, 'green'))
self.objects.append(FallingPyramid(3, 20, 0, 1, 'red'))
def floorMaker(floor):
rooms = list(map(lambda x: roomMaker(x), floor["rooms"]))
hallways = list(map(lambda x: hallMaker(x), floor["hallways"]))
key_pos = floor["objects"][0]["position"]
exit_pos = floor["objects"][1]["position"]
new_floor = Floor(rooms, hallways)
new_floor.set_exit(translate_to_xy(exit_pos))
new_floor.place_item("Key", translate_to_xy(key_pos))
return new_floor
def __init__(self, genomes, config, gen):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.computer_player = []
self.gen = gen
self.genomes = []
if computer_playing:
for g_id, genome in genomes:
self.birds.append(Bird())
net = neat.nn.FeedForwardNetwork.create(genome,config)
self.computer_player.append(net)
self.genomes.append(genome)
#self.networks = self.computer_player.increment_gen()
self.scores = [0]*len(self.computer_player)
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
def main():
currentIndex = 0
time_tick = 0
cumulative_time = 0
#reads from jsonfile
with open('testcases/elevator_practice1.json') as json_data:
jsonFile = json.load(json_data)
#intializing floor and elevators
numFloors = jsonFile["floors"]
numElevators = jsonFile["elevators"]
floorList = []
elevatorList = []
drawGui = DrawElevator(numFloors, numElevators)
drawGui.initialDraw()
for i in range(numFloors):
floorList.append(Floor(i))
for i in range(numElevators):
elevatorList.append(Elevator(5, numFloors))
while time_tick < 1000:
#stores the data locally from the json object
if time_tick == jsonFile["events"][currentIndex]["time"]:
startFloor = jsonFile["events"][currentIndex]["start"]
endFloor = jsonFile["events"][currentIndex]["end"]
#populates the floor class
new_person = Person(time_tick, startFloor, endFloor)
floorList[startFloor].appendPerson(new_person)
currentIndex += 1
#updates the elevator class
for elevator in elevatorList:
floorList = elevator.update(floorList)
drawGui.update(elevatorList, floorList)
time_tick += 1
time.sleep(0.1)
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)), (0, 0))
self.screen.blit(FONT.render("Patience is a virtue.", True, (255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles()
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles, self.characters, self.items, self.bullets, self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen, x=0, y=0, obstaclemap=self.obstacles, **temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
class Warehouse(object):
# The simpy environment is our clock
def __init__(self, env):
self.clock = env
self.floor = Floor(env)
self.inventory = Inventory(env)
self.robot_scheduler = RobotScheduler(env)
self.order_control = OrderControl(env)
def populateStock(self):
for item in self.inventory.stock:
random_sarea = random.choice(self.floor.shelfareas)
random_shelf = random.choice(random_sarea.areacontents).getContents()
random_shelf.addItem(item)
item.changeShelf(random_shelf.getShelfNo())
def robotRequest(self, robot, destination):
robotlocation = robot.location
# Calculate a path from the Robot's current location to requested
# At some point make this so it doesn't go through Cells containing objects
path = self.floor.getPath(robotlocation, destination)
robot.setDestination(path)
# Moving the robot to location
# Running moveByOne multiple times to emulate ticks for time being)
#print(f'Robot needs to move {len(path)} steps')
for num in range(0, len(robot.getDestination())):
robot.moveByOne()
# print("Robot is now at: " + str(robot.getLocation()))
# Sim Function
def getItem(self, item):
print("\nGrabbing Item: ", item, " at tick ", self.clock.now)
yield self.clock.timeout(2)
def findItemNameSim(self, item):
print("Finding", item, "location at tick", self.clock.now)
yield self.clock.timeout(1)
def findShelfLocationSim(self, shelf):
print(f'Finding {shelf} location at tick {self.clock.now}')
yield self.clock.timeout(1)
def robotRequestSim(self, robot, destination):
path = self.floor.getPath(robot.location, destination)
num_of_steps = len(path)
print(f'Robot starts moving to location at tick {self.clock.now}')
print(f'Robot needs to move {len(path)} steps')
for num in range(0, len(path)):
yield env.process(self.robotMoveSim(robot, path[num]))
print(f'Robot is now at {destination}')
yield self.clock.timeout(1)
def robotMoveSim(self, robot, nextStep):
#print(f'Robot moving to {nextStep} at tick {self.clock.now}')
yield self.clock.timeout(1)
def robotPickUpSim(self, robot, shelf):
print(f'Robot picking up {shelf} at tick {self.clock.now}')
yield self.clock.timeout(1)
def robotPutDownSim(self, robot, shelf):
print(f'Robot putting down {shelf} at tick {self.clock.now}')
yield self.clock.timeout(1)
def pickerTakeItemSim(self, item, shelf):
print(f'Picker takes {item} off of shelf {shelf.shelfNumber} at tick {self.clock.now}')
yield self.clock.timeout(2)
spec = importlib.util.spec_from_file_location(dataObject.LiftClassName + ".Lift", dataObject.LiftClassPath)
liftClassFile = importlib.util.module_from_spec(spec)
spec.loader.exec_module(liftClassFile)
#liftClassFile = __import__(dataObject.LiftClassPath)
liftClass = liftClassFile.Lift
except Exception as e:
print(e)
sys.exit()
#- Set Constant Values
Logger.Initialise(dataObject.NumberOfItterations, DirectoryManager.DirectoryRoot)
TickTimer.Initialise(dataObject.TotalTicks, dataObject.SecondsPerTick)
Floor.Initialise(dataObject.ArrivalMeans, dataObject.FloorWeightings)
#- Instantiate Objects
allFloors = []# list of floors in all simulations
for simNo in range(dataObject.NumberOfItterations):
# Create an array with the floors
floors = np.empty(dataObject.NumberOfFloors, Floor)
for i in range(len(floors)):
floors[i] = Floor(i)
allFloors.append(floors)
allLifts = []
for simNo in range(dataObject.NumberOfItterations):
def __init__(self, num_floors):
super(ElevatorSystem, self).__init__()
# initialize components
self.elevController = ElevatorController()
self.requestProc = RequestProcessor()
self.doorStatusProc = DoorStatusProcessor()
# Special Instation for Elevator Car to handle dependencies for inner communication
self.elevCar = ElevatorCar(None)
self.elevCarCtrl = CarCtrl(None, None, None, None)
self.elevCarDoor = CarDoor(self.elevCarCtrl, self.elevCar)
self.elevCarBtn = CarBtn(self.elevCar)
self.elevCarMotor = Motor(self.elevCarCtrl)
self.elevCar.ctrl = self.elevCarCtrl
self.elevCarCtrl.car = self.elevCar
self.elevCarCtrl.door = self.elevCarDoor
self.elevCarCtrl.motor = self.elevCarMotor
# Attack One: Leave Car Door closed when destination is reached
#self.attack_one = AttackCloseCarDoor(self.elevCarDoor)
#self.elevCarCtrl.attack = self.attack_one
self.attack_one = None
# Attack Two: Set floor request to a nonexistent floor to cause the motor to never stop
#self.attack_two = AttackMotorRun()
self.attack_two = None
# Attack Three: Force all request from car button to go to a specific floor
#self.attack_three = AttackButtonReq()
self.attack_three = None
# setup pipes, output->input
self.elevController.done, self.requestProc.next = Pipe()
"""self.elevController.oCmdCar, self.elevCar.iCmd = Pipe()"""
# Setup Floor pipes separately, skipping self.elevController.oCmdFloor...
self.elevController.out, self.doorStatusProc.input = Pipe()
self.requestProc.out, self.elevController.iReq = Pipe()
self.doorStatusProc.out, self.elevController.iStDoor = Pipe()
# MitM for Attack Two
if (self.attack_two):
self.elevCar.iCmd, self.attack_two.oCmdCar = Pipe()
self.attack_two.iCmd, self.elevController.oCmdCar = Pipe()
else:
self.elevCar.iCmd, self.elevController.oCmdCar = Pipe()
# MitM for Attack Three:
if (self.attack_three):
self.elevCar.oReq, self.attack_three.IN = Pipe()
self.attack_three.oReq, self.requestProc.input_car = Pipe()
else:
self.elevCar.oReq, self.requestProc.input_car = Pipe(
) # input[0] reserved for ElevCar, [1] = F1, [2] = F2, etc.
self.elevCar.oStCar, self.elevController.iStCar = Pipe()
self.elevCar.oStDoor, self.doorStatusProc.iStCar = Pipe()
# setup pipes to get component states
self.requestProc.state_comm, self.rp_pipe = Pipe()
# Floor Pipes
f1_iCmd, self.elevController.oCmdFloor1 = Pipe()
f1_oReq, self.requestProc.input_floor1 = Pipe()
f1_oStatus, self.doorStatusProc.iStFloor1 = Pipe()
#
f2_iCmd, self.elevController.oCmdFloor2 = Pipe()
f2_oReq, self.requestProc.input_floor2 = Pipe()
f2_oStatus, self.doorStatusProc.iStFloor2 = Pipe()
#
f3_iCmd, self.elevController.oCmdFloor3 = Pipe()
f3_oReq, self.requestProc.input_floor3 = Pipe()
f3_oStatus, self.doorStatusProc.iStFloor3 = Pipe()
#
f4_iCmd, self.elevController.oCmdFloor4 = Pipe()
f4_oReq, self.requestProc.input_floor4 = Pipe()
f4_oStatus, self.doorStatusProc.iStFloor4 = Pipe()
#
f5_iCmd, self.elevController.oCmdFloor5 = Pipe()
f5_oReq, self.requestProc.input_floor5 = Pipe()
f5_oStatus, self.doorStatusProc.iStFloor5 = Pipe()
# Instantiate Floors
# self.floors = [Floor(num) for num in range(num_floors)]
self.floors = {
1: Floor(1, f1_iCmd, f1_oReq, f1_oStatus),
2: Floor(2, f2_iCmd, f2_oReq, f2_oStatus),
3: Floor(3, f3_iCmd, f3_oReq, f3_oStatus),
4: Floor(4, f4_iCmd, f4_oReq, f4_oStatus),
5: Floor(5, f5_iCmd, f5_oReq, f5_oStatus)
}
"""
def eval_genomes(genomes, config):
"""
runs the simulation of the current population of
birds and sets their fitness based on the distance they
reach in the game.
"""
global WIN, gen
win = WIN
gen += 1
# start by creating lists holding the genome itself, the
# neural network associated with the genome and the
# bird object that uses that network to play
nets = []
birds = []
ge = []
for genome_id, genome in genomes:
genome.fitness = 0 # start with fitness level of 0
net = neat.nn.FeedForwardNetwork.create(genome, config)
nets.append(net)
birds.append(Bird(230,350))
ge.append(genome)
floor = Floor(FLOOR)
pipes = [Pipe(700)]
score = 0
clock = pygame.time.Clock()
run = True
while run and len(birds) > 0:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.quit()
quit()
break
pipe_ind = 0
if len(birds) > 0:
if len(pipes) > 1 and birds[0].x > pipes[0].x + pipes[0].WIDTH: # determine whether to use the first or second
pipe_ind = 1 # pipe on the screen for neural network input
for x, bird in enumerate(birds): # Reward each bird for each frame they sta alive
ge[x].fitness += 0.1
bird.move()
# send bird location, top pipe location and bottom pipe location and determine from network whether to jump or not
output = nets[birds.index(bird)].activate((bird.y, abs(bird.y - pipes[pipe_ind].height), abs(bird.y - pipes[pipe_ind].bottom)))
if output[0] > 0.5:
bird.jump()
floor.move()
# MOVE THE SCENE
rem = []
add_pipe = False
for pipe in pipes:
pipe.move()
# check for collision
for bird in birds:
if pipe.collide(bird, win): # REDUCE FITNESS OF COLLIDED BIRDS AND REMOVE THEM
ge[birds.index(bird)].fitness -= 1
nets.pop(birds.index(bird))
ge.pop(birds.index(bird))
birds.pop(birds.index(bird))
if pipe.x + pipe.WIDTH < 0:
rem.append(pipe)
if not pipe.passed and pipe.x < bird.x:
pipe.passed = True
add_pipe = True
if add_pipe:
score += 1
pipes.append(Pipe(WIN_WIDTH))
for r in rem:
pipes.remove(r)
for bird in birds:
if bird.y + bird.img.get_height() - 10 >= FLOOR or bird.y < -50:
nets.pop(birds.index(bird))
ge.pop(birds.index(bird))
birds.pop(birds.index(bird))
draw_window(WIN, birds, pipes, floor, score, gen)
class Controller(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.networks = []
if computer_playing:
self.computer_player = Neat_O_Player()
for i in range(self.computer_player.num_per_gen):
self.birds.append(Bird())
self.networks = self.computer_player.increment_gen()
self.scores = [0] * self.computer_player.num_per_gen
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
self.play_game()
def play_game(self):
time_since_pipe = 1
score = 0
collisions = [False] * len(self.birds)
if not computer_playing:
try:
#os.remove("./player_data.csv")
pass
except:
pass
self.data_to_write = []
while (self.playing_game):
if not computer_playing:
self.read_keyboard_input(self.birds[0])
else:
for i in range(len(self.birds)):
if self.birds[i].alive:
self.read_computer_input(self.birds[i],
self.networks[i])
count = 0
for b in self.birds:
if b.alive and not collisions[count]:
b.move()
count += 1
self.draw_everything(score)
#COLLISIONS DETECTED
if not computer_playing and any(collisions):
self.playing_game = False
else:
col_count = 0
#CHECK ALL COLLISIONS
for i in range(len(collisions) - 1, -1, -1):
if self.birds[i].alive:
if collisions[i]:
self.birds[i].alive = False
self.scores[i] = self.frame_score
self.num_alive -= 1
self.computer_player.network_score(
self.networks[i], self.frame_score)
#IF NO BIRDS LEFT, RESET GAME AND CONTINUE
if self.num_alive == 0:
if self.computer_player.cur_gen < self.computer_player.max_gen:
self.reset_for_new_gen()
collisions = [False] * len(self.birds)
time_since_pipe = 1
score = 0
continue
else:
self.print_network_stats()
self.playing_game = False
col_count = 0
for b in self.birds:
if b.alive:
collisions[col_count] = self.check_for_collision(b)
col_count += 1
if play_with_pipes:
self.update_pipes()
if time_since_pipe % 62 == 0 and play_with_pipes:
time_since_pipe = 1
self.lay_pipe()
pygame.display.update()
pygame.event.pump()
pygame.time.Clock().tick(fr)
time_since_pipe += 1
score = self.increment_score(score, self.birds[0])
self.increment_frame_score()
self.display_score()
self.quit_game()
def reset_for_new_gen(self):
self.print_network_stats()
self.birds = []
self.pipes = []
for i in range(self.computer_player.num_per_gen):
self.birds.append(Bird())
self.networks = self.computer_player.increment_gen()
self.scores = [0] * self.computer_player.num_per_gen
self.num_alive = len(self.birds)
self.frame_score = 0
self.lay_pipe()
def get_stimuli(self, bird):
#x distance to next pipe, y distance to center of pipe
stimuli = [999]
if bad_stimuli:
stimuli = [999, 999, 999, 999, 999]
next_pipe = None
for p in self.pipes:
if p.top_left[0] + p.pipe_width > bird.top_left[0]:
next_pipe = p
break
if next_pipe:
stimuli = [next_pipe.center - bird.top_left[1]]
if bad_stimuli:
stimuli.extend([
next_pipe.top_left[0] - bird.top_left[0] +
next_pipe.pipe_width, bird.y_velocity, bird.acceleration,
next_pipe.center
])
return stimuli
def increment_frame_score(self):
self.frame_score += 1
if self.frame_score == 700:
c = 0
for b in self.birds:
if b.alive:
break
c = c + 1
self.computer_player.save_best_score(self.frame_score, c)
def get_network_stats(self):
cur_gen = self.computer_player.cur_gen
if len(self.computer_player.generations.generations[0].genomes) == 0:
return 1, 0, 0, 0
scores = [
g.score
for g in self.computer_player.generations.generations[-1].genomes
]
best = max(scores)
avg = np.mean(scores)
std = np.std(scores)
return cur_gen, best, avg, std
def print_network_stats(self):
cur_gen, best, avg, std = self.get_network_stats()
print("Generation # %d had a best score of %f, an average score of %f,"
"and a standard deviation of %f" % (cur_gen, best, avg, std))
def increment_score(self, score, bird):
for p in self.pipes:
if p.top_left[0] < bird.top_left[0] - p.pipe_width and not p.scored:
p.scored = True
score += 1
return score
def display_score(self):
pass
def quit_game(self):
pygame.quit()
def read_keyboard_input(self, bird):
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bird.flap()
return "SPACE"
elif event.key == pygame.K_ESCAPE:
self.playing_game = False
return "NO_INPUT"
def read_computer_input(self, bird, nn):
s = [self.get_stimuli(bird)]
action = self.computer_player.make_decision(s, nn)
if action == "SPACE":
bird.flap()
def check_for_collision(self, bird):
if bird.top_left[1] < 0:
return True
if pygame.sprite.collide_rect(bird, self.floor):
if pygame.sprite.collide_mask(bird, self.floor):
return True
for p in self.pipes:
if p.top_left[0] < size[0]:
if p.check_for_collision(bird, pixel_collision=False):
return True
return False
def update_pipes(self):
for p in self.pipes:
if p.top_left[0] < -200:
self.pipes.remove(p)
break
for p in self.pipes:
p.move()
def lay_pipe(self):
p = Pipe(random.randint(round(256), round(size[1] - 256)), size[1],
size[0])
self.pipes.append(p)
def draw_everything(self, score):
self.draw_background()
self.draw_birds()
self.draw_pipe()
self.draw_floor()
self.draw_score(score)
if computer_playing:
self.draw_computer_info()
def draw_computer_info(self):
cur_gen, best, avg, std = self.get_network_stats()
num_alive = len([b for b in self.birds if b.alive])
num_per_gen = self.computer_player.num_per_gen
best_ever = self.computer_player.best_score_ever
if self.frame_score > best_ever:
best_ever = self.frame_score
s = self.score_text.render("Frame Score: %d" % self.frame_score, False,
(255, 255, 255))
na = self.score_text.render(
"Alive: %d / %d" % (num_alive, num_per_gen), False,
(255, 255, 255))
g = self.score_text.render("Generation: %d" % cur_gen, False,
(255, 255, 255))
b = self.score_text.render("Best Score: %d" % best_ever, False,
(255, 255, 255))
self.screen.blit(g, (5, 5))
self.screen.blit(na, (5, 25))
self.screen.blit(s, (5, 45))
self.screen.blit(b, (5, 65))
def draw_score(self, score):
t = self.score_text.render("%s" % score, False, (255, 255, 255))
self.screen.blit(t, (round(size[0] / 2), 100))
def draw_birds(self):
for b in self.birds:
if b.alive:
b.draw(self.screen)
def draw_background(self):
self.screen.fill(bg_color)
def draw_pipe(self):
for p in self.pipes:
p.draw(self.screen)
def draw_floor(self):
self.floor.draw(self.screen)
class Controller(object):
def __init__(self, genomes, config, gen):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.computer_player = []
self.gen = gen
self.genomes = []
if computer_playing:
for g_id, genome in genomes:
self.birds.append(Bird())
net = neat.nn.FeedForwardNetwork.create(genome,config)
self.computer_player.append(net)
self.genomes.append(genome)
#self.networks = self.computer_player.increment_gen()
self.scores = [0]*len(self.computer_player)
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
def play_game(self):
time_since_pipe = 1
score = 0
collisions = [False] * len(self.birds)
if not computer_playing:
try:
#os.remove("./player_data.csv")
pass
except:
pass
self.data_to_write = []
while(self.playing_game):
if not computer_playing:
self.read_keyboard_input(self.birds[0])
else:
for i in range(len(self.birds)):
if self.birds[i].alive:
self.read_computer_input(self.birds[i], self.computer_player[i])
count = 0
for b in self.birds:
if b.alive and not collisions[count]:
b.move()
count += 1
self.draw_everything(score)
#COLLISIONS DETECTED
if not computer_playing and any(collisions):
self.playing_game = False
else:
col_count = 0
#CHECK ALL COLLISIONS
for i in range(len(collisions)-1, -1, -1):
if self.birds[i].alive:
if collisions[i]:
self.birds[i].alive = False
self.scores[i] = self.frame_score
self.num_alive -= 1
if self.num_alive == 0:
self.playing_game = False
self.save_best_score()
return self.scores
col_count = 0
for b in self.birds:
if b.alive:
collisions[col_count] = self.check_for_collision(b)
col_count += 1
if play_with_pipes:
self.update_pipes()
if time_since_pipe % 62 == 0 and play_with_pipes:
time_since_pipe = 1
self.lay_pipe()
pygame.display.update()
pygame.event.pump()
pygame.time.Clock().tick(fr)
time_since_pipe += 1
score = self.increment_score(score, self.birds[0])
self.increment_frame_score()
self.display_score()
self.quit_game()
def get_stimuli(self, bird):
#x distance to next pipe, y distance to center of pipe
stimuli = [999]
if bad_stimuli:
stimuli = [999, 999, 999, 999, 999]
next_pipe = None
for p in self.pipes:
if p.top_left[0] + p.pipe_width > bird.top_left[0]:
next_pipe = p
break
if next_pipe:
stimuli = [next_pipe.center - bird.top_left[1]]
if bad_stimuli:
stimuli.extend([next_pipe.top_left[0] - bird.top_left[0] + next_pipe.pipe_width, bird.y_velocity, bird.acceleration, next_pipe.center])
return stimuli
def increment_frame_score(self):
self.frame_score += 1
if self.frame_score == 700:
c = 0
for b in self.birds:
if b.alive:
break
c+=1
self.save_best_score(self.frame_score, self.genomes[c])
def save_best_score(self, frame_score = None, net = None):
global best_score_ever, best_per_gen_file, best_ever_file
best_score_in_gen = -1
best_in_gen = None
c = 0
if not frame_score:
for s in self.scores:
if s > best_score_in_gen:
best_in_gen = self.genomes[c]
best_score_in_gen = s
c = c + 1
else:
best_score_in_gen = frame_score
best_in_gen = net
best_in_gen = str(best_in_gen).replace('\n', '').replace('\r', '')
fhandler = open(best_per_gen_file, "a")
fhandler.writelines("Gen #%d scored %f pts: " % (GENERATION, best_score_in_gen) + str(
best_in_gen) + "\n")
fhandler.close()
if best_score_in_gen > best_score_ever:
fhandler = open(best_ever_file, "w")
fhandler.writelines("Gen #%d scored %f pts: " % (GENERATION, best_score_in_gen) + str(best_in_gen) + "\n")
fhandler.close()
best_score_ever = best_score_in_gen
def increment_score(self, score, bird):
for p in self.pipes:
if p.top_left[0] < bird.top_left[0] - p.pipe_width and not p.scored:
p.scored = True
score += 1
return score
def display_score(self):
pass
def quit_game(self):
pygame.quit()
def read_keyboard_input(self, bird):
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bird.flap()
return "SPACE"
elif event.key == pygame.K_ESCAPE:
self.playing_game = False
return "NO_INPUT"
def read_computer_input(self, bird, nn):
s = self.get_stimuli(bird)
input = s
out = nn.activate(input)
if out[0] >= .5:
action = 'SPACE'
else:
action = 'NO_INPUT'
if action == "SPACE":
bird.flap()
def check_for_collision(self, bird):
if bird.top_left[1] < 0:
return True
if pygame.sprite.collide_rect(bird, self.floor):
if pygame.sprite.collide_mask(bird, self.floor):
return True
for p in self.pipes:
if p.top_left[0] < size[0]:
if p.check_for_collision(bird,pixel_collision=False):
return True
return False
def update_pipes(self):
for p in self.pipes:
if p.top_left[0] < -200:
self.pipes.remove(p)
break
for p in self.pipes:
p.move()
def lay_pipe(self):
p = Pipe(random.randint(round(256), round(size[1]-256)), size[1], size[0])
self.pipes.append(p)
def draw_everything(self, score):
self.draw_background()
self.draw_birds()
self.draw_pipe()
self.draw_floor()
self.draw_score(score)
if computer_playing:
self.draw_computer_info()
def draw_computer_info(self):
# cur_gen, best, avg, std = self.get_network_stats()
num_alive = len([b for b in self.birds if b.alive])
# num_per_gen = self.computer_player.num_per_gen
# best_ever = self.computer_player.best_score_ever
# if self.frame_score > best_ever:
# best_ever = self.frame_score
s = self.score_text.render("Frame Score: %d" % self.frame_score, False, (255, 255, 255))
na = self.score_text.render("Alive: %d / %d" % (num_alive, gen_size), False, (255, 255, 255))
g = self.score_text.render("Generation: %d" % self.gen, False, (255, 255, 255))
# b = self.score_text.render("Best Score: %d" % best_ever, False, (255, 255, 255))
self.screen.blit(g, (5, 5))
self.screen.blit(na, (5, 25))
self.screen.blit(s, (5, 45))
# self.screen.blit(b, (5, 65))
def draw_score(self, score):
t = self.score_text.render("%s" % score, False, (255, 255, 255))
self.screen.blit(t, (round(size[0]/2), 100))
def draw_birds(self):
for b in self.birds:
if b.alive:
b.draw(self.screen)
def draw_background(self):
self.screen.fill(bg_color)
def draw_pipe(self):
for p in self.pipes:
p.draw(self.screen)
def draw_floor(self):
self.floor.draw(self.screen)
class Engine():
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)),
(0, 0))
self.screen.blit(
FONT.render("Remember - patience is a virtue.", True,
(255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles(
)
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles,
self.characters, self.items, self.bullets,
self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen,
x=0,
y=0,
obstaclemap=self.obstacles,
**temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
self.show_fps = True
def savegame(self):
if not os.path.isdir("save"):
os.mkdir("save")
for path, item in self.loaded_maps.items():
final_path = os.path.join("save", path)
if not os.path.exists(final_path):
os.makedirs(final_path)
self.obstacles.save(final_path,
item["characters"] + item["dead_characters"],
item["item_map"], item["triggers"],
item["obstacles"])
self.floor.save(os.path.join(final_path, "floor.py"),
item["floor"])
with open(os.path.join(final_path, "config.py"), "w") as f:
f.write("config = " + repr(item["config"]))
if not os.path.exists(os.path.join("save", self.current_map)):
os.makedirs(os.path.join("save", self.current_map))
self.obstacles.save(
os.path.join("save", self.current_map),
self.obstacles.charactermap + self.obstacles.dead_characters,
self.obstacles.item_map, self.obstacles.triggers,
self.obstacles.layers)
self.floor.save(os.path.join("save", self.current_map, "floor.py"),
self.floor.layers)
with open(os.path.join("save", self.current_map, "config.py"),
"w") as f:
f.write("config = " + repr(self.config))
player_config = {
"dead": self.player.dead,
"grid_pos": self.player.grid_pos.copy(),
"current_map": self.current_map,
"won": self.wongame,
"lost": self.lostgame,
"inventory": self.player.get_inventory(),
"health": self.player.health
}
with open(os.path.join("save", "config.py"), "w") as f:
f.write("player_config = " + repr(player_config))
def load_game(self):
if os.path.isdir("save"):
self.wongame = False
self.lostgame = False
player_config = load_module(os.path.join(
"save", "config.py")).player_config.copy()
self.player.reset()
self.player.dead = player_config["dead"]
self.player.load_inventory(player_config["inventory"])
self.saved_maps = os.listdir("save")
self.current_map = player_config["current_map"]
self.player.health = player_config["health"]
self.saved_maps = [
os.path.join("maps", x) for x in os.listdir("save/maps")
]
self.loaded_maps = {}
self.load_map(self.current_map,
spawn_pos=player_config["grid_pos"])
if player_config["won"]:
self.wingame()
elif player_config["lost"]:
self.losegame()
def load_map(self, path, **kwargs):
if path in self.saved_maps:
self.saved_maps.remove(path)
path = os.path.join("save", path)
self.current_map = None
if self.current_map:
self.loaded_maps[self.current_map] = {}
self.loaded_maps[
self.current_map]["floor"] = self.floor.layers.copy()
self.loaded_maps[
self.current_map]["obstacles"] = self.obstacles.layers.copy()
self.loaded_maps[self.current_map][
"characters"] = self.obstacles.charactermap.copy()
self.loaded_maps[self.current_map][
"dead_characters"] = self.obstacles.dead_characters.copy()
self.loaded_maps[
self.current_map]["item_map"] = self.obstacles.item_map.copy()
self.loaded_maps[
self.current_map]["bullets"] = self.obstacles.bullets.copy()
self.loaded_maps[
self.current_map]["triggers"] = self.obstacles.triggers.copy()
self.loaded_maps[self.current_map]["config"] = self.config.copy()
if path.startswith("save"):
self.current_map = path[5:]
else:
self.current_map = path
if path in self.loaded_maps:
self.floor.layers = self.loaded_maps[path]["floor"].copy()
self.obstacles.layers = self.loaded_maps[path]["obstacles"].copy()
self.obstacles.charactermap = self.loaded_maps[path][
"characters"].copy()
self.obstacles.dead_characters = self.loaded_maps[path][
"dead_characters"].copy()
self.obstacles.item_map = self.loaded_maps[path]["item_map"].copy()
self.obstacles.bullets = self.loaded_maps[path]["bullets"].copy()
self.obstacles.triggers = self.loaded_maps[path]["triggers"].copy()
self.config = self.loaded_maps[path]["config"].copy()
else:
self.floor.load_tilemap(os.path.join(path, "floor.py"))
self.obstacles.load_obstaclemap(os.path.join(path, "obstacles.py"))
self.obstacles.load_charactermap(
os.path.join(path, "characters.py"))
self.obstacles.load_item_map(os.path.join(path, "items.py"))
self.obstacles.load_triggermap(os.path.join(path, "triggers.py"))
self.obstacles.dead_characters = []
self.obstacles.bullets = []
self.config = load_module(os.path.join(path,
"config.py")).config.copy()
try:
pygame.mixer.music.load(self.config.get("music", "Betrayed.ogg"))
pygame.mixer.music.play(-1)
except:
pass
if kwargs.get("spawn_pos", None):
self.player.grid_pos = kwargs["spawn_pos"].copy()
else:
self.player.grid_pos = self.config.get("spawn_pos", [0, 0]).copy()
self.player.reset()
mapsize = self.config.get("level_dimensions", [50, 50])
self.obstacles.change_size(mapsize)
self.obstacles.refresh_trigger_quadtree()
self.obstacles.refresh_grid()
def update(self, event=None):
if not self.wongame:
screen_size = self.screen.get_size()
isox = (self.player.grid_pos[0] -
self.player.grid_pos[1]) * (ISOWIDTH // 2)
isoy = (self.player.grid_pos[0] +
self.player.grid_pos[1]) * (ISOHEIGHT // 2)
self.screen_offset = [
screen_size[0] // 2 - isox, screen_size[1] // 2 - isoy
]
current_time = pygame.time.get_ticks()
self.floor.update(current_time)
self.obstacles.update(current_time=current_time, event=event)
if event and event.type == KEYDOWN:
if event.key == K_F3:
self.savegame()
elif event.key == K_F4:
self.load_game()
elif event.key == K_F11:
self.show_fps = not self.show_fps
def wingame(self):
self.wongame = True
pygame.mixer.music.load("wingame.ogg")
pygame.mixer.music.play(-1)
def losegame(self):
self.lostgame = True
pygame.mixer.music.load("Sad_Piano_3.ogg")
pygame.mixer.music.play(-1)
def draw(self):
self.floor.draw(self.screen_offset)
self.obstacles.draw(self.screen_offset)
if self.wongame:
screen.blit(
FONT.render("Congratulations, you won!", True,
(255, 255, 255)), (0, 0))
elif self.lostgame:
screen.blit(
FONT.render("Shame be upon you! You lost!", True,
(255, 255, 255)), (0, 0))
self.screen.blit(
FONT.render("Health: " + str(self.player.health), True,
(255, 255, 255)), (self.screen.get_size()[0] - 200, 0))
if self.show_fps:
self.screen.blit(
FONT.render("FPS: " + str(round(clock.get_fps(), 2)), True,
(255, 255, 255)),
(self.screen.get_size()[0] - 400, 0))
def main(inFilename):
# parse/use inFilename
img = cv.imread(inFilename, cv.IMREAD_GRAYSCALE)
print(inFilename)
outFilename = path.join("data", "polygons", path.basename(inFilename))
building = path.basename(inFilename)[:4]
floornum = path.splitext(path.basename(inFilename))[0][-1]
# get settings for this building
settings = {}
for line in open("scripts/settings.txt", "r"):
tokens = line.split("\t")
settings[tokens[0].strip(":").lower()] = building in tokens[1:]
# run analysis
floor = Floor(cv.imread(inFilename, cv.IMREAD_COLOR),
floornum,
building,
preprocessed=preprocessed)
text_thresh = 2200
if building == "0010":
text_thresh = 3000
floor.segment(room_upper_thresh=None, text_thresh=text_thresh)
floor.find_doors(settings["cluttered"],
settings["close_door"],
corr_thresh=.03)
floor.transplant_doors()
floor.find_rooms(settings["efr"], settings["two_digit"])
# draw results
floor.draw_doors()
floor.draw_rooms()
# output results
if not real:
outFilename = "debug.png"
jsonFilename = path.splitext(outFilename)[0] + ".json"
json.dump(floor.toJSON(), open(jsonFilename, "w"))
cv.imwrite(outFilename, floor.original)
# output extra debugging info
if mark:
cv.imwrite(path.join("marked", path.basename(inFilename)),
floor.segments["rooms"].colored())
if verbose:
cv.imwrite("debug_rooms.png", floor.segments["rooms"].colored())
cv.imwrite("debug_text.png", floor.segments["text"].img)
cv.imwrite("debug_no_text.png", floor.segments["no_text"].img)
class Engine():
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)), (0, 0))
self.screen.blit(FONT.render("Patience is a virtue.", True, (255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles()
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles, self.characters, self.items, self.bullets, self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen, x=0, y=0, obstaclemap=self.obstacles, **temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
def savegame(self):
if not os.path.isdir("save"):
os.mkdir("save")
for path, item in self.loaded_maps.items():
final_path = os.path.join("save", path)
if not os.path.exists(final_path):
os.makedirs(final_path)
self.obstacles.save(final_path, item["characters"] + item["dead_characters"], item["item_map"], item["triggers"], item["obstacles"])
self.floor.save(os.path.join(final_path, "floor.py"), item["floor"])
with open(os.path.join(final_path, "config.py"), "w") as f:
f.write("config = " + repr(item["config"]))
if not os.path.exists(os.path.join("save", self.current_map)):
os.makedirs(os.path.join("save", self.current_map))
self.obstacles.save(os.path.join("save", self.current_map), self.obstacles.charactermap + self.obstacles.dead_characters, self.obstacles.item_map, self.obstacles.triggers, self.obstacles.layers)
self.floor.save(os.path.join("save", self.current_map, "floor.py"), self.floor.layers)
with open(os.path.join("save", self.current_map, "config.py"), "w") as f:
f.write("config = " + repr(self.config))
player_config = {"dead": self.player.dead, "grid_pos": self.player.grid_pos.copy(), "current_map": self.current_map, "won": self.wongame, "lost": self.lostgame, "inventory": self.player.get_inventory(), "health": self.player.health}
with open(os.path.join("save", "config.py"), "w") as f:
f.write("player_config = " + repr(player_config))
def load_game(self):
if os.path.isdir("save"):
player_config = load_module(os.path.join("save", "config.py")).player_config.copy()
self.player.reset()
self.player.dead = player_config["dead"]
self.player.load_inventory(player_config["inventory"])
self.saved_maps = os.listdir("save")
self.current_map = player_config["current_map"]
self.player.health = player_config["health"]
self.saved_maps = os.listdir("save")
self.load_map(self.current_map, spawn_pos=player_config["grid_pos"])
if player_config["won"]:
self.wingame()
elif player_config["lost"]:
self.losegame()
def load_map(self, path, **kwargs):
if path in self.saved_maps:
self.saved_maps.remove(path)
path = os.path.join("save", path)
if self.current_map:
self.loaded_maps[self.current_map] = {}
self.loaded_maps[self.current_map]["floor"] = self.floor.layers.copy()
self.loaded_maps[self.current_map]["obstacles"] = self.obstacles.layers.copy()
self.loaded_maps[self.current_map]["characters"] = self.obstacles.charactermap.copy()
self.loaded_maps[self.current_map]["dead_characters"] = self.obstacles.dead_characters.copy()
self.loaded_maps[self.current_map]["item_map"] = self.obstacles.item_map.copy()
self.loaded_maps[self.current_map]["bullets"] = self.obstacles.bullets.copy()
self.loaded_maps[self.current_map]["triggers"] = self.obstacles.triggers.copy()
self.loaded_maps[self.current_map]["config"] = self.config.copy()
if path.startswith("save"):
self.current_map = path[5:]
else:
self.current_map = path
if path in self.loaded_maps:
self.floor.layers = self.loaded_maps[path]["floor"].copy()
self.obstacles.layers = self.loaded_maps[path]["obstacles"].copy()
self.obstacles.charactermap = self.loaded_maps[path]["characters"].copy()
self.obstacles.dead_characters = self.loaded_maps[path]["dead_characters"].copy()
self.obstacles.item_map = self.loaded_maps[path]["item_map"].copy()
self.obstacles.bullets = self.loaded_maps[path]["bullets"].copy()
self.obstacles.triggers = self.loaded_maps[path]["triggers"].copy()
self.config = self.loaded_maps[path]["config"].copy()
else:
self.floor.load_tilemap(os.path.join(path, "floor.py"))
self.obstacles.load_obstaclemap(os.path.join(path, "obstacles.py"))
self.obstacles.load_charactermap(os.path.join(path, "characters.py"))
self.obstacles.load_item_map(os.path.join(path, "items.py"))
self.obstacles.load_triggermap(os.path.join(path, "triggers.py"))
self.obstacles.dead_characters = []
self.obstacles.bullets = []
self.config = load_module(os.path.join(path, "config.py")).config.copy()
try:
pygame.mixer.music.load(self.config.get("music", "Search_Art_S31_Undercover_Operative_0.ogg"))
pygame.mixer.music.play(-1)
except:
pass
if kwargs.get("spawn_pos", None):
self.player.grid_pos = kwargs["spawn_pos"].copy()
else:
self.player.grid_pos = self.config.get("spawn_pos", [0, 0]).copy()
self.player.reset()
mapsize = self.config.get("level_dimensions", [50, 50])
self.obstacles.change_size(mapsize)
self.obstacles.refresh_trigger_quadtree()
self.obstacles.refresh_grid()
def update(self, event=None):
if not self.wongame:
screen_size = self.screen.get_size()
isox = (self.player.grid_pos[0] - self.player.grid_pos[1]) * (ISOWIDTH // 2)
isoy = (self.player.grid_pos[0] + self.player.grid_pos[1]) * (ISOHEIGHT // 2)
self.screen_offset = [screen_size[0] // 2 - isox, screen_size[1] // 2 - isoy]
current_time = pygame.time.get_ticks()
self.floor.update(current_time)
self.obstacles.update(current_time=current_time, event=event)
if event and event.type == KEYDOWN:
if event.key == K_F3:
self.savegame()
elif event.key == K_F4:
self.load_game()
def wingame(self):
self.wongame = True
pygame.mixer.music.load("wingame.ogg")
pygame.mixer.music.play(-1)
def losegame(self):
self.lostgame = True
pygame.mixer.music.load("Sad_Piano_3.ogg")
pygame.mixer.music.play(-1)
def draw(self):
self.floor.draw(self.screen_offset)
self.obstacles.draw(self.screen_offset)
if self.wongame:
screen.blit(FONT.render("Congratulations, you won!", True, (255, 255, 255)), (0, 0))
elif self.lostgame:
screen.blit(FONT.render("Shame be upon you! You lost!", True, (255, 255, 255)), (0, 0))
self.screen.blit(FONT.render("Health: " + str(self.player.health), True, (255, 255, 255)), (self.screen.get_size()[0] - 200, 0))
def __init__(self, env):
self.clock = env
self.floor = Floor(env)
self.inventory = Inventory(env)
self.robot_scheduler = RobotScheduler(env)
self.order_control = OrderControl(env)
