Python World.render方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class MainGameState(object):
    def __init__(self):
        self.background = backgrounds.Cave()
        self.world = World()
        self.player = Player(self.world, (-100, 52.4))
        self.camera = Camera((0, 100.0), tracking=self.player)

    def update(self, delta):
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit(0)
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    raise states.StateChange(states.PauseMenuState(self))

        self.world.center = self.player.pos

        self.background.update(delta)
        self.world.update(delta)
        self.player.update(delta)
        self.camera.update(delta)

    def render(self, screen):
        self.background.render(screen, self.camera)
        self.world.render(screen, self.camera)
        self.player.render(screen, self.camera)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Game(object):

    def __init__(self):
        pygame.init()
        self.caption = "Zelda Love Candy"
        self.resolution = (640, 480)
        self.screen = pygame.display.set_mode(self.resolution)
        pygame.display.set_caption(self.caption)
        self.clock = pygame.time.Clock()
        self.isGameOver = False

        self.world = World()

    def update(self):
        """overide this to add neccessary update
        """
        self.world.update()
        self.world.render(self.screen)

    def start(self):
        """ start the game
        """
        while not self.isGameOver:
            self.clock.tick(30)
            for events in pygame.event.get():
                if events.type == pygame.QUIT:
                    self.isGameOver = True

            self.update()
            pygame.display.flip()

        pygame.quit()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Game:


    def __init__(self):

        self.init_window()

        self.world = World()
        self.bot = Bot(SimpleController())
        self.bot.position = self.world.size * 0.5
        self.world.add_bot(self.bot)

        clock.schedule(self.update)

    def init_window(self):
        config = pyglet.gl.Config(sample_buffers=1, samples=4)
        self.window = pyglet.window.Window(config=config, resizable=True) 
        self.window.set_size(1024, 768)

        self.window.on_draw = self.on_draw
        self.window.on_mouse_press = self.on_mouse_press

    def update(self, dt):
        self.world.update(dt)


    def run(self):
        pyglet.app.run()

    def on_draw(self):

        self.window.clear()                                                                 
        self.world.render()

        # pyglet.gl.glColor4f(1.0,0,0,1.0)                                               
        # glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)                             
        # glEnable (GL_BLEND)                                                            
        # glEnable (GL_LINE_SMOOTH);                                                     
        # glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE)                                     
        # glLineWidth (3)                                                                
        # pyglet.graphics.draw(2, pyglet.gl.GL_LINES,                                    
        #     ('v2i', (10, 15, 300, 305))                                                
        # )                                                                              

    def on_mouse_press(self, x, y, button, modifiers):
        self.bot.target.x = (float(x) / self.window.width) * 520.0 - 10.0
        self.bot.target.y = (float(y) / self.window.height) * 520.0 - 10.0
        #self.bot.position = self.bot.target
        print self.bot.target
        pass

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_LENGTH), 0, 32)
    world = World(SCREEN_LENGTH,SCREEN_WIDTH)
    world.set_ball_list(NUMBER_OF_BALLS)
    clock = pygame.time.Clock()
    # Game loop:
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                exit()
        time_passed_seconds = clock.tick()/ 1000.0
        world.update(time_passed_seconds)
        world.render(screen)
        pygame.display.update()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class SurfaceGenState(object):
    def __init__(self):
        self.world = World()
        self.heightmap = heightmap_1d(14)
        self.camera = Camera()
        self.x = 0
        try:
            shutil.rmtree("data/world")
        except OSError:
            pass
        os.makedirs("data/world")

    def update(self, delta):
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit(0)
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    self.world.unload()
                    raise states.StateChange(states.PauseMenuState(self))

        left = self.heightmap[self.x] * 51.2
        right = self.heightmap[(self.x + 20) % 16384] * 51.2
        self.world.center = (self.x / 10.0, left)
        self.world.update(0.0)
        body = self.world.b2world.CreateStaticBody(
            shapes=b2PolygonShape(vertices=(
                (self.x / 10.0, left),
                (self.x / 10.0 + 2.0, right),
                (self.x / 10.0 + 2.0, right + 200.0),
                (self.x / 10.0, right + 200.0)
            )
        ))
        self.world.carve(body)
        self.world.b2world.DestroyBody(body)

        self.camera.pos = self.world.center

        self.x += 5
        if self.x > len(self.heightmap) - 5:
            self.world.unload()
            raise states.StateChange(CaveGenState(self.world))

    def render(self, screen):
        self.world.render(screen, self.camera)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Game(object):
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.world = World()
        self.world.setup(4, 3, 64)
        self.player = Player()
        self.world.addPlayer(self.player)
        area = AreaTest(64, 64)
        area2 = AreaTest2(64, 64)
        area3 = AreaTest3(64, 64)
        self.world.addArea(area)
        self.world.addArea(area2)
        self.world.addArea(area3)
        self.world.loadStartArea(area)
        self.keyPressed = None
        
    def controls(self):
        self.keyPressed = pygame.key.get_pressed()
        for event in pygame.event.get():
            if event.type == QUIT:
                self.quitGame()
            elif event.type == KEYDOWN:
                if event.key == K_SPACE: #Action key
                    d = self.player.facingDirection
                    if not self.player.direction:
                        #return node that the player is facing towards
                        print self.player.mover.getNeighborNode(d)

    def readObjectText(self):
        pass
    
    def pause(self):
        pass
    
    def quitGame(self):
        '''Quit the game'''
        exit()
        
    def gameLoop(self):
        while True:
            dt = self.clock.tick(30) / 1000.0
            self.controls()
            self.world.update(dt, self.keyPressed)
            self.world.render()
            pygame.display.update()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
floor7.setSize(20, 200)

other1 = Entity(334, 210)
other1.setSize(radius=40)
other2 = Entity(23, 20)
other2.setSize(radius=15)

world.addDynamicObject(particle)
#world.addDynamicObject(particle2)
world.addStaticObject(floor)
world.addStaticObject(floor2)
world.addStaticObject(floor3)
world.addStaticObject(floor4)
world.addStaticObject(floor5)
world.addStaticObject(floor6)
world.addStaticObject(floor7)
world.addOtherObject(other1)
world.addOtherObject(other2)

registry = ForceRegistry()
registry.addGravity(particle)
#registry.addGravity(particle2)

while True:
    world.handleEvents()
    dt = clock.tick(30) / 1000.0
    registry.updateForces(dt)
    world.integrateObjects(dt)
    world.render()
    pygame.display.update()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
    def play():
        keys = defaultdict(lambda: False)
        clock = pygame.time.Clock()
        paused = False

        world = World((50, 50), default=Tile.GRASS)
        px, py = world.random_position()
        player = Player((px, py), loadimage("player.png"))
        world.add_entity(player)
        MOVE_SPEED = 3
        for i in range(1):
            world.spawn_clock()
        for i in range(3):
            world.spawn_fastenemy()
        for i in range(5):
            world.spawn_slowenemy()

        ticks = 0
        started = False

        while True:
            for ev in pygame.event.get():
                if ev.type == QUIT:
                    pygame.quit()
                    sys.exit(0)
                elif ev.type == KEYDOWN:
                    keys[ev.key] = True
                    if ev.key == K_SPACE:
                        if not started:
                            started = True
                        else:
                            paused = not paused
                    if ev.key in [K_UP, K_LEFT, K_DOWN, K_RIGHT]:
                        slash.play()
                    if ev.key == K_e and player.bombs > 0:
                        world.bomb((player.x, player.y))
                        player.bombs -= 1
                elif ev.type == KEYUP:
                    keys[ev.key] = False

            if keys[K_ESCAPE]:
                pygame.quit()
                sys.exit(0)

            if started and not paused:
                if keys[K_w]:
                    player.move((player.x           , player.y-MOVE_SPEED))
                if keys[K_s]:
                    player.move((player.x           , player.y+MOVE_SPEED))
                if keys[K_a]:
                    player.move((player.x-MOVE_SPEED, player.y           ))
                if keys[K_d]:
                    player.move((player.x+MOVE_SPEED, player.y           ))

                if keys[K_UP]:
                    player.attack("UP")
                elif keys[K_LEFT]:
                    player.attack("LEFT")
                elif keys[K_DOWN]:
                    player.attack("DOWN")
                elif keys[K_RIGHT]:
                    player.attack("RIGHT")

                world.tick()

            if player.health <= 0 or world.timer <= 0:
                return player.score, ticks

            px, py = player.x, player.y
            xo = SWIDTH/2 - player.x
            yo = SHEIGHT/2 - player.y

            #screen.fill(BLACK)
            screen.blit(bg, (0, 0))

            # Draw world
            world.render(screen, (xo, yo), (TWIDTH, THEIGHT))

            # Draw HUD
            for e in world.entities:
                if isinstance(e, Clock):
                    ex = e.x + xo
                    ey = e.y + yo
                    if (ex < 0 or ex > SWIDTH or
                        ey < 0 or ey > SHEIGHT):
                        ang = math.atan2(ey - SHEIGHT/2, ex - SWIDTH/2)
                        icon = pygame.transform.rotate(arrow, -ang*180/math.pi)
                        w = icon.get_width()/2
                        h = icon.get_height()/2
                        dx = math.cos(ang) * 50 - h
                        dy = math.sin(ang) * 50 - w
                        screen.blit(icon, (SWIDTH/2 + dx, SHEIGHT/2 + dy))

            msg = regfont.render("{} fps".format(int(clock.get_fps())), 1,
                                 WHITE, BLACK)
            blitfont(screen, msg, (0, 0))
            msg = regfont.render("{:.1f} seconds".format(world.timer / 60.0), 1,
                                 WHITE, BLACK)
            blitfont(screen, msg, (SWIDTH-1, 0), align="RIGHT")
            msg = regfont.render("Bombs: {}".format(player.bombs), 1,
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
            side_spd += 1
        if pressed[K_d] or pressed[K_RIGHT]:
            side_spd -= 1

        sideways = np.cross((0, 0, 1), forwards)
        sideways /= length(sideways)
        hor_velocity = np.cross(sideways, (0, 0, 1)) * forward_spd + sideways * side_spd
        hor_velocity *= movement_speed

        velocity[:2] = hor_velocity[:2]

        if pressed[K_SPACE] and (onGround or pressed[K_LSHIFT]):
            velocity[2] = movement_speed

        # Update the OpenGL window
        glViewport(0, 0, SCREEN_SIZE[0], SCREEN_SIZE[1])
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(60.0, float(SCREEN_SIZE[0]) / SCREEN_SIZE[1], .5, 1000.)
        gluLookAt(*append(position, position + forwards, (0, 0, 1)))
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

        util.frustum = Frustum().fromViewingMatrix()

        # Render the map
        game_world.render(position)

        # Show the screen
        pygame.display.flip()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Simulation():
	"""
	Controls the simulation
		- Runs the main loop
		- Detects mouse, keyboard and other events
		- Loads the necessary images
		- Controls the framerate of the simulation
	"""
	def __init__(self):
		self.clock = time.Clock()
		self.framerate = 60
		self.images = {}

		self.quit = False
		self.pause = False

		self.add_image("ant", "ant.png")
		self.add_image("grass", "grass.png")
		self.add_image("food", "food.png")
		self.add_image("home", "home.png")
		self.add_image("obstacle", "obstacle.png")
		self.add_image("home_scent", "home_scent.png")
		self.add_image("food_scent", "food_scent.png")
		self.add_image("cell", "cell.png")

		self.settings = {
		"no_of_ants": 150,
		"evaporation_rate": .03,
		"home_size": 10,
		"cell_size": 10
		}

		self.world = World(130, 70, self.images, self.settings)

	def add_image(self, name, path):
		"""
		Loads an image
		"""
		self.images[name] = image.load('images/' + path)		

	def run(self):
		"""
		Runs the main loop till the user quits
		"""
		while self.quit is False and self.pause is False:
			self.main_loop()

	def main_loop(self):
		"""
		Updates the simulation
			- Draws the world and update it
			- Handles all user events
			- Controls frame rate
		"""
		self.world.render()
		self.world.advance()

		self.handle_events()

		self.clock.tick(self.framerate)

	def handle_events(self):
		"""
		Handles all keyboard, mouse and events like QUIT, etc
		"""
		self.handle_keyboard_events()
		self.handle_mouse_events()
		self.handle_general_events() 

	def handle_keyboard_events(self):
		"""
		set quit as true if user presses ESCAPE key
		"""
		keys = key.get_pressed()
		if keys[K_q] or keys[K_ESCAPE]:
			self.quit = True

	def handle_general_events(self):
		"""
		set quit true if user clicks the close button
		"""
		for evt in event.get():
			if evt.type == QUIT:
				self.quit = True

	def handle_mouse_events(self):
		"""
		- Creates obstacles on left clicks
		- Removes obstacles on right clicks
		"""
		pressed = mouse.get_pressed()
		x, y = mouse.get_pos()
		size = self.settings["cell_size"]
		cell = self.world[(x/size, y/size)]
		if pressed[0]:
			cell.make_obstacle()
		elif pressed[2]:
			if cell.is_obstacle():
				cell.remove_obstacle()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
def game():
    screen.fill(black)
    running = True
    keyboard = Keyboard()
    world = World(32, 32)
    off = ((WIDTH - world.get_render_width()) / 2,
           (HEIGHT - world.get_render_height()) / 2)
    world.offX = off[0]
    world.offY = off[1]
    ply = Player(0, 0, world)
    ply.x = random.randint(0, WIDTH - ply.w)
    ply.y = random.randint(0, HEIGHT - ply.h)
    while world.entity_hitpos(ply):
        ply.x = random.randint(0, WIDTH - ply.w)
        ply.y = random.randint(0, HEIGHT - ply.h)
    physics = Physics(world, (WIDTH, HEIGHT))
    physics.watch(ply)
    clock = pygame.time.Clock()
    last = pygame.time.get_ticks()
    ticks = 0
    plydeathtimer = 0
    lastrect = pygame.Rect(0, 0, 0, 0)

    while running:
        ticks += 1
        clock.tick(0)
        for ev in pygame.event.get():
            if ev.type == QUIT:
                running = False
                break
            elif ev.type == FRAMECOUNTER:
                print clock.get_fps()
            elif ev.type == WORLDREGEN:
                world.regen_once()
            elif ev.type == ENTITYGEN:
                x = random.randint(0, WIDTH)
                y = random.randint(0, HEIGHT)
                physics.watch(Enemy(x, y, world, physics))
            elif ev.type == MOUSEBUTTONDOWN:
                if ev.button == 0 and plydeathtimer == 0:
                    mpos = ev.pos
                    center = ply.get_center()
                    a = mpos[0] - center[0]
                    b = mpos[1] - center[1]
                    # tan(ang) = b / a
                    ang = math.atan2(b, a)

                    # Calculate bullet pos
                    pos = [math.cos(ang) * ply.w + center[0],
                           math.sin(ang) * ply.h + center[1]]

                    bull = Bullet(pos[0], pos[1], world)
                    speed = 2
                    bull.vx = speed * math.cos(ang)
                    bull.vy = speed * math.sin(ang)
                    physics.watch(bull)
                    shootsound.play()

            elif ev.type == KEYDOWN:
                keyboard.keydown(ev.key)
            elif ev.type == KEYUP:
                keyboard.keyup(ev.key)

        # Handle movement
        if plydeathtimer == 0:
            if keyboard.is_down(K_w):
                ply.vy = -1
            elif keyboard.is_down(K_s):
                ply.vy = 1
            else:
                ply.vy = 0
            if keyboard.is_down(K_a):
                ply.vx = -1
            elif keyboard.is_down(K_d):
                ply.vx = 1
            else:
                ply.vx = 0

        # Shooting repeat
        if ticks % 10 == 0 and pygame.mouse.get_pressed()[0]:
            mpos = pygame.mouse.get_pos()
            center = ply.get_center()
            a = mpos[0] - center[0]
            b = mpos[1] - center[1]
            # tan(ang) = b / a
            ang = math.atan2(b, a)

            # Calculate bullet pos
            pos = [math.cos(ang) * ply.w + center[0],
                   math.sin(ang) * ply.h + center[1]]

            bull = Bullet(pos[0], pos[1], world)
            speed = 2
            bull.vx = speed * math.cos(ang)
            bull.vy = speed * math.sin(ang)
            physics.watch(bull)
            shootsound.play()


        for ent in physics.entities:
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Domination:
    """ Initializes the game. Keeps track of events. """
    def __init__(self, options):
        self.options = options
        
        if options['record']:
            replay.start(options['record'], options['level'])
        elif options['replay']:
            options['level'], rand_state = replay.open(options['replay'])
            utils.RANDOM.setstate(rand_state)
        self.output_file = options['output']
        self.viewport = Viewport()
        self.world = World(options['red'], options['blue'], options['level'])
        self.viewport.set_world(self.world)
        self.running = True
        self.world_lock = threading.Lock()
 
    def game_loop(self):
        step = 0
        while(self.running):
            #if the world lock is set, only update the GUI, don't move agents.
            if self.world_lock.acquire(False):
                self.on_simulation_step()
                if step % SIMULATION_RESOLUTION == 0:
                    threading.Thread(target=self.on_action).start()
                    #on_action will release the lock after all agents have
                    #declared their action or the time ran out.
                else:
                    self.world_lock.release()
                step += 1
                replay.step()
            
            for event in pygame.event.get():
                self.on_event(event)
                
            self.on_render()
                
            if step > MAX_TIMESTEPS:
                self.running = False
            
        self.on_cleanup()
        
    def on_event(self, event):
        if event.type == KEYS_EVENT:
            self.on_keys()
        if event.type == VIDEORESIZE:
            self.viewport.resize(event.size)
        if event.type == QUIT:
            self.running = False
    
    def on_action(self):
        self.world.action_step()
        self.world_lock.release()

    def on_keys(self):
        move_speed = 10
        keys = pygame.key.get_pressed()
        if keys[K_UP]:
            self.viewport.move_offset((0,-move_speed))
        if keys[K_RIGHT]:
            self.viewport.move_offset((move_speed,0))
        if keys[K_DOWN]:
            self.viewport.move_offset((0,move_speed))
        if keys[K_LEFT]:
            self.viewport.move_offset((-move_speed,0))
        
        if ((keys[K_RALT] or keys[K_LALT]) and keys[K_F4]) or keys[K_ESCAPE]:
            self.running = False
 
    def on_simulation_step(self):
        self.world.simulation_step()
    
    def on_render(self):
        if not self.options['invisible']:
            self.world.render(self.viewport)
            pygame.display.update()
        
    def on_cleanup(self):
        replay.end()
        self.world.cleanup()
        with open(self.output_file, "w") as f:
            for team in self.world.teams:
                f.write(str(team) + "\n")
        
        pygame.quit()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
def runLevel(screen, level_number, cat_number):
    soundChannel = pygame.mixer.Channel(0)
    finishSound = pygame.mixer.Sound('../sounds/finish.ogg')  
    
    builder = LevelBuilder()
    level = builder.buildLevelFromFile('../levels/level%s.txt' % level_number)
    world = World(SCREEN_SIZE, level)
    
    car = Car(Vector2(100,100))
    player = Player(Vector2(100, 180))
    
    world.add_entity(player)
    world.add_entity(car)
    world.setFocus(player)
    
    worldobserver = WorldObserver(world)
    clock = pygame.time.Clock()
    
    for i in range(cat_number):
        cat = Cat(Vector2(randint(0, world.dimension[0]), 
                          randint(0, world.dimension[1])), 
                  world)
        world.add_entity(cat)
    
    countdown_to_next_level = LEVEL_INTERMEDIATE_TIME
    while True:
        
        for event in pygame.event.get():
            if event.type == QUIT:
                exit()
            if event.type == KEYDOWN:
                if event.key == K_LEFT:
                    player.move(LEFT)
                elif event.key == K_RIGHT:
                    player.move(RIGHT)
                elif event.key == K_UP:
                    player.move(UP)
                elif event.key == K_DOWN:
                    player.move(DOWN)
                elif event.key == K_SPACE:
                    food = player.dropFood()
                    if food is not None:
                        world.add_entity(food)
                elif event.key == K_c:
                    player.switchVehicle(car)
                    world.setFocus(player.vehicle or player)
                elif event.key == K_m:
                    world.toggleMinimap()
                        
        time_passed = clock.tick(30)
        
        world.process(time_passed)
        world.render(screen)
        worldobserver.writeMessages(screen)
        
        if worldobserver.levelFinished:
            if countdown_to_next_level == LEVEL_INTERMEDIATE_TIME:
                soundChannel.play(finishSound)
            countdown_to_next_level -= 2
            if countdown_to_next_level <= 0:
                return
            
            for r in range(countdown_to_next_level+1, LEVEL_INTERMEDIATE_TIME, 8):
                pygame.draw.circle(screen, (0, 0, 0), (SCREEN_SIZE[0]/2, SCREEN_SIZE[1]/2), r, 1)
        
        pygame.display.update()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]
class Game(object):
	''' The main game object ''' 
	def __init__(self, width=900, height=700, antialiased=True):
		
		self.width = width
		self.height = height
		self.antialiased = antialiased
		self.backgroundColor = rgba('1d1f21') # Dull grey


		# Create the pyglet window and context
		self.createWindow()

		# Make and clear the world
		self.resetWorld()

		# Make sure everything's in place and sized correctly
		self.on_resize(self.width, self.height)

		# Start the game loop!
		self.gameLoop()

		
	# Creates a pyglet window and set glOptions
	def createWindow(self):
		
		self.win = None
		if(self.antialiased):
			config = pyglet.gl.Config(sample_buffers=1, samples=4, double_buffer=True)
			self.win = window.Window(width=self.width, height=self.height, vsync=True, resizable=True, config=config)
		else:
			self.win = window.Window(width=self.width, height=self.height, vsync=True, resizable=True)
		
		glEnable(GL_BLEND)
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

		# needed so that egi knows where to draw
		egi.InitWithPyglet(self.win)

		# prep the fps display
		self.fps_display = clock.ClockDisplay()
		self.fps_display.label.color = rgba('fff', 0.05)

		# register key and mouse event handlers
		self.win.push_handlers(self.on_key_press)
		self.win.push_handlers(self.on_mouse_press)
		self.win.push_handlers(self.on_resize)


	# Creates a new world and sets up its initial state
	def resetWorld(self):

		# create a world for fishes!
		self.world = World(self.width, self.height)

		# Build our info state and assign it to the world
		self.makeInfo()
		
		# add initial fishies
		self.world.addFish(10)


	# Just fills the screen with a solid color
	def renderBackground(self):
		
		egi.set_pen_color(self.backgroundColor)
		egi.rect(0, self.height, self.width, 0, filled=True)
		

	def gameLoop(self):
		# Main game loop
		while not self.win.has_exit:

			# House keeping, fire events
			self.win.dispatch_events()
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

			# Render the background
			# Now separate from the world's rendering so that debug rendering
			# done in update() will still appear above the bg
			self.renderBackground()

			# Update and render the world
			delta = clock.tick()
			self.world.update(delta)
			
			self.world.render()

			# show nice FPS top left
			self.fps_display.draw()

			# Draw our instructions if enabled
			self.drawInfo()
			
			# swap the double buffer
			self.win.flip()


	# Window resize event
	def on_resize(self, width, height):
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import render [as 别名]

#.........这里部分代码省略.........
        # Fighter 1
        if e.key == pygame.K_a:
            self.fighter1.stop_left()
        elif e.key == pygame.K_d:
            self.fighter1.stop_right()


    def opponent(self, caller):
        opp = self.fighter2
        if opp == caller:
            opp = self.fighter1
        return opp

    def hit_opponent(self, caller, damage, hit_boxes=None, kind='physical'):
        opp = self.opponent(caller)
        opp_hb = opp.hit_boxes()
        direction = 1
        if caller.looking_right:
            direction = -1
        if hit_boxes == None:
            hit_boxes = caller.hit_boxes()
        if any([x.collidelist(opp_hb) != -1 for x in hit_boxes]):
            opp.take_damage(damage, direction, kind=kind)
            return True
        return False

    def game_over(self):
        if self.fighter1.wins > self.fighter2.wins:
            gameover_image = pygame.image.load("gfx/player1won.png")
        else:
            gameover_image = pygame.image.load("gfx/player2won.png")

        self.surface.blit(gameover_image, (330, 140))
        self.roundcounter.render(self.surface)
        pygame.display.flip()
        while True:
            for e in pygame.event.get():
                if e.type == pygame.KEYDOWN:
                    if e.key == pygame.K_RETURN:
                        self.roundcounter.round = -1
                        self.fighter1.wins = 0
                        self.fighter2.wins = 0
                        self.fighter1.reset()
                        self.fighter2.reset()
                        self.menu.activate()
                        return

    def next_round(self):
        if self.roundcounter.round < len(self.roundcounter.rounds) - 1:
            if self.fighter1.wins == 2 or self.fighter2.wins == 2:
                self.game_over()
                return
            self.fighter1.reset()
            self.fighter2.reset()
            self.ai.reset()
            for inj in self.injectionsbar1.injections[1:]:
                inj.disabled = False
                inj.activate = False
            for inj in self.injectionsbar2.injections[1:]:
                inj.disabled = False
                inj.activate = False
            self.pointsbar1.health = self.fighter1.health
            self.pointsbar2.health = self.fighter2.health
            self.viewport.offset = 0
            self.roundcounter.next_round()
        else: