def main():
    clock.schedule(rabbyt.add_time)

    window.game_window = Window(width=SCREEN_WIDTH, height=SCREEN_HEIGHT)
    rabbyt.set_default_attribs()

    mower = Mower()
    bubble = RPMBubble()
    guage = Guage(mower)

    objs = [mower, guage, bubble]
    magicEventRegister(window.game_window, events, objs)

    while not window.game_window.has_exit:
        tick = clock.tick()
        window.game_window.dispatch_events()

        for obj in objs:
            obj.update(tick)
        
        events.ConsumeEventQueue()

        rabbyt.clear((1, 1, 1))

        guage.draw()
        mower.draw()
        bubble.draw()

        window.game_window.flip()

def main():
    window_w = w
    window_h = h

    #window_w = 1280
    #window_h =  720
    #window_w = 1024
    #window_h =  576
    #window_w =  800
    #window_h =  450

    window = MainWindow(width=window_w, height=window_h, vsync=False)
    #window = MainWindow(vsync=False, fullscreen=True)
    window.set_caption(
        "%i sprites :: Super Ultimate Sprite Machine Factory Window" % num_sprites
    )
    rabbyt.set_default_attribs()
    #window.push_handlers(pyglet.window.event.WindowEventLogger())
    #pyglet.clock.schedule_interval(window.update, 1.0/70.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/4.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/60.0)
    pyglet.clock.schedule(window.update)
    #pyglet.clock.schedule_interval(window.update, 4.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/120)
    #window.update(0)
    pyglet.app.run()

def init(world, options):

    window = pyglet.window.Window(
        fullscreen=options.fullscreen,
        vsync=options.vsync,
        resizable=not options.fullscreen,
        caption='Zerkcom',
    )

    rabbyt.set_default_attribs()

    draw_glyphs = glyph.init(window, world)
    draw_sprites = sprite.init(window, world, load_all('data/images'))

    @window.event
    def on_draw():
        rabbyt.clear(rgba=CLEAR_COLOR_DEFAULT)
        rabbyt.set_viewport(
            get_viewport(window.width, window.height),
            WORLD_BOUNDS
        )
        draw_glyphs()
        draw_sprites()

    return window

    def _create_display(self, width, height):
        size = width, height
        flags = pygame.OPENGL | pygame.DOUBLEBUF

        self.screen = pygame.display.set_mode(size, flags)
        rabbyt.set_viewport(size)
        rabbyt.set_default_attribs()

def main():
    global win
    clock.schedule(rabbyt.add_time)

    win = Window(width=800, height=600)
    rabbyt.set_default_attribs()

    lawn = Lawn()
    wind = Wind()

    magicEventRegister(win, events, list(lawn))

    while not win.has_exit:
        tick = clock.tick()
        win.dispatch_events()

        lawn.update(tick)
        wind.update(tick)
        events.ConsumeEventQueue()

        rabbyt.clear((1, 1, 1))

        lawn.draw()

        win.flip()

def main():
    window_w = WIDTH
    window_h = HEIGHT

    #window_w = 1280
    #window_h =  720
    #window_w = 1024
    #window_h =  576
    #window_w =  800
    #window_h =  450

    window = MainWindow(width=window_w, height=window_h, vsync=False)
    #window = MainWindow(vsync=False, fullscreen=True)
    window.set_caption(
        "moving magic!"
    )
    rabbyt.set_default_attribs()
    #window.push_handlers(pyglet.window.event.WindowEventLogger())
    #pyglet.clock.schedule_interval(window.update, 1.0/70.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/4.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/60.0)
    pyglet.clock.schedule(window.update)
    #pyglet.clock.schedule_interval(window.update, 4.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/120)
    #window.update(0)
    pyglet.app.run()

def main():
    global fps_display

    win = Window(width=800, height=600)

    clock.schedule(rabbyt.add_time)

    rabbyt.set_default_attribs()

    bg = Background()

    fps_display = clock.ClockDisplay()

    while not win.has_exit:
        tick = clock.tick()
        win.dispatch_events()

        bg.update(tick)

        rabbyt.clear((bg.color))

        bg.draw()
        fps_display.draw()

        win.flip()

    def __init__(self, size=(800,600), fullscreen=0, caption="snowui"):
        pyglet_window.Window.__init__(self, width=size[0], height=size[1])
        if fullscreen:
            self.set_fullscreen(True)

        self.set_caption(caption)
        rabbyt.set_default_attribs()

def main():
    global win
    clock.schedule(rabbyt.add_time)

    win = pyglet.window.Window(width=leaves.SCREEN_WIDTH, height=leaves.SCREEN_HEIGHT)
    window.set_window(win)
    rabbyt.set_default_attribs()

    garbage = GarbageCan()

    leafs = leaves.LeafGroup()
    leafs += [leaves.Leaf(), leaves.Leaf(), leaves.Leaf() ]
    for i in range(len(leafs)):
        leafs[i].logicalX = 260 + i*80
        leafs[i].logicalY = 100 + i*60
        leafs[i].logicalZ = 10

    while not win.has_exit:
        tick = clock.tick()
        win.dispatch_events()

        leafs.update(tick)
        garbage.update(tick)
        
        events.ConsumeEventQueue()

        rabbyt.clear((1, 1, 1))

        leafs.draw()
        garbage.draw()

        win.flip()

def main():
    window = pyglet.window.Window(fullscreen=config.fullscreen)
    window.set_exclusive_mouse(config.fullscreen)
    window.set_exclusive_keyboard(config.fullscreen)
    rabbyt.set_default_attribs()
    pyglet.resource.path = ['@pycarus']
    TitleScreen(window)
    pyglet.app.run()

 def __init__(self):
     super(Controller, self).__init__(width=constants.WIDTH, height=constants.HEIGHT, caption="Nanobiotics")#, fullscreen=True)        
     self.viewport = fixed_resolution.FixedResolutionViewport(self, constants.WIDTH, constants.HEIGHT, filtered=False)        
     rabbyt.set_viewport((constants.WIDTH, constants.HEIGHT))
     rabbyt.set_default_attribs()        
     
     self.set_exclusive_mouse(True)
     self.set_mouse_visible(False)
     self.state = None

def init () :
    global window
    flags = pygame.OPENGL | pygame.DOUBLEBUF
    if BCONF.fullscreen :
        flags |= pygame.FULLSCREEN

    pygame.display.init ()
    window = pygame.display.set_mode ( ( BCONF.width, BCONF.height ), flags )
    rabbyt.set_viewport ( ( BCONF.width, BCONF.height ), ( -width, height, width, -height ) )
    rabbyt.set_default_attribs ()

def other_main():
    #window = MainWindow(*size, vsync=False)
    window = MainWindow(width=size[0], height=size[1], vsync=False)
    window.set_caption(
        "%i sprites :: Super Ultimate Sprite Machine Factory Window" % num_sprites
    )
    rabbyt.set_default_attribs()
    #window.push_handlers(pyglet.window.event.WindowEventLogger())
    pyglet.clock.schedule_interval(window.update, 1.0/70.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/120)
    pyglet.app.run()

def main():
	def tuio(dt):
		"""pyglet callback event to check for OSC messages"""
		server.recv(0.0333333333333)
	skreen=canvas(photoDeck(skreenPics().sprites))
	server = liblo.Server(3333)
	server.add_method('/tuio/2Dcur', None, skreen.handleOsc)
	#server.add_method('/tuio/2Dcur', None, debugtuio)
	pyglet.clock.schedule_interval(tuio, 0.0001)
	pyglet.clock.schedule(rabbyt.add_time)
	rabbyt.set_default_attribs()
	rabbyt.set_viewport((skreen.window.height,skreen.window.width))
	pyglet.app.run()

def main():
    """Initialize environment, then start game instance."""
    pygame.init()
    pygame.display.set_mode( (WINWIDTH, WINHEIGHT),
                             pygame.OPENGL | pygame.DOUBLEBUF )
    # (0,0) is center point of screen
    rabbyt.set_viewport( (WINWIDTH, WINHEIGHT) )
    rabbyt.set_default_attribs()
    pygame.display.set_icon(pygame.image.load(os.path.join('images',
        'gameicon.png')).convert_alpha())
    pygame.display.set_caption('Escape from Wikipedia')

    while True:
        runGame()       # Allows restarts

    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 __init__(self, fps=False, **kwargs):
     super(MyWindow, self).__init__(**kwargs)
     rabbyt.set_default_attribs()
     glClearColor(1, 1, 1, 0)
     glColor3f(0, 0, 0)
     self.fps = fps
     self.fps_display = pyglet.clock.ClockDisplay()
     if '--animation-editor' in sys.argv:
         self.my_screen = AnimationEditor(self)
     elif '--skeleton-editor' in sys.argv:
         self.my_screen = SkeletonEditor(self)
     elif '--skin-editor' in sys.argv:
         self.my_screen = SkinEditor(self)
     else:
         self.my_screen = GameScreen(self)

def other_main():
    #window = MainWindow(width=w, height=h, vsync=False)
    window = MainWindow(vsync=False, fullscreen=True)
    # See bookmarks for scaling...
    #window = MainWindow(width=w, height=h, vsync=False, fullscreen=True)
    #window = MainWindow(width=w, height=h, vsync=True)
    window.set_caption(
        "%i sprites :: Super Ultimate Sprite Machine Factory Window" % num_sprites
    )
    rabbyt.set_default_attribs()
    #window.push_handlers(pyglet.window.event.WindowEventLogger())
    #pyglet.clock.schedule_interval(window.update, 1.0/70.0)
    pyglet.clock.schedule_interval(window.update, 1.0/4.0)
    #pyglet.clock.schedule_interval(window.update, 1.0/120)
    pyglet.app.run()

 def __init__(self, **kwargs):
     super(MyWindow, self).__init__(**kwargs)
     self.set_exclusive_mouse(self.fullscreen)
     self.set_exclusive_keyboard(self.fullscreen)
     rabbyt.set_default_attribs()
     glClearColor(1, 1, 1, 0)
     self.background = load_tileable_texture('background.png')
     self.ship_texture = pyglet.resource.texture('ship.png')
     self.ship = rabbyt.Sprite(self.ship_texture,
                               alpha=rabbyt.ease(0, 1, dt=2),
                               rot=rabbyt.lerp(end=60, dt=1,
                                               extend='extrapolate'))
     self.shadow = create_shadow(self.ship, self.ship_texture, x=20, y=-30,
                                 alpha=0.5)
     self.time = 0.

 def __init__(self, world, camera, options):
     self.world = world
     self.camera = camera
     self.options = options
     self.clock_display = None
     rabbyt.set_default_attribs()
     
     # lists of sprites to render, keyed by layer
     # 0: ground level
     # 1: old images of player
     # 2: player
     # 3: treetops
     # 4: hud
     self.sprites = {}
     world.item_added += self.on_item_added
     world.item_removed += self.on_item_removed