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