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)