def draw_ellipse(self, color, position, size=None, border_width=0, anchor='topleft'): """ Draws an ellipse on this image. :param color: a three-tuple of RGB values ranging from 0-255. Example: (255, 128, 0) is orange. :type color: a three-tuple of ints. :param position: The starting position of the ellipse (top-left corner). If position is a Rect, then size should be `None`. :type position: :class:`Vec2D <spyral.Vec2D>` or :class:`Rect <spyral.Rect>` :param size: The size of the ellipse; should not be given if position is a rect. :type size: :class:`Vec2D <spyral.Vec2D>` :param int border_width: The width of the ellipse. If it is 0, the ellipse is filled with the color specified. :param str anchor: The anchor parameter is an :ref:`anchor position <ref.anchors>`. :returns: This image. """ if size is None: rect = spyral.Rect(position) else: rect = spyral.Rect(position, size) offset = self._calculate_offset(anchor, rect.size) pygame.draw.ellipse(self._surf, color, (rect.pos + offset, rect.size), border_width) self._version += 1 spyral.util.scale_surface.clear(self._surf) return self
def __init__(self, scene): super(Scoreboard, self).__init__() self.scene = scene self.curr_score = 0 self.curr_shots = 0 self.curr_x_input = "" self.curr_y_input = "" self.score_posn = (1000, 100) # @TODO: magic self.inputs_text_posn = (1000, self.score_posn[1] + FONT_SIZE) # @TODO: magic self.x_input_posn = (self.inputs_text_posn[0] + 10, self.score_posn[1] + FONT_SIZE) # TODO: magic self.y_input_posn = (self.inputs_text_posn[0] + 68, self.score_posn[1] + FONT_SIZE) # TODO: magic self.submit_text_posn = (1000, self.y_input_posn[1] + FONT_SIZE) # @TODO: magic self.submit_input_posn = (1000 + 15, self.y_input_posn[1] + FONT_SIZE) # @TODO: magic self.input_rect_size = (45, 30) # @TODO: magic self.submit_rect_size = (95, 30) # @TODO: magic self.x_input_rect = spyral.Rect(self.x_input_posn, self.input_rect_size) self.y_input_rect = spyral.Rect(self.y_input_posn, self.input_rect_size) self.submit_input_rect = spyral.Rect(self.submit_input_posn, self.submit_rect_size) self.highlighted_coord = "x" self.redraw_all_pieces()
def _set_collision_box(self): """ Updates this View's collision box. """ if self._mask is not None: pos = self._mask.topleft - self._offset area = spyral.Rect((0, 0), self._mask.size) else: pos = self._pos - self._offset area = spyral.Rect((0, 0), self.size) c = spyral.util._CollisionBox(pos, area) warped_box = self._parent()._warp_collision_box(c) self._scene()._set_collision_box(self, warped_box.rect)
def _draw(self): """ Internal method for generating this sprite's blit, unless it is invisible or currently static. If it has aged sufficiently or is being forced, it will become static; otherwise, it ages one step. """ if not self.visible: return if self._image is None: raise spyral.NoImageError("A sprite must have an image" " set before it can be drawn.") if self._image_version != self._image._version: self._image_version = self._image._version self._recalculate_transforms() self._expire_static() if self._static: return area = spyral.Rect(self._transform_image.get_rect()) b = spyral.util._Blit(self._transform_image, self._pos - self._offset, area, self._computed_layer, self._blend_flags, False) if self._make_static or self._age > 4: b.static = True self._make_static = False self._static = True self._parent()._static_blit(self, b) return self._parent()._blit(b) self._age += 1
def __init__(self, scene): spyral.Sprite.__init__(self, scene) self.image = spyral.Image("images/mati2.png") self.layer = "fondo" self.scale = 2 self.pos = (self.width, self.width) 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 _get_rect(self): """ A :class:`Rect <spyral.Rect>` representing the position and size of this View. Can be set through a ``Rect``, a 2-tuple of position and size, or a 4-tuple. """ return spyral.Rect(self._pos, self.size)
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 clip(self, rect): """ Applies any necessary cropping to this blit :param rect: The new maximal size of the blit. :type rect: :class:`Rect <spyral.Rect>` """ self.area = self.area.clip(spyral.Rect(rect))
def _recalculate_mask(self): """ Forces a recomputation of the widget's mask, based on the position, internal boxes size, and the padding. """ self.mask = spyral.Rect(self.x + self.padding, self.y + self.padding, self.box_width + self.padding, self._box_height + self.padding)
def get_rect(self): """ Returns a :ref:`rect <spyral_Rect>` representing where this sprite will be drawn. """ return spyral.Rect( (self._pos[0] - self._offset[0], self._pos[1] - self._offset[1]), self.size)
def _warp_collision_box(self, box): """ Transforms the given collision box according to this view's scaling, cropping, and offset; then passes the box to this boxes parent. """ box.position += self.pos box.apply_scale(self.scale) if self.crop: box.clip(spyral.Rect((0, 0), self.crop_size)) return self._parent()._warp_collision_box(box)
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 apply_scale(self, scale): """ Applies the scaling factor to this blit. :param scale: The scaling factor :type scale: :class:`Vec2D <spyral.Vec2D>` """ self.position = self.position * scale self.final_size = self.final_size * scale self.area = spyral.Rect(self.area.topleft * scale, self.area.size * scale)
def _static_blit(self, key, blit): """ If this View is visible, applies offseting, scaling, and cropping before passing it up the transformation chain. """ if self.visible: blit.position += self.pos blit.apply_scale(self.scale) if self.crop: blit.clip(spyral.Rect((0, 0), self.crop_size)) self._parent()._static_blit(key, blit)
def _set_state(self, state): old_value = self.value self._state = state if self.value != old_value: e = spyral.Event(name="changed", widget=self, form=self.form, value=self._get_value()) self.scene._queue_event("form.%(form_name)s.%(widget)s.changed" % {"form_name": self.form.__class__.__name__, "widget": self.name}, e) self.button.image = self._images[state] self.mask = spyral.Rect(self.pos, self.button.size) self._on_state_change()
def _set_collision_box(self): """ Updates this sprite's collision box. """ if self.image is None: return if self._mask is None: area = spyral.Rect(self._transform_image.get_rect()) else: area = self._mask c = spyral.util._CollisionBox(self._pos - self._offset, area) warped_box = self._parent()._warp_collision_box(c) self._scene()._set_collision_box(self, warped_box.rect)
def crop(self, position, size=None): """ Removes the edges of an image, keeping the internal rectangle specified by position and size. :param position: The upperleft corner of the internal rectangle that will be preserved. :type position: a :class:`Vec2D <spyral.Vec2D>` or a :class:`Rect <spyral.Rect>`. :param size: The size of the internal rectangle to preserve. If a Rect was passed in for position, this should be None. :type size: :class:`Vec2D <spyral.Vec2D>` or None. :returns: This image. """ if size is None: rect = spyral.Rect(position) else: rect = spyral.Rect(position, size) new = _new_spyral_surface(size) new.blit(self._surf, (0, 0), (rect.pos, rect.size)) self._surf = new self._version += 1 return self
def _get_rect(self): """ Returns a :class:`Rect <spyral.Rect>` representing the position and size of this Sprite's image. Note that if you change a property of this rect that it will not actually update this sprite's properties: >>> my_sprite.rect.top = 10 Does not adjust the y coordinate of `my_sprite`. Changing the rect will adjust the sprite however >>> my_sprite.rect = spyral.Rect(10, 10, 64, 64) """ return spyral.Rect(self._pos, self.size)
def _render_images(self): """ Recreates the cached images of this widget (based on the **self._image_locations** internal variabel) and sets the widget's image based on its current state. """ for state in self._states: if self._nine_slice: size = self._padding + self._content_size nine_slice_image = spyral.Image(self._image_locations[state]) self._images[state] = spyral.image.render_nine_slice(nine_slice_image, size) else: self._images[state] = spyral.Image(self._image_locations[state]) self.button.image = self._images[self._state] self.mask = spyral.Rect(self.pos, self.button.size) self._on_state_change()
def __init__(self, scene): spyral.Sprite.__init__(self, scene) self.image = spyral.Image(filename="images/comodo.png") self.layer = "frente" self.pos = (0, scene.height - self.height) self.estado = "normal" self.cajita = spyral.Rect(0, 60, scene.width - self.width, scene.height - self.height) self.vida = 100 spyral.event.register("input.keyboard.down.space", self.salto) spyral.event.register("input.keyboard.down.up", self.salto) spyral.event.register("Comodo.y.animation.end", self.fin_salto) spyral.event.register("Comodo.muere", self.muere) spyral.event.register("director.update", self.chequea) pygame.mixer.init() pygame.mixer.music.load("sounds/Harp.ogg") pygame.mixer.music.play(-1) self.flap = pygame.mixer.Sound('sounds/bird_flap.ogg')
def finalize(self): self.rect = spyral.Rect(self.position, self.area.size)
def _recalculate_mask(self): """ Recalculate this widget's mask based on its size, position, and padding. """ self.mask = spyral.Rect(self.pos, self.size + self.padding)
def __init__(self, form, name): self.__style__ = form.__class__.__name__ + '.' + name self.name = name self.form = form spyral.View.__init__(self, form) self.mask = spyral.Rect(self.pos, self.size)
def _get_rect(self): """ Returns a :class:`Rect <spyral.Rect>` representing the position (0, 0) and size of this Scene. """ return spyral.Rect((0, 0), self.size)
def apply_scale(self, scale): self.position = self.position * scale self.area = spyral.Rect(self.area.topleft * scale, self.area.size * scale)
def real_rect(self): return spyral.Rect(self.rect.left - self.width/2.0, self.rect.top - self.height, self.width, self.height)
def clip(self, rect): self.area = self.area.clip(spyral.Rect(rect))