def main():
# Create the main window
window = Window(800, 600, visible=False,
caption="FF:Tactics.py", style='dialog')
# Create the default camera and have it always updating
camera = Camera((-600, -300, 1400, 600), (400, 300), 300, speed=PEPPY)
clock.schedule(camera.update)
# Load the first scene
world = World(window, camera)
world.transition(MainMenuScene)
# centre the window on whichever screen it is currently on
window.set_location(window.screen.width/2 - window.width/2,
window.screen.height/2 - window.height/2)
# clear and flip the window
# otherwise we see junk in the buffer before the first frame
window.clear()
window.flip()
# make the window visible at last
window.set_visible(True)
# finally, run the application
pyglet.app.run()
def __init__(self, window, player, console):
self.keys = key.KeyStateHandler()
self.player = player
# Console
self.console = console
# States
self.states = {}
self.states[wireframe] = False
self.states[flight] = False
self.mouse_speed = 0.0014
# Key Press Events
self.keyPressEvents = {}
clock.schedule(self.update)
window.push_handlers(self.on_key_press)
window.push_handlers(self.on_key_release)
window.push_handlers(self.keys)
window.push_handlers(self.on_mouse_motion)
window.push_handlers(self.on_mouse_drag)
window.push_handlers(self.on_mouse_press)
window.push_handlers(self.on_mouse_release)
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():
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 on_key_release(self, symbol, modifiers):
super().on_key_press(symbol, modifiers)
if symbol == key.SPACE:
if self.qr is None:
self.init_all_reg()
clock.schedule(self.tick)
return
def main():
# Create the main window
window = Window(800,
600,
visible=False,
caption="FF:Tactics.py",
style='dialog')
# Create the default camera and have it always updating
camera = Camera((-600, -300, 1400, 600), (400, 300), 300, speed=PEPPY)
clock.schedule(camera.update)
# Load the first scene
world = World(window, camera)
world.transition(MainMenuScene)
# centre the window on whichever screen it is currently on
window.set_location(window.screen.width / 2 - window.width / 2,
window.screen.height / 2 - window.height / 2)
# clear and flip the window
# otherwise we see junk in the buffer before the first frame
window.clear()
window.flip()
# make the window visible at last
window.set_visible(True)
# finally, run the application
pyglet.app.run()
def play(self):
if self.playing: return
clock.schedule(self.update)
self.player.play()
self.control.play.setVisible(False)
self.control.pause.setVisible(True)
self.playing = True
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():
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, obj, attr, target_value, rate=1.0):
self.obj = obj
self.attr = attr
self.rate = rate
self.target_value = target_value
self.direction = 1 if target_value > getattr(obj, attr) else -1
clock.schedule(self.update)
def play(self):
if self.playing: return
clock.schedule(self.time_update)
self.player.play()
self.control.pause.setVisible(True)
self.control.play.setVisible(False)
self.playing = True
def __init__(self):
super(hello_visionseed, self).__init__()
self.skipSync = False
self.frame = None
self.msg = None
self.sprite = None
self.label = cocos.text.Label('O',
font_name='Time New Noman',
font_size=32,
anchor_x="center",
anchor_y="center")
self.label.position = (window_width / 2, window_height / 2)
# self.add(self.label, z=100)
self.mouth = []
for i in range(2):
mouth = cocos.sprite.Sprite('mouth%d.png' % i)
mouth.position = (window_width / 2, window_height / 2)
self.add(mouth, z=200)
mouth.opacity = 0
self.mouth.append(mouth)
self.setDebugDrawing(1)
clock.schedule(self.callback)
def __init__(self, window, on_finished=None):
global current_screen
if current_screen:
current_screen.end()
current_screen = self
handlers = {}
global serial_number
serial_number += 1
self.serial_number = serial_number
self.log("__init__. large and in charge.")
for k in dir(self):
if k.startswith('on_'):
handlers[k] = getattr(self, k)
self.window = window
self.on_finished = on_finished
self.load()
self.batch = pyglet.graphics.Batch()
self.t = 0
self.clock = clock.Clock(time_function=self._time)
clock.schedule(self._tick)
self.start()
self.log(">>>> push handlers >>>>")
window.push_handlers(**handlers)
def __init__(self, object, tween='linear', duration=1, on_finished=None,
clock=None,
**targets):
self.targets = targets
self.function = TWEEN_FUNCTIONS[tween]
self.duration = duration
self.on_finished = on_finished
self.t = 0
self.object = object
self.initial = {}
self.running = True
for k in self.targets:
try:
a = getattr(object, k)
except AttributeError:
raise ValueError('object %r has no attribute %s to animate' % (object, k))
self.initial[k] = a
key = id(object), k
previous_animation = self._animation_dict.get(key)
if previous_animation is not None:
previous_animation._remove_target(k)
self._animation_dict[key] = self
clock = clock or pyglet.clock
clock.schedule(self.update)
self.clock = clock
self.animations.append(self)
def _schedule_callback(dt, func, *args, **kwargs):
"""
Schedule a callback to occur every event loop.
"""
# schedule it
clock.schedule(func, *args, **kwargs)
# call it
func(dt, *args, **kwargs)
def on_scene_enter(self):
#glEnable(GL_POINT_SMOOTH)
#glEnable(GL_TEXTURE_2D)
self.player = Player()
self.players = [self.player]
self.dynamic.append(self.player)
self.last_lead = self.player.position = self.campos = self.cam_spline.get_point(0)
clock.schedule(self.update)
def __init__(self, *args, **kwargs):
clock.schedule(self.update)
self.autoRun = False
#self.autoRun = True
self.translatex = self.translatey = 0
self.rotx = 0
self.depthtarget = self.depth = -7
super(AppWindow, self).__init__(*args,**kwargs)
def _schedule_callback(dt, func, *args, **kwargs):
"""
Schedule a callback to occur every event loop.
"""
# schedule it
clock.schedule(func, *args, **kwargs)
# call it
func(dt, *args, **kwargs)
def start(self):
# schedule update function to be called every frame
# I need to add some sort of FPS setting here
clock.schedule(self.update)
# instantiate the main game instance
# this will be changed to the menu instance when it's implemented
gameState = Game(self)
self.stateManager.addState('game', gameState)
self.stateManager.setState('game')
def __init__(self): config = gl.Config(sample_buffers=1, samples=4, depth_size=16, double_buffer=True) try: super(HypyrApp, self).__init__(resizable=True, config=config, vsync=False, width=800, height=600) except pyglet.window.NoSuchConfigException: super(HypyrApp, self).__init__(resizable=True) self.scene = scene.Thing() self.camera = scene.Camera() clock.schedule(self.update) self.setupOpenGL()
def explode(self):
explosion = ExplosionDrawable()
schedule(explosion.timer)
schedule_once(lambda x: unschedule(explosion.timer), 2.)
schedule_once(lambda x: self._mesh.remove_drawable(explosion), 2.)
explosion_animator = Explosion(self._mesh.all_faces)
self._mesh.add_animation(explosion_animator.animate)
schedule_once(lambda x: explosion_animator.expire(), 6.)
self._mesh.add_drawable(explosion)
self._mesh.set_double_sided(True)
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 main():
window = pyglet.window.Window(width=400, height=400)
model = Model()
view = View(model, window)
clock.schedule_interval(model.update, 0.001)
clock.schedule(view.render)
pyglet.app.run()
def __init__(self, parent, file=None, source=None, playing=False,
x=0, y=0, z=0, width=None, height=None, scale=True, **kw):
self.parent = parent
self.scale = scale
if file is not None:
source = self.source = media.load(file, streaming=True)
else:
assert source is not None, 'one of file or source is required'
self.player = media.Player()
self.player.eos_action = self.player.EOS_PAUSE
self.player.on_eos = self.on_eos
# poke at the video format
if not source.video_format:
raise ValueError("Movie file doesn't contain video")
video_format = source.video_format
if width is None:
width = video_format.width
if video_format.sample_aspect > 1:
width *= video_format.sample_aspect
if height is None:
height = video_format.height
if video_format.sample_aspect < 1:
height /= video_format.sample_aspect
super().__init__(parent, x, y, z, width, height, **kw)
# control frame top-level
c = self.control = Frame(self, bgcolor=(1, 1, 1, .5),
is_visible=False, width='100%', height=64)
# controls underlay
f = Frame(c, is_transparent=True, width='100%', height='100%')
f.layout = layouts.Horizontal(f, valign='center', halign='center',
padding=10)
c.play = Image(f, data.load_gui_image('media-play.png'),
classes=('-play-button',), is_visible=not playing)
c.pause = Image(f, data.load_gui_image('media-pause.png'),
bgcolor=None, classes=('-pause-button',),
is_visible=playing)
fi = Frame(f, is_transparent=True)
c.range = Image(fi, data.load_gui_image('media-range.png'))
im = data.load_gui_image('media-position.png')
c.position = Image(fi, im, x=0, y=-2, classes=('-position',))
c.time = Label(f, '00:00', font_size=20)
c.anim = None
# make sure we get at least one frame to display
self.player.queue(source)
clock.schedule(self.update)
self.playing = False
if playing:
self.play()
def start_stop_frames(self):
if self.is_playing:
clock.unschedule(self.call_draw)
self.is_playing = False
print('stopping frames!')
else:
clock.unschedule(self.call_draw)
clock.schedule(self.call_draw)
self.is_playing = True
print('playing frames at ' + str(SPEED_ARR[self.curr_speed]) +
'x speed')
def test_schedule_multiple(self):
clock.set_default(clock.Clock())
clock.schedule(self.callback)
clock.schedule(self.callback)
self.callback_count = 0
clock.tick()
self.assertTrue(self.callback_count == 2)
clock.tick()
self.assertTrue(self.callback_count == 4)
def main(): window = pyglet.window.Window( width=400, height=400 ) model = None view = View(model, window) #clock.schedule_interval(model.update, 0.001) clock.schedule(view.render) pyglet.app.run()
def test_unschedule(self):
clock.set_default(clock.Clock())
clock.schedule(self.callback)
result = clock.tick()
self.assertTrue(result == self.callback_dt)
self.callback_dt = None
time.sleep(1)
clock.unschedule(self.callback)
result = clock.tick()
self.assertTrue(self.callback_dt == None)
def __init__(self, parent, file=None, source=None, title=None,
playing=False, bgcolor=(1, 1, 1, 1), color=(0, 0, 0, 1),
font_size=20, **kw):
"""Pass in a filename as "file" or a pyglet Source as "source".
"""
self.parent = parent
if file is not None:
source = media.load(file, streaming=True)
else:
assert source is not None, 'one of file or source is required'
self.player = media.Player()
# poke at the audio format
if not source.audio_format:
raise ValueError("File doesn't contain audio")
super().__init__(parent, bgcolor=bgcolor, **kw)
# lay it out
# control frame top-level
c = self.control = Frame(self, width='100%', height=64)
ft = Frame(c, is_transparent=True, width='100%', height='100%')
ft.layout = layouts.Vertical(ft)
Label(ft, title or 'unknown', color=color, bgcolor=bgcolor,
padding=2, font_size=font_size)
# controls underlay
f = Frame(ft, is_transparent=True, width='100%', height='100%')
f.layout = layouts.Horizontal(f, valign='center', halign='center',
padding=10)
c.play = Image(f, data.load_gui_image('media-play.png'),
classes=('-play-button',), is_visible=not playing)
c.pause = Image(f, data.load_gui_image('media-pause.png'),
bgcolor=None, classes=('-pause-button',),
is_visible=playing)
fi = Frame(f, is_transparent=True)
c.range = Image(fi, data.load_gui_image('media-range.png'))
c.position = Image(fi, data.load_gui_image('media-position.png'),
y=-2, classes=('-position',))
c.time = Label(f, '00:00', font_size=20)
c.anim = None
# make sure we get at least one frame to display
self.player.queue(source)
clock.schedule(self.update)
self.playing = False
if playing:
self.play()
def start_game(self, controller, player_name = "Samus", host="localhost", game_name = "Deathtroid"):
self.menu = None
#self.init_gl()
if controller == "server" or controller == "both":
if self.server == None:
self.server = server_controller.ServerController(game_name)
#clock.schedule(self.server.update)
clock.schedule_interval_soft(self.server.update, 1./30.)
if controller == "client" or controller == "both":
if self.client == None:
self.client = client_controller.ClientController(player_name, host)
clock.schedule(self.client.update)
def __init__(self, parent, file=None, source=None, title=None,
playing=False, bgcolor=(1, 1, 1, 1), color=(0, 0, 0, 1),
font_size=20, **kw):
'''Pass in a filename as "file" or a pyglet Source as "source".
'''
self.parent = parent
if file is not None:
source = media.load(file, streaming=True)
else:
assert source is not None, 'one of file or source is required'
self.player = media.Player()
# poke at the audio format
if not source.audio_format:
raise ValueError("File doesn't contain audio")
super(Music, self).__init__(parent, bgcolor=bgcolor, **kw)
# lay it out
# control frame top-level
c = self.control = Frame(self, width='100%', height=64)
ft = Frame(c, is_transparent=True, width='100%', height='100%')
ft.layout = layouts.Vertical(ft)
Label(ft, title or 'unknown', color=color, bgcolor=bgcolor,
padding=2, font_size=font_size)
# controls underlay
f = Frame(ft, is_transparent=True, width='100%', height='100%')
f.layout = layouts.Horizontal(f, valign='center', halign='center',
padding=10)
c.play = Image(f, data.load_gui_image('media-play.png'),
classes=('-play-button',), is_visible=not playing)
c.pause = Image(f, data.load_gui_image('media-pause.png'),
bgcolor=None, classes=('-pause-button',), is_visible=playing)
fi = Frame(f, is_transparent=True)
c.range = Image(fi, data.load_gui_image('media-range.png'))
c.position = Image(fi, data.load_gui_image('media-position.png'),
y=-2, classes=('-position',))
c.time = Label(f, '00:00', font_size=20)
c.anim = None
# make sure we get at least one frame to display
self.player.queue(source)
clock.schedule(self.update)
self.playing = False
if playing:
self.play()
def start(self):
def run():
time_per_cycle = 1.0 / cycles_per_second
while True:
begin = time.time()
self.cycle()
sleep_time = time_per_cycle - (time.time() - begin)
if sleep_time > 0:
time.sleep(sleep_time)
td = Thread(target=run)
td.daemon = True
td.start()
clock.schedule(self.on_draw)
pyglet.app.run()
def startup(self, win):
self.add(Sky())
self.add(Ground())
self.add(StressTest())
self.add(HudLives())
self.add(HudScore())
self.add(HudMultiplier())
def update_and_refresh(win, dt):
self.update(dt)
win.invalid = True
clock.schedule(lambda dt: update_and_refresh(win, dt))
self.title()
def main():
win = Window(fullscreen=True, visible=False)
camera = Camera(win.width, win.height, (0, 0), 100)
renderer = Renderer()
maze = Maze()
maze.create(50, 30, 300)
keyboard = Keyboard()
keyboard.key_handlers[key.ESCAPE] = win.close
keyboard.key_handlers.update(camera.key_handlers)
clock.schedule(maze.update)
win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
win.on_key_press = keyboard.on_key_press
keyboard.print_handlers()
win.set_visible()
app.run()
def __init__(self, window):
if exists('saved.view'):
data = load(open('saved.view'))
self.rotation = Vector(data['rx'], data['ry'])
self.position = Vector(data['x'], data['y'], data['z'])
else:
self.rotation = Vector()
self.position = Vector(0, 0, -1)
self.rotspeed = Vector()
self.speed = Vector()
self.keys = key.KeyStateHandler()
self.navigator = Navigator()
schedule(self.update)
window.push_handlers(self.on_key_press)
def main():
win = Window(fullscreen=True, visible=False)
camera = Camera(win.width, win.height, (0, 0), 100)
renderer = Renderer()
maze = Maze()
maze.create(50, 30, 300)
keyboard = Keyboard()
keyboard.key_handlers[key.ESCAPE] = win.close
keyboard.key_handlers.update(camera.key_handlers)
clock.schedule(maze.update)
win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
win.on_key_press = keyboard.on_key_press
keyboard.print_handlers()
win.set_visible()
app.run()
def __init__(self, window):
if exists('saved.view'):
data = load(open('saved.view'))
self.rotation = Vector(data['rx'], data['ry'])
self.position = Vector(data['x'], data['y'], data['z'])
else:
self.rotation = Vector()
self.position = Vector(0, 0, -1)
self.rotspeed = Vector()
self.speed = Vector()
self.keys = key.KeyStateHandler()
self.navigator = Navigator()
schedule(self.update)
window.push_handlers(self.on_key_press)
def main():
clock.schedule(rabbyt.add_time)
window.game_window.set_window(Window(width=800, height=600))
rabbyt.set_default_attribs()
bgPat = pyglet.image.SolidColorImagePattern((0, 0, 0, 255))
bg = pyglet.image.create(window.game_window.width, window.game_window.height, bgPat)
bub = ThoughtBubble(
"Click to make this disappear."
" This is a thought bubble."
" asdf asdf .qwer p30n fpin pp) ) *HNPO *H#NN ! #RFL"
)
bub2 = HintBubble("This is a hint bubble.")
maker = BubbleMaker()
magicEventRegister(window.game_window, events, [bub])
counter = 0
objects = [bub, bub2, maker]
events.Fire("Shoo", 1, 2, None)
while not window.game_window.has_exit:
tick = clock.tick()
window.game_window.dispatch_events()
counter += tick
if counter > 8:
counter = -10
events.Fire("NewThought", "new thought")
events.Fire("Shoo", 3, 4, None)
for obj in objects:
obj.update(tick)
events.ConsumeEventQueue()
rabbyt.clear((1, 1, 1))
bg.blit(0, 0)
for obj in objects:
obj.draw()
window.game_window.flip()
def main():
global win
clock.schedule(rabbyt.add_time)
win = pyglet.window.Window(width=SCREEN_WIDTH, height=SCREEN_HEIGHT)
window.set_window(win)
bgPat = pyglet.image.SolidColorImagePattern((200, 200, 255, 255))
bg = pyglet.image.create(window.game_window.width, window.game_window.height, bgPat)
rabbyt.set_default_attribs()
bubbles.init()
bubbles.win = win
storyTeller = narrative.StoryTeller()
fGen = FloaterGenerator()
fGen.hitRequiredStage = True
fGen.active = True
sGen = SourcecodeGenerator()
sGen.hitRequiredStage = True
sGen.active = True
events.Fire("NewStage", narrative.terror)
scene = sky.Background(None)
while not win.has_exit:
tick = clock.tick()
win.dispatch_events()
bubbles.bubbleMaker.update(tick)
scene.update(tick)
fGen.update(tick)
sGen.update(tick)
events.ConsumeEventQueue()
rabbyt.clear((1, 1, 1))
bg.blit(0, 0)
scene.draw()
fGen.draw()
bubbles.bubbleMaker.draw()
sGen.draw()
win.flip()
def play(level):
view = FlatView.from_window(w, layers=[level, effectlayer, rocketlayer])
# set rocket start
for col in level.cells:
for cell in col:
if 'player-start' in cell.properties:
rocket.midtop = cell.midtop
clock.schedule(rocket.update)
rocket.properties.update(dict(dx=0, dy=0, done=0))
# run game
while not (w.has_exit or rocket.properties['done']):
dt = clock.tick()
w.dispatch_events()
view.fx, view.fy = rocket.center
view.clear((.2, .2, .2, .2))
view.draw()
fps.draw()
w.flip()
# put up a message
done = rocket.properties['done']
if not done:
return
if done == 1:
text = 'YAY YOU LANDED!'
if done == 2:
text = 'BOO YOU CRASHED!'
text += ' (press [escape] to continue)'
sprite = TextSprite(font, text, color=(1., 1., 1., 1.))
sprite.x, sprite.y = w.width / 2 - sprite.width / \
2, w.height / 2 - sprite.height / 2
w.has_exit = False
while not w.has_exit:
dt = clock.tick()
w.dispatch_events()
view.clear((.2, .2, .2, .2))
view.draw()
sprite.draw()
w.flip()
clock.unschedule(rocket.update)
if boom in effectlayer.sprites:
effectlayer.sprites.remove(boom)
def play(level):
view = FlatView.from_window(w, layers=[level, effectlayer, rocketlayer])
# set rocket start
for col in level.cells:
for cell in col:
if 'player-start' in cell.properties:
rocket.midtop = cell.midtop
clock.schedule(rocket.update)
rocket.properties.update(dict(dx=0, dy=0, done=0))
# run game
while not (w.has_exit or rocket.properties['done']):
dt = clock.tick()
w.dispatch_events()
view.fx, view.fy = rocket.center
view.clear((.2, .2, .2, .2))
view.draw()
fps.draw()
w.flip()
# put up a message
done = rocket.properties['done']
if not done:
return
if done == 1:
text = 'YAY YOU LANDED!'
if done == 2:
text = 'BOO YOU CRASHED!'
text += ' (press [escape] to continue)'
sprite = TextSprite(font, text, color=(1., 1., 1., 1.))
sprite.x, sprite.y = w.width / 2 - sprite.width / \
2, w.height / 2 - sprite.height / 2
w.has_exit = False
while not w.has_exit:
dt = clock.tick()
w.dispatch_events()
view.clear((.2, .2, .2, .2))
view.draw()
sprite.draw()
w.flip()
clock.unschedule(rocket.update)
if boom in effectlayer.sprites:
effectlayer.sprites.remove(boom)
def init(self, *args, **kwargs):
# Setup a clock for frame rate
clock.set_fps_limit(settings.FPS_LIMIT)
# Setup updates to run once per tick
if kwargs.get('noreset', True):
clock.schedule(self.update)
#---------------------------------------------------------
# MENU.
# set up a menu system. It is a hack.
# don't let anyone else tell you otherwise.
self.menubatch = pyglet.graphics.Batch()
self.menugroup = pyglet.graphics.OrderedGroup(1)
self.bggroup = pyglet.graphics.OrderedGroup(0)
theme = kytten.Theme(fp('theme'))
menu_choices = {
'Play Game': self.remove_menu_load_level,
'Help!' : partial(show_help, self,
self.menubatch, self.menugroup, theme),
'Quit' : pyglet.app.exit,
}
def on_select(choice):
menu_choices.get(choice)()
self.background = load(fp('background.png'))
self.dialog = kytten.Dialog(
kytten.TitleFrame("Altered Panda",
kytten.VerticalLayout([
kytten.Menu(options=[
"Play Game",
"Help!",
"Quit",],
on_select=on_select),
])
),
window=self, batch=self.menubatch,
group=self.menugroup, anchor=kytten.ANCHOR_TOP_LEFT,
theme=theme
)
self.do_draw = True
def main():
clock.schedule(rabbyt.add_time)
win = Window(width=800, height=600)
rabbyt.set_default_attribs()
lawn = NewLawn()
while not win.has_exit:
tick = clock.tick()
win.dispatch_events()
lawn.update(tick)
rabbyt.clear((1, 1, 1))
lawn.draw()
win.flip()
def main():
global win
clock.schedule(rabbyt.add_time)
win = pyglet.window.Window(width=SCREEN_WIDTH, height=SCREEN_HEIGHT)
window.set_window(win)
rabbyt.set_default_attribs()
bubbles.init()
bubbles.win = win
storyTeller = narrative.StoryTeller()
wind = Wind()
leafgen = LeafGenerator()
leafgen.active = True
leaves = LeafGroup()
#bg = sky.Background(None)
objs = [leafgen, leaves]
magicEventRegister(win, events, objs)
while not win.has_exit:
tick = clock.tick()
win.dispatch_events()
bubbles.bubbleMaker.update(tick)
#bg.update(tick)
for obj in objs:
obj.update(tick)
wind.update(tick)
events.ConsumeEventQueue()
rabbyt.clear((1, 1, 1))
#bg.draw()
leaves.draw()
bubbles.bubbleMaker.draw()
win.flip()
def main():
clock.schedule(rabbyt.add_time)
win = pyglet.window.Window(width=800, height=600)
window.set_window(win)
rabbyt.set_default_attribs()
grill = Grill()
while not win.has_exit:
tick = clock.tick()
win.dispatch_events()
grill.update(tick)
rabbyt.clear((1, 1, 1))
grill.draw()
win.flip()
def on_scene_enter(self):
clock.schedule(self.update)
self.player = Player()
self.players = [self.player]
self.generate_level()
# set up collision detection
self.coll_detector = collision.CollisionDetector()
# collisions between:
# flock-player, player-bullets, player-objstacles, bulltets-obstacles, bullets-flock
#self.coll_detector.register_once(self, group_name1, group_name2, group1, group2, coll_strategy, type_tuple, func):
self.coll_detector.register_group('player', self.players)
self.coll_detector.register_group('flocks', self.flocks)
self.coll_detector.register_group('obstacles', self.obstacles)
self.coll_detector.register_group('enemies', self.enemies)
self.coll_detector.register_group('bullets', self.bullets)
self.coll_detector.register_pair('player', 'flocks', PlayerFlockCollisionStrategy(self))
self.coll_detector.register_pair('player', 'bullets', PlayerBulletsCollisionStrategy(self))
self.coll_detector.register_pair('player', 'obstacles', PlayerObstaclesCollisionStrategy(self))
self.coll_detector.register_pair('bullets', 'obstacles', BulletsObstaclesCollisionStrategy(self))
self.coll_detector.register_pair('flocks', 'bullets', FlockBulletsCollisionStrategy(self))
#self.coll_detector.register_once('player', 'flocks', self.players, self.flocks, PlayerFlockCollisionStrategy(self), tuple(), None):
# enemy
#scene, fire_rate, position, orientation)
self.enemies.append( Enemy(self, 1, Vec3(300, 10), Vec3(0, 1) * 100.0) )
self.enemies.append( Enemy(self, 0.1, Vec3(10, 200), Vec3(1, -0.1) * 300.0) )
self.enemies.append( Enemy(self, 1, Vec3(500, 10), Vec3(0, 1) * 200) )
p = Polygon()
p.add_vertex(400, 400)
p.add_vertex(550, 400)
p.add_vertex(550, 420)
p.add_vertex(400, 450)
self.obstacles.append(p)
def on_enter(self):
super(VisionSeedLayer, self).on_enter()
clock.schedule(self.callback)
self.x += v.x
self.y += v.y
w = pyglet.window.Window(width=512, height=512)
w.set_exclusive_mouse()
# load the map and car and set up the scene and view
dirname = os.path.dirname(__file__)
m = RectMap.load_xml(os.path.join(dirname, 'road-map.xml'), 'map0')
car = CarSprite.from_image(0, 0, Image2d.load(os.path.join(dirname,
'car.png')))
view = FlatView.from_window(w, layers=[m], sprites=[car])
keyboard = key.KeyStateHandler()
w.push_handlers(keyboard)
clock.set_fps_limit(30)
clock.schedule(car.update)
while not w.has_exit:
dt = clock.tick()
w.dispatch_events()
# re-focus on the car
view.fx, view.fy = car.center
# draw
view.draw()
w.flip()
w.close()
def drawCube(x, y, z, size):
cubeVL = pyglet.graphics.vertex_list(8, 'v3f', 'c3B')
glPushMatrix()
glLoadIdentity()
glTranslatef(x, y, z)
cubeVL.vertices = [
-size, size, size, size, size, size, size, -size, size, -size, -size,
size, -size, size, -size, size, size, -size, size, -size, -size, -size,
-size, -size
]
cubeVL.colors = np.repeat([255, 0, 0], 8)
cubeVL.draw(pyglet.gl.GL_LINE_LOOP)
glPopMatrix()
@win.event
def on_draw():
global x
x += 1
win.clear()
glLoadIdentity()
glEnable(GL_DEPTH_TEST)
drawCube(x, 0, 0, 50)
clock.schedule(on_draw)
pyglet.app.run()
evt.run()
win = Window(fullscreen=True, visible=False)
camera = Camera((0, 0), 10)
renderer = Renderer()
army_shape = Army.MakeShape(400, 1500, all_ghosts)
armies = []
for i in range(20, 0, -1):
army = Creature(army_shape, rand_point(500), uniform(-pi, pi))
army.dx = uniform(-0.4, +0.4)
army.dy = uniform(-0.4, +0.4)
armies.append(army)
def update(dt):
for army in armies:
army.update(dt)
camera.zoom(1.003)
clock.schedule(update)
key_handlers[key.ESCAPE] = win.close
win.on_draw = lambda: renderer.on_draw(armies, camera, win.width, win.height)
win.on_key_press = on_key_press
print "keys to try:", [symbol_string(k) for k in key_handlers.keys()]
stdout.flush()
win.set_visible()
app.run()
def __init__(self, world, pos, value, max_value=10):
super().__init__(world, pos)
self.create_particles(value, max_value)
clock.schedule(self.update)
# load the sprites & level
dirname = os.path.dirname(__file__)
r = Resource.load(os.path.join(dirname, 'lander.xml'))
rocket = RocketSprite.from_image(0,
0,
r['rocket'],
offset=(18, 0),
properties=dict(dx=0, dy=0, done=0))
rocket.width = 92
frames = [r['flame%d' % i] for i in range(1, 7)]
flame = AnimatedSprite.from_image(0,
0,
frames[0],
properties=dict(frame=0, t=0, frames=frames))
clock.schedule(flame.update)
frames = [r['boom%d' % i] for i in range(1, 4)]
boom = AnimatedSprite.from_image(0,
0,
frames[0],
properties=dict(frame=0, t=0, frames=frames))
clock.schedule(boom.update)
fps = clock.ClockDisplay(color=(1., .5, .5, .5))
effectlayer = SpriteLayer(5)
rocketlayer = SpriteLayer(1, [rocket])
def play(level):
def on_key_press(self, keyp, mod):
if keyp in (key.ENTER,):
# Dispatch an event rather than directly call self()
flask_api.eventdispatcher.add_text("your lucky number is %d" % (randint(0, 255)))
elif keyp in (key.Q,):
director.terminate_app = True
elif keyp in (key.B,):
# Dispatch a local event, rather than a flask_api.eventdispatcher event
localdispatcher.dispatch_event("on_change_bgcolor")
elif keyp in (key.R,):
self.on_reset()
def ping(self):
print 'sending pong!'
flask_api.eventdispatcher.pong()
if __name__ == "__main__":
# Register Event Handler
http_server = flask_api.runWebController()
if http_server:
print "web api started successfully!"
else:
# TODO add exception handling
print "unable to start web api"
# Schedule clock to update the http poller
clock.schedule(http_poller, http_server)
# initiate the pyglet run loop
director.run(cocos.scene.Scene(ForFunLayer()))
def __init__(self,
parent,
file=None,
source=None,
playing=False,
x=0,
y=0,
z=0,
width=None,
height=None,
scale=True,
**kw):
self.parent = parent
self.scale = scale
if file is not None:
source = self.source = media.load(file, streaming=True)
else:
assert source is not None, 'one of file or source is required'
self.player = media.Player()
self.player.eos_action = self.player.EOS_PAUSE
self.player.on_eos = self.on_eos
# poke at the video format
if not source.video_format:
raise ValueError("Movie file doesn't contain video")
video_format = source.video_format
if width is None:
width = video_format.width
if video_format.sample_aspect > 1:
width *= video_format.sample_aspect
if height is None:
height = video_format.height
if video_format.sample_aspect < 1:
height /= video_format.sample_aspect
super().__init__(parent, x, y, z, width, height, **kw)
# control frame top-level
c = self.control = Frame(self,
bgcolor=(1, 1, 1, .5),
is_visible=False,
width='100%',
height=64)
# controls underlay
f = Frame(c, is_transparent=True, width='100%', height='100%')
f.layout = layouts.Horizontal(f,
valign='center',
halign='center',
padding=10)
c.play = Image(f,
data.load_gui_image('media-play.png'),
classes=('-play-button', ),
is_visible=not playing)
c.pause = Image(f,
data.load_gui_image('media-pause.png'),
bgcolor=None,
classes=('-pause-button', ),
is_visible=playing)
fi = Frame(f, is_transparent=True)
c.range = Image(fi, data.load_gui_image('media-range.png'))
im = data.load_gui_image('media-position.png')
c.position = Image(fi, im, x=0, y=-2, classes=('-position', ))
c.time = Label(f, '00:00', font_size=20)
c.anim = None
# make sure we get at least one frame to display
self.player.queue(source)
clock.schedule(self.update)
self.playing = False
if playing:
self.play()
def run(xml_file):
gui = GUI(window)
loadxml.fromFile(gui, xml_file)
if '--dump' in sys.argv:
print '-' * 75
gui.dump()
print '-' * 75
window.push_handlers(gui)
gui.push_handlers(dragndrop.DragHandler('.draggable'))
@gui.select('#press-me')
def on_click(widget, *args):
print 'on_click', widget
return event.EVENT_HANDLED
@gui.select('#enable-other')
def on_click(widget, *args):
w = gui.get('#press-me')
w.setEnabled(not w.isEnabled())
return event.EVENT_HANDLED
@gui.select('button, text-button')
def on_click(widget, *args):
print 'DEBUG', widget, 'PRESSED'
return event.EVENT_UNHANDLED
@gui.select('.show-value')
def on_change(widget, value):
print 'DEBUG', widget, 'VALUE CHANGED', ` value `
return event.EVENT_UNHANDLED
@gui.select('frame#menu-test', 'on_click')
def on_menu(w, x, y, button, modifiers, click_count):
if not widgets.PopupMenu.isActivatingClick(button, modifiers):
return event.EVENT_UNHANDLED
gui.get('#test-menu').expose((x, y))
return event.EVENT_HANDLED
@gui.select('.hover')
def on_element_enter(widget, *args):
print 'ENTER ELEMENT', widget.id
return event.EVENT_HANDLED
@gui.select('.hover')
def on_element_leave(widget, *args):
print 'LEAVE ELEMENT', widget.id
return event.EVENT_HANDLED
@gui.select('.drawer-control')
def on_click(widget, *args):
id = widget.id.replace('drawer-control', 'test-drawer')
gui.get('#' + id).toggle_state()
return event.EVENT_HANDLED
@gui.select('#question-dialog-test')
def on_click(widget, *args):
def f(*args):
print 'DIALOG SAYS', args
dialogs.Question(widget.getGUI(),
'Did this appear correctly?',
callback=f).run()
return event.EVENT_HANDLED
@gui.select('#message-dialog-test')
def on_click(widget, *args):
def f(*args):
print 'DIALOG SAYS', args
dialogs.Message(widget.getGUI(), 'Hello, World!', callback=f).run()
return event.EVENT_HANDLED
@gui.select('#music-test')
def on_click(widget, x, y, button, modifiers, click_count):
if not button & mouse.RIGHT:
return event.EVENT_UNHANDLED
def load_music(file=None):
if not file: return
gui.get('#music-test').delete()
m = widgets.Music(gui, file, id='music-test', playing=True)
m.gainFocus()
dialogs.FileOpen(gui, callback=load_music).run()
return event.EVENT_HANDLED
@gui.select('#movie-test')
def on_click(widget, x, y, button, modifiers, click_count):
if not button & mouse.RIGHT:
return event.EVENT_UNHANDLED
def load_movie(file=None):
print 'DIALOG SELECTION:', file
if not file: return
gui.get('#movie-test').delete()
m = widgets.Movie(gui, file, id='movie-test', playing=True)
m.gainFocus()
dialogs.FileOpen(gui, callback=load_movie).run()
return event.EVENT_HANDLED
@gui.select('#movie-test')
def on_text(widget, text):
if text == 'f':
gui.get('#movie-test').video.pause()
anim.Delayed(gui.get('#movie-test').video.play, duration=10)
window.set_fullscreen()
return event.EVENT_HANDLED
@gui.select('.droppable')
def on_drop(widget, x, y, button, modifiers, element):
element.reparent(widget)
widget.bgcolor = (1, 1, 1, 1)
return event.EVENT_HANDLED
@gui.select('.droppable')
def on_drag_enter(widget, x, y, element):
widget.bgcolor = (.8, 1, .8, 1)
return event.EVENT_HANDLED
@gui.select('.droppable')
def on_drag_leave(widget, x, y, element):
widget.bgcolor = (1, 1, 1, 1)
return event.EVENT_HANDLED
try:
sample = gui.get('#xhtml-sample')
except KeyError:
sample = None
if sample:
@layout.select('#click-me')
def on_mouse_press(element, x, y, button, modifiers):
print 'CLICK ON', element
return event.EVENT_HANDLED
sample.label.push_handlers(on_mouse_press)
if gui.has('.progress-me'):
class Progress:
progress = 0
direction = 1
def animate(self, dt):
self.progress += dt * self.direction
if self.progress > 5:
self.progress = 5
self.direction = -1
elif self.progress < 0:
self.progress = 0
self.direction = 1
for e in gui.get('.progress-me'):
e.value = self.progress / 5.
animate_progress = Progress().animate
clock.schedule(animate_progress)
my_escape.has_exit = False
while not (window.has_exit or my_escape.has_exit):
clock.tick()
window.dispatch_events()
media.dispatch_events()
glClearColor(.2, .2, .2, 1)
glClear(GL_COLOR_BUFFER_BIT)
gui.draw()
fps.draw()
window.flip()
if '--once' in sys.argv:
window.close()
sys.exit()
if '--dump' in sys.argv:
print '-' * 75
gui.dump()
print '-' * 75
if gui.has('.progress-me'):
clock.unschedule(animate_progress)
# reset everything
window.pop_handlers()
gui.delete()
window.set_size(800, 600)
return window.has_exit
