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 start(self):
if self.__running:
unschedule(self.update)
self.__running = False
else:
schedule_interval(self.update, self.speed)
self.__running = True
def __init__(self, *args, **kwargs):
# All arguments go to superclass
self.win = window.Window.__init__(self, *args, **kwargs)
clock.schedule_interval(self.update, 1.0 / 30) # update at 30 Hz
clock.schedule_interval(self.create_alien, 1.0 / 5) # update at 5 Hz
self.score = pyglet.text.Label('Score: 0',
font_name="Tahoma",
font_size=14,
x=self.width / 2,
y=10)
self.fpstext = pyglet.text.Label('',
font_name="Tahoma",
font_size=14,
y=10) # object to display the FPS
# loading image
self.spaceship_image = pyglet.image.load('images/ship3.png')
self.spaceship_image.anchor_x = self.spaceship_image.width // 2
self.spaceship_image.anchor_y = self.spaceship_image.height // 2
self.spaceship = Spaceship(self.spaceship_image, x=200, y=50)
self.alien_image = pyglet.image.load('images/invader.png')
self.alien_image.anchor_x = self.spaceship_image.width // 2
self.alien_image.anchor_y = self.spaceship_image.height // 2
self.bullet_image = pyglet.image.load('images/bullet_white_16.png')
self.bullet_image.anchor_x = self.bullet_image.width // 2
self.bullet_image.anchor_y = self.bullet_image.height // 2
self.aliens = []
self.bullets = []
def __init__(self, size, color):
self.zulus = []
self.ruleset = []
self.size = size
self.color = color
# schedule the update function, 60 times per second
clock.schedule_interval(self.update, 1.0 / 120.0)
def __init__(self, width=640, height=480, resizable=True, visible=True):
super(TestWindow, self).__init__(width=width,
height=height,
resizable=resizable,
visible=visible)
self.rpoly = 0.0
clock.schedule_interval(self.update, 0.01)
vertex1 = Vertex([0.0, 1.0, 0.0], color=RED)
vertex2 = Vertex([-1.0, -1.0, 1.0], color=GREEN)
vertex3 = Vertex([1.0, -1.0, 1.0], color=BLUE)
vertex4 = Vertex([1.0, -1.0, -1.0], color=GREEN)
vertex5 = Vertex([0.0, -3.0, -3.0], color=GREEN)
a = Vertex([1.0, 1.0, -1.0], color=RED)
b = Vertex([-1.0, 1.0, -1.0], color=GREEN)
c = Vertex([-1.0, 1.0, -2.0], color=ORANGE)
d = Vertex([-2.0, 1.0, 1.0], color=BLUE)
e = Vertex([1.0, 1.0, 1.0], color=RED)
vertex_list1 = [vertex1, vertex2, vertex3]
vertex_list2 = [vertex1, vertex3, vertex4]
vertex_list3 = [a, b, c, d, e]
self.polygon1 = Polygon(vertex_list1)
self.polygon2 = Polygon(vertex_list2)
self.polygon3 = Polygon(vertex_list3)
glShadeModel(GL_SMOOTH)
glClearColor(1.0, 1.0, 1.0, 0.0) # bg color
glClearDepth(1.0)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
def __init__(self, *args, **kwargs):
self._id = chr((Agent.new_id() % 26) + 97) # converts int to letters
self._items = set()
if args:
self._items.update(args)
else:
self._items.add(dummy)
for i in kwargs:
setattr(self, i, kwargs[i])
if not hasattr(self, 'agenttype'):
self.agenttype = 'persistent'
# default agenttype
if self.agenttype == 'persistent':
_persistent.add(self)
# periodic agents, of course agent must have a 'period' attribute
elif self.agenttype == 'periodic':
_periodic.add(self) # is this necessary ?
schedule_interval(self.tick,
self.period) # or schedule a oneshot agent ?
# will run only once, then erased from list
elif self.agenttype == 'oneshot':
_oneshot.add(self)
# of course agent must have a 'condition' attribute
elif self.agenttype == 'conditional':
_conditional.add(self)
else:
print ':: unrecognized type of agent'
self.setup()
print "::"
print ":: new agent :::::::::::::::::::::::::::::::::::::::::::::::::::"
print "::"
dumpObj(self)
def __init__(self, *args, **kwargs):
#Let all of the arguments pass through
self.win = window.Window.__init__(self, *args, **kwargs)
clock.schedule_interval(self.update, 1.0/30) # update at 30 Hz
clock.schedule_interval(self.create_alien, 1.0/2) # update at 5 Hz
# setting text objects
ft = font.load('Tahoma', 20) #Create a font for our FPS clock
self.fpstext = font.Text(ft, y=10) # object to display the FPS
self.score = font.Text(ft, x=self.width, y=self.height,
halign=pyglet.font.Text.RIGHT,
valign=pyglet.font.Text.TOP)
# loading image
self.spaceship_image = pyglet.image.load('images/ship3.png')
self.spaceship = Spaceship(self.spaceship_image, x=200, y=50)
self.alien_image = pyglet.image.load('images/invader.png')
self.aliens = []
self.bullet_image = pyglet.image.load('images/bullet_white_16.png')
self.bullets = []
def __init__(self, *args, **kwargs):
self._items=set()
if args:
self._items.update(args)
else:
self._items.add(dummy)
for i in kwargs:
setattr(self,i,kwargs[i])
if not hasattr (self,'ruletype'):
self.ruletype='persistent'
# default ruletype
if self.ruletype == 'persistent':
_persistent.add(weakref.ref(self))
# periodic rules, of course rule must have a 'period' attribute
elif self.ruletype == 'periodic':
_periodic.add(weakref.ref(self)) # is this necessary ?
schedule_interval(self,self.period) # or schedule a oneshot rule ?
# will run only once, then erased from list
elif self.ruletype == 'oneshot':
_oneshot.add(weakref.ref(self))
# of course rule must have a 'condition' attribute
elif self.ruletype == 'conditional':
_conditional.add(weakref.ref(self))
else:
print ':: unrecognized type of rule'
self.setup()
print "::"
print ":: new rule :::::::::::::::::::::::::::::::::::::::::::::::::::"
print "::"
dumpObj(self)
def __init__(self,size,color):
self.zulus=[]
self.ruleset=[]
self.size=size
self.color=color
# schedule the update function, 60 times per second
clock.schedule_interval(self.update, 1.0/120.0)
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.keys = window.key.KeyStateHandler()
self.push_handlers(self.keys)
# self.set_exclusive_mouse()
self.width, self.height, self.rat3d, self.ratex = 640, 480, 1.05, 0.5
self.zoom, self.expand, self.mapping, self.blend = 0, 0, 0, 1
self.fgc, self.bgc = (1.0, 1.0, 1.0, 0.9), (0.1, 0.1, 0.1, 0.1)
self.loadfgc, self.loadbgc = (0.4, 0.2, 0.4, 0.3), (0.6, 0.3, 0.6, 0.9)
self.instfgc, self.instbgc = (0.1, 0.1, 0.5, 0.9), (0.5, 0.9, 0.9, 0.8)
self.instbkwidth, self.instbkheight = 480, 400
bmplen = (self.instbkwidth / 8) * self.instbkheight
self.instbkbmp = (ctypes.c_ubyte * bmplen)(*([255] * bmplen))
self.ticktimer, self.tick, self.insttimer, self.inst = 0.5, 0.0, 30, 1
self.printing, self.solver = 1, deque()
self.stat = [None, 0, Queue.Queue(512)] # (key(1-9), direc), count, queue
self.cmax, self.tanim = 18, [6, 3, 1, 3] # frames in rotate moving, speeds
self.tcos, self.tsin = [1.0] * (self.cmax + 1), [0.0] * (self.cmax + 1)
for i in xrange(1, self.cmax):
t = i * math.pi / (2.0 * self.cmax) # 0 < t < pi/2
self.tcos[i], self.tsin[i] = math.cos(t), math.sin(t)
self.tcos[self.cmax], self.tsin[self.cmax] = 0.0, 1.0 # pi/2 regulation
self.InitRot()
self.InitAxis()
self.InitGL(self.width, self.height)
self.textures = [None] * (len(self.ary_norm) * 2 + 1 + len(TEXIMG_CHAR))
self.loading, self.dat = 0, [('', 0, 0)] * len(self.textures)
resource.add_font(FONT_FILE)
self.font = font.load(FONT_FACE, 20)
self.fontcolor = (0.5, 0.8, 0.5, 0.9)
self.fps_display = clock.ClockDisplay(font=self.font, color=self.fontcolor)
self.fps_pos = (-60.0, 30.0, -60.0)
clock.set_fps_limit(60)
clock.schedule_interval(self.update, 1.0 / 60.0)
def __init__(self, *args, **kwargs):
#Let all of the arguments pass through
self.win = window.Window.__init__(self, *args, **kwargs)
self.maxaliens = 50 # max num of aliens simultaneously on the screen
clock.schedule_interval(self.create_alien, 0.5)
clock.schedule_interval(self.update, 1.0/30) # update at FPS of Hz
#clock.set_fps_limit(30)
# setting text objects
ft = font.load('Tahoma', 20) #Create a font for our FPS clock
self.fpstext = font.Text(ft, y=10) # object to display the FPS
self.score = font.Text(ft, x=self.width, y=self.height,
halign=pyglet.font.Text.RIGHT,
valign=pyglet.font.Text.TOP)
# reading and saving images
self.spaceship_image = pyglet.image.load('images/ship3.png')
self.alien_image = pyglet.image.load('images/invader.png')
self.bullet_image = pyglet.image.load('images/bullet_white_16.png')
# create one spaceship
self.spaceship = Spaceship(self.spaceship_image, x=50, y=50)
self.aliens=[] # list of Alien objects
self.bullets=[] # list of Bullet objects
def __init__(self):
super(HelloWorld, self).__init__()
# a cocos.text.Label is a wrapper of pyglet.text.Label
# with the benefit of being a cocosnode
self.left = cocos.sprite.Sprite('foot.png', (300, 100))
self.right = cocos.sprite.Sprite('footr.png', (375, 100))
self.add(self.left)
self.add(self.right)
self.steps = cycle([
random.choice([
self.hop_left,
self.hop_right,
self.wait,
self.step_left,
self.step_right,
self.wiggle,
self.reset,
self.reset,
]) for _ in range(7)] + [self.reset]
)
clock.schedule_interval(self.next_step, 0.5)
def __init__(self, *args, **kwargs):
#Let all of the arguments pass through
self.win = window.Window.__init__(self, *args, **kwargs)
clock.schedule_interval(self.update, 1.0/30) # update at 30 Hz
clock.schedule_interval(self.create_alien, 1.0/2) # update at 5 Hz
# setting text objects
ft = font.load('Tahoma', 20) #Create a font for our FPS clock
self.fpstext = font.Text(ft, y=10) # object to display the FPS
self.score = font.Text(ft, x=self.width, y=self.height,
halign=pyglet.font.Text.RIGHT,
valign=pyglet.font.Text.TOP)
# loading image
self.spaceship_image = pyglet.image.load('images/ship3.png')
self.spaceship = Spaceship(self.spaceship_image, x=200, y=50)
self.alien_image = pyglet.image.load('images/invader.png')
self.aliens = []
self.bullet_image = pyglet.image.load('images/bullet_white_16.png')
self.bullets = []
def __init__(self):
super(HelloWorld, self).__init__()
# a cocos.text.Label is a wrapper of pyglet.text.Label
# with the benefit of being a cocosnode
self.left = cocos.sprite.Sprite('foot.png', (300, 100))
self.right = cocos.sprite.Sprite('footr.png', (375, 100))
self.add(self.left)
self.add(self.right)
self.steps = cycle([
random.choice([
self.hop_left,
self.hop_right,
self.wait,
self.step_left,
self.step_right,
self.wiggle,
self.reset,
self.reset,
]) for _ in range(7)
] + [self.reset])
clock.schedule_interval(self.next_step, 0.5)
def test_view(): global map_width map_ = Map(values.map_width, values.map_height) for i in range(values.banks): map_.add(EnergyBank(map_, random())) for i in range(values.bodies): map_.add(Body(map_, random())) def update(dt): map_.tick() sim = Window(map_.width, map_.height) sim_view = SimView(map_) schedule_interval(update, 0.1) @sim.event def on_draw(): glClearColor(.5, .6, .6, 1) sim.clear() sim_view.draw() graph = Window(500, 100) graph_view = GraphView(map_) @graph.event def on_draw(): graph.clear() graph_view.draw() app.run()
def _schedule_interval_callback(dt, func, interval, *args, **kwargs):
"""
Schedule a callback with specified interval.
Parameters
----------
dt: float
The number of seconds since the last function call.
func:function
The function to call when the timer lapses.
interval: float
The number of seconds to wait between each call
Example
-------
_schedule_interval_callback(dt, function, 1.0)
The function will be called one second after it
was last called.
"""
# schedule it
if interval > 0:
clock.schedule_interval(func, interval, *args, **kwargs)
# call it
func(dt, *args, **kwargs)
def animate(field):
e = Engine(field,fullscreen=True)
# normal loop : run the preview at good rate
clock.schedule_interval(e.paint_a_frame, FRAMERATE)
# and try (soft) to run anim at same speed
clock.schedule_interval_soft(e.tick, FRAMERATE)
pyglet.app.run()
def run(self):
if not self.ticking:
self.ticking = True
clock.schedule_interval(self.tick, 1 / self.get_val('speed'))
self.buttons['tick'].off()
self.buttons['run'].off()
self.buttons['stop'].on()
def main():
# schedule pyglet loop at max framerate
# and the tick function at more than fps
# frame / time driven loop
options = {
'DEBUG': 1,
'PREVIEW_SIZE': (800, 600),
'BGCOLOR': (0.95, 0.95, 0.95, 0), # background
'FPS': 60, # display max framerate
'PicPS': 25, # images per second for movie export
'MODE': 'PREVIEW', # options are: 'FULL'; 'PREVIEW'; 'EXPORT'
'DURATION' : 3,
'SCENE_FOLDER' : 'scene',
}
engine = Engine(**options)
#---run loop options-------------------------------------------------------
if engine.MODE in ('FULL','PREVIEW'):
clock.schedule_interval(engine.frame_paint,1.0/engine.FPS)
clock.schedule_interval_soft(engine.tick, 1.0/(1.0*engine.FPS))
elif engine.MODE == 'EXPORT': # export loop
# try (soft) to run export method at final anim speed,
clock.schedule_interval_soft(engine.export_loop,1.0/engine.PicPS)
# while (soft) run the preview at good rate
#clock.schedule_interval_soft(self.frame_, 1.0/self.FPS,scene)
pyglet.app.run()
def __init__(self, width=640, height=480, resizable=True, visible=True):
super(TestWindow, self).__init__(width=width,
height=height,
resizable=resizable,
visible=visible)
self.viewport = PerspectiveViewport(0, 0, self.width, self.height,
YELLOW, [1.0, 0.5, -5.0],
[0.0, 0.0, 0.0])
self.rpoly = 0.0
self.pressed_key = None
clock.schedule_interval(self.update, 0.01)
clock.schedule_interval(self.update_pressed_key, 0.1)
a = Vertex([1.0, 1.0, -1.0], color=RED)
b = Vertex([-1.0, 1.0, -1.0], color=GREEN)
c = Vertex([-1.0, 1.0, -2.0], color=ORANGE)
d = Vertex([-2.0, 1.0, 1.0], color=BLUE)
e = Vertex([1.0, 1.0, 1.0], color=RED)
vertex_list = [a, b, c, d, e]
self.polygon = Polygon(vertex_list)
glShadeModel(GL_SMOOTH)
glClearColor(1.0, 1.0, 1.0, 0.0) # bg color
glClearDepth(1.0)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
def add_transition(self, previous, next):
self.queue.append({
"previous": previous,
"next": next,
"phase": 1.,
})
clock.schedule_interval(self.tick, 1.0 / 30)
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 __init__(self):
pyglet.window.Window.__init__(self,vsync = True,fullscreen=True)
self.set_mouse_visible(False)
self.bgcolor=bgcolor
self.size_x,self.size_y=self.get_display_size()
self.center= self.size_x*0.5,self.size_y*0.5
self.paused=False
self.camera=Camera((self.center), 0.1)
self.key_actions = {
key.ESCAPE: lambda: exit(),
key.PAGEUP: lambda: self.camera.zoom(2),
key.PAGEDOWN: lambda: self.camera.zoom(0.5),
key.LEFT: lambda: self.camera.pan(self.camera.scale, -1.5708),
key.RIGHT: lambda: self.camera.pan(self.camera.scale, 1.5708),
key.DOWN: lambda: self.camera.pan(self.camera.scale, 3.1416),
key.UP: lambda: self.camera.pan(self.camera.scale, 0),
key.COMMA: lambda: self.camera.tilt(-1),
key.PERIOD: lambda: self.camera.tilt(+1),
key.P : lambda: self.toggle_pause(),
}
self.gl_setup()
# schedule the update function at 'fps' times per second
clock.schedule_interval(self.update, 1.0/100.0)
clock.set_fps_limit(max_fps)
def animate():
VIEW.set_fullscreen(True)
# normal loop : run the preview at good rate
# clock.schedule_interval(paint, FRAMERATE)
# and try (soft) to run anim at same speed
clock.schedule_interval(tick, FRAMERATE)
pyglet.app.run()
def __init__(self, *k, **d):
super(Window, self).__init__(*k, **d)
self.img = pyglet.resource.image('undo.png')
self._enable_alpha()
self._load_cursors()
clock.schedule_interval(self.update, 1/60.0)
self.logo = Logo()
def __init__(self, *args, **kwargs):
self._id = chr((Agent.new_id()%26)+97) # converts int to letters
self._items=set()
if args:
self._items.update(args)
else:
self._items.add(dummy)
for i in kwargs:
setattr(self,i,kwargs[i])
if not hasattr (self,'agenttype'):
self.agenttype='persistent'
# default agenttype
if self.agenttype == 'persistent':
_persistent.add(self)
# periodic agents, of course agent must have a 'period' attribute
elif self.agenttype == 'periodic':
_periodic.add(self) # is this necessary ?
schedule_interval(self.tick,self.period) # or schedule a oneshot agent ?
# will run only once, then erased from list
elif self.agenttype == 'oneshot':
_oneshot.add(self)
# of course agent must have a 'condition' attribute
elif self.agenttype == 'conditional':
_conditional.add(self)
else:
print ':: unrecognized type of agent'
self.setup()
print "::"
print ":: new agent :::::::::::::::::::::::::::::::::::::::::::::::::::"
print "::"
dumpObj(self)
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 __init__(self):
super(GameWindow, self).__init__()
clock.schedule_interval(self.on_update, 1.0 / 60)
self.quad_sprite = Quad(self, 1, 1, scale=3)
self.game_map = Map(self, 0, 0)
app.run()
def animate(cls):
VIEW.set_fullscreen(True)
cls.focus()
# normal loop : run the preview at good rate
clock.schedule_interval(cls.redraw, FRAMERATE)
# and try (soft) to run anim at same speed
clock.schedule_interval(cls.tick, FRAMERATE)
pyglet.app.run()
def __init__(self, difficulties, camera):
self.difficulties = difficulties
self.counter = 0
self.labels = deque()
self.credit_it = self.credit_text()
self.camera = camera
schedule_interval(self.update_position, 0.017)
schedule_once(self.update_text, 0)
def scene1():
print "scene1"
s.Narration('Sending me into the snow-storm')
s.Narration('Without any help')
s.Narration('Again')
s.Narration('Alone')
clock.schedule_interval(spawn_troll, 5)
clock.schedule_once(scene2, 20)
def animate(cls):
VIEW.set_fullscreen(True)
cls.focus()
# normal loop : run the preview at good rate
clock.schedule_interval(cls.redraw, FRAMERATE)
# and try (soft) to run anim at same speed
clock.schedule_interval(cls.tick, FRAMERATE)
pyglet.app.run()
def run(self):
if self.mode in ('FULL', 'PREVIEW'): # normal loop
# run the preview at good rate
clock.schedule_interval(self.frame_paint, self.framerate)
# and try (soft) to run export method at final anim speed,
clock.schedule_interval_soft(self.tick, self.framerate)
elif self.mode == 'EXPORT': # trigger the export loop
clock.schedule_interval_soft(self.pic_export_loop, movie_framerate)
pyglet.app.run()
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 run(self):
if MODE in ('FULLSCREEN', 'PREVIEW'): # normal loop
# run the preview at good rate
clock.schedule_interval(self.frame_paint, FRAMERATE)
# and try (soft) to run export method at final anim speed,
clock.schedule_interval_soft(self.tick, FRAMERATE)
elif MODE == 'EXPORT': # trigger the export loop
clock.schedule_interval_soft(self.pic_export_loop, MOVIE_FRAMERATE)
pyglet.app.run()
def run(self):
if MODE in ('FULLSCREEN', 'PREVIEW'): # normal loop
# run the preview at good rate
clock.schedule_interval(self.frame_paint, FRAMERATE)
# and try (soft) to run export method at final anim speed,
clock.schedule_interval_soft(self.tick, FRAMERATE)
elif MODE == 'EXPORT': # trigger the export loop
clock.schedule_interval_soft(self.pic_export_loop, MOVIE_FRAMERATE)
pyglet.app.run()
def __init__(self): """This is run when the game is created""" super(main_menu, self).__init__() self.keyboard = KeyStateHandler() self.set_handlers(self.keyboard) # Call update() 60 times a second clock.schedule_interval(self.update, 1/60.0)
def __init__(self, parent, step=16):
super(KBHandler, self).__init__(self)
self.parent = parent
self.parent.push_handlers(self)
clock.schedule_interval(self.update, 1/60.0)
self.repeat = 0
self.step = step
self._KEYS = set([key.UP, key.DOWN, key.LEFT, key.RIGHT, key.K, key.J,
key.H, key.L])
def _schedule_interval_callback(dt, func, interval, *args, **kwargs):
"""
Schedule a callback with specified interval.
"""
# schedule it
if interval > 0:
clock.schedule_interval(func, interval, *args, **kwargs)
# call it
func(dt, *args, **kwargs)
def _schedule_interval_callback(dt, func, interval, *args, **kwargs):
"""
Schedule a callback with specified interval.
"""
# schedule it
if interval > 0:
clock.schedule_interval(func, interval, *args, **kwargs)
# call it
func(dt, *args, **kwargs)
def run(self):
if self.mode in ('FULL', 'PREVIEW'): # normal loop
# run the preview at good rate
clock.schedule_interval(self.frame_paint, self.framerate)
# and try (soft) to run export method at final anim speed,
clock.schedule_interval_soft(self.tick, self.framerate)
elif self.mode == 'EXPORT': # trigger the export loop
clock.schedule_interval_soft(self.pic_export_loop, movie_framerate)
pyglet.app.run()
def _update_flags(self):
"""Update OpenGL state based on the current flags.
"""
clock.set_fps_limit(self._animate_rate)
glLineWidth(float(self._line_width))
clock.unschedule(SceneViewer.time_event)
if self._flags['animate'] or self._flags['record']:
clock.schedule_interval(SceneViewer.time_event,
1.0 / self._animate_rate, self)
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 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, *args, **kwargs):
#Let all of the arguments pass through
self.win = window.Window.__init__(self, *args, **kwargs)
clock.schedule_interval(self.update, 1.0 / 30) # update at 30 Hz
# setting text objects
ft = font.load('Tahoma', 20) #Create a font for our FPS clock
self.fpstext = font.Text(ft, y=10) # object to display the FPS
def __init__(self, *args, **kwargs):
#Let all of the arguments pass through
self.win = window.Window.__init__(self, *args, **kwargs)
clock.schedule_interval(self.update, 1.0/30) # update at 30 Hz
# setting text objects
ft = font.load('Tahoma', 20) #Create a font for our FPS clock
self.fpstext = font.Text(ft, y=10) # object to display the FPS
def __init__(self,land):
pyglet.window.Window.__init__(self,fullscreen=True)
self.set_mouse_visible(False)
self.land=land
glClearColor(self.land.color[0],self.land.color[1],\
self.land.color[2],self.land.color[3])
#glClearColor(1.0, 1.0, 1.0, 1.0) # set background color to white
glLoadIdentity() # reset transformation matrix
# schedule the update function, 60 times per second
clock.schedule_interval(self.update, 1.0/30.0)
def __init__(self, main_menu, keyboard, *args, **kwargs):
super(Select, self).__init__(*args, **kwargs)
# Reference the keyboard object so that we can watch it
self.keyboard = keyboard
self.main_menu = main_menu
# Call move_player() 60 times a second
clock.schedule_interval(self.move, 1/60.0)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# batch for efficient drawing
self.batch = graphics.Batch()
background = graphics.OrderedGroup(0)
foreground = graphics.OrderedGroup(1)
self.gamelayer = graphics.OrderedGroup(2)
toplayer = graphics.OrderedGroup(3)
# window size
self.size = self.get_size()
# start with empty asteroid set
self.asteroids = set()
# empty explosions set
self.explosions = set()
# background and moving foreground sprites
self.background = physicalobject.ScaledMovingSprite(img=resources.background_image,
screensize=self.size, batch=self.batch, group=background)
self.debris = load.debris(screensize=self.size, batch=self.batch, group=foreground)
self.splashscreen = load.ClickableSprite(hook_function=self.start,
img=resources.splashscreen,
x = self.size[0] / 2.0, y=self.size[1] / 2.0,
batch=self.batch, group=toplayer)
# player ship
self.player = load.ship(screensize=self.size, batch=self.batch, group=self.gamelayer)
self.score = 0
self.lives = LIVES
self.started = False
self.fps_display = clock.ClockDisplay()
# Lives and score labels
self.lives_label = text.Label(font_size=20, text="Lives: %d" % self.lives, x=40, y=self.size[1]-40,
batch=self.batch, group=toplayer)
self.score_label = text.Label(font_size=20, anchor_x='right', text="Score: %d" % self.score, x=self.size[0]-40,
y=self.size[1]-40, batch=self.batch, group=toplayer)
# update frequency
clock.schedule_interval(self.update, 1 / 120)
# spawn a new asteroid each second
clock.schedule_interval(self.spawn_asteroid, 1)
# add event handlers to the ship and splashscreen
self.push_handlers(self.player)
self.push_handlers(self.splashscreen)
def main():
import ctypes
import time
from pyglet import app, clock, font, gl, image, window
from MusicDefs import MusicDefs
#pic = PianoOctavePic(width=400, height=200)
pic = HexagonalLayoutPic(D=100, scale=SCALE_MAJOR_DIATONIC, tonic=1, h=4)
window = window.Window(width=pic.width, height=pic.height)
#ft = font.load('Arial', 24)
#text = font.Text(ft, 'Hello World')
# create data shared by ImageSurface and Texture
data = (ctypes.c_ubyte * (pic.width * pic.height * 4))()
stride = pic.width * 4
surface = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
pic.width, pic.height, stride)
texture = image.Texture.create_for_size(gl.GL_TEXTURE_2D,
pic.width * pic.height, gl.GL_RGBA)
def update_surface(dt, surface):
ctx = cairo.Context(surface)
pic.draw_pic(ctx)
@window.event
def on_draw():
window.clear()
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture.id)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, pic.width, pic.height,
0, gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, data)
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0, 1.0)
gl.glVertex2i(0, 0)
gl.glTexCoord2f(1.0, 1.0)
gl.glVertex2i(pic.width, 0)
gl.glTexCoord2f(1.0, 0.0)
gl.glVertex2i(pic.width, pic.height)
gl.glTexCoord2f(0.0, 0.0)
gl.glVertex2i(0, pic.height)
gl.glEnd()
#text.draw()
#print('FPS: %f' % clock.get_fps())
clock.schedule_interval(update_surface, 1 / 120.0, surface)
app.run()
def set_screen(self, next_screen: "Screen") -> None:
"""Change the active screen.
:param next_screen: The new screen to be active.
"""
if self.screen:
self.window.pop_handlers()
unschedule(self.screen.update)
self.window.push_handlers(next_screen.on_draw)
schedule_interval(next_screen.update, 0.01)
self.screen = next_screen
def start_moving(self):
clock.schedule_interval(self.update, 1 / 60.0)
if (self.facing == Direction.SOUTH):
self.image = Player.south_animation
elif (self.facing == Direction.WEST):
self.image = Player.west_animation
elif (self.facing == Direction.NORTH):
self.image = Player.north_animation
else:
self.image = Player.east_animation
self.is_moving = True
def __init__(self, parent_x: int, parent_y: int, parent_w: int,
parent_h: int):
super().__init__(parent_x, parent_y, parent_w, parent_h)
self.jitter = 2
self._x = int(parent_x + (parent_w / 2))
self.sway_right = True
self._y = parent_y
self.x = randint(self._x - self.jitter, self._x + self.jitter)
self.y = self._y
clock.schedule_interval(self.set_x, 0.25)
def __init__(self):
super(Main, self).__init__()
clock.schedule_interval(self.new_triangle, 0.25)
#car = SImage('res/ring.png',0,0)
#self.world.objects.append(car)
w = self.win.width / 10.0
h = self.win.height / 10.0
for i in range(11):
s = SImage('res/ring.png', i * w, i * h)
self.world.objects.append(s)
def __init__(self,
width,
height,
caption='Window Caption',
bg=(0, 0, 0),
ticktime=0,
*args,
**kwargs):
"""
Window constructor.
:type width: int
:param width: width
:type height: int
:param height: height
:type caption: str
:param caption: caption
:type bg: list(int * 3)
:param bg: background color
:type ticktime: float
:param ticktime: interval between ticks in seconds, zero to disable ticking
"""
super().__init__(width=width,
height=height,
caption=caption,
*args,
**kwargs)
self.set_minimum_size(width, height)
self.real_width, self.real_height = width, height
self.set_bg(bg)
self._batch = _graphics.Batch()
self.screens = {}
self.buttons = {}
self.labels = {}
self.fields = {}
self.sliders = {}
self.labelrows = {}
self.boxes = {}
self.valset = ValSet()
self.focus = None
self.hover = None
self.mousedown = False
self.set_vars()
self.update_labels()
self.ticktime = ticktime
if ticktime > 0:
_clock.schedule_interval(self.tick, ticktime)
'''
def login(self, dt):
# we'll do the below to login and recieve a list of characters.
self.connect(self.LoginWindow.serverIP.text,
int(self.LoginWindow.serverPort.text))
# set our client_name for future sending.
self.client_name = self.LoginWindow.username.text
command = Command(self.LoginWindow.username.text, "login", ["noargs"])
self.send(command)
# -------------------------------------------------------
clock.schedule_interval(self.check_messages_from_server, 0.1)
def __init__(self, start=0, factor=1., freq=1/120.):
''' if we suppose the refresh frequency is 60hz,
the timer must run at least two times faster
in case an out of sync rendering occurs,
wich leads to glitches.
recomputing the timer on every frame is safer
if we need high fréquency or expect slowdowns.
'''
self.init = time.time()
self.start = start
self.factor = factor
self.time = start
schedule_interval(self.update, freq)
def __init__(self, parent_x: int, parent_y: int, parent_w: int,
parent_h: int, get_trunk_y: classmethod,
get_trunk_w: classmethod):
super().__init__(parent_x, parent_y, parent_w, parent_h)
self.get_trunk_y = get_trunk_y
self.get_trunk_w = get_trunk_w
self.x_jitter = 1
self.y_jitter = 3
self.t_num = 1
self.t_variance = 1
clock.schedule_interval(self.set_x, 0.50)
clock.schedule_interval(self.set_y, 0.12)
