def start(self):
if self.__running:
unschedule(self.update)
self.__running = False
else:
schedule_interval(self.update, self.speed)
self.__running = True
def stopRepeat(self):
if self.delay_timer is not None:
self.delay_timer.cancel()
self.delay_timer = None
if self.repeating:
clock.unschedule(self.repeat)
self.repeating = False
def visible(self, visible):
self._visible = visible
clock.unschedule(self._blink)
if visible and self._active and self.PERIOD:
clock.schedule_interval(self._blink, self.PERIOD)
self._blink_visible = False # flipped immediately by next blink
self._blink(0)
def leave(self):
# get the end time
self.end_time = now()
# update the parent state time to actual elapsed time if necessary
if self.duration < 0:
if isinstance(self, ParentState):
# advance the duration the children moved the this parent
duration = self.state_time-self.start_time
else:
# advance the duration of this state
duration = self.end_time-self.start_time
self.advance_parent_state_time(duration)
# remove the callback from the schedule
clock.unschedule(self.callback)
# notify the parent that we're done
self.active = False
self.done = True
if self.parent:
self.parent.check = True
# call custom leave code
self._leave()
# write log to the state log
#print self.get_log()
if self.save_log:
dump([self.get_log()],self.get_log_stream())
pass
def game_exit_callback(self, *args):
if self._overlay:
unschedule(self._overlay.update)
self._overlay = None
self.win.pop_handlers()
self.win.close()
def pause(self):
if not self.playing: return
clock.unschedule(self.update)
self.player.pause()
self.control.play.setVisible(True)
self.control.pause.setVisible(False)
self.playing = False
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()
def village_scene(dt):
clock.unschedule(spawn_troll)
s.Narration("This time")
s.Narration("They will say")
s.Title("You are the Villain")
clock.schedule_interval(village_callback, 5)
for i in range(counter + 4):
s.Villager(on_death = decrement_counter)
def _update_schedule(self):
clock.unschedule(self.dispatch_events)
if self._playing and self._sources:
interval = 1000.0
if self._sources[0].video_format:
interval = min(interval, 1 / 24.0)
if self._audio:
interval = min(interval, self._audio.UPDATE_PERIOD)
clock.schedule_interval_soft(self.dispatch_events, interval)
def in_transition(self):
for index, transition in enumerate(self.queue):
if transition["phase"] == 0:
del self.queue[index]
if len(self.queue) <= 0:
clock.unschedule(self.tick)
return len(self.queue) > 0
def scene2(dt):
print "scene2"
s.Narration('Why me?')
s.Narration('Alone')
s.Narration('Why me?')
s.Narration('Alone')
s.Narration('This is not fair')
clock.unschedule(spawn_troll)
clock.schedule_interval(spawn_troll, 3)
clock.schedule_once(scene3, 20)
def delete(self):
"""Force immediate removal of the sprite from video memory.
This is often necessary when using batches, as the Python garbage
collector will not necessarily call the finalizer as soon as the
sprite is garbage.
"""
if self._animation:
clock.unschedule(self._animate)
self._vertex_list.delete()
self._vertex_list = None
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 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.unschedule(self.callback)
clock.tick()
self.assertTrue(self.callback_count == 2)
def update(self, dt):
self._total_time += dt
alpha = self._total_time / float(self._duration)
self._label.begin_update()
self._label.x = alpha * (self._x1 - self._x0) + self._x0
self._label.y = alpha * (self._y1 - self._y0) + self._y0
self._label.font_size = alpha * (self._end_font_size - self._init_font_size) + self._init_font_size
self._label.end_update()
if self._total_time > self._duration:
self.window.remove_handlers(self)
clock.unschedule(self.update)
def _set_image(self, img):
if self._animation is not None:
clock.unschedule(self._animate)
self._animation = None
if isinstance(img, image.Animation):
self._animation = img
self._frame_index = 0
self._set_texture(img.frames[0].image.get_texture())
self._next_dt = img.frames[0].duration
clock.schedule_once(self._animate, self._next_dt)
else:
self._set_texture(img.get_texture())
self._update_position()
def delete(self):
"""Force immediate removal of the sprite from video memory.
This is often necessary when using batches, as the Python garbage
collector will not necessarily call the finalizer as soon as the
sprite is garbage.
"""
if self._animation:
clock.unschedule(self._animate)
self._vertex_list.delete()
self._vertex_list = None
self._texture = None
# Easy way to break circular reference, speeds up GC
self._group = None
def callborg(dt):
global ANS, NBSEC
if ANS:
c = ANS.pop()
console.write(c)
console._caret.position = len(console._document.text)
elif ANS==[]:
console.write (' ',attributes={'color': (255, 255, 255, 255)})
console.write ('\n')
console.prompt()
#console._document.delete_text(0, len(console._document.text)-1)
#console._prompt_end = 0
ANS = None
clock.unschedule(callborg)
else: ANS=None
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)
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 update(self, dt):
p = self.properties
p['dx'] += (keyboard[key.RIGHT] - keyboard[key.LEFT]) * 25 * dt
p['dx'] = min(300, max(-300, p['dx']))
if keyboard[key.SPACE]:
if flame not in effectlayer.sprites:
effectlayer.sprites.append(flame)
p['dy'] += 50 * dt
elif flame in effectlayer.sprites:
effectlayer.sprites.remove(flame)
p['dy'] = min(300, max(-300, p['dy']))
gravity = 25
# don't need topleft or topright until I get a ceiling
for point in (self.bottomleft, self.bottomright):
cell = r['level1'].get(*list(map(int, point)))
if cell is None or cell.tile is None:
continue
if 'pad' in cell.tile.properties:
p['done'] = 1
gravity = 0
if p['dy'] < 0:
p['dy'] = 0
p['dx'] = 0
self.bottom = cell.top - 1
elif 'open' not in cell.tile.properties:
p['done'] = 2
clock.unschedule(self.update)
if flame in effectlayer.sprites:
effectlayer.sprites.remove(flame)
boom.center = self.midbottom
if boom not in effectlayer.sprites:
effectlayer.sprites.append(boom)
p['dy'] -= gravity * dt
self.y += p['dy']
self.x += p['dx']
flame.midtop = self.midbottom
def reschedule_once(callback, interval, *args, **kwargs):
clock.unschedule(callback)
clock.schedule_once(callback, interval, *args, **kwargs)
def exit(self):
clock.unschedule(self._update_characters)
def on_key_release(self, symbol, modifiers):
clock.unschedule(self.key_press)
def on_deactivate(self):
clock.unschedule(self.step)
def _leave(self):
# unschedule the various callbacks
clock.unschedule(self.update_callback)
clock.unschedule(self.draw_callback)
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', repr(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
def remove_from_batch(self, batch):
self.titleLabel.delete()
self.titleLabel = None
self.pressAnyKeyLabel.delete()
self.pressAnyKeyLabel = None
clock.unschedule(self.blink)
# collision detection
for shot in list(enemies[0].bullets):
shot.y -= 200 * dt
if shot.overlaps(player):
print('YOU LOST!')
dead = True
break
if shot.y < 0:
enemies[0].bullets.remove(shot)
view.sprites.remove(shot)
for shot in list(player.bullets):
shot.y += 200 * dt
for enemy in list(enemies):
if shot.overlaps(enemy):
view.sprites.remove(enemy)
enemies.remove(enemy)
clock.unschedule(enemy.update)
if shot.y > 512:
player.bullets.remove(shot)
view.sprites.remove(shot)
# end game
if not enemies:
print('YOU WON!')
break
view.clear()
view.draw()
w.flip()
w.close()
def stop(self):
if self.running:
clock.unschedule(self.tick)
self.running = False
def set_fps(self, fps):
self.fps = max(fps, 5)
clock.unschedule(self.update)
clock.schedule_interval(self.update, 1.0 / self.fps)
def on_scene_leave(self):
#glDisable(GL_POINT_SMOOTH)
#glDisable(GL_TEXTURE_2D)
clock.unschedule(self.update)
def on_scene_leave(self):
clock.unschedule(self.update)
def __del__(self):
clock.unschedule(self._spawn)
def remove_from_batch(self, batch):
HudMessage.remove_from_batch(self, batch)
clock.unschedule(self.next_text)
def stop(self):
self._timestamp = 0.0
clock.unschedule(self.dispatch_events)
managed_players.remove(self)
def scene3(dt):
print "scene3"
clock.unschedule(spawn_troll)
clock.schedule_interval(spawn_troll, 2)
s.Choice("I had enough", on_select=pre_village)
def reschedule_once(callback, interval, *args, **kwargs):
clock.unschedule(callback)
clock.schedule_once(callback, interval, *args, **kwargs)
def go_to_state(self, state_id):
unschedule(self.current_state.on_update)
self.current_state_index = state_id
self.update_current_state()
def stop_move(self):
clock.unschedule(self.move)
