def _get_size(self):
"""
The size of the image after all transforms (:class:`Vec2D <spyral.Vec2D>`).
"""
if self._transform_image:
return spyral.Vec2D(self._transform_image.get_size())
return spyral.Vec2D(0, 0)
def _set_scale(self, scale):
if isinstance(scale, (int, float)):
scale = spyral.Vec2D(scale, scale)
if scale == self._get_scale():
return
self._output_size = self._size * spyral.Vec2D(scale)
self._changed()
def __init__(self, group=None):
""" Adds this sprite to any number of groups by default. """
_all_sprites.append(_wref(self))
self._age = 0
self._static = False
self._image = None
self._layer = '__default__'
self._groups = []
self._make_static = False
self._pos = spyral.Vec2D(0, 0)
self._blend_flags = 0
self.visible = True
self._anchor = 'topleft'
self._offset = spyral.Vec2D(0, 0)
self._scale = spyral.Vec2D(1.0, 1.0)
self._scaled_image = None
self._group = None
self._angle = 0
self._transform_image = None
self._transform_offset = spyral.Vec2D(0, 0)
self._flip_x = False
self._flip_y = False
self.on_remove = spyral.Signal()
if group is not None:
group.add(self)
def __init__(self, parent):
_all_sprites.append(_wref(self))
self._age = 0
self._static = False
self._image = None
self._image_version = None
self._layer = None
self._computed_layer = 1
self._make_static = False
self._pos = spyral.Vec2D(0, 0)
self._blend_flags = 0
self._visible = True
self._anchor = 'topleft'
self._offset = spyral.Vec2D(0, 0)
self._scale = spyral.Vec2D(1.0, 1.0)
self._scaled_image = None
self._parent = _wref(parent)
self._scene = _wref(parent.scene)
self._angle = 0
self._crop = None
self._transform_image = None
self._transform_offset = spyral.Vec2D(0, 0)
self._flip_x = False
self._flip_y = False
self._animations = []
self._progress = {}
self._mask = None
parent._add_child(self)
self._scene()._register_sprite(self)
self._scene()._apply_style(self)
spyral.event.register('director.render',
self._draw,
scene=self._scene())
def _set_scale(self, scale):
if isinstance(scale, (int, float)):
scale = spyral.Vec2D(scale, scale)
if self._scale == scale:
return
self._scale = spyral.Vec2D(scale)
self._recalculate_transforms()
self._expire_static()
def handle_motion(self, pos):
#self.scene.tablero.cursor.pos = pos
self.scene.tablero.cursor.visible = False
if self.ACTIVADO:
from_pos = (pos - self.scene.tablero.pos) / spyral.Vec2D(140, 140)
ubicacion = spyral.Vec2D(int(from_pos.x), int(from_pos.y))
if ubicacion != self.mov_anterior and ubicacion != self.ACTIVADO:
self.mov_anterior = ubicacion
event = spyral.event.Event(ubicacion=ubicacion)
spyral.event.queue("Tablero.movimiento", event)
def __init__(self, scene, player):
spyral.Sprite.__init__(self, scene)
self.vel = 20
self.anchor = "center"
self.layer = "carros"
self.girando = False
self.moviendo = False
self.frenando = False
self.bonus = pygame.mixer.Sound('sounds/BonusCube_0.ogg')
self.puntos = 4
self.player = player
if player == 1:
self.x, self.y = spyral.Vec2D(scene.size) / 8.0
spyral.event.register("input.keyboard.down.s", self.frena)
spyral.event.register("input.keyboard.down.w", self.avanza)
spyral.event.register("input.keyboard.down.a", self.izquierda)
spyral.event.register("input.keyboard.down.d", self.derecha)
# game keys
spyral.event.register("input.keyboard.down.keypad_2", self.frena)
spyral.event.register("input.keyboard.down.keypad_8", self.avanza)
spyral.event.register("input.keyboard.down.keypad_4",
self.izquierda)
spyral.event.register("input.keyboard.down.keypad_6", self.derecha)
self.image = spyral.Image("images/etoys-car.png")
self.angle = 0
elif player == 2:
self.x, self.y = spyral.Vec2D(scene.size) * 0.875
spyral.event.register("input.keyboard.down.down", self.frena)
spyral.event.register("input.keyboard.down.up", self.avanza)
spyral.event.register("input.keyboard.down.left", self.izquierda)
spyral.event.register("input.keyboard.down.right", self.derecha)
# game keys
spyral.event.register("input.keyboard.down.keypad_3", self.frena)
spyral.event.register("input.keyboard.down.keypad_9", self.avanza)
spyral.event.register("input.keyboard.down.keypad_7",
self.izquierda)
spyral.event.register("input.keyboard.down.keypad_1", self.derecha)
self.image = spyral.Image("images/etoys-car-green.png")
self.angle = math.pi
size = spyral.Vec2D(self.image.size)
self.mask = spyral.Rect(size / 8, size * 0.875)
spyral.event.register("director.update", self.corrige_dir)
spyral.event.register("director.pre_render", self.chequea_choque)
spyral.event.register("Carrito.angle.animation.end", self.fin_anim)
spyral.event.register("Carrito.pos.animation.end", self.fin_mov)
spyral.event.register("Carrito.vel.animation.end", self.fin_fren)
spyral.event.register("Carrito.image.animation.end",
self.fin_explosion)
def move_player(self, direction):
if not self.player_animation_lock.acquire(False):
return
#self.player_animation_lock.acquire()
#self.player_sprite.stop_all_animations()
pos = self.player_sprite.pos
tile_height = int(self.renderer.tmx_data.tileheight * self.scale_height)
tile_width = int(self.renderer.tmx_data.tilewidth * self.scale_width)
if direction == 'down':
move_animation = spyral.Animation('y', spyral.easing.Linear(pos.y, pos.y + tile_height), STEP_INTERVAL)
new_pos = spyral.Vec2D(pos.x, pos.y + tile_height)
elif direction == 'up':
move_animation = spyral.Animation('y', spyral.easing.Linear(pos.y, pos.y - tile_height), STEP_INTERVAL)
new_pos = spyral.Vec2D(pos.x, pos.y - tile_height)
elif direction == 'left':
move_animation = spyral.Animation('x', spyral.easing.Linear(pos.x, pos.x - tile_width), STEP_INTERVAL)
new_pos = spyral.Vec2D(pos.x - tile_width, pos.y)
elif direction == 'right':
move_animation = spyral.Animation('x', spyral.easing.Linear(pos.x, pos.x + tile_width), STEP_INTERVAL)
new_pos = spyral.Vec2D(pos.x + tile_width, pos.y)
try:
assert(new_pos.x % self.renderer.tmx_data.tilewidth == 0)
assert(new_pos.y % self.renderer.tmx_data.tileheight == 0)
except AssertionError:
import pdb; pdb.set_trace()
properties = self.get_renderer_tile_properties(new_pos)
walking_animation = load_walking_animation(self.sprite_file, direction, self.sprite_offset)
if self.position_in_scene(new_pos):
if properties.get('collision'):
collision_event = spyral.Event(pos = pos, new_pos = new_pos)
spyral.event.handle('rpg.map.collision', event = collision_event)
else:
walking_animation = (walking_animation & move_animation)
event_name = None
if 'x' in walking_animation.properties:
event_name = self.player_sprite.__class__.__name__ + '.x.animation.end'
elif 'y' in walking_animation.properties:
event_name = self.player_sprite.__class__.__name__ + '.y.animation.end'
if event_name:
def test_function(*args, **kwargs):
self.player_animation_lock.release()
spyral.event.unregister(event_name, test_function)
spyral.event.register(event_name, test_function)
else:
self.player_animation_lock.release()
try:
self.player_sprite.animate(walking_animation)
except ValueError:
if event_name:
self.player_animation_lock.release()
spyral.event.unregister(event_name, test_function)
def _anchor_offset(anchor, width, height):
"""
Given an `anchor` position (either a string or a 2-tuple position), finds
the correct offset in a rectangle of size (`width`, `height`). If the
`anchor` is a 2-tuple (or Vec2D), then it multiplies both components by -1.
>>> anchor_offset("topleft", 100, 100)
Vec2D(0,0)
>>> anchor_offset("bottomright", 100, 100)
Vec2D(100,100)
>>> anchor_offset("center", 100, 100)
Vec2D(50,50)
>>> anchor_offset((10, 10), 100, 100)
Vec2D(-10,-10)
For a complete list of the anchor positions, see `Anchor Offset Lists`_.
:param anchor: The (possibly named) position to offset by.
:type anchor: string or :class:`Vec2D <spyral.Vec2D>`
:param width: the width of the rectangle to offset in.
:type width: int
:param height: the height of the rectangle to offset in.
:type height: int
:rtype: :class:`Vec2D <spyral.Vec2D>`
"""
w = width
h = height
a = anchor
if a == 'topleft':
offset = (0, 0)
elif a == 'topright':
offset = (w, 0)
elif a == 'midtop':
offset = (w / 2., 0)
elif a == 'bottomleft':
offset = (0, h)
elif a == 'bottomright':
offset = (w, h)
elif a == 'midbottom':
offset = (w / 2., h)
elif a == 'midleft':
offset = (0, h / 2.)
elif a == 'midright':
offset = (w, h / 2.)
elif a == 'center':
offset = (w / 2., h / 2.)
else:
offset = a * spyral.Vec2D(-1, -1)
return spyral.Vec2D(offset)
def update(self):
self.visible = True
newpos = self.ubicacion * spyral.Vec2D(140, 140) + spyral.Vec2D(70, 70)
if self.desplaz_anim:
self.stop_animation(self.desplaz_anim)
self.desplaz_anim = spyral.Animation("pos",
QuadraticOutTuple(
self.pos, newpos),
duration=0.4)
self.animate(self.desplaz_anim)
event = spyral.event.Event(ubicacion=self.ubicacion)
spyral.event.queue("Tablero.movimiento", event)
def venir_de(self, ubicacion):
self.visible = True
direccion = tuple(spyral.Vec2D(self.COL, self.ROW) - ubicacion)
if not self.vengo_de:
self.vengo_de = spyral.Vec2D(direccion)
if direccion == (0, +1):
self.image = self.gosouth
elif direccion == (0, -1):
self.image = self.gonorth
elif direccion == (-1, 0):
self.image = self.gowest
elif direccion == (+1, 0):
self.image = self.goeast
def from_sequence(images, orientation="right", padding=0):
"""
A function that returns a new Image from a list of images by
placing them next to each other.
:param images: A list of images to lay out.
:type images: List of :class:`Image <spyral.Image>`
:param str orientation: Either 'left', 'right', 'above', 'below', or
'square' (square images will be placed in a grid
shape, like a chess board).
:param padding: The padding between each image. Can be specified as a
scalar number (for constant padding between all images)
or a list (for different paddings between each image).
:type padding: int or a list of ints.
:returns: A new :class:`Image <spyral.Image>`
"""
if orientation == 'square':
length = int(math.ceil(math.sqrt(len(images))))
max_height = 0
for index, image in enumerate(images):
if index % length == 0:
x = 0
y += max_height
max_height = 0
else:
x += image.width
max_height = max(max_height, image.height)
sequence.append((image, (x, y)))
else:
if orientation in ('left', 'right'):
selector = spyral.Vec2D(1, 0)
else:
selector = spyral.Vec2D(0, 1)
if orientation in ('left', 'above'):
reversed(images)
if type(padding) in (float, int, long):
padding = [padding] * len(images)
else:
padding = list(padding)
padding.append(0)
base = spyral.Vec2D(0, 0)
sequence = []
for image, padding in zip(images, padding):
sequence.append((image, base))
base = base + selector * (image.size + (padding, padding))
return from_conglomerate(sequence)
def _recalculate_transforms(self):
"""
Calculates the transforms that need to be applied to this sprite's
image. In order: flipping, scaling, and rotation.
"""
source = self._image._surf
# flip
if self._flip_x or self._flip_y:
source = pygame.transform.flip(source, self._flip_x, self._flip_y)
# scale
if self._scale != (1.0, 1.0):
new_size = self._scale * self._image.size
new_size = (int(new_size[0]), int(new_size[1]))
if 0 in new_size:
self._transform_image = spyral.image._new_spyral_surface(
(1, 1))
self._recalculate_offset()
self._expire_static()
return
new_surf = spyral.image._new_spyral_surface(new_size)
source = pygame.transform.smoothscale(source, new_size, new_surf)
# rotate
if self._angle != 0:
angle = 180.0 / math.pi * self._angle % 360
old = spyral.Vec2D(source.get_rect().center)
source = pygame.transform.rotate(source, angle).convert_alpha()
new = source.get_rect().center
self._transform_offset = old - new
self._transform_image = source
self._recalculate_offset()
self._expire_static()
def _recalculate_offset(self):
if self.image is None:
return
size = self._scale * self._image.get_size()
w = size[0]
h = size[1]
a = self._anchor
if a == 'topleft':
offset = (0, 0)
elif a == 'topright':
offset = (w, 0)
elif a == 'midtop':
offset = (w / 2., 0)
elif a == 'bottomleft':
offset = (0, h)
elif a == 'bottomright':
offset = (w, h)
elif a == 'midbottom':
offset = (w / 2., h)
elif a == 'midleft':
offset = (0, h / 2.)
elif a == 'midright':
offset = (w, h / 2.)
elif a == 'center':
offset = (w / 2., h / 2.)
else:
offset = a
self._offset = spyral.Vec2D(offset) - self._transform_offset
def __init__(self, scene):
spyral.Sprite.__init__(self, scene)
self.num_stars = 256
self.max_depth = 16
self.layer = "abajo"
self.speed = 0.2
self.pos = spyral.Vec2D(scene.size) / 2
self.anchor = "center"
self.ESTADO = "bigbang"
self.gone = False
self.R = 0
self.G = 0
self.B = 48
self.image = spyral.Image(size=(700, 700)).fill(
(self.R, self.G, self.B))
self.init_stars()
self.init_animations()
spyral.event.register("director.update", self.update)
spyral.event.register("director.pre_update", self.predraw)
self.delay = DelayAnimation(5)
self.delay.property = "demora"
#self.defered_spawn()
spyral.event.register("CampodeEstrellas.demora.animation.end",
self.spawn)
def _set_child_anchor(self, anchor):
for sprite in self._internal_group.sprites():
sprite._expire_static()
try:
self._child_anchor = spyral.Vec2D(anchor)
except Exception:
self._child_anchor = anchor
def _recalculate_transforms(self):
source = self._image._surf
# flip
if self._flip_x or self._flip_y:
source = pygame.transform.flip(source, self._flip_x, self._flip_y)
# scale
if self._scale != (1.0, 1.0):
new_size = self._scale * self._image.get_size()
new_size = (int(new_size[0]), int(new_size[1]))
if 0 in new_size:
self._transform_image = pygame.Surface((1,1), pygame.SRCALPHA)
self._recalculate_offset()
self._expire_static()
return
source = pygame.transform.smoothscale(source, new_size, pygame.Surface(new_size, pygame.SRCALPHA))
# rotate
if self._angle != 0:
angle = 180.0 / math.pi * self._angle % 360
old = spyral.Vec2D(source.get_rect().center)
source = pygame.transform.rotate(source, angle).convert_alpha()
new = source.get_rect().center
self._transform_offset = old - new
self._transform_image = source
self._recalculate_offset()
self._expire_static()
def __init__(self, scene, texto, callback=None):
spyral.Sprite.__init__(self, scene)
self.callback = callback
self.anchor = 'center'
self.pos = spyral.Vec2D(scene.size) / 2
self.margen = 5
self.layer = "primer"
self.image = spyral.Image(filename=gamedir("imagenes/Menu_2.png"))
#self.image.draw_rect(color=(128,128,128),
# position=(0,0), size=(self.height,self.width))
font_path = gamedir("../fonts/DejaVuSans.ttf")
self.font = spyral.Font(font_path, 14, (0, 0, 0))
self.line_height = self.font.linesize
nueva = self.set_text(texto)
self.image.draw_image(nueva,
position=(self.margen / 2, 0),
anchor="midleft")
spyral.event.register("input.mouse.down.left", self.go_callback)
spyral.event.register("input.keyboard.down.return", self.go_callback)
spyral.event.register("input.keyboard.down.space", self.go_callback)
def __init__(self, scene):
spyral.Sprite.__init__(self, scene)
self.ubicacion = spyral.Vec2D(2, 2)
self.anchor = "center"
self.layer = "primer"
self.image = spyral.Image(
filename=gamedir("imagenes/square-01-whole.png"))
#self.scale = 0.5
spyral.event.register("input.keyboard.down.left", self.left)
spyral.event.register("input.keyboard.down.up", self.up)
spyral.event.register("input.keyboard.down.down", self.down)
spyral.event.register("input.keyboard.down.right", self.right)
spyral.event.register("input.keyboard.down.keypad_2", self.down)
spyral.event.register("input.keyboard.down.keypad_8", self.up)
spyral.event.register("input.keyboard.down.keypad_4", self.left)
spyral.event.register("input.keyboard.down.keypad_6", self.right)
spyral.event.register("input.keyboard.down.keypad_3", self.click)
spyral.event.register("input.keyboard.down.keypad_9", self.click)
spyral.event.register("input.keyboard.down.keypad_7", self.click)
spyral.event.register("input.keyboard.down.keypad_1", self.click)
spyral.event.register("input.keyboard.down.space", self.click)
spyral.event.register("input.keyboard.down.return", self.click)
self.desplaz_anim = None
self.update()
self.visible = False
def __init__(self, scene, texto, callback=None, transparent=False):
spyral.Sprite.__init__(self, scene)
self.callback = callback
self.anchor = 'center'
self.pos = spyral.Vec2D(scene.size) / 2
self.margen = 5
self.layer = "primer"
font_path = gamedir("../fonts/DejaVuSans.ttf")
if transparent:
self.font = spyral.Font(font_path, 20, (255, 255, 255))
self.font_red = spyral.Font(font_path, 20, (255, 0, 0))
self.line_height = self.font.linesize
nueva = self.set_trans_text(texto)
self.image = nueva
self.scale = 2
else:
self.font = spyral.Font(font_path, 14, (0, 0, 0))
self.line_height = self.font.linesize
self.image = spyral.Image(filename=gamedir("imagenes/Menu_2.png"))
nueva = self.set_text(texto)
self.image.draw_image(nueva,
position=(self.margen / 2, 0),
anchor="midleft")
if not transparent:
spyral.event.register("input.mouse.down.left", self.go_callback)
spyral.event.register("input.keyboard.down.return",
self.go_callback)
spyral.event.register("input.keyboard.down.space",
self.go_callback)
def ir_a(self, ubicacion):
direccion = spyral.Vec2D(self.COL, self.ROW) - ubicacion
name = "canopy_"
if self.vengo_de == (0, 1):
name += "north"
if self.vengo_de == (0, -1):
name += "south"
if self.vengo_de == (-1, 0):
name += "east"
if self.vengo_de == (1, 0):
name += "west"
name += "_"
if direccion == (0, 1):
name += "north"
if direccion == (0, -1):
name += "south"
if direccion == (-1, 0):
name += "east"
if direccion == (1, 0):
name += "west"
name += ".png"
try:
self.image = spyral.Image(filename=gamedir("imagenes/" + name))
except pygame.error:
pass
def movimiento(self, ubicacion):
#print "Movimiento: "+str(ubicacion)
self.scene.tablero.cursor.ubicacion = spyral.Vec2D(ubicacion)
if self.ACTIVADO:
if (ubicacion.distance(self.ACTIVADO)) == 1.0:
ANTERIOR = self.tablero[self.ACTIVADO.y][self.ACTIVADO.x]
try:
CANDIDATO = self.tablero[ubicacion.y][ubicacion.x]
except IndexError:
self.intentos += 1
self.desactivar()
return
if "Nexo" in CANDIDATO.__class__.__name__:
if CANDIDATO.visible:
return
if "Nexo" in ANTERIOR.__class__.__name__:
ANTERIOR.ir_a(ubicacion)
# Encontramos el camino!
CANDIDATO.venir_de(self.ACTIVADO)
self.ACTIVADO = ubicacion
self.camino.append(ubicacion)
else:
self.intentos += 1
if "Nexo" in ANTERIOR.__class__.__name__:
ANTERIOR.ir_a(ubicacion)
INICIAL = self.tablero[self.ACTIVADO_INICIAL.y][
self.ACTIVADO_INICIAL.x]
if CANDIDATO.COLOR == INICIAL.COLOR and (CANDIDATO
is not INICIAL):
self.match(INICIAL, CANDIDATO)
elif CANDIDATO == INICIAL:
return
else:
self.desactivar()
def __init__(self, scene):
spyral.Sprite.__init__(self, scene)
self.image = spyral.Image("images/mati2.png")
self.scale = 2
self.pos = spyral.Vec2D(self.scene.size) / 2
self.anchor = "midbottom"
self.velocidad = 100.0 * self.scale.x
self.pensamiento = None # Empezamos sin pensar
self.animando = False
self.moviendo = False
self.cajita = spyral.Rect(self.width/2.0, self.height,
self.scene.width - self.width,
self.scene.height - self.height)
self.estado = "despertando"
# posicion del mouse inicial
self.pos_mouse_anterior = self.scene.canvas.get_pointer()
spyral.event.register("director.update", self.actualizar)#, scene=scene)
spyral.event.register("Gato.image.animation.end", self.fin_animacion)#, scene=scene)
spyral.event.register("Gato.pos.animation.end", self.fin_movimiento)#, scene=scene)
def _pygame_to_spyral(event):
"""
Convert a Pygame event to a Spyral event, correctly converting arguments to
attributes.
"""
event_attrs = _TYPE_TO_ATTRS[event.type]
event_type = _TYPE_TO_TYPE[event.type]
e = Event()
for attr in event_attrs:
setattr(e, attr, getattr(event, attr))
if event_type.startswith("input"):
setattr(e, "type", event_type.split(".")[-1])
if event_type.startswith('input.keyboard'):
k = keys.reverse_map.get(event.key, 'unknown')
event_type += '.' + k
if event_type.startswith('input.mouse.motion'):
e.left, e.middle, e.right = map(bool, event.buttons)
elif event_type.startswith('input.mouse'):
try:
m = MOUSE_MAP[event.button - 1]
setattr(e, "button", m)
except IndexError:
m = str(event.button)
event_type += '.' + m
if event_type.startswith('input.mouse'):
e.pos = spyral.Vec2D(e.pos) / spyral.director.get_scene()._scale
return (event_type, e)
def check_pos(self, pos):
r = spyral.Rect(self.pos.x + 20, self.pos.y + 20, self.pos.x + 100,
self.pos.y + 100)
if r.collide_point(pos):
event = spyral.event.Event(
ubicacion=spyral.Vec2D(self.ROW, self.COL))
spyral.event.queue("Tablero.movimiento", event)
def calcular_puntero(self):
pos_mouse = spyral.Vec2D(self.scene.canvas.get_pointer())
distancia_al_mouse = pos_mouse.distance(self.pos)
if distancia_al_mouse > 6:
linea_al_mouse = (pos_mouse - self.pos)
angulo = math.degrees(linea_al_mouse.get_angle())
if angulo < 0:
angulo = angulo + 360
if 22.5 <= angulo < 67.5:
estado = "corre_se"
elif 67.5 <= angulo < 112.5:
estado = "corre_s"
elif 112.5 <= angulo < 157.5:
estado = "corre_so"
elif 157.5 <= angulo < 202.5:
estado = "corre_o"
elif 202.5 <= angulo < 247.5:
estado = "corre_no"
elif 247.5 <= angulo < 292.5:
estado = "corre_n"
elif 292.5 <= angulo < 337.5:
estado = "corre_ne"
elif 337.5 <= angulo or angulo < 22.5:
estado = "corre_e"
if not self.moviendo and not self.cajita.collide_point(pos_mouse):
estado = estado.replace("corre", "rasca")
return estado
def actualizar(self, delta):
pos_mouse = spyral.Vec2D(self.scene.canvas.get_pointer())
movimiento_del_mouse = pos_mouse.distance(self.pos_mouse_anterior)
nuevo_estado = self.calcular_puntero() or "quieto"
if movimiento_del_mouse > 7:
# posibilidades:
# - no se está ni moviendo ni animando -> animar y mover
# - se está moviendo y animando -> cambiar dirección solo si se necesita
# - no se está moviendo pero sí animando -> esperar
if self.estado in ["dormido", "quieto"]:
self.animar("despertando")
else:
if not (self.estado=="despertando") and not self.estado.startswith("rasca"):
self.mover(pos_mouse)
if self.estado.startswith("corre") and not self.animando:
if nuevo_estado.startswith("rasca"):
self.animar(nuevo_estado)
if not self.animando or (self.estado is not nuevo_estado):
if self.estado!="despertando":
if not(self.estado.startswith("rasca") and nuevo_estado.startswith("rasca")):
self.animar(nuevo_estado)
if self.pensamiento:
self.pensamiento.kill()
else:
# posibilidades:
# - no se está moviendo -> llegamos!
# - se está moviendo -> esperar hasta llegar!
if not self.moviendo:
if self.animando:
if self.estado.startswith("corre"):
self.stop_animation(self.anim)
self.pensamiento = RetroTexto()
self.pensamiento.pos = self.pos
if (self.y + self.pensamiento.image.height) > self.scene.height:
self.pensamiento.anchor = "bottomleft"
if (self.x + self.pensamiento.image.width) > self.scene.width:
if self.y - self.pensamiento.image.height < 0:
self.pensamiento.anchor = "topright"
else:
self.pensamiento.anchor = "bottomright"
else:
if self.estado=="quieto":
self.animar("dormido")
if self.pensamiento:
self.pensamiento.kill()
elif self.estado=="despertando":
self.mover(pos_mouse)
nuevo_estado = nuevo_estado.replace("rasca", "corre")
self.animar(nuevo_estado)
else:
self.animar("quieto")
self.pos_mouse_anterior = pos_mouse
def __init__(self, scene):
spyral.Sprite.__init__(self, scene)
self.anchor = "midbottom"
self.layer = "abajo2"
self.image = spyral.Image(filename=gamedir("images/entrada.png"))
self.pos = spyral.Vec2D(self.scene.size)/2
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 lejos_de_otros(self, x=None, y=None):
if not y or not x:
x, y = random.randint(50, self.scene.width - 100), random.randint(
50, self.scene.height - 100)
for i in self.scene.interruptores:
if spyral.Vec2D(x, y).distance(i.pos) < self.size.get_length():
return self.lejos_de_otros()
return x, y
