def mainLoop(photoPath='images/cxy.png'): Floor.setLastHeight(0) screen = Screen('images/bg.jpg') X = screen.getWindowX() Y = screen.getWindowY() print(Y) doodle = Doodle(photoPath, 'piepie', X, Y, 180, 250) screen.setDoodle(doodle) clock = pygame.time.Clock() while True: clock.tick(Screen.getFps()) for event in pygame.event.get(): if event.type == pygame.QUIT: print("exit game.") pygame.quit() exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: doodle.setMovingDir(-1) print("left") elif event.key == pygame.K_RIGHT: doodle.setMovingDir(1) print("right") elif event.type == pygame.KEYUP: doodle.setMovingDir(0) screen.step() if not doodle.isAlive(): return True
def on_init(self): pygame.init() self.screen = pygame.display.set_mode((576, 1025)) self.clock = pygame.time.Clock() self.gameActive = True self.gravity = 0.25 self.score = 0 self.scoreText = Text(self.score, 40) self.highScore = 0 self.highScoreText = Text(f'High score: {int(self.score)}', 40) self.background = pygame.image.load( "assets/background-day.png").convert() self.background = pygame.transform.scale2x(self.background) self.floor = Floor() self.bird = Bird() self.pipes = [] self.SPAWNPIPE = pygame.USEREVENT self.BIRDFLAP = pygame.USEREVENT + 1 pygame.time.set_timer(self.SPAWNPIPE, 1200) pygame.time.set_timer(self.BIRDFLAP, 200)
def __init__(self): self.blinks_detector = BlinkDetector() self.blinks_detector.start() pygame.init() pygame.event.set_allowed([ QUIT, KEYDOWN, KEYUP, Pipes.SPAWN_PIPE_EVENT, Bird.BIRD_FLAP_EVENT ]) self.active = True self.score = 0 self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), DOUBLEBUF) self.screen.set_alpha(None) self.clock = pygame.time.Clock() self.font = pygame.font.Font('fonts/04B_19.ttf', 40) # Game objects self.bg_surface = pygame.transform.scale2x( pygame.image.load("assets/background-day.png").convert()) self.gameover_surface = pygame.transform.scale2x( pygame.image.load("assets/gameover.png").convert_alpha()) self.gameover_rect = self.gameover_surface.get_rect( center=(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)) self.floor = Floor() self.bird = Bird() self.bird.start_flapping() self.pipes = Pipes() self.pipes.start_spawning()
def test_properties(self): floors = [Floor(1, 7), Floor(2, 7)] elevators = [Elevator(id=1, size=10)] c = Controller(floors, elevators) self.assertTrue(type(c.signal_change_velocity) is Signal) self.assertTrue(type(c.signal_stop) is Signal)
def __init__(self, level): super(HowlGame, self).__init__(255, 255, 255, 255, 4000, 2000) # init voice self.NUM_SAMPLES = 1000 # pyAudio内部缓存块大小 self.LEVEL = 1500 # 声音保存的阈值 self.sample_count = 0 # 取样次数 self.average_volume = 0 # 平均音量 # init floor self.floor = Floor(self, level) self.add(self.floor, 0) # init voiceBar self.voiceBar = Sprite('ground/black.png', color=(0, 0, 255)) # self.voiceBar.position = 100, 460 self.voiceBar.scale_y = 0.1 self.voiceBar.image_anchor = 0, 0 self.add(self.voiceBar, 1) # init role self.role = Role(self) self.role_run_to_right = False self.role_run_to_left = False self.add(self.role, 2) self.action = FadeOut(0.5) # init monster # self.monster_node = cocos.cocosnode.CocosNode() # for i in range(5): # self.monster_node.add(Monster(self)) # self.add(self.monster_node) # init flag # flag = cocos.sprite.Sprite('scene/flag.png') # flag.position = 3500, 120 # flag.scale = 0.5 # self.flag = flag # self.add(flag) # init stone self.stone = None self.boom = cocos.sprite.Sprite('scene/boom.png') # init gameoverlayer self.gameover = None # Open Audio Input pa = PyAudio() SAMPLING_RATE = int( pa.get_device_info_by_index(0)['defaultSampleRate']) self.stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True, frames_per_buffer=self.NUM_SAMPLES) self.schedule(self.update)
def main(): # initialize game engine pygame.init() # Setup main window window_width = 400 window_height = 300 screen = pygame.display.set_mode((window_width, window_height)) pygame.display.set_caption("YARL!") # Initialize Hero floor = Floor("floors/dungeon.json") hero = Hero() print(hero.name + " just entered " + floor.name) hero.loc_x = floor.spawn[0] hero.loc_y = floor.spawn[1] set_position(hero, floor) # Initialize ennemies nb_ennemies = 1 ennemies = [] for ennemy in range(nb_ennemies): ennemies.append(Ennemy()) loc = get_ennemy_spawn(floor, ennemies, hero) ennemies[-1].loc_x = loc[0] ennemies[-1].loc_y = loc[1] set_position(ennemies[-1], floor) # Example of event handling while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: next_loc = [hero.loc_x, hero.loc_y] if event.key == pygame.K_LEFT: next_loc[0] -= 1 if event.key == pygame.K_RIGHT: next_loc[0] += 1 if event.key == pygame.K_UP: next_loc[1] -= 1 if event.key == pygame.K_DOWN: next_loc[1] += 1 set_loc(floor, hero, ennemies, next_loc) set_position(hero, floor) # Get all items to blit blits = floor.get_blits() blits += ui.get_blits() blits += hero.get_blits() for ennemy in ennemies: blits += ennemy.get_blits() # Blit and update display at every frame for item in blits: screen.blit(item[0], item[1]) pygame.display.update()
def __init__(self, player=None): # generate first floor self.floors = [ Floor.generate_basic_floor(DEFAULT_FLOOR_WIDTH, DEFAULT_FLOOR_HEIGHT) ] # generate other floors for i in range(1, DEFAULT_NUM_FLOORS): self.floors.append( Floor.generate_basic_floor(DEFAULT_FLOOR_WIDTH, DEFAULT_FLOOR_HEIGHT, self.floors[i - 1].down)) # close off top and bottom self.floors[0].set_base_pt(self.floors[0].up, '.') self.floors[-1].set_base_pt(self.floors[-1].down, '.') # generate a random player if none is given if player is None: self.player = Player() else: self.player = player # place player on upstairs of floor of dungeon self.player.pos = self.floors[0].up # generate NPCs self.npcs = [] Bug.generate(self) Segfault.generate(self) Spectre.generate(self) # generate loot and potions self.objs = [] for f in range(len(self.floors)): for i in range(random.randrange(3, 8)): self.objs.append( Loot(f, self.floors[f].random_point_in_room(), random.randrange((f + 1), 2 * (f + 1) + 1))) for i in range(random.randrange(0, 3)): self.objs.append( Potion(f, self.floors[f].random_point_in_room())) # victory square self.break_floor = DEFAULT_NUM_FLOORS - 1 self.break_pos = self.floors[self.break_floor].random_point_in_room() # game info self.cur_turn = 1 self.history = [] self.set_status("Welcome! Press '?' for help text.") self.xray_vis = False # starting visibility self.update_visibility()
def generation_room(x_initial, y_initial, room): x = x_initial y = y_initial for i in range(len(room)): for j in range(len(room[0])): if room[i][j] == "f": pf = Floor(x, y, random.randint(0,5)) layer_0.add(pf) if room[i][j] == "w": pf = Wall(x, y, 4) layer_1.add(pf) if room[i][j] == "d": pf = Wall(x, y, 1) layer_2.add(pf) if room[i][j] == "v": pf = Wall(x, y, 2) layer_2.add(pf) if room[i][j] == "x": pf = Wall(x, y, 0) layer_0.add(pf) wall.append(pf) if room[i][j] == "u": pf = Wall(x, y, 3) layer_1.add(pf) r = random.randint(0, 100) if r <= 5: torch = Torch(x, y, 3) layer_1.add(torch) if room[i][j] == "c": r = random.randint(3, 10) if r >= 5: pf = Floor(x, y, 6) layer_0.add(pf) pf = Chest(x, y-6, random.randint(1, 2)) layer_1.add(pf) chest.append(pf) else: pf = Floor(x, y, 6) layer_0.add(pf) if room[i][j] == "z": pf = Monster_spawn(x, y) layer_0.add(pf) r = random.randint(2, 5) for i in range(r): x_ = random.randint(pf.rect.x-32, pf.rect.x+64) y_ = random.randint(pf.rect.y-32, pf.rect.y+64) pf = Monster(x_, y_, random.randint(1, 4)) layer_1.add(pf) layer_monster.add(pf) layer_all_monster_and_layer.add(pf) x += 32 x = x_initial y += 32
def eval_genomes(pop): global WIN clock = pygame.time.Clock() pipes = [Pipe(700)] base = Floor(FLOOR) win = WIN score = 0 run = True while run: clock.tick(30) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False pygame.quit() quit() break rem = [] add_pipe = False for pipe in pipes: pipe.move() pop.check_colision_with_pipe(pipe, win) if pipe.x + pipe.PIPE_TOP.get_width() < 0: rem.append(pipe) if not pipe.passed and pipe.x < pop.pop[0].x: pipe.passed = True add_pipe = True if add_pipe: score += 1 pop.increment_score_by_n(10) pipes.append(Pipe(WIN_WIDTH)) for r in rem: pipes.remove(r) pipe_ind = 0 if pop.done() != True: if len(pipes) > 1 and pop.pop[ 0].x > pipes[0].x + pipes[0].PIPE_TOP.get_width(): pipe_ind = 1 pop.increment_score_by_n(0.03) pop.update_alive(pipes, pipe_ind, FLOOR) base.move() else: pop.natural_selection() run = False draw_window(WIN, pop.pop, pipes, base, score, gen, pipe_ind)
def __init__(self, elevator_count, floor_count, message_width, name='Building', trace_riders=False): self.elevators = [Elevator(n) for n in range(elevator_count)] self.floors = [Floor(0, has_down_button=False)] self.floors.extend(Floor(n) for n in range(floor_count)[1:-1]) self.floors.append(Floor(floor_count - 1, has_up_botton=False)) self._all_riders = [] self._message_width = message_width self._messages = [] self._name = name self._trace_riders = trace_riders
def step(self): self.__doodle.move() if self.__doodle.getTop() <= self.__magicLine: if self.__doodle.getSpeedY() < 0: self.__doodle.reachMagicLine() self.__doodle.increaseScore() else: self.__doodle.leaveMagicLine() if self.__doodle.isAtMagicLine(): for floor in self.__floors: floor.moveY(-self.__doodle.getSpeedY()) for floor in list(self.__floors): if floor.isDoodleLandOn(self.__doodle.getCenterX(), self.__doodle.getBottom(), self.__doodle.getSpeedY()): # 看看是掉到了什么东西上 if floor.getLandOnItemType() == ItemType.ROCKET: self.__doodle.landOnRocket(floor.getItemOn()) elif floor.getLandOnItemType() == ItemType.SPRING: self.__doodle.landOnSpring() elif floor.getLandOnItemType() == ItemType.FLOOR: self.__doodle.landOnFloor() if floor.isOutOfScreen(): self.__floors.remove(floor) self.__floors.add( Floor(self.getWindowX(), self.getWindowY(), isNew=True)) self.drawAll() pygame.display.update()
def __init__(self, game, speed, location, gameboard): super(Player, self).__init__(location, (CELL_SIZE, CELL_SIZE)) self.game = game self.root = game.root self.gameboard = gameboard self.speed = speed self.flyable = False self.condition = "NORMAL" self.on_power = False self.get_top = False self.health = 500 self.magic = 200 self.feature = "NONE" self.defence = 0 self.ykeynum = 0 self.bkeynum = 0 self.rkeynum = 0 self.gkeynum = 0 self.swordkeynum = 0 self.snakedp = 0 self.snakerocknum = 0 self.money = 0 self.exp = 0 self.level = 1 STARTFLOOR = 1 self.currentfloor = Floor(STARTFLOOR) self.visited_floors = {STARTFLOOR: self.currentfloor} self.quests = []
def main(argv): loop = True floors = [] if len(sys.argv) < 3: printWarning( "usage:\nMVP\t -n = Number of floors\n\t -m= Number of Elevators") return 0 m, n = int(sys.argv[1]), int(sys.argv[2]) printInfo("received values:" + str(n) + " " + str(m)) admin = Admin(n, m) for i in range(m): floors.append(Floor(i, admin)) while loop: ## While loop which will keep going until loop = False admin.printStatusElevators() print_menu() ## Displays menu choice = input("Enter your choice [1-3]: ") if choice == 1: floor, destination = map( int, raw_input(" <floor> <destination floor>\n").split(" ")) if floor <= m and destination <= m and destination != floor: up_down = 1 if destination > floor else 2 closer_elevator = floors[floor].askResources(up_down) print "The elevator " + str( closer_elevator) + " will attend this request" threading.Timer( 1, set_floor, [admin.elevators[closer_elevator], floor, destination ]).start() #routine to ask elevator elif choice == 2: admin.printStatusElevators() elif choice == 3: loop = False
def load_tower(flo, newgame=True): with open(flo, 'r') as file: temp_tower = [] if newgame: pass for n, line in enumerate(file, 0): if n != 51: temp_floor = {} line = line.strip('\n').strip('(').strip(')').split(')((') for entry in line: point, item = entry.split('), ') i, j = point.split(', ') temp_floor.update({(int(i), int(j)): item.strip("'")}) temp_tower.append(Floor(n, *temp_floor.items())) else: tower = Tower(temp_tower) tower.current = tower.tower[int( line.strip('\n').split('/')[6])] temp = zip([ 'i', 'j', 'hp', 'attack', 'defense', 'gold', 'num', 'yellow_key', 'blue_key', 'red_key', 'shop', 'cross', 'lucky_coin', 'magic_defense', 'dragon_dagger', 'hallows' ], line.strip('\n').split('/')) prot = Protagonist('protagonist', tower, **dict([i for i in temp])) return tower, prot
def scroll(self): """ 地面を右から左へスクロールする """ # スクロールする for f in self.floors: f_x = f.left - self.scroll_step f.left = f_x # 画面左端に達した地面を消す if self.floors[0].right < 0: del self.floors[0] # 画面右端にブロックを追加する if (conf.SCREEN_WIDTH - self.floors[-1].right) > self.gap_to_next: if random.choice([True, False]): # 新しいブロックは前のブロックよりも上 floor_y_top = max(self.floors[-1].top - conf.GAP_UP_Y_TO_NEXT, 230) floor_y = random.randint(floor_y_top, self.floors[-1].top) else: # 新しいブロックは前のブロックよりも下 floor_y = random.randint(self.floors[-1].top, conf.SCREEN_HEIGHT - 30) floor_length = random.randint(90 - self.new_floor_level, 200 - self.new_floor_level) new_floor = Floor(conf.SCREEN_WIDTH, floor_y, floor_length, conf.FLOOR_HEIGHT) self.floors.append(new_floor) # 新しい床の出現までランダムに間隔を空ける self.gap_to_next = self.get_gap_to_next()
def test_properties(self, method): f = Floor(num=1, height=10) self.assertEqual(1, f.num) self.assertEqual(10, f.height) self.assertTrue(type(f.signal_elevator_requested) is Signal) self.assertTrue(type(f.people) is list) self.assertTrue(type(f.queue) is list)
def load_all(self): self.game_w = GAME_SIZE[0] self.game_h = GAME_SIZE[1] self.floor_y = self.game_h - FLOOR_Y self.bird_x = self.game_w / 3 - FLOOR_Y self.bird_y = self.game_h / 2 self.pipe_w = PIPE_W self.build_y = self.floor_y - 229 self.mes_x = (self.game_w - MES_W) / 2 self.mes_y = (self.game_h - MES_H) / 2 self.game_p = self.game_w - DIST - self.pipe_w self.max_s = self.floor_y - MIN_PIPE_H - DIST self.min_pipe_h = MIN_PIPE_H self.end_s_x = (self.game_w - 139) / 2 self.sc_x = (self.game_w - 70) / 2 self.score = 0 self.sprites = pygame.sprite.LayeredUpdates() self.tubes = pygame.sprite.LayeredUpdates() self.background = make_back(self) self.screen.blit(self.background, (0, 0)) ######################################################################## self.floor = Floor(0, self.floor_y, self.game_w) self.floor.mVel = 0 self.bird = Bird(self, self.bird_x, self.bird_y) self.bird.mAcc = 0 self.end_scores = EndScore(self.end_s_x, 200) self.message = Message(self.mes_x, self.mes_y) self.currentS = CurrentScore(self, self.sc_x, 100) ######################################################################## self.sprites.add(self.floor, layer=0) self.sprites.add(self.bird, layer=2) self.sprites.add(self.message, layer=3)
def _initialize_sprites(self, level_map): """A method which initializes the level, creates all objects necessary for the game to run Args: level_map: the layout of the level in a two dimensional list [y][x] """ height = len(level_map) width = len(level_map[0]) for pos_y in range(height): for pos_x in range(width): cell = level_map[pos_y][pos_x] normalized_x = pos_x * self.cell_size normalized_y = pos_y * self.cell_size if cell == 0: self.floors.add(Floor(normalized_x, normalized_y)) elif cell == 1: self.walls.add(Wall(normalized_x, normalized_y)) elif cell == 2: self.player = Player(pos_x, pos_y, normalized_x, normalized_y) self.floors.add(Floor(normalized_x, normalized_y)) self.level_map[pos_y][pos_x] = self.player elif cell == 3: self.stairs = Stairs(normalized_x, normalized_y) elif cell == 4: enemy = Slime(pos_x, pos_y, normalized_x, normalized_y) self.enemies.add(enemy) self.floors.add(Floor(normalized_x, normalized_y)) self.level_map[pos_y][pos_x] = enemy elif cell == 5: enemy = Ranger(pos_x, pos_y, normalized_x, normalized_y) self.enemies.add(enemy) self.floors.add(Floor(normalized_x, normalized_y)) self.level_map[pos_y][pos_x] = enemy elif cell == 6: item = Item(pos_x, pos_y, normalized_x, normalized_y) self.floors.add(Floor(normalized_x, normalized_y)) self.objects.add(item) self.level_map[pos_y][pos_x] = item self.all_sprites.add(self.walls, self.floors, self.stairs, self.objects, self.enemies, self.player) self.refresh_enemy_queue() self.setup_camera()
def test_request_elevator(self, method): observer = Mock() f = Floor(num=0, height=0) f.signal_elevator_requested.connect(observer) f.signal_elevator_requested.emit(from_floor=1, to_floor=2) observer.assert_called_once_with(from_floor=1, to_floor=2)
def init_scene(self): self.add_entity(Sky(0, 0, self)) self.add_entity(Floor(0, 0, self)) self.generate_beams() self.generate_coins() self.generate_magnets() self.add_entity(Dragon(10, 450, self)) self.__mando = Mando(10, 0, self) self.add_entity(self.__mando)
def __init__(self, width, height): super(Game, self).__init__(width=width, height=height) pyglet.clock.schedule_interval(self.update, 1 / 120.0) self.fps_display = pyglet.window.FPSDisplay(self) self.player = Player(50, 300) self.floor = Floor(0, 10) self.enemy = Enemy(300, 400) self.push_handlers(self.player.key_handler) self.game_objects = [self.player, self.floor, self.enemy]
def __init__(self, floors_count, elevators_count): self.floors_count = floors_count self.elevators_count = elevators_count self.floors = [Floor(number) for number in range(1, floors_count + 1)] self.elevators = [ Elevator(ind, self.floors[0]) for ind in range(1, elevators_count + 1) ] print(self)
def main(): ground = Floor() # Create the ground ground.gen_coor() # Generate coordinates of the ground fl_coor = ground.coor # fl_coor are the coordinates of the ground (numpy array) # print fl_coor ground.gen_versors() # Generate local versors in all the ground segments par_ver = ground.par_ver #par_ver has all the parallel versos of the segments nor_ver = ground.nor_ver #par_ver has all the parallel versos of the segments # print par_ver bike_test = Bike() # Initiate Bike object bike_test.gen_rand_bike() # Random parameters #EXAMPLE # l0_ww = bike_test.l0_ww # # print l0_ww # Test Distance routine # res = bk_gd_int(bike_test,ground) # print res # print w1_pos[0],w1_pos[1] RuKu4(bike_test,ground) bike_new = Bike() bike_new.gen_sp_bike(bike_positions,bike_mass,k_sp)
def generate_floor(self,floor_lvl): self.floor_lvl = floor_lvl if self.floor_lvl >= SETTINGS['max_floor_size']: self.floor_lvl = SETTINGS['max_floor_size']-1 cards = [] cards.append(self._gen_exit_card()) for i in range(self.floor_lvl): randroll = randint(0,99) # 5% if randroll > 0 and randroll <= 4: cards.append(self._gen_free_card()) # 15% elif randroll > 4 and randroll <= 19: cards.append(self._gen_loot_card()) # 10% elif randroll > 19 and randroll <= 29: cards.append(self._gen_tip_card()) # 5% elif randroll > 29 and randroll <= 34: cards.append(self._gen_chest_card()) # 15% elif randroll > 34 and randroll <= 49: cards.append(self._gen_trade_card()) # 10% elif randroll > 49 and randroll <= 59: cards.append(self._gen_fairy_card()) # 5% elif randroll > 59 and randroll <= 64: cards.append(self._gen_slots_card()) # 20% elif randroll > 64 and randroll <= 84: cards.append(self._gen_monster_card()) # 5% elif randroll > 84 and randroll <= 89: cards.append(self._gen_trap_card()) # 5% elif randroll > 89 and randroll <= 94: cards.append(self._gen_arena_card()) # 5% else: cards.append(self._gen_thief_card()) shuffle(cards) return Floor(cards)
def setup(self): for i in range(0, self.numFloors): self.floors.append(Floor(i)) for elevatorID in range(0, self.numElevators): self.elevators.append(Elevator(elevatorID, self)) self.graphics = PelevatorGraphics(self) # create some persons initially for i in range(0, 3): self.addPerson() self.graphics.start()
def __init__(self,screen_rect): # set screen_rect self.screen_rect = screen_rect # load images self.load_images() # load font self.font = pygame.font.SysFont(None,44) # setup player self.player = Player(self.images["player"]) # teleport player to starting position self.player.teleport((200,200)) # create starting level self.floor = Floor(self.images,screen_rect) self.running = True
def __init__(self, rows): super(Map, self).__init__() self.height = len(rows) self.width = len(rows[0]) for y, row in enumerate(rows): self._map[y] = {} for x, item in enumerate(row): if item == '#': self._map[y][x] = Floor() elif item == '|': self._map[y][x] = Door() elif item == '@': self._map[y][x] = Player() else: self._map[y][x] = None
def __init__(self, FloorNumber, ElevatorNumber): self.FloorNumber = FloorNumber self.ElevatorNumber = ElevatorNumber self.Elevators = [] self.Passengers = [] self.Floors = [] self.Lines = [] self.RenderedText = [] self.FloorNumberRects = [] self.PressedButtonsRect = [] self.SavedButtonsUp = [] self.SavedButtonsDown = [] self.RenderedTextUp = [] self.RenderedTextDown = [] self.addPassenger(config.BASEPASSENGERS) pressedUpDestination, pressedDownDestination = [], [] for i in range(self.FloorNumber): self.RenderedTextUp.append( config.SMALLFONT.render("tempText", True, config.BLUE)) self.RenderedTextDown.append( config.SMALLFONT.render("tempText", True, config.BLUE)) for i in range(self.FloorNumber): self.SavedButtonsUp.append([set(), set()]) self.SavedButtonsDown.append([set(), set()]) for i in range(ElevatorNumber): self.Elevators.append(Elevator(i, config.FLOORHEIGHT)) self.Floors.append([]) [ self.Floors[i].append( Floor(self.Elevators[-1], j, config.FLOORHEIGHT)) for j in range(FloorNumber) ] [ self.Lines.append([ (130, i * config.FLOORHEIGHT), (130 + (self.ElevatorNumber + 1) * config.FLOORWIDTH, i * config.FLOORHEIGHT) ]) for i in range(FloorNumber) ] [ self.RenderedText.append( config.BIGFONT.render(str(i), True, config.BLUE)) for i in range(FloorNumber) ] self.resizeFloorNumbers() self.resizePressedButtons() self.setSectorList()
def generateFloors(): """ return [ floor1, floor2, ... ] """ NUM_FLOORS = 3 floors = [] for num in range(1, NUM_FLOORS + 1): floor = Floor(num=num, height=FLOOR_HEIGHT_PX) floors.append(floor) Clock.schedule_interval(floor.tick, UPDATE_INTERVAL_SEC) # remove this floors[-1].people.append(Person(floors[-1].num, 1)) return floors
def getParkingData(self,vehicleList): print "\n<--- ENTER VEHICLE DATA --->" for numOfFloors in range(2): vehicleDict = {} print "\n --- Floor {} ---".format(numOfFloors) vehicleLimit = int(input("\nEnter the Number of vehicles: ")) totalvehicles = 0 for vehicles in vehicleList: vehicleDict[vehicles] = int(input("\n\t {}: ".format(vehicles))) totalvehicles += vehicleDict[vehicles] if totalvehicles == vehicleLimit: self.floorObject = Floor(vehicleDict) print "\nDATA STORED SUCCESSFULLY" else: print "\nEnter vehicles count within {}\n".format(vehicleLimit) break self.addFloorData(self.floorObject) return self.data,self.floorObject
def create_map(self): self.random_map() self.tiles = [] for i in range(self.number_of_tiles): for j in range(self.number_of_tiles): tile = [] position = j * self.number_of_tiles + i if position in self.walls: tile.append(Wall()) else: tile.append(Floor()) tile.append(position) x = self.tile_size * j y = self.tile_size * i tile[0].x = x tile[0].y = y tile.append([x, y]) self.tiles.append(tile)
class Game(object): def __init__(self,screen_rect): # set screen_rect self.screen_rect = screen_rect # load images self.load_images() # load font self.font = pygame.font.SysFont(None,44) # setup player self.player = Player(self.images["player"]) # teleport player to starting position self.player.teleport((200,200)) # create starting level self.floor = Floor(self.images,screen_rect) self.running = True def update(self,keys,time_passed): ''' update the objects Game.update(keys): return Bool Updates all game objects, checks for collisions. Returns alive status. ''' # update player with keyboard input and passed time self.player.update(keys,time_passed) # handle collisions self.floor.collide(self.player) # interact with objects if keys[K_SPACE]: self.floor.interact(self.player) #### debugging / cheating #### if keys[K_n]: self.floor.next() if keys[K_m]: self.floor.tiles.empty() if keys[K_COMMA]: print(self.floor.level) if keys[K_b]: self.player.money += 5 if self.player.health <= 0: self.end() return self.running def draw(self,screen): ''' draw the objects on the screen Game.draw(screen): return None ''' # fill screen with background surface screen.blit(self.images["bg"],(0,0)) # draw objects in right order self.floor.interacts.draw(screen) self.floor.enemies.draw(screen) self.floor.collectables.draw(screen) self.floor.tiles.draw(screen) self.player.draw(screen) # draw status bar screen.fill((100,70,30),(0,500,500,25)) screen.blit(self.images["coin"],(0,500)) coins = self.font.render( "%03d" % self.player.money, False, (255,255,255) ) screen.blit(coins,(30,500)) for i in range(self.player.health): screen.blit( self.images["heart"], (100+i*30,500) ) def load_images(self): ''' load all images Game.load_images(): return None Loads all images and stores them into the self.images dictionary. ''' self.images = {} # load images and scale them for name in ["tile","tile2","tile3","ground","door","enemy"]: self.images[name] = pygame.image.load("images/%s.bmp" % name).convert() self.images[name] = pygame.transform.scale(self.images[name],(50,50)) # load player image and scale it self.images["player"] = pygame.image.load("images/player2.bmp").convert() self.images["player"] = pygame.transform.scale(self.images["player"],(30,30)) # load symbols symbols = pygame.image.load("images/symbols.bmp").convert() self.images["coin"] = pygame.Surface((26,25)) self.images["heart"] = pygame.Surface((26,25)) self.images["coin"].blit(symbols, (0,0), pygame.Rect(0,0,26,25) ) self.images["heart"].blit(symbols, (0,0), pygame.Rect(26,0,26,25) ) # set black as transparent for name in ["player","enemy","heart","coin"]: self.images[name].set_colorkey((0,0,0)) # create background surface self.images["bg"] = pygame.Surface((self.screen_rect.size)) for i in range(10): for j in range(10): self.images["bg"].blit(self.images["ground"],(i*50,j*50)) def end(self): self.running = False
#from creature import CreatureBaes #from player import Player from node import Node, node_search, node_move from floor import FloorBase, Floor, FloorRandom from room import RoomBase #from item import ItemBase, Pickup, Feature, etc. room1 = RoomBase("Room1", "This is room1") room2 = RoomBase("Room2", "This is room2") room3 = RoomBase("Room3", "This is room3") room4 = RoomBase("Room4", "This is room4") room5 = RoomBase("Room5", "This is room5") room6 = RoomBase("Room6", "This is room6") floor1 = Floor("floor1", "I am floor1", 3, 3, (0,0)) rooms = [room1, room2, room3, room4, room5, room6] rc = [(1,1), (1,2), (1,0), (0,1), (2,1), (0,2)] floor1.add_rooms(rooms, rc) print(room1.exits) print(room2.exits) print(room3.exits) print(room4.exits) print(room5.exits) print(room6.exits) room1.find_exits() #nsew room2.find_exits() #sw room3.find_exits() #n
def load_floors(self): del self.floors[:] if self.load_file and os.path.exists(self.load_file): f = open(self.load_file,'r') floors = [] last_breaker_trigger = None last_door_trigger = None tile_list = world_tile_list for line in f: line = line[:-1] s = line.split(':') if s[0] == 'floor': new_floor = Floor(int(s[1]), int(s[2])) floors.append(new_floor) new_floor.world_tiles = [] new_floor.other_tiles = [] elif s[0] == 'world': tile_list = world_tile_list append_list = floors[-1].world_tiles elif s[0] == 'other': tile_list = other_tile_list append_list = floors[-1].other_tiles elif s[0] == 'col': append_list.append([]) elif s[0] == 'tile': new_tile = tile_list[int(s[1])] floor = floors[-1] illum = float(s[2]) x = int(s[3]) y = int(s[4]) o = int(s[5]) append_list[-1].append(new_tile(floor, illum ,x ,y, o)) elif s[0] == 'entity': if s[1] == 'AssistantEntity': floors[-1].assistant.x = int(s[2]) floors[-1].assistant.y = int(s[3]) elif s[1] == 'GhoulEntity': floors[-1].add_entity(GhoulEntity(floors[-1], int(s[2]), int(s[3]))) elif s[1] == 'PlayerEntity': floors[-1].player.x = int(s[2]) floors[-1].player.y = int(s[3]) elif s[1] == 'OrbEntity': floors[-1].add_entity(OrbEntity(floors[-1], int(s[2]), int(s[3]))) elif s[1] == 'DoorTriggerEntity': last_door_trigger = DoorTriggerEntity(floors[-1], int(s[2]), int(s[3]), int(s[4]), int(s[5])) last_door_trigger.hide() floors[-1].add_entity(last_door_trigger) elif s[1] == 'BreakerTriggerEntity': last_breaker_trigger = BreakerTriggerEntity(floors[-1], int(s[2]), int(s[3]), int(s[4]), int(s[5])) last_breaker_trigger.hide() floors[-1].add_entity(last_breaker_trigger) elif s[1] == 'DoorMarkEntity': mark = DoorMarkEntity(floors[-1], int(s[2]), int(s[3]), int(s[4]), int(s[5]), last_door_trigger) floors[-1].add_entity(mark) mark.hide() elif s[1] == 'BreakerMarkEntity': mark = BreakerMarkEntity(floors[-1], int(s[2]), int(s[3]), int(s[4]), int(s[5]), last_breaker_trigger) floors[-1].add_entity(mark) mark.hide() #self.floors = floors for f in floors: self.floors.append(f) else: self.floors.append(Floor(20,20))