Python Window.push_handlers方法代码示例

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Egg(object):
    def __init__(self, width, height):
        # display initializations
        self.__window = Window(width, height, vsync=True)
        self.__background_color = (0, 0, 0, 1.0)
        # self._fps_display = pyglet.clock.ClockDisplay()
        self.__key_state_handler = key.KeyStateHandler()
        self.__scene = None
        self.__window.event(self.on_draw)
        self.__window.push_handlers(self.__key_state_handler)
        self.__camera = None
        #schedule regular updates
        pyglet.clock.schedule_interval(self.update, 1 / 100.0)

    @property
    def window(self):
        return self.__window

    @property
    def background_color(self):
        return self.__background_color

    @background_color.setter
    def background_color(self, value):
        self.__background_color = value

    def register_scene(self, scene):
        self.__scene = scene
        self.__camera = Camera("main_camera", (0, 0), self.__window.height / 2.)
        self.__scene.root.add_child(self.__camera)
        self.__camera.target.x = self.__window.width / 2.
        self.__camera.target.y = self.__window.height / 2.
        self.__window.event(self.__scene.on_mouse_press)
        self.__window.event(self.__scene.on_mouse_release)
        self.__window.event(self.__scene.on_mouse_drag)
        self.__window.event(self.__scene.on_mouse_motion)


    def on_draw(self):
        self.__window.clear()
        glClearColor(*self.__background_color)
        if self.__scene is not None:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)

            # draw batches
            self.__camera.focus(self.__window.width, self.__window.height)
            self.__scene.draw()
            # draw specific batches for the hud
            self.__camera.hud_mode(self.__window.width, self.__window.height)
            self.__scene.draw_head_display()

    def update(self, dt):
        if self.__scene is not None:
            self.__scene.update(dt)
            self.__scene.process_keyboard(self.__key_state_handler, dt)
            self.__camera.update(dt)

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Application(object):

    def __init__(self):
        self.win = None
        self.music = None
        self.vsync = (
            not settings.has_option('all', 'vsync') or
            settings.getboolean('all', 'vsync')
        )


    def launch(self):
        self.win = Window(
            width=1024, height=768,
            vsync=self.vsync,
            visible=False)
        self.win.set_mouse_visible(False)
        GameItem.win = self.win

        load_sounds()

        self.music = Music()
        self.music.load()
        self.music.play()

        keystate = key.KeyStateHandler()
        self.win.push_handlers(keystate)

        game = Game(keystate, self.win.width, self.win.height)

        handlers = {
            key.M: self.toggle_music,
            key.F4: self.toggle_vsync,
            key.ESCAPE: self.exit,
        }
        game.add(KeyHandler(handlers))

        render = Render(game)
        render.init(self.win)
        game.startup(self.win)
        self.win.set_visible()
        pyglet.app.run()


    def toggle_vsync(self):
        self.vsync = not self.vsync
        self.win.set_vsync(self.vsync)

    def toggle_music(self):
        self.music.toggle()

    def exit(self):
        self.win.has_exit = True

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class App(object):

    def __init__(self, pmap):
        self.world = World(pmap)
        self.win = Window(width=pmap['bounds'][2], height=pmap['bounds'][3])
#        pyglet.clock.set_fps_limit(10)
#        pyglet.clock.set_fps_limit(60)
        self.win.push_handlers(self.on_key_press)
        self.fullscreen = False

    def main_loop(self):
        self.world.annealing.kickoff()
        while not (self.win.has_exit or self.world.finished):
            self.win.dispatch_events()
            if (not self.world.finished) and (not self.world.pause):
                self.world.update()
                if (self.world.showvisuals):
                    self.world.draw()
            pyglet.clock.tick()
            self.win.flip()
        self.win.close()

    def on_key_press(self, symbol, modifiers):        
        # IDEA more key toggles, make it a dictionary
        if symbol == key.D:
            self.world.showdebug = not self.world.showdebug
        elif symbol == key.F:
            self.fullscreen = not self.fullscreen
            self.win.set_fullscreen(fullscreen=self.fullscreen)
            self.world.draw()
        elif symbol == key.G:
            self.world.showgrid = not self.world.showgrid
        elif symbol == key.S:
            self.world.pause = not self.world.pause
        elif symbol == key.U:
            self.world.showUI = not self.world.showUI
        elif symbol == key.V:
            self.world.showvisuals = not self.world.showvisuals

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Gameloop(object):

    def __init__(self, options):
        self.options = options
        self.window = None
        self.fpss = []
        self.time = 0.0
        self.level = None


    def prepare(self, options):
        self.window = Window(
            fullscreen=options.fullscreen,
            vsync=options.vsync,
            visible=False,
            resizable=True)
        self.window.on_draw = self.draw_window

        self.world = World()
        self.player = Player(self.world)
        self.camera = GameItem(
            position=origin,
            update=CameraMan(self.player, (3, 2, 0)),
        )
        self.level_loader = Level(self)
        success = self.start_level(1)
        if not success:
            logging.error("ERROR, can't load level 1")
            sys.exit(1)

        self.update(1/60)

        self.window.push_handlers(KeyHandler(self.player))

        self.render = Render(self.world, self.window, self.camera)
        self.render.init()

        self.music = Music()
        self.music.load()
        self.music.play()


    def run(self):
        pyglet.clock.schedule(self.update)
        self.window.set_visible()
        self.window.invalid = False
        pyglet.app.run()


    def update(self, dt):
        if self.options.print_fps:
            self.fpss.append(1/max(1e-6, dt))
        dt = min(dt, 1 / 30)
        self.time += dt

        for item in self.world:
            if hasattr(item, 'update'):
                item.update(item, dt, self.time)

        if self.player_at_exit():
            self.world.remove(self.player)
            pyglet.clock.schedule_once(
                lambda *_: self.start_level(self.level + 1),
                1.0
            )

        self.window.invalid = True


    def start_level(self, n):
        success = self.level_loader.load(self.world, n)
        if not success:
            logging.info('No level %d' % (n,))
            self.stop()
            return False
               
        self.level = n
        pyglet.clock.schedule_once(
            lambda *_: self.world.add(self.player),
            2.0,
        )
        return True


    def player_at_exit(self):
        items = self.world.collision.get_items(self.player.position)
        if any(hasattr(item, 'exit') for item in items):
            dist2_to_exit = dist2_from_int_ords(self.player.position)
            if dist2_to_exit < EPSILON2:
                return True
        return False


    def draw_window(self):
        self.window.clear()
        self.render.draw_world()
        if self.options.display_fps:
            self.render.draw_hud()
        self.window.invalid = False
        return EVENT_HANDLED
#.........这里部分代码省略.........

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Client:
    """
    While we aren't networking this game it's better to learn this structure now
    rather than later. Even if you never plan on learning how to network your
    games this is still a very good architecture to use.

    This Client class should be considered completely separate from the Game. It
    is just a way of interacting with the game. The game should not depend on
    anything in this class. Working like this will help you keep your code much
    cleaner and, as stated before, networkable. You could also make multiple
    clients using different technologies. In our case we are using pyglet and
    rabbyt libraries, but it wouldn't be difficult to make a client using pygame
    or even just the consol (for a text mode).
    """
    def __init__(self, game):
        # While the game needs to work independently of the client the client
        # can't work independently of the game. The client will be sending
        # input to the game as well as looking up different elements (such as
        # all the blocks so we can draw them and tell the game when we click on
        # one).
        self.game = game

        # Setup our pyglet window.
        self.window = Window(width=self.game.size_xy[0]*20,
                height=self.game.size_xy[1]*20+50)
        self.window.set_caption("Mines")
        self.window.on_close = sys.exit
        # The default pyglet OpenGL display is setup a bit different than how
        # rabbyt would like, thus rabbyt.set_default_attribs
        rabbyt.set_default_attribs()

        # Using pyglet for input is really easy. When you get further down
        # you'll see GameContorl inherits from EventDispatcher. That's how
        # window.push_handlers does the magic as we'll see further down.
        self.ctrl = GameContorl(self)
        self.window.push_handlers(self.ctrl)


        # Here we have some sprites we are going to use for the client. For
        # bigger games I think it's better to separate stuff like this out;
        # but this is quite small and not an issue.
        self.smile_face = rabbyt.Sprite("data/smile.png")
        self.smile_face.x = self.window.width/2
        self.smile_face.y = self.window.height-25

        self.dead_face = rabbyt.Sprite("data/smile_dead.png")
        self.dead_face.xy = self.smile_face.xy

        self.won_face = rabbyt.Sprite("data/smile_won.png")
        self.won_face.xy = self.smile_face.xy
        # That sprite stuff was pretty self explanatory. It is also very basic.
        # I'm not going to be going into much depth with rabbyt in these
        # tutorials so you may want to check out the rabbyt documentation from
        # http://matthewmarshall.org/projects/rabbyt/
        # Very cool and elegant stuff there. Check it out!

        self.clock = Clock()
        self.clock.set_fps_limit(20)
        self.window.push_handlers(self.clock)
        self.time = 0
        self.clock.schedule(self._add_time)

        self.setup()


    def setup(self):
        """
        Just like the setup in the Game class this one fills out the block data.
        But wait, why do we have to do this again? Remeber how in the GameBlock
        we only had stuff related to the game engine; no display stuff? Well,
        we need display stuff for the client - that's why we have ClientBlock!
        As you'll see soon the ClientBlock sorta wraps the GameBlock to provide
        the graphical stuff we need.
        """
        self.blocks = {}
        for key,b in self.game.blocks.items():
            self.blocks[key] = ClientBlock(self, b)


    def _add_time(self, dt):
        """
        This is kept track of so we can pass it onto rabbyt (so animation works)
        """
        self.time += dt


    def loop(self):
        """
        And here is our main game loop! In case you are new to game programming
        this is what is called every frame. This is where we will handle the
        display and stuff.
        """
        # clock.tick is used for keeping track of time and limiting the frame
        # rate.
        self.clock.tick()
        self.window.dispatch_events()
        # And this is where that mysterious "time" comes in. This way rabbyt
        # knows how much time has passed and can do the awesome animations.
        rabbyt.set_time(self.time)

#.........这里部分代码省略.........

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
            # print "after",list[:10]
            # print len(clist)
            vertexlist.vertices = clist
            vertexlist.draw(pyglet.gl.GL_LINE_STRIP)


def plot_field():
    granularity = 10
    width = window.width / granularity
    height = window.height / granularity
    print EfieldC((1.0, 1.0))
    data = bytearray(EfieldC)
    fieldtexture = pyglet.image.ImageData(width, height, "RGB", data)


buttonevents = ButtonEventHandler()

window.push_handlers(buttonevents)
window.push_handlers(buttonevents.keys)

pyglet.clock.schedule_interval(buttonevents.compute, 1.0 / 20.0)

held_objects = set()
selected_objects = set()
hovered = None
Buttons = [Button(mouseX, mouseY, 20, charge=10), Button(mouseX, mouseY + 100, 20, charge=10)]
Links = set()  # set([Link(Buttons[0] , Buttons[1], 10.0, 100.0)])
# window.push_handlers(pyglet.window.event.WindowEventLogger())

pyglet.app.run()

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
        window.clear()
        with nested(Projection(0, 0, window.width, window.height, far=1000.0), Matrix, Lighting):
            glTranslatef(0, 0, -500)
            glRotatef(tilt*0.3, 1.0, 0, 0)
            glRotatef(rotate*0.3, 0.0, 1.0, 0)

            for body in bodies:
                with Matrix:
                    glMultMatrixf(body.matrix)
                    cube(size=body.size, color=(0.5, 0.5, 0.5, 1.0))

        fps.draw()
        description.draw()

    keys = pyglet.window.key.KeyStateHandler()
    window.push_handlers(keys)

    constant = 300.0
    def simulate(delta):
        for i, body1 in enumerate(bodies):
            for body2 in bodies[i+1:]:
                vec = body1.position - body2.position
                gravity = (body1.mass*body2.mass/vec.magnitude) * constant * delta
                normal = vec.normalized
                body1.add_force(linear=normal.inversed*gravity, relative=False)
                body2.add_force(linear=normal*gravity, relative=False)

        world.step(delta, iterations=10)
    schedule_interval(simulate, 0.005)
    
    run()

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Client( object ):
    def __init__(self, app):
		self.app = app
		self.window = Window(	width=self.app.size[0],
		        				height=self.app.size[1], 
		        				style='dialog',
		        				resizable=False )

		self.window.set_caption("ASTAR MAZE")
		self.window.on_close = sys.exit
		self.ctrl = InputHandler(self)
		self.window.push_handlers(self.ctrl)

		self.clock = Clock()
		self.clock.set_fps_limit(30)
		self.window.push_handlers(self.clock)

		self.grid = ClientGrid( self.app.grid )

		# S q u a r e s
		self.entities = {}
		self.setup()


    def setup(self):
		glClearColor( .113, .121, .1289, 1 )
		glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA )
		glDisable( GL_LIGHTING )
		glCullFace( GL_BACK )
		glDisable( GL_DEPTH_TEST )

		self.runner = None
		self.goal = None
		self.isSearching = False
		self.found = False
		self.solution = []
		self.prev = None

		self.entitiesBatch = pyglet.graphics.Batch()
		group = ClientGroup()
		for k,v in self.app.squares.iteritems():
			verts = self.entitiesBatch.add( 4, GL_QUADS, group, 'v2i/static', 'c4B/dynamic' )
			verts.vertices 		= v.vertices['positions']
			verts.colors 		= v.vertices['colors']
			self.entities[k] 	= ClientSquare( v, verts )


    def draw(self):
		self.grid.draw()
		self.entitiesBatch.draw()
		if self.found: 
			curr = None
			if self.prev:
				self.setVisited( self.entities[self.prev] )
			if len(self.solution):
				curr = self.solution.pop()
				self.entities[curr].update( SquareType.RUNNER )
				self.prev = curr


    def update(self):
        self.clock.tick()
        self.window.dispatch_events()
        self.window.clear()
        self.draw()
        self.window.flip()


    def reset(self):
    	self.app.setup()
    	self.setup()


    def astar(self):
		startState = ASState( self.runner.pos, self.goal.pos, self )
		nodesGenerated = 1
		frontier = Heap()
		expanded = set()
		frontier.push( 0, ASNode( startState ) )

		while len(frontier):
			n = frontier.pop()

			if n.state.isGoal():
				self.solution = n.execute()
				print "%d node(s) generated.\n" % nodesGenerated
				return True

			successors = n.state.expand()
			for succ in successors:
				if succ['successor'] not in expanded:
					nodesGenerated = nodesGenerated + 1
					nprime = ASNode( succ['successor'], succ['action'], n )
					frontier.push( nprime.hCost, nprime )
					expanded.add( succ['successor'] )
		return False


    def search(self):
    	if not self.runner or not self.goal:
#.........这里部分代码省略.........

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
@select('#shone')
def on_mouse_press(element, x, y, button, modifiers):
    e = layout.document.get_element('wishing')
    if e.style['display'] == 'none':
        del e.style['display'] 
    else:
        e.style['display'] = 'none'
layout.push_handlers(on_mouse_press)

@select('#para2')
def on_mouse_press(element, x, y, button, modifiers):
    element.add_text('One fish two fish red fish blue fish.')
layout.push_handlers(on_mouse_press)

window.push_handlers(layout)


def print_style(style, indent=''):
    import textwrap
    print '\n'.join(textwrap.wrap(repr(style), initial_indent=indent,
            subsequent_indent=indent))
    if style.parent:
        print_style(style.parent, '  ' + indent)

def print_element(element, indent=''):
    import textwrap
    print '\n'.join(textwrap.wrap(repr(element), initial_indent=indent,
            subsequent_indent=indent))
    if element.style_context:
        print_style(element.style_context, indent + '  ')

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]

@window.event
def on_text(text):
    sprite.text += text.replace('\r', '\n')


@window.event
def on_key_press(symbol, modifiers):
    if symbol == key.BACKSPACE:
        sprite.text = sprite.text[:-1]


sprite = TextSprite(arial, text, color=(0, 0, 0, 1))

fps = clock.ClockDisplay()
window.push_handlers(fps)

glClearColor(1, 1, 1, 1)

window.set_visible()
while not window.has_exit:
    window.dispatch_events()
    clock.tick()

    glClear(GL_COLOR_BUFFER_BIT)
    sprite.y = sprite.height  # TODO align on bottom
    sprite.draw()
    fps.draw()
    window.flip()

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
                self.source = []
                self.write('>>> ')

        sys.stdout = _stdout

    def backspace(self):
        self.buffer = self.buffer[:-1]
        # There is no easy way to change element text yet...
        self.element.text = self.element.text[:-1]
        self.element.document.element_modified(self.element)

window = Window(visible=False, vsync=False)

layout = Layout()
layout.set_xhtml(data)
window.push_handlers(layout)

interp = DOMInterpreter(layout.document.get_element('interpreter'))

def on_text(text):
    interp.input(text.replace('\r', '\n'))
window.push_handlers(on_text)

def on_key_press(symbol, modifiers):
    if symbol == key.BACKSPACE:
        interp.backspace()
    else:
        return True
window.push_handlers(on_key_press)

def blink_cursor(dt):

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class World(object):

    def __init__(self):

        self.map_objects = []
        self.player_objects = []
        self.players = {}
        self.mini_objects = []
        self.window = Window(width=1300, height=768)
        self.stop_update = False



    def addPlayer(self, player, main=False):
        """
        add a player to the player list
        """
        if main:
            self.p1 = player
            self.p1.keys = key.KeyStateHandler()
            self.window.push_handlers(self.p1.keys)

        player.world = self

        self.players[player.name] = player
        self.mini_objects.append(player.mini)
        player.send(0, 'new')

    def addPlayerFromMini(self, mini):
        """
        what the title says
        """
        p = Player(mini.name, 'tanktop', 'tankbot')
        self.addPlayer(p)


    def gameUpdate(self, dt):
        """
        To be called every Tick
        """
        self.recvServer()
        rabbyt.add_time(dt)
        default_system.update(dt)
        

        for name, po in self.players.items():
            delete_keys=[]
            for k, k_pressed in po.keys.iteritems():
                if k_pressed and k in po.input:
                    action = po.input[k][0]
                    arg = po.input[k][1]
                    po.action(action, arg, dt)
            
    def displayScore(self):
        """
        Render the score for the players
        """
        x_start = 1200
        y_start = 750
        labels = []
        for p in self.mini_objects:
            y_start -= 25
            score = '%s : %s' % (p.name, p.score)
            label = text.Label(score,
                font_name='Times New Roman',
                font_size=12,
                x=x_start, y=y_start,
                )
            labels.append(label)
        for l in labels:
            l.draw()



    def selectLevel(self, name):
        """
        Maybe add more levels?
        """
        self.bgimage = resource.image('images/'+name+'.jpg')
        map = self.buildMap(name)
        for building in map:
            b = rabbyt.Sprite(None, building[0])
            b.xy = building[1]
            self.map_objects.append(b)



    def buildMap(self, name):
        """
        Need to DOC this
        """
         
        city1 = [
            ((-75, 24, 75, -24),(490, 373)), ((-24, 24, 24, -24),(590, 373)), ((-24, 24, 24, -24),(590, 325)),
            ((-24, 24, 24, -24),(838, 373)), ((-24, 24, 24, -24),(738, 275)), ((-24, 24, 24, -24),(488, 525)),
            ((-24, 24, 24, -24),(938, 525)), ((-24, 24, 24, -24),(988, 525)), ((-49, 49, 49, -49),(563, 549)),
            ((-49, 49, 49, -49),(763, 549)), ((-49, 49, 49, -49),(863, 549)), ((-49, 49, 49, -49),(763, 349))
        ]
        
        levels = {'city1':city1}
#.........这里部分代码省略.........

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
import pyglet
import serial
import struct
from jaraco.input import Joystick
from pyglet.window import key, Window


arial = pyglet.font.load('Arial', 14, bold=True, italic=False)

window = Window()
keyboard = key.KeyStateHandler()
window.push_handlers(keyboard)
fps_display = pyglet.clock.ClockDisplay()
string_display = pyglet.text.Label('NULL', y=128)

joysticks = Joystick.enumerate_devices()
xbox = joysticks[0]
print xbox

xbox_axes = {}

@xbox.event
def on_axis(axis, value):
    xbox_axes[axis] = value
    print(axis, value)

xbee = serial.Serial('COM6', baudrate=9600,
    bytesize=serial.EIGHTBITS,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE)

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Game(object):

    INITIAL_UPDATE_INTERVAL = UPDATE_INTERVAL

    def __init__(self):
        impl.funcs.load_resources()
        self.gameInfo = GameInfo()
        self.win = Window(FIELD_WIDTH, FIELD_HEIGHT)
        self.win.set_caption("snake")
        impl.funcs.setup_background_color()
        impl.funcs.setup_opengl_blend_func()
        self.gameField = GameField(self.gameInfo, self.win)
        self.menu = Menu(FIELD_WIDTH//2, FIELD_HEIGHT//2, self.game_start_callback, self.game_exit_callback, self.win)
        self._overlay = None
        self._update_interval = Game.INITIAL_UPDATE_INTERVAL

        @self.gameField.event
        def on_restart_snake():
             unschedule(func=self.update)
             self._setup_overlay("restart")
             schedule_once(func=self.run_snake, delay=DELAY_FOR_NEW_RUN)

        @self.gameField.event
        def on_rerun_menu():
            unschedule(func=self.update)

            #reset current handler
            self.win.pop_handlers()
            #and setup update handler
            self.win.push_handlers(self.menu)
            self.menu.start_bgrn_animation()

        @self.gameField.event
        def on_game_over():
            unschedule(func=self.update)
            self._setup_overlay('game over...')
            schedule_once(func=self.game_exit_callback, delay=DELAY_FOR_EXIT)

        @self.gameField.event
        def on_score_up():
            if self._update_interval > MAX_UPDATE_SPEED_INTERVAL:
                self._update_interval -= UPDATE_INTERVAL_SPEED_DX
                unschedule(func=self.update)
                schedule_interval(func=self.update,interval=self._update_interval)

    def _setup_overlay(self, text):
        self._overlay = BouncingLabel(FIELD_WIDTH//2,FIELD_HEIGHT//2,text,DEFAULT_OVERLAY_COLOR)
        self.win.pop_handlers()
        def on_draw():
            self.win.clear()
            self._overlay.draw()
        self.win.push_handlers(on_draw)

        schedule_interval(func=self._overlay.update, interval=OVERLAY_UPDATE_INTERVAL)

    def game_start_callback(self):
        self._setup_overlay("start")
        schedule_once(func=self.run_snake, delay=DELAY_FOR_NEW_RUN)

    def game_exit_callback(self, *args):
        if self._overlay:
            unschedule(self._overlay.update)
            self._overlay = None

        self.win.pop_handlers()
        self.win.close()

    def start(self):
         self.win.push_handlers(self.menu)
         pyglet.app.run()

    def update(self, dt):
        if not self.gameInfo.pause:
            self.gameField.update(dt)

    def run_snake(self, *args):
        if self._overlay:
            unschedule(self._overlay.update)
            self._overlay = None

        #reset current handlers
        self.win.pop_handlers()

        self.gameInfo.pause = False
        self.gameField.reset()

        #setup new handlers
        self.win.push_handlers(self.gameField)

        #and setup update handler
        self._update_interval = Game.INITIAL_UPDATE_INTERVAL
        schedule_interval(func=self.update,interval=self._update_interval)

# 需要导入模块: from pyglet.window import Window [as 别名]
# 或者: from pyglet.window.Window import push_handlers [as 别名]
class Gameloop(object):

    instance = None

    def __init__(self):
        Gameloop.instance = self
        self.window = None
        self.camera = None
        self.world = None
        self.renderer = None
        self.paused = False
        self.fps_display = None
        Keyboard.handlers.update({
            key.PAGEUP: lambda: self.camera.zoom(2.0),
            key.PAGEDOWN: lambda: self.camera.zoom(0.5),
            key.ESCAPE: self.quit_game,
            key.PAUSE: self.toggle_pause,
            key.F12: lambda: save_screenshot(self.window),
        })


    def init(self, name, version):
        clock.set_fps_limit(FPS_LIMIT)
        self.fps_display = clock.ClockDisplay()

        self.camera = Camera((0, 0), 800)
        self.renderer = Renderer(self.camera)
        caption = '%s v%s' % (name, version)
        self.window = Window(
            caption=caption, fullscreen=True, visible=False)
        self.window.on_key_press = on_key_press
        self.window.push_handlers(Keyboard.keystate)

        graphics = load_graphics()

        self.world = World()
        builder = LevelBuilder()
        seed(1)
        builder.build(self.world, 75, graphics)

        self.world.player = Player()
        self.world.player.add_to_space(self.world.space, (0, 200), 0)
        self.world.chunks.update(self.world.player.chunks)


    def dispose(self):
        if self.window:
            self.window.close()


    def run(self):
        try:
            self.window.set_visible()
            while not self.window.has_exit:
                self.window.dispatch_events()
                clock.tick()
                if self.world and not self.paused:
                    self.world.tick(1/FPS_LIMIT)
                if self.world and hasattr(self.world, 'player'):
                    player_position = self.world.player.chunks[0].body.position
                    self.camera.x, self.camera.y = player_position
                    self.camera.angle = atan2(
                        player_position.x,
                        player_position.y)

                self.camera.update()
                if self.renderer:
                    aspect = (
                        self.window.width / self.window.height)
                    self.renderer.draw(self.world, aspect)
                self.camera.hud_projection(
                    (self.window.width, self.window.height))
                self.fps_display.draw()
                self.window.flip()
        finally:
            self.dispose()


    def toggle_pause(self):
        self.paused = not self.paused


    def quit_game(self):
        self.window.has_exit = True