def on_draw(self):
rabbyt.clear()
# glBegin(GL_LINES)
# glVertex3f(0,0,0)
# glVertex3f(10,0,0)
# glEnd()
self.system.draw()
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 continue_level(self):
"""continues"""
if self.game.get_ticks() - self.game.fps > 1000:
print "FPS: ", self.game.clock.get_fps()
self.game.fps = self.game.get_ticks()
self.handle_user_events()
if self.saving:
self.handle_save()
#Timing
rabbyt.set_time(self.get_ticks()/1000.0)
rabbyt.scheduler.pump()
rabbyt.clear()
#Update
self.update_UI()
self.update_game_objects()
self.handle_collisions_between(self.ship, self.enemies)
self.handle_collisions_between(self.ship, self.enemy_bullets)
self.handle_collisions_between(self.bullets, self.enemies)
self.handle_collisions_between(self.past_selves, self.enemies)
self.handle_collisions_between(self.past_selves, self.enemy_bullets)
self.handle_item_pickups_between(self.ship, self.items)
#Render
self.render_game_objects()
self.game.clock.tick(40)
pygame.display.flip()
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 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 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 on_draw(): rabbyt.clear() gun.render() rabbyt.render_unsorted(aliens) rabbyt.render_unsorted(bullets_my) rabbyt.render_unsorted(bullets_alien) win.flip()
def loop(self):
"""
And here is our main game loop! In case you are new to game programming
this is what is called every frame. This is where we will handle the
display and stuff.
"""
# clock.tick is used for keeping track of time and limiting the frame
# rate.
self.clock.tick()
self.window.dispatch_events()
# And this is where that mysterious "time" comes in. This way rabbyt
# knows how much time has passed and can do the awesome animations.
rabbyt.set_time(self.time)
# If you are new to this sort of thing rabbyt.clear clears the screen
# (erases what was drawn last loop). We pass white as the color that we
# want to clear it with.
rabbyt.clear((1,1,1,1))
# And now we draw our blocks and smile face.
for b in self.blocks.values():
b.draw()
if self.game.gameover == True:
if self.game.won == False:
self.dead_face.render()
else:
self.won_face.render()
else:
self.smile_face.render()
# This draws the buffer onto the screen. Without this we would be
# staring at a blank screen.
self.window.flip()
def run(queue):
running = True
game = Game(1240, 780)
while running:
clock.tick(40)
for event in pygame.event.get():
running &= game.handle_event(event)
try:
item = queue.get(False)
update = simplejson.loads(item)
for (key, value) in update.iteritems():
print Piece._items[update['id']], key, value
current = getattr(Piece._items[update['id']], key)
setattr(Piece._items[update['id']], key, rabbyt.lerp(current, value, dt=200))
except Empty:
pass
#game.render()
rabbyt.set_time(pygame.time.get_ticks())
rabbyt.clear()
rabbyt.render_unsorted(game.boards)
rabbyt.render_unsorted(game.pieces)
rabbyt.scheduler.pump()
pygame.display.flip()
def on_draw(self):
rabbyt.clear()
# Draw the current scene
if self.current_scene is not None:
self.current_scene.on_draw()
# Draw fps
rabbyt.set_viewport((self.width, self.height), projection=self.static_projection())
self.fps_display.draw()
def on_draw():
rabbyt.clear(rgba=CLEAR_COLOR_DEFAULT)
rabbyt.set_viewport(
get_viewport(window.width, window.height),
WORLD_BOUNDS
)
draw_glyphs()
draw_sprites()
def on_draw(self):
if self.scale_needed(): self.viewport.begin()
rabbyt.clear()
self.reset_color_hack()
self.draw_fps()
if self.scale_needed(): self.viewport.end()
def on_draw(self):
if self.fullscreen: self.viewport.begin()
rabbyt.clear()
rabbyt.render_unsorted(sprites)
fps_display.label.color = (0.0, 0.0, 0.0, 0.5)
fps_display.label.draw()
fps_display.label.color = (1.0, 1.0, 1.0, 0.5)
fps_display.label.draw()
if self.fullscreen: self.viewport.end()
def run(self, game, state_stack):
"""Makes the Cutscene run"""
game.set_state_time()
scene = rabbyt.Sprite("1cutscene.png")
scene.scale = 0.95
scene.y = -60
scene.alpha = rabbyt.lerp(0.0, 0.8, startt=1, endt=8)
scene.x = rabbyt.lerp(-20, 60, startt=1, endt=6)
scene2 = rabbyt.Sprite("1cutscene2.png")
scene2.alpha = rabbyt.lerp(0.8, 0.0, startt=6, endt=13)
scene2.scale = 0.95
scene2.xy = (60, -60)
words = FontSprite(game.font, "Scientist: I'll be back soon.")
words.xy = (-195, -250)
#set music
pygame.mixer.music.stop()
pygame.mixer.music.load('scene1.wav')
pygame.mixer.music.play()
game.done = False
while not game.done:
rabbyt.clear()
rabbyt.set_time(game.get_ticks()/1000.0)
ticks = game.get_ticks()/1000.0
if ticks < 6:
scene.render()
if ticks >= 6:
scene2.render()
if ticks >= 14:
game.done = True
state_stack.append(states.name.Name())
words.render()
for event in pygame.event.get():
if event.type == QUIT:
game.done = True
fdata = open("RabbitHighScores", 'w')
for i in range(5):
fdata.write(game.high_score_names[i] + " " \
+ str(game.high_scores[i]) + "\n")
if event.type == KEYDOWN:
if event.key == K_ESCAPE or event.key == K_RETURN:
game.done = True
state_stack.append(states.name.Name())
elif event.type == pygame.JOYBUTTONDOWN and game.joystick.get_button(game.controls.settings["Escape"]):
game.done = True
state_stack.append(states.name.Name())
pygame.display.flip()
def on_draw(self):
if self.scale_needed(): self.viewport.begin()
rabbyt.clear()
self.reset_color_hack()
self.bg.blit(0, 0, 0)
self.sprite.render()
rabbyt.render_unsorted(self.factory.bullets)
fps_display.label.draw()
if self.scale_needed(): self.viewport.end()
def on_draw(self):
if self.scale_needed(): self.viewport.begin()
rabbyt.clear()
self.reset_color_hack()
self.bg.blit(0, 0, 0)
rabbyt.render_unsorted(self.sprites)
self.draw_fps()
if self.scale_needed(): self.viewport.end()
def loop(self):
dt = clock.tick()
self.time += dt
self.window.dispatch_events()
rabbyt.set_time(self.time)
rabbyt.clear()
self.gui.render()
self.bg_overlay.render()
self.selection_marker.render()
self.window.flip()
return True
def run(self, game, state_stack):
"""starts the menu state"""
backg = rabbyt.Sprite('1Menu_Screen1.png')
self.game = game
self.state_stack = state_stack
self.menu_option = 0
self.game.user.score = 0
text_start = FontSprite(game.font, "Start Game")
text_instruct = FontSprite(game.font, "Instructions")
text_score = FontSprite(game.font, "High Scores")
text_quit = FontSprite(game.font, "Quit")
#set menu item positions
text_start.xy = (-65, 100)
text_instruct.xy = (-70, 50)
text_score.xy = (-70, 0)
text_quit.xy = (-19, -50)
self.menu_items = [ text_start, \
text_instruct, \
text_score, \
text_quit]
self.highlight()
game.done = False
while not game.done:
pygame.event.pump()
for event in pygame.event.get():
if event.type == QUIT:
pass
#self.quit()
elif event.type == KEYDOWN:
self.key_press(event.key)
elif event.type == pygame.JOYBUTTONDOWN:
self.handle_joy()
rabbyt.clear()
backg.render()
text_start.render()
text_instruct.render()
text_score.render()
text_quit.render()
pygame.display.flip()
game.clock.tick(40)
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 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 on_draw(self):
if self.scale_needed(): self.viewport.begin()
rabbyt.clear()
self.reset_color_hack()
self.bg.blit(0, 0, 0)
self.sprite.render()
for shot in self.sprite.shots:
for factory in shot.factories:
rabbyt.render_unsorted(factory.bullets)
self.fps_display.label.draw()
self.coll_ctr.draw()
if self.scale_needed(): self.viewport.end()
def run():
running = True
game = Game(1240, 780)
while running:
clock.tick(40)
for event in pygame.event.get():
running &= game.handle_event(event)
#game.render()
rabbyt.set_time(pygame.time.get_ticks())
rabbyt.clear()
rabbyt.render_unsorted(game.boards)
rabbyt.render_unsorted(game.pieces)
rabbyt.scheduler.pump()
pygame.display.flip()
def run(self, game, state_stack):
header = rabbyt.Sprite('1bunny3.png')
font = Font(pygame.font.Font(None, 80))
name_list = []
score_list = []
for i in range(5):
temp = FontSprite(font, str(game.high_score_names[i]))
temp2 = FontSprite(font, str(game.high_scores[i]))
temp.rgb = (255, 255, 255)
temp2.rgb = (255, 255, 255)
temp.xy = (-220, 87 - 55*i)
temp2.xy = (150, 87 - 55*i)
name_list.append(temp)
score_list.append(temp2)
game.done = False
while not game.done:
rabbyt.clear()
header.render()
for name, score in zip(name_list, score_list):
name.render()
score.render()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.done = True
fdata = open("RabbitHighScores", 'w')
for i in range(5):
fdata.write(game.high_score_names[i] + " " + \
str(game.high_scores[i]) + "\n")
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE or event.key == \
pygame.K_RETURN:
game.done = True
state_stack.append(states.menu.Menu())
elif event.type == pygame.JOYBUTTONDOWN and game.controls.settings["Escape"]:
game.done = True
state_stack.append(states.menu.Menu())
game.clock.tick(40)
pygame.display.flip()
def TitleScreen(self, state_stack):
""" Title Screen"""
self.frame = 0
self.done = False
"""rabbit_screen = rabbyt.Sprite
('8jumping_rabbit.png', (-321,184.5,321,-184.5))
rabbit_tex_shapes = settings.get_tex_shapes(rabbit_screen.tex_shape, 8)"""
while not self.done:
self.clock.tick(40)
if pygame.time.get_ticks() - self.fps > 1000:
print "FPS: ", self.clock.get_fps()
self.fps = pygame.time.get_ticks()
for event in pygame.event.get():
if event.type == QUIT:
self.done = True
fdata = open("RabbitHighScores", 'w')
for i in range(5):
fdata.write(self.highScoreNames[i] + \
" " + str(self.highScores[i]) + "\n")
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.done = True
fdata = open("RabbitHighScores", 'w')
for i in range(5):
fdata.write(self.highScoreNames[i] + \
" " + str(self.highScores[i]) + "\n")
## Some sample reaction to events.
elif event.key == K_SPACE:
## This screen will end and go to another screen.
self.done = True
state_stack.append("Menu Screen")
rabbyt.set_time(pygame.time.get_ticks()/1000.0)
rabbyt.scheduler.pump()
rabbyt.clear()
#self.animate(rabbit_screen, rabbit_tex_shapes)
#rabbit_screen.render()
pygame.display.flip()
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 run(self, game, state_stack):
backg = rabbyt.Sprite('1Menu_Screen1.png')
self.actions = ["Up", "Down", "Left", "Right", "Fire", "Tilt left", "Tilt right", "Boost", "Toggle time travel", "Skip", "Escape"]
self.index = 0
self.instruction_text = FontSprite(game.font, "Press the key you would like to correspond to the given action")
self.instruction_text.x = -380
self.instruction_text.y = 100
self.action_text = FontSprite(game.font, self.actions[self.index])
self.action_text.x = -380
self.game = game
game.controls = user_settings.UserSettings()
game.done = False
while not self.game.done:
rabbyt.clear()
backg.render()
self.action_text.render()
self.instruction_text.render()
self.game.clock.tick(40)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game.done = True
fdata = open("RabbitHighScores", 'w')
for i in range(5):
fdata.write(self.game.high_score_names[i] + " " + \
str(self.game.high_scores[i]) + "\n")
elif event.type == pygame.locals.JOYBUTTONDOWN: # 10
print 'button down'
game.controls.settings[self.actions[self.index]] = event.button
self.index += 1
if self.index >= len(self.actions):
print game.controls.settings
game.done = True
break
self.action_text = FontSprite(game.font, self.actions[self.index])
self.action_text.x = -380
print self.index
print len(self.actions)
pygame.display.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 main():
clock.schedule(rabbyt.add_time)
window.game_window = Window(width=SCREEN_WIDTH, height=SCREEN_HEIGHT)
rabbyt.set_default_attribs()
bgPat = pyglet.image.SolidColorImagePattern((200,200,200,255))
bg = pyglet.image.create(window.game_window.width, window.game_window.height, bgPat)
dog = Dog()
mowr = mower.Mower()
guage = mower.Guage(mowr)
bubbles.init()
pooMaster = PooMaster()
events.Fire('NewStage', narrative.foreshadowing)
objs = [dog, mowr, guage]
while not window.game_window.has_exit:
tick = clock.tick()
window.game_window.dispatch_events()
bubbles.bubbleMaker.update(tick)
for obj in objs:
obj.update(tick)
events.ConsumeEventQueue()
rabbyt.clear((1, 1, 1))
bg.blit(0,0)
mowr.draw()
guage.draw()
pooMaster.draw()
dog.draw()
bubbles.bubbleMaker.draw()
window.game_window.flip()
def on_draw(self):
"""
Draw method to be called on every frame.
"""
rabbyt.set_time(self.time)
# Handle player movement due to keyboard/mouse input.
if self.keyboard[KEYBOARD_CONTROLS["UP"]]:
self.player.mup(PLAYER_SPEED_FORWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["DOWN"]]:
self.player.mdown(PLAYER_SPEED_FORWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["RIGHT"]]:
self.player.mright(PLAYER_SPEED_FORWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["LEFT"]]:
self.player.mleft(PLAYER_SPEED_FORWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["FORWARD"]] or \
self.mouse & MOUSE_CONTROLS["MOUSEMOVE"] == MOUSE_CONTROLS["MOUSEMOVE"]:
self.player.forward(PLAYER_SPEED_FORWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["BACKWARD"]]:
self.player.backward(PLAYER_SPEED_BACKWARD * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["STRAFE_RIGHT"]]:
self.player.strafe_right(PLAYER_SPEED_STRAFE * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["STRAFE_LEFT"]]:
self.player.strafe_left(PLAYER_SPEED_STRAFE * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["TURN_RIGHT"]]:
self.player.turn_right(PLAYER_TURN_SPEED * self.dt)
if self.keyboard[KEYBOARD_CONTROLS["TURN_LEFT"]]:
self.player.turn_left(PLAYER_TURN_SPEED * self.dt)
# Turn the player to face the mouse if we need to.
if (self.mouse & MOUSE_CONTROLS["FACE"] or PLAYER_ALWAYS_FACE_MOUSE) and \
self.mousex is not None and self.mousey is not None:
# Calculate the x, y coordinates of the click based on the given
# screen coordinates.
self.player.face(
self.mousex + self.player.x - self.window.get_size()[0] / 2,
self.mousey + self.player.y - self.window.get_size()[1] / 2)
# Update the sprite used based on the player's facing direction and movement.
self.player.updatedir()
# Update the player's x, y coordinates.
self.player.updatepos()
# Keep the player inside the map.
self.player.clamp(0, MAP_HEIGHT * MAP_TILE_SIZE,
MAP_WIDTH * MAP_TILE_SIZE, 0)
# Reset the screen to a blank state.
rabbyt.clear((0, 0, 0, 1))
# Center the viewable area around the player.
self.view(self.player.x - self.window.get_size()[0] / 2,
self.player.y - self.window.get_size()[1] / 2)
# Do the drawing.
# Determine which tile the player is on.
tilex = int(self.player.x / MAP_TILE_SIZE)
tiley = int(self.player.y / MAP_TILE_SIZE)
# Determine how many tiles need to be drawn on the screen on each side
# of the player (the center).
tilecountx = int(self.window.get_size()[0] / (MAP_TILE_SIZE * 2)) + 2
tilecounty = int(self.window.get_size()[1] / (MAP_TILE_SIZE * 2)) + 2
startx = max(0, tilex - tilecountx)
endx = min(MAP_WIDTH, tilex + tilecountx)
starty = max(0, tiley - tilecounty)
endy = min(MAP_HEIGHT, tiley + tilecounty)
# Draw the background terrain.
terrain = self.terrain
for x in range(startx, endx):
for y in range(starty, endy):
terrain[x][y].left = x * MAP_TILE_SIZE
terrain[x][y].bottom = y * MAP_TILE_SIZE
terrain[x][y].render()
# Draw the player.
self.player.render()
# Set the render mode to HUD mode.
self.hud()
# Draw the FPS. This is a Pyglet sprite and not a Rabbyt sprite, so we
# use .draw() instead of .render().
self.fps_display.draw()
def maybe_shoot():
if held['shoot']:
shot = rabbyt.Sprite("bullet.png")
shot.x = player.x
shot.y = player.y
shot.scale = 0.25
bullets.append(shot)
def move_bullets():
for bullet in bullets:
bullet.x += game_settings['bullet-speed']
while keep_running:
handle_events()
rabbyt.clear()
maybe_shoot()
move_sprites()
move_bullets()
bg.render()
player.render()
# This seems to get about 1FPS more, oh boy
rabbyt.render_unsorted(bullets)
rabbyt.render_unsorted(sprites)
#pygame.display.set_caption("%i objects" % len(sprites))
pygame.display.set_caption('FPS: %6.2f' % the_clock.get_fps())
pygame.display.flip()
for i in range(2400):
s = rabbyt.Sprite("rounded_square.png")
s.rgba = lerp((.5, .2, 1, .2), (0, .8, 0, .6),
dt=3 * r() + 2,
extend="reverse")
s.x = wrap([-320, 320],
lerp(r() * 640, r() * 640, dt=2, extend="extrapolate"))
s.y = wrap([-240, 240],
lerp(r() * 480, r() * 480, dt=2, extend="extrapolate"))
s.scale = lerp(.1, 1, dt=r() + .75, extend="reverse")
s.rot = lerp(0, 360, dt=2, extend="extrapolate")
sprites.append(s)
print "Drawing 2400 sprites..."
c = pygame.time.Clock()
last_fps = 0
while not pygame.event.get(pygame.QUIT):
c.tick()
if pygame.time.get_ticks() - last_fps > 1000:
print "FPS: ", c.get_fps()
last_fps = pygame.time.get_ticks()
rabbyt.clear()
rabbyt.set_time(pygame.time.get_ticks() / 1000.0)
rabbyt.render_unsorted(sprites)
pygame.display.flip()
l, t, r, b = self.font.get_char_tex_shape(char)
self.char_sprites.append(
rabbyt.Sprite(texture=self.texture_id,
shape=(x, 0, x + w, -h),
tex_shape=self.font.get_char_tex_shape(char),
rgba=self.attrgetter('rgba')))
x += w + 1
text = property(_get_text, _set_text, doc="the text to be displayed")
def render_after_transform(self):
rabbyt.render_unsorted(self.char_sprites)
if __name__ == "__main__":
pygame.init()
pygame.display.set_mode((640, 480), pygame.OPENGL | pygame.DOUBLEBUF)
rabbyt.set_viewport((640, 480))
rabbyt.set_default_attribs()
font = Font(pygame.font.Font(pygame.font.get_default_font(), 20))
sprite = FontSprite(font, "hello world")
sprite.rot = rabbyt.lerp(0, 360, dt=6, extend="repeat")
sprite.x = 100
sprite.rgb = 0, 1, 1
while not pygame.event.get(pygame.QUIT):
rabbyt.clear((0, .5, .5, 1))
rabbyt.set_time(pygame.time.get_ticks() / 1000)
sprite.render()
pygame.display.flip()
# But note that all times will be in *seconds*, not milliseconds like when we
# use pygame.time.get_ticks().
clock.schedule(rabbyt.add_time)
window = Window(width=640, height=480)
rabbyt.set_default_attribs()
car = rabbyt.Sprite("car.png")
# Rabbyt automatically detected that we are using pyglet, and used pyglet
# to load the texture.
assert isinstance(car.texture, image.Texture)
car.xy = (320, 240)
# Fade the car in after one second.
car.alpha = rabbyt.lerp(0.0, 1.0, startt=1, endt=2)
# Rotate the car from 0 to 360 over three seconds, then repeat.
car.rot = rabbyt.lerp(0, 360, dt=3, extend="repeat")
while not window.has_exit:
clock.tick()
window.dispatch_events()
rabbyt.clear((1, 1, 1))
car.render()
window.flip()
import rabbyt
import pygame
# This is pretty much the bare minimum.
pygame.init()
pygame.display.set_mode((640, 480), pygame.OPENGL | pygame.DOUBLEBUF)
rabbyt.set_viewport((640, 480))
rabbyt.set_default_attribs()
while not pygame.event.get(pygame.QUIT):
# Clear the screen to white. (Colors in rabbyt are the same as in OpenGL,
# from 0.0 to 1.0.)
rabbyt.clear((1.0,1.0,1.0))
pygame.display.flip()
if event.key in (pygame.K_ESCAPE, pygame.K_q):
import sys
sys.exit(0)
elif event.key == pygame.K_SPACE:
car1.boost()
pressed = pygame.key.get_pressed()
car1.accelerating = pressed[pygame.K_UP]
car1.turning_right = pressed[pygame.K_RIGHT]
car1.turning_left = pressed[pygame.K_LEFT]
rabbyt.set_time(pygame.time.get_ticks()/1000.0)
for c in cars:
c.update()
rabbyt.scheduler.pump()
rabbyt.clear((.56, .3, 0, 1))
for c in cars:
c.render()
rabbyt.render_unsorted(Car.dust_particles)
rabbyt.render_unsorted(Car.boost_particles)
pygame.display.flip()
def draw(self):
"""draw all of the photos, in stack order"""
rabbyt.clear()
rabbyt.render_unsorted(self)
