def __init__(self, form, name, width, value='', default_value=True,
text_length=None, validator=None):
self.box_width, self._box_height = 0, 0
BaseWidget.__init__(self, form, name)
self.layers = ["base", "content"]
child_anchor = (self._padding, self._padding)
self._back = spyral.Sprite(self)
self._back.layer = "base"
self._cursor = spyral.Sprite(self)
self._cursor.anchor = child_anchor
self._cursor.layer = "content:above"
self._text = spyral.Sprite(self)
self._text.pos = child_anchor
self._text.layer = "content"
self._focused = False
self._cursor.visible = False
self._selection_pos = 0
self._selecting = False
self._shift_was_down = False
self._mouse_is_down = False
self._cursor_time = 0.
self._cursor_blink_interval = self._cursor_blink_interval
self.default_value = default_value
self._default_value_permanant = default_value
self._view_x = 0
self.box_width = width - 2*self._padding
self.text_length = text_length
self._box_height = int(math.ceil(self.font.linesize))
self._recalculate_mask()
self._cursor.image = spyral.Image(size=(2,self._box_height))
self._cursor.image.fill(self._cursor_color)
if validator is None:
self.validator = str(set(string.printable).difference("\n\t"))
else:
self.validator = validator
if text_length is not None and len(value) < text_length:
value = value[:text_length]
self._value = None
self.value = value
self._render_backs()
self._back.image = self._image_plain
spyral.event.register("director.update", self._update, scene=self.scene)
def addMenuItem(self, itemText, itemDelegate):
self.options.append(itemText)
self.optionsDelegates.append(itemDelegate)
#add the actual sprite. These are drawn automatically on the scene that's passed in.
#there is no draw loop.
option = spyral.Sprite(self.parentScene)
textOption = FontLoader.GuidedText(self.parentScene, "game/fonts/DejaVuSans.ttf", "Test", self.height * 1. / 8)
self.sprites.append(option)
self.text.append(textOption)
#quick check if you added only 1 item.
if(len(self.options) != 1):
option.image = spyral.Image("game/images/logo.png")
else:
option.image = spyral.Image("game/images/selectedMenuItem.png")
#recalculate the position of everything on the screen.
option.anchor = "center"
option.x = self.width/2
textOption.x = self.width/2
#fix positions.
print("Length: " + str(self.height/2))
curY = self.height/2 - ((len(self.options) - 1 )* self.sprites[0].height/2)
for i in range(0, len(self.sprites)):
print("CurY: " + str(curY))
self.sprites[i].y = curY
self.text[i].y = curY
curY = curY + self.sprites[i].height + 30
def add_sprite(self):
k = spyral.Sprite(self)
k.image = spyral.Image(size=(50, 50)).fill((255, 0, 0))
k.x = random.randint(0, 100)
k.y = random.randint(0, 100)
k.gs = global_simple
k.bb = lambda: spyral.director.quit
k.gb = global_bound(k.image, k.rect, k, k, p=k.image, j=k)
spyral.event.register("#.global.simple", k.gs)
spyral.event.register("#.builtin.bound", k.bb)
spyral.event.register("#.global.bound", k.gb)
def local_simple():
return 5
def local_bound(obj):
return lambda: obj
def local_self():
return lambda: k
k.lsi = local_simple
k.lb = local_bound(k)
k.lse = local_self
spyral.event.register("#.local.bound", k.lb)
spyral.event.register("#.local.self", k.lse)
spyral.event.register("#.local.simple", k.lsi)
spyral.event.register("#.class.simple", k.kill)
self.test.append(k)
print "B", len(self._handlers)
for name, handlers in self._handlers.iteritems():
print "B", name, [h[0] for h in handlers]
print "*" * 10
def __init__(self):
global first_scene
global old_sprite
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill(BG_COLOR)
first_scene = self
v_top = spyral.View(self)
v_bottom = spyral.View(v_top)
over = spyral.Sprite(v_bottom)
over.image = spyral.Image(size=(50, 50)).fill((255, 0, 0))
over.should_be_dead = lambda: 10
old_sprite = over
self.khan = over.should_be_dead
spyral.event.register("system.quit", spyral.director.quit)
spyral.event.register("input.keyboard.down.k", over.should_be_dead)
spyral.event.register("input.keyboard.down.e", over._get_mask)
spyral.event.register("input.keyboard.down.j", self.advance)
objgraph.show_backrefs(
[old_sprite],
filename='sprite-alive.png',
filter=lambda x: not isinstance(x, types.FrameType),
extra_ignore=[id(locals()), id(globals())],
max_depth=7)
def __init__(self):
spyral.Scene.__init__(self, SIZE)
# START LOAD RENDERER
self.renderer = renderer.TiledRenderer(self.map_file)
background = spyral.Image(size=self.renderer.size)
self.renderer.render(background._surf)
background.scale(SIZE)
self.background = background
self.scale_height = float(self.background.size.y) / float(self.renderer.size[1])
self.scale_width = float(self.background.size.x) / float(self.renderer.size[0])
self.player_animation_lock = threading.Lock()
# END LOAD RENDERER
spyral.event.register("system.quit", spyral.director.quit)
self.player_sprite = spyral.Sprite(self)
walking_animation = load_walking_animation(self.sprite_file, 'down', self.sprite_offset)
self.player_sprite.animate(walking_animation)
# spyral built in events
spyral.event.register('input.keyboard.down.down', lambda: self.move_player('down'))
spyral.event.register('input.keyboard.down.up', lambda: self.move_player('up'))
spyral.event.register('input.keyboard.down.left', lambda: self.move_player('left'))
spyral.event.register('input.keyboard.down.right', lambda: self.move_player('right'))
# custom events
spyral.event.register('rpg.map.collision', self.handle_map_collision)
def __init__(self, frase, infodato, ganaste):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill(BG_COLOR)
self.text = frase
font_path = "fonts/SFDigitalReadout-Medium.ttf"
font = spyral.Font(font_path, 72, FG_COLOR)
self.finale = spyral.Sprite(self)
self.finale.image = font.render(self.text)
self.finale.anchor = 'midtop'
self.finale.x = SIZE[0] / 2
self.finale.y = 75
self.infodato_label = MultilineText(self, infodato, self.finale.x, 500,
1000, 500)
if ganaste:
animation = spyral.Animation('y',
spyral.easing.Sine(50),
shift=75,
duration=3,
loop=True)
else:
animation = spyral.Animation('x',
spyral.easing.Sine(50),
shift=self.finale.x,
duration=3,
loop=True)
self.finale.animate(animation)
spyral.event.register("input.keyboard.down.*", self.procesar_tecla)
self.closing = False
spyral.event.register("system.quit", spyral.director.quit)
def InitValues(self):
if self.key == '-':
self.image = tileBasic
self.type = 'empty'
self.amount = 0
elif self.key == '#':
self.image = tileBush
self.type = 'obstacle'
self.amount = 0
#addition gates
elif self.key == '1' or self.key == '2' or self.key == '3' or self.key == '4' or self.key == '5' or self.key == '6' or self.key == '7' or self.key == '8' or self.key == '9':
self.amount = int(self.key)
self.image = tileAdd
self.type = 'add'
self.textSprite = spyral.Sprite(self.parent)
text = spyral.Font("game/fonts/DejaVuSans.ttf", 22, (0, 255, 0))
self.textSprite.x = self.x
self.textSprite.y = self.y + 2
self.textSprite.anchor = 'center'
self.textSprite.image = text.render(self.key)
#subtraction gates
elif self.key in subtractDict:
self.amount = subtractDict[self.key]
self.image = tileSubtract
self.type = 'subtract'
self.textSprite = spyral.Sprite(self.parent)
text = spyral.Font("game/fonts/DejaVuSans.ttf", 22, (255, 0, 0))
self.textSprite.image = text.render(str(subtractDict[self.key]))
self.textSprite.x = self.x
self.textSprite.y = self.y + 2
self.textSprite.anchor = 'center'
#go to next level gate
elif self.key == 'G':
self.image = tileGate
self.type = 'gate'
#other
else:
self.image = tileOther
self.type = 'obstacle'
def __init__(self):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill(BG_COLOR)
spyral.event.register("system.quit", spyral.director.quit)
player = spyral.Sprite(self)
player.image = spyral.Image(filename='EchFF.png')
player.image.crop(spyral.Vec2D(10, 10))
def addImage(self, filename, x, y, layer="__default__"):
sprite = spyral.Sprite(self.group)
sprite._set_layer(layer)
sprite.image = spyral.Image(filename=filename)
sprite.pos = [x, y]
sprite.anchor = 'center'
self.group.add(sprite)
return sprite
def __init__(self, form, name, text = "Okay"):
MultiStateWidget.__init__(self, form, name,
['up', 'down', 'down_focused', 'down_hovered',
'up_focused', 'up_hovered'])
self._text_sprite = spyral.Sprite(self)
self._text_sprite.layer = "content"
self.text = text
def __init__(self, menuScene, SIZE, filename):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill((25, 150, 25))
self.menuScene = menuScene
self.sceneSize = SIZE
self.levelWidth = 20
self.levelHeight = 20
self.currentLevel = 1
self.goalAmount = 3
self.startLength = 1
self.levelData = self.CreateLevel(SIZE, filename)
#create the text on the top of the screen that informs the player the length the snake needs
#to be in order to progress to the next level
self.hudGoalText = spyral.Sprite(self.parent)
self.hudGoalStatus = spyral.Sprite(self.parent)
self.text = spyral.Font("game/fonts/DejaVuSans.ttf", 22,
(255, 255, 255))
self.hudGoalText.image = self.text.render(
"The snake needs to be " + str(self.goalAmount) +
" pieces long to go to the next level!")
self.hudGoalText.x = SIZE[0] / 2
self.hudGoalText.y = self.text.get_size("X").y
self.hudGoalText.anchor = 'center'
#create snake player object
self.player = snake.Snake(self, (2, self.levelWidth / 2))
spyral.event.register("input.keyboard.down.*",
self.handleKeyboard,
scene=self)
self.hudGoalStatus.image = self.text.render(
"The snake is currently " + str(self.player.bodyLength) +
" pieces long!")
self.hudGoalStatus.x = SIZE[0] / 2
self.hudGoalStatus.y = self.text.get_size("X").y * 2.1
self.hudGoalStatus.anchor = 'center'
def __init__(self, form, name, states):
self._states = states
self._state = self._states[0]
self.button = None # Hack for now; TODO need to be able to set properties on it even though it doesn't exist yet
BaseWidget.__init__(self, form, name)
self.layers = ["base", "content"]
self._images = {}
self._content_size = (0, 0)
self.button = spyral.Sprite(self)
self.button.layer = "base"
def __init__(self, SIZE=None, activity=None, *args, **kwargs):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=self.size).fill((255, 255, 255))
self.title = spyral.Sprite(self)
self.title.image = spyral.Font("fonts/SFDigitalReadout-Medium.ttf",
105).render("Consenso en 8-bits")
self.title.anchor = "midbottom"
self.title.pos = spyral.Vec2D(self.size) / 2
#anim = spyral.Animation("visible", spyral.easing.Iterate([True,False]), duration=0.5, loop=True)
#self.title.animate(anim)
self.subtitle = spyral.Sprite(self)
self.subtitle.image = spyral.Font("fonts/SFDigitalReadout-Medium.ttf",
75).render("presiona espacio")
self.subtitle.anchor = "midtop"
self.subtitle.pos = spyral.Vec2D(self.size) / 2
self.player = Carrito(self, 1)
self.player.pos = 150, 150
self.player.vel = 30
self.player.scale = 3
self.player = Carrito(self, 2)
self.player.pos = self.width - 150, self.height - 150
self.player.vel = 30
self.player.scale = 3
self.angle = math.pi
self.interruptores = []
spyral.event.register("input.keyboard.down.space", self.continuar)
spyral.event.register("input.keyboard.down.*", self.mostrar)
spyral.event.register("system.quit", spyral.director.pop)
if activity:
activity.box.next_page()
activity._pygamecanvas.grab_focus()
activity.window.set_cursor(None)
self.activity = activity
def __init__(self, SIZE, player):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=self.size).fill((255, 255, 255))
if player:
self.player = Carrito(self, player)
self.player.pos = spyral.Vec2D(self.width / 2, self.height / 3)
self.player.vel = 0
self.player.scale = 3
self.interruptores = []
if player == 1:
texto = "gana rojo"
elif player == 2:
texto = "gana verde"
self.nota = spyral.Sprite(self)
self.nota.image = spyral.Font("fonts/SFDigitalReadout-Medium.ttf",
105).render(texto)
self.nota.anchor = "center"
self.nota.pos = spyral.Vec2D(self.width / 2, 2 * self.height / 3)
else:
self.player = spyral.Sprite(self)
self.player.image = spyral.Font(
"fonts/SFDigitalReadout-Medium.ttf",
55).render("no hay consenso")
self.player.anchor = "center"
self.player.pos = spyral.Vec2D(self.size) / 2
self.aplauso = pygame.mixer.Sound('sounds/applause.wav')
self.aplauso.play()
anim = spyral.Animation("scale", spyral.easing.Sine(1), shift=2)
self.player.animate(anim + anim + anim + anim + anim)
spyral.event.register("Sprite.scale.animation.end", self.continuar)
spyral.event.register("Carrito.scale.animation.end", self.continuar)
spyral.event.register("system.quit", spyral.director.pop)
def __init__(self, *args, **kwargs):
super(Pong, self).__init__(*args, **kwargs)
self.camera = self.parent_camera.make_child(virtual_size=(WIDTH,
HEIGHT))
paddle_image = spyral.Image(size=(20, 300))
paddle_image.fill((255, 255, 255))
# We want to make sure we keep the paddles around, since we'll
# work with them for motion and collision detection
self.left_paddle = spyral.Sprite()
self.left_paddle.image = paddle_image
# This anchor means that the x and y coordinates we assign are
# relative to the middle left of the image.
self.left_paddle.anchor = 'midleft'
# We'll keep the paddle just slightly off of the wall
self.left_paddle.x = 20
# We'll have the paddle start out vertically centered
self.left_paddle.y = HEIGHT / 2
self.right_paddle = spyral.Sprite()
self.right_paddle.image = paddle_image
self.right_paddle.anchor = 'midright'
self.right_paddle.x = WIDTH - 20
self.right_paddle.y = HEIGHT / 2
self.ball = Ball(self)
# We have to give our camera to the group so it knows where to draw
self.group = spyral.Group(self.camera)
# We can add the sprites to the group
self.group.add(self.left_paddle, self.right_paddle, self.ball)
# We should track whether the paddles are moving up and down
self.left_paddle.moving = False
self.right_paddle.moving = False
def __init__(self, activity=None, SIZE=None, *args, **kwargs):
spyral.Scene.__init__(self, SIZE)
# Estrategia para ganar rendimiento en la XO:
# En vez de deslizar todo el fondo de la pantalla, hemos escogido una
# imagen que podemos recortar como una franja, dejando colores sólidos
# arriba y abajo.
self.background = spyral.Image(size=self.size).fill((109, 164, 26))
self.layers = ["fondo", "frente"]
# Este es el fondo móvil.
self.fondo1 = Fondo(self, 1)
self.fondo2 = Fondo(self, 2)
# Fondo inmóvil en la franja superior
bloque_verde = spyral.Sprite(self)
bloque_verde.layer = "fondo"
bloque_verde.image = spyral.Image(size=(self.width, 200)).fill(
(122, 183, 30))
self.comodo = Comodo(self)
self.barra = Barra_de_Vida(self)
self.tick = 0
# Esto es para poder salir correctamente del juego
spyral.event.register("system.quit", spyral.director.pop)
spyral.event.register("director.scene.enter", self.wave)
self.spawned = False
# Este código es para salir de la imagen de inicio del juego
if activity:
activity.game_button.set_active(True)
activity.box.next_page()
activity._pygamecanvas.grab_focus()
activity.window.set_cursor(None)
self.activity = activity
def __init__(self):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill(BG_COLOR)
screen = self.rect
debug = spyral.DebugText(self, "1) Red square in middle of room", BLUE)
debug.anchor = 'midbottom'
debug.pos = self.rect.midbottom
self.top_view = spyral.View(self)
self.top_view.label = "TopV"
self.top_view.pos = (0, 0)
# TODO: To see it flip out, try commenting out the next line.
self.top_view.crop = False
self.top_view.crop_size = (40, 40)
self.bottom_view = spyral.View(self.top_view)
self.bottom_view.label = "BottomV"
self.bottom_view.pos = (0, 0)
self.bottom_view.crop = False
self.bottom_view.crop_size = (20, 20)
self.red_block = spyral.Sprite(self.bottom_view)
self.red_block.image = spyral.Image(size=SMALL).fill(RED)
self.red_block.pos = screen.center
self.red_block.anchor = "center"
def tester():
debug.text = "2) Red square partially offscreen"
self.red_block.pos = screen.midtop
yield
debug.text = "3) Red square doubled in size"
self.red_block.pos = screen.center
self.red_block.scale = 2
yield
debug.text = "4) Red square angled .1 radians"
self.red_block.angle = .1
yield
debug.text = "5) Red square shifted by bottom view 16px diagonal"
self.bottom_view.pos = (16, 16)
yield
debug.text = "6) Red square half scaled by bottom view"
self.bottom_view.scale = .5
yield
debug.text = "7) Red square doubled by top view"
self.top_view.scale = 2
yield
debug.text = "8) Red square shifted by top view in other direction 8x"
self.top_view.pos = (-8, -8)
yield
debug.text = "9) Bottom view cropping 16x16 pixels, no scaling"
self.red_block.scale = 1
self.bottom_view.scale = 1
self.top_view.scale = 1
self.bottom_view.crop = True
self.bottom_view.crop_size = (16, 16)
yield
debug.text = "9) Top view cropping 16x16 pixels, no bottom crop"
self.bottom_view.crop = False
self.top_view.crop = True
self.top_view.crop_size = (16, 16)
yield
debug.text = "9) Top crops 20px, bottom crops 10px"
self.bottom_view.crop = True
self.top_view.crop = True
self.bottom_view.crop_size = (10, 10)
self.top_view.crop_size = (20, 20)
yield
debug.text = "9) Top crops 10px, bottom crops 20px"
self.bottom_view.crop_size = (20, 20)
self.top_view.crop_size = (10, 10)
yield
def key_down(event):
self.top_view.crop_height += 10
def key_up(event):
self.top_view.crop_height -= 10
def key_left(event):
self.top_view.crop_width -= 10
def key_right(event):
self.top_view.crop_width += 10
def notify(event):
pass
#print self.blue_block.x
spyral.event.register("input.keyboard.down.down", key_down)
spyral.event.register("input.keyboard.down.up", key_up)
spyral.event.register("input.keyboard.down.left", key_left)
spyral.event.register("input.keyboard.down.right", key_right)
tests = tester()
def next_test():
try:
next(tests)
except StopIteration:
spyral.director.quit()
spyral.event.register("input.keyboard.down.space", next_test)
#self.register("director.update", )
spyral.event.register("system.quit", spyral.director.quit)
def inducir_falla(self):
self.error = spyral.Sprite(self.game)
def __init__(self):
spyral.Scene.__init__(self)
self.camera = self.parent_camera.make_child(
virtual_size=(CK_WIDTH, CK_HEIGHT), layers=['__default__', 'tool'])
self.group = spyral.Group(self.camera)
self.tools = [
random_tool("tsp."),
random_tool("tbsp."),
random_tool("cup"),
random_tool("pint")
]
self.ingredients = [
Ingredient(self.group, "flour", "FLOUR.png", 230, 10),
Ingredient(self.group, "sugar", "SUGAR.png", 230, 170),
Ingredient(self.group, "chocolate", "CHOCOLATE.png", 230, 330),
Ingredient(self.group, "water", "WATER.png", 350, 10),
Ingredient(self.group, "eggs", "EGG.png", 350, 170),
Ingredient(self.group, "butter", "BUTTER.png", 350, 330)
]
recipeSprite = self.addImage("cooking_images/RECIPE_SCROLL.png", 112,
125)
self.emptyBG = spyral.Sprite(self.group)
self.emptyBG.image = spyral.Image(size=[CK_WIDTH, CK_HEIGHT])
self.group.add(self.emptyBG)
self.font = pygame.font.SysFont(None, 20)
self.recipe = random_recipe(self.tools, self.ingredients)
recipelist = self.recipe.__str__().split("\n")
bigfont = pygame.font.SysFont(None, 40)
recipeTitle = bigfont.render("COOKIES", True,
[0, 0, 0, 255]).convert_alpha()
recipeSprite.image._surf.blit(recipeTitle, [30, 10])
for i in range(len(recipelist)):
recipe = recipelist[i]
surf = self.font.render(recipe, True,
[0, 0, 0, 255]).convert_alpha()
recipeSprite.image._surf.blit(
surf, [max(max(15, 20 - 5 * i), 5 * i - 5), 50 + 25 * i])
self.bowl = Recipe([
Measurement(Fraction(0, 1), "tsp.") for ingred in self.ingredients
], self.ingredients)
self.tsp = self.addImage("cooking_images/TEA_SPOON.png", 65, 285,
'tool')
self.tbsp = self.addImage("cooking_images/TBL_SPOON.png", 165, 285,
'tool')
self.cup = self.addImage("cooking_images/MEASURING_CUP2.png", 65, 395,
'tool')
self.pint = self.addImage("cooking_images/MEASURING_CUP.png", 165, 395,
'tool')
self.toolSprites = [self.tsp, self.tbsp, self.cup, self.pint]
self.addImage("cooking_images/BOWL.png", 545, 225)
for i in range(4):
tool = self.tools[i]
x = 65 + 100 * (i % 2)
y = 310
if i > 1: y += 130
self.addText(tool.__str__(), x, y)
for i in range(6):
ingred = self.ingredients[i]
string = ingred.name
string = string[0].upper() + string[1:]
x = 280
if i > 2: x += 120
y = 150 * (i % 3) + 130
self.addText(string, x, y)
self.toolSelect = 0
self.pointer1 = self.addImage("cooking_images/SPOINTER.png", 65, 330)
self.ingredSelect = 0
self.pointer3 = self.addImage("cooking_images/SPOINTER.png", 545, 320)
self.group.remove(self.pointer3)
self.curTool = None
self.state = 0
try:
import _path
except NameError:
pass
import pygame
import spyral
resolution = (640, 480)
if __name__ == "__main__":
spyral.director.init(resolution)
my_scene = spyral.Scene(resolution)
my_scene.background = spyral.Image(size=resolution).fill((0,0,0))
my_sprite = spyral.Sprite(my_scene)
my_sprite.image = spyral.Image(size=(50,50))
spyral.event.register("system.quit", spyral.director.quit, scene=my_scene)
# Can accept the keys directly
def key_down(key, unicode, mod):
print key, unicode, mod
def mouse_down(pos, button):
print type(pos)
print pos.x
print pos, button
# Or maybe none or only some of them!
def key_down_alt1(key, mod):
print key, mod
def mouse_down_alt1():