def update(self, screen: pygame.Surface) -> None: """Move the goat.""" if self._timer % 60 == 0: self._timer += random.choice([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) self._x += self._speed * math.cos(math.radians(self._angle)) self._y += self._speed * math.sin(math.radians(self._angle)) if self._x <= 0: self._x = 0 self._angle += 10 self._change_rotation() elif self._x + self.image.get_width() >= screen.get_width(): self._x = screen.get_width() - self.image.get_width() self._angle += 10 self._change_rotation() if self._y <= 0: self._y = 0 self._angle += 10 self._change_rotation() elif self._y + self.image.get_height() >= screen.get_height(): self._y = screen.get_height() - self.image.get_height() self._angle += 10 self._change_rotation() self.rect.top = self._y self.rect.left = self._x self._timer += 1 if self._timer == self._max_timer: self._randomize()
def _inner_pre_draw(self, surface: Surface): main_group_x = surface.get_width() / 2 main_group_y = surface.get_height() / 2 + 100 aux_group_x = surface.get_width() - 200 - 20 aux_group_y = surface.get_height() - 20 surface.blit(self._background_image, (0, 0)) self._start_button.set_position_centered(main_group_x, main_group_y - 80) self._how_to_play.set_position_centered(main_group_x, main_group_y) self._settings_button.set_position(aux_group_x, aux_group_y - 115) self._credits_button.set_position(aux_group_x, aux_group_y - 75) self._quit_button.set_position(aux_group_x, aux_group_y - 35) title_pos = (main_group_x - (self._title_surface.get_width() / 2), 50) surface.blit(self._title_surface, title_pos) surface.blit(self._espiria_image, (main_group_x - 110, 690)) surface.blit(self._insta_image, (10, 650)) surface.blit(self._discord_image, (10, 710)) surface.blit(self._insta_text, (70, 670)) surface.blit(self._discord_text, (70, 730))
def render(self, surface: pygame.Surface, camera: Camera, pixelsPerMeter=1): newVertices = [] for i in range(len(self.__vertices)): newVertices.append( pygame.Vector3(self.__vertices[i].dot(self.getHorisontal()), self.__vertices[i].dot(self.getVertical()), self.__vertices[i].dot(self.getFacing()))) for edge in self.__edges: if camera.isInView(self.getLocation() + newVertices[edge[0]] * self.__scale) or camera.isInView( self.getLocation() + newVertices[edge[1]] * self.__scale): startPosition = (camera.calculatePerspective( self.getLocation() + newVertices[edge[0]] * self.__scale)).elementwise() * pixelsPerMeter endPosition = (camera.calculatePerspective( self.getLocation() + newVertices[edge[1]] * self.__scale)).elementwise() * pixelsPerMeter pygame.draw.line( surface, self.__colour, (startPosition.x, surface.get_height() - startPosition.y), (endPosition.x, surface.get_height() - endPosition.y))
def update_percent(self, screen: pygame.Surface) -> None: self.add_percent() pygame.draw.rect(screen, (0, 0, 0), (0, screen.get_height() - 20, screen.get_width(), 10)) pygame.draw.rect(screen, (187, 11, 11), (0, screen.get_height() - 20, (screen.get_width() / 100) * self.percent, 10))
def draw_card(surface: pygame.Surface, card: SushiCardType, color_fore: Color, color_back: Color, num: int = 1, wasabi: bool = False): OFFSET = 0.03 BORDER_SIZE = 2 if wasabi: num = 2 offset = max(OFFSET * surface.get_width(), OFFSET * surface.get_height()) h = surface.get_height() - offset * (num - 1) w = surface.get_width() - offset * (num - 1) for i in range(num): x = int(offset * i) y = int(offset * i) pygame.draw.rect(surface, color_back, Rect(x, y, w, h)) pygame.draw.rect(surface, color_fore, Rect(x, y, w, h), BORDER_SIZE) App.draw_centered_text(surface, w / 2 + x, h / 2 + y, card, color_fore, 14) if wasabi: App.draw_centered_text(surface, w / 2 + x, h / 2 + y + 15, 'with WASABI', color_fore, 14) else: App.draw_centered_text(surface, w / 2 + x, h / 2 + y + 15, f'x{num}', color_fore, 14)
def finish_game(win: bool, screen: pygame.Surface): """ Is called when game is finished. """ if win: pygame.draw.rect(screen, pygame.Color('yellow'), screen.get_rect()) final_message = 'You win!' else: pygame.draw.rect(screen, pygame.Color('red'), screen.get_rect()) final_message = 'You lost...' # Set font. font = pygame.font.SysFont(name='Ani', size=100) # Place messages. screen.blit(font.render(final_message, True, pygame.Color('black')), (screen.get_width() // 3 + 80, screen.get_height() // 5)) screen.blit( font.render('To exit, press ESC.', True, pygame.Color('black')), (screen.get_width() // 6, screen.get_height() // 4 + 150)) screen.blit( font.render('To restart the game, press any other button.', True, pygame.Color('black')), (screen.get_width() // 4 + 30, screen.get_height() // 4 + 300)) # Display changes. pygame.display.update() _wait_for_command()
def move(self, screen: pygame.Surface, direction: int) -> None: """Move in direction.""" if direction == LEFT: self._angle = 180 self.image = pygame.transform.rotate(self._raw_image, 180) self.rect.left -= self._speed if self.rect.left < 0: self.rect.left = 0 elif direction == RIGHT: self._angle = 0 self.image = self._raw_image self.rect.left += self._speed if self.rect.right > screen.get_width(): self.rect.right = screen.get_width() elif direction == UP: self._angle = 270 self.image = pygame.transform.rotate(self._raw_image, 90) self.rect.top -= self._speed if self.rect.top < 0: self.rect.top = 0 elif direction == DOWN: self._angle = 90 self.image = pygame.transform.rotate(self._raw_image, -90) self.rect.top += self._speed if self.rect.bottom > screen.get_height(): self.rect.bottom = screen.get_height()
class Cell(): def __init__(self, x, y, width, height, block_image): self.x = x self.y = y self.activated = False self.small_block_image = scale_image(block_image, (20, 20)) self.image = Surface((width, height)) self.image.fill((139,69,19)) self.image.set_alpha(60) def update(self, event, cells): if event.type == MOUSEBUTTONDOWN: if event.button == 1: if event.pos[0] in range(self.x, self.x + self.image.get_width()) and event.pos[1] in range(self.y, self.y + self.image.get_height()): button_press_sound.play() self.activated = True for cell in cells: if cell != self: cell.activated = False def draw(self, window): window.blit(self.image, (self.x, self.y)) if self.activated: draw_rect(window, (0, 0, 0), (self.x, self.y, self.image.get_width(), self.image.get_height()), 2) else: draw_rect(window, (150, 150, 150), (self.x, self.y, self.image.get_width(), self.image.get_height()), 2) window.blit(self.small_block_image, ((self.x + self.image.get_width() // 2) - self.small_block_image.get_width() // 2, (self.y + self.image.get_height() // 2) - self.small_block_image.get_height() // 2))
def visualize(self, resolution=1): rotations = [i.rotation for i in self.keyframes] xPositions = [i.x for i in self.keyframes] yPositions = [i.y for i in self.keyframes] maxRotation = max(rotations) minRotation = min(rotations) maxX = max(xPositions) minX = min(xPositions) maxY = max(yPositions) minY = min(yPositions) lowestPoint = min([minX, minY, minRotation]) highestPoint = max([maxX, maxY, maxRotation]) timeEnd = self.keyframes[-1].time sOut = Surface((timeEnd + 20, highestPoint - lowestPoint + 20)) sOut.fill((255, 255, 255)) point = 0 while point < timeEnd: #print(self.current_position(point)) rot, x, y = self.current_position(point) sOut.set_at((int(point + 10), sOut.get_height() - int(rot - lowestPoint + 10)), (255, 0, 0)) sOut.set_at((int(point + 10), sOut.get_height() - int(x - lowestPoint + 10)), (0, 255, 0)) sOut.set_at((int(point + 10), sOut.get_height() - int(y - lowestPoint + 10)), (0, 0, 255)) point += resolution sOut = transform.smoothscale( sOut, (sOut.get_width() * 4, sOut.get_height() * 4)) image.save(sOut, 'rotationVisual.png')
def p_update(self): self.start_x_pos -= self.speed if self.start_x_pos + self.img_width <= 0: self.start_x_pos = Surface.get_width(self.surface) self.y_pos = randint( Surface.get_height(self.surface) / 2 - self.y_range, Surface.get_height(self.surface) / 2 + self.y_range)
def __init__( self, screen: "in_game.screen.screen.InGameScreen", surface: Surface, fonts: Dict[str, Font], sounds: Dict[str, Sound], images: Dict[str, Surface], player: "in_game.play_area.sprites.player.Player") -> None: self.__screen = screen self.__surface = surface self.__fonts = fonts self.__sounds = sounds self.__images = images self.__keyboard = Keyboard( screen, surface, player, self.__fonts, WHITE) for event_handler in self.__keyboard.get_event_handlers(): screen.add_event_handler(event_handler) block_rect = surface.get_rect( topleft=(PlayArea.LEFT_MARGIN, PlayArea.TOP_MARGIN), width=surface.get_width() - PlayArea.LEFT_MARGIN, height=surface.get_height() - PlayArea.TOP_MARGIN) block_surface = surface.subsurface(block_rect) self.__block_area = BlockArea(self, block_surface, fonts, images, sounds, player) player_string = "PLAYER {0:d}: ".format(player.get_number()) size = self.__fonts["big"].size(player_string) initial_pos = (self.__surface.get_width() // 2 - size[0], 5) self.__player_text = pygame.sprite.GroupSingle( TextSprite(initial_pos, player_string, self.__fonts["big"], GREEN) ) initial_pos = (self.__surface.get_width() // 2, 5) score = Score(initial_pos, fonts["big"], sounds["score"]) self.__score = pygame.sprite.GroupSingle(score) self.__debug_info = pygame.sprite.GroupSingle(DebugInfo(self, fonts)) self.__scroll_velocity = 8 self.__line_numbers = pygame.sprite.OrderedUpdates() self.__active_power_up_jump = GroupSingleAnyRect() self.__active_power_up_shield = GroupSingleAnyRect() self.__game_over_score = pygame.sprite.GroupSingle() # (735 - 35) / 32 = 22 self.__max_line_numbers = round((surface.get_height() - PlayArea.TOP_MARGIN) / Block.BLOCK_HEIGHT) if player.get_joystick() is not None: screen.add_event_handler(PlayerJoystickEventHandler(screen, player.get_joystick(), player)) event_handler = PlayerKeyboardEventHandler( screen, PlayArea.key_mappings[player.get_number() - 1], player) screen.add_event_handler(event_handler) self.__game_over_bg = None
def draw(self, screen: pygame.Surface) -> None: screen.blit(self.image, tuple(self.top_left_point)) scrrect = Rect(Color(0, 0, 0), Vector2D(0, 0), Vector2D(screen.get_width(), screen.get_height()), 0) radius = self.width / 2 if self.center.x - radius < 0 or self.center.x + radius > screen.get_width(): self.speed = Vector2D(-self.speed.x, self.speed.y) if self.center.y - radius < 0 or self.center.y + radius > screen.get_height(): self.speed = Vector2D(self.speed.x, -self.speed.y)
def double_tile_surface(surfaceIn: Surface): surfaceOut = Surface( (surfaceIn.get_width() * 2, surfaceIn.get_height() * 2), SRCALPHA) surfaceOut.blit(surfaceIn, (0, 0)) surfaceOut.blit(surfaceIn, (surfaceIn.get_width(), 0)) surfaceOut.blit(surfaceIn, (0, surfaceIn.get_height())) surfaceOut.blit(surfaceIn, (surfaceIn.get_width(), surfaceIn.get_height())) return surfaceOut
def image_action_upscale(self, image: pygame.Surface, parent) -> pygame.Surface: if parent.size != 0: scale_factor_x = parent.size[0] / image.get_width() scale_factor_y = parent.size[1] / image.get_height() scale_factor = min(scale_factor_x, scale_factor_y) new_width = int(image.get_width() * scale_factor) new_height = int(image.get_height() * scale_factor) image = pygame.transform.scale(image, (new_width, new_height)) return image
def image_action_scale_to_height( self, image: pygame.Surface, parent, ) -> pygame.Surface: scale_factor = parent.size[1] / image.get_height() new_width = int(image.get_width() * scale_factor) new_height = int(image.get_height() * scale_factor) image = pygame.transform.scale(image, (new_width, new_height)) return image
def draw(self, surface: pygame.Surface, index: int, color: Tuple[int, int, int] = (255, 0, 0)): bar_height = self.value * surface.get_height() / max(self.parent).value rect = (index * self.parent.bar_width, surface.get_height() - bar_height, self.parent.bar_width, bar_height) pygame.draw.rect(surface, color, rect) pygame.draw.rect(surface, (0, 0, 0), rect, 1) """
def update(self, screen: pygame.Surface) -> None: self.rect.top += self._dy self.rect.left += self._dx if self.rect.right > screen.get_width(): self.rect.right = screen.get_width() elif self.rect.left < 0: self.rect.left = 0 if self.rect.bottom > screen.get_height(): self.rect.bottom = screen.get_height() elif self.rect.top < 0: self.rect.top = 0
def __init__(self, image: pygame.Surface, screen: pygame.Surface) -> None: """Initialize the sprite.""" super().__init__() self.image = image self.rect = self.image.get_rect() self.rect.left = random.randint( int(-image.get_width() / 2), screen.get_width() + int(image.get_width() / 2)) self.rect.top = random.randint( int(-image.get_height() / 2), screen.get_height() + int(image.get_height() / 2)) self._dy = random.randint(4, 10)
def draw(self, screen: pygame.Surface, camera: pygame.Vector3, rx: int, ry: int): vec3 = projection(self.points[0], camera, rx, ry) if (-screen.get_width() < vec3.x < screen.get_width() * 2 and -screen.get_height() * 1 < vec3.y < screen.get_height() * 1.5): c = [ min(max(0, vec3.z * 2) + self.color[0], 255), min(max(0, vec3.z * 2) + self.color[1], 255), min(max(0, vec3.z * 2) + self.color[2], 255) ] if vec3.z > 0: pygame.draw.circle(screen, c, vec3.xy, 30, 10)
def update(self, screen: pygame.Surface) -> None: """Move sprite by _dx, _dy.""" self.rect.top += self._boost * self._dy self.rect.left += self._boost * self._dx if self.rect.right > screen.get_width(): self.rect.right = screen.get_width() - int(self.rect.width / 2) elif self.rect.left < 0: self.rect.left = int(self.rect.width / 2) if self.rect.bottom > screen.get_height(): self.rect.bottom = screen.get_height() - int(self.rect.height / 4) elif self.rect.top < 0: self.rect.top = int(self.rect.height / 4)
def update(self, screen: pygame.Surface) -> None: """Update sprite location.""" self.rect.left += self._dx self.rect.top += self._dy if self.rect.left < 0: self.rect.left = 0 elif self.rect.right > screen.get_width(): self.rect.right = screen.get_width() if self.rect.top < 0: self.rect.top = 0 elif self.rect.bottom > screen.get_height(): self.rect.bottom = screen.get_height()
def pos_of_picture(picture: pygame.Surface, pos: int) -> Point: x = pic_size.w * (pos % COLUMNS) y = pic_size.h * int(pos / COLUMNS) if (picture.get_width() / picture.get_height()) > screen_ratio: h = int((pic_size.w - BORDER * 2) / (picture.get_width() / picture.get_height())) y += int((pic_size.h - h) / 2) elif (picture.get_width() / picture.get_height()) < screen_ratio: w = int((pic_size.h - BORDER * 2) * (picture.get_width() / picture.get_height())) x += int((pic_size.w - w) / 2) return Point(x, y)
def update(self, screen: pygame.Surface) -> None: """Move sprite by _dx, _dy.""" self.rect.top += self._dy self.rect.left += self._dx if self.rect.right < screen.get_width(): self.rect.right = screen.get_width() elif self.rect.left > 0: self.rect.left = 0 if self.rect.bottom < screen.get_height(): self.rect.bottom = screen.get_height() elif self.rect.top > 0: self.rect.top = 0
def render(self, surface: pygame.Surface, size_factor: float): self.previous_state.render(surface, size_factor) s = pygame.Surface((surface.get_width(), surface.get_height())) s.set_alpha(150) s.fill((0, 0, 0)) surface.blit(s, (0, 0)) surface_width = surface.get_width() surface_height = surface.get_height() font = pygame.font.Font("res/arcade.ttf", surface_height // 10) entries = [(font.render(text, True, (255, 255, 255)), font.render(str(score), True, (255, 255, 255))) for text, score in self.high_score] height = max(x.get_height() for x, _ in entries) + 2 * GameMenu.PADDING left = int(surface_width * 0.25) right = int(surface_width * 0.75) top = surface_height // 2 - (height * (len(self.high_score) + 1.5) // 2) header = font.render("High score", True, (255, 255, 255)) header_left = surface_width // 2 - header.get_width() // 2 surface.blit(header, (header_left, top)) top += int(height * 1.5) index = 0 for text, score in entries: if self.index == index: s = pygame.Surface( (surface_width // 2 + GameMenu.PADDING * 2, height)) s.set_alpha(70) s.fill((255, 255, 255)) surface.blit(s, (left - GameMenu.PADDING, top + index * height)) surface.blit(text, (left, top + index * height + GameMenu.PADDING)) surface.blit(score, (right - score.get_width(), top + index * height + GameMenu.PADDING)) t = time.time() if self.index == index and self.score is not None and t - int( t) < 0.5: surface.fill( (255, 255, 255), pygame.Rect(left + text.get_width(), top + index * height, size_factor * Const.pixel_size, height)) index += 1
def __init__(self, filepath: str, surface: pg.Surface): self.surface = surface self.image = pg.image.load(filepath).convert_alpha() self.background = pg.transform.scale( self.image, (self.image.get_width() * int(surface.get_height() / self.image.get_height()), surface.get_height())) # The x-coordinate of the position where the background will be blitted self.blit_position = 0 self.BACKGROUND_WIDTH = self.background.get_width() self.BACKGROUND_HEIGHT = self.background.get_height()
def draw_colourless_rounded_rectangle( large_corner_radius: int, large_shape_surface: pygame.Surface, clear_colour_string: str = '#FFFFFF00', corner_offset: int = 0): """ Draw a rounded rectangle shape in pure white so it is ready to be multiplied by a colour or gradient. TODO: We should be able to make this faster in Pygame 2 with the planned rounded rectangle drawing functions. :param large_corner_radius: The radius of the corners. :param large_shape_surface: The surface to draw onto, the shape fills the surface. :param clear_colour_string: The colour to clear the background to. :param corner_offset: Offsets the corners, used to help avoid overlaps that look bad. """ pygame.draw.circle(large_shape_surface, pygame.Color('#FFFFFFFF'), (large_corner_radius + corner_offset, large_corner_radius + corner_offset), large_corner_radius) if corner_offset > 0: large_shape_surface.fill( pygame.Color(clear_colour_string), pygame.Rect(0, int(large_shape_surface.get_height() / 2), large_shape_surface.get_width(), int(large_shape_surface.get_height() / 2))) large_shape_surface.fill( pygame.Color(clear_colour_string), pygame.Rect(int(large_shape_surface.get_width() / 2), 0, int(large_shape_surface.get_width() / 2), large_shape_surface.get_height())) x_flip = pygame.transform.flip(large_shape_surface, True, False) large_shape_surface.blit(x_flip, (0, 0)) y_flip = pygame.transform.flip(large_shape_surface, False, True) large_shape_surface.blit(y_flip, (0, 0)) large_shape_surface.fill( pygame.Color("#FFFFFFFF"), pygame.Rect( (large_corner_radius, 0), (large_shape_surface.get_width() - (2 * large_corner_radius), large_shape_surface.get_height()))) large_shape_surface.fill( pygame.Color("#FFFFFFFF"), pygame.Rect((0, large_corner_radius), (large_shape_surface.get_width(), large_shape_surface.get_height() - (2 * large_corner_radius))))
def __init__(self, surface, img, offset, y_range, speed=10): self.surface = surface self.img = img self.offset = offset self.y_range = y_range self.speed = speed self.start_x_pos = Surface.get_width(self.surface) + self.offset self.y_pos = randint( Surface.get_height(self.surface) / 2 - self.y_range, Surface.get_height(self.surface) / 2 + self.y_range) self.img_bounds = list(Surface.get_bounding_rect(self.img)) self.img_width = self.img_bounds[2] self.img_height = self.img_bounds[3]
def addScreen(self, screen: pygame.Surface): if self.removeBeforePosting: self.removeScreen() self.removeBeforePosting = False oldHeight = self.screens[-1].get_height() self.scrollLimit += oldHeight if oldHeight < self.height else self.height if screen.get_height() > self.height: self.scrollLimit += (screen.get_height() - self.height) self.screens.append(screen) if self.scrollLimit - self.scrollPosition > 400: self.scrollPosition = self.scrollLimit - 400 self.mode = 'newPanel' else: self.scrollPosition = self.scrollLimit
def draw(self, mousePos, mouseButtons, xPos, yPos, width = None): if width == None: drawSurf = Surface((self.getWidth(), self.height)) else: drawSurf = Surface((width, self.height)) if Rect(xPos, yPos, drawSurf.get_width(), drawSurf.get_height()).collidepoint(mousePos): if mouseButtons[0]: drawSurf.fill(self.clickColour) else: drawSurf.fill(self.hoverColour) else: drawSurf.fill(self.normalColour) renderedLabel = dropDownOptionFont.render(self.label, True, (60, 60, 60)) drawSurf.blit(renderedLabel,(13, drawSurf.get_height()//2-renderedLabel.get_height()//2)) return drawSurf
def scale_picture(picture: pygame.Surface) -> pygame.Surface: if (picture.get_width() / picture.get_height()) > screen_ratio: h = int((pic_size.w - BORDER * 2) / (picture.get_width() / picture.get_height())) image = pygame.transform.scale(picture, (pic_size.w - BORDER * 2, h)) elif (picture.get_width() / picture.get_height()) < screen_ratio: w = int((pic_size.h - BORDER * 2) * (picture.get_width() / picture.get_height())) image = pygame.transform.scale(picture, (w, pic_size.h - BORDER * 2)) else: image = pygame.transform.scale( picture, (pic_size.w - BORDER * 2, pic_size.h - BORDER * 2)) return image
def ingredient_count(self, items, money): # sides are at 650 and 675 # /1200 /900 # 13/24 27/36 ingredient_block = Surface((self.game_engine.width * 11/24, self.game_engine.height * 9/36)) ingredient_block.fill((255, 255, 255)) icon_size = int(ingredient_block.get_width() / (len(items) * 1.5)) icon_width = ingredient_block.get_width() / len(items) j = icon_size / 3 render_top = 15 + icon_size for name, count in items.items(): icon = image.load("images/icon-%s.gif" % name).convert() icon = transform.scale(icon, (icon_size, icon_size)) ingredient_block.blit(icon, (j, 10)) # Put an item count under the icon. ren = self.__font.render(str(count), True, (0, 0, 0)) fw, fh = ren.get_size() render_left = j + (icon_size / 2) - (fw / 2) ingredient_block.blit(ren, (render_left, render_top)) j += icon_width ren = self.__font.render("Funds: %s" % format_money(money), True, (0, 0, 0)) fw, fh = ren.get_size() render_left = ingredient_block.get_width() / 2 - fw / 2 render_top = (ingredient_block.get_height() - render_top) / 2 + render_top ingredient_block.blit(ren, (render_left, render_top)) return ingredient_block
def make_background(self,img_file,desktop_size): in_img = image.load(img_file) out_img = Surface(desktop_size) for x in range((out_img.get_width() // in_img.get_width()) + 1): for y in range((out_img.get_height() // in_img.get_height()) + 1): out_img.blit(in_img, (in_img.get_width() * x, in_img.get_height() * y)) return out_img
def create_dialog(self): f = font.Font(font.get_default_font(), 30) text = f.render(self.text, True, (255, 255, 255)) dialog = Surface((text.get_width() + 20, text.get_height() + 20)) self.stroke(dialog, (255, 0, 0)) dialog.blit(text, ((dialog.get_width() - text.get_width()) / 2, (dialog.get_height() - text.get_height()) / 2)) return dialog
def make_background(self, img_file, desktop_size): in_img = image.load(img_file) out_img = Surface(desktop_size) out_img.fill((0, 0, 0)) left = (out_img.get_width() - in_img.get_width()) / 2 top = (out_img.get_height() - in_img.get_height()) / 2 out_img.blit(in_img, (left, top)) return out_img
class IonField(Sprite): """Sprite that draws a bunch of random horizontal lines inside a rectangle.""" def __init__(self, left, top, width, height, noise_width, noise_height, delay): Sprite.__init__(self) self.top = top self.left = left self.width = width self.height = height self.image = Surface((self.width, self.height)) self.rect = Rect(left, top, self.width, self.height) self.rect = Rect(left, top, 0, 0) self.mask = Mask((self.width, self.height)) self.mask.fill() self.noise_width = noise_width self.noise_height = noise_height self.tick = 0 self.delay = delay def update(self): self.tick = self.tick + 1 if self.tick % self.delay == 0: self.generate_noise() def draw(self, screen): screen.blit(self.image, self.rect) def generate_noise(self): for col in range(0, self.image.get_width(), self.noise_width): for row in range(0, self.image.get_height(), self.noise_height): c = choice(COLORS) draw.rect(self.image, c, Rect(col, row, self.noise_width, self.noise_height))
def drawplant(head_node): devprint("drawing plant") surface = Surface((40, 43), SRCALPHA) rootpos = (surface.get_width()/2, surface.get_height()-3) # the stack has the node, the currentx, and the currenty for each node in it # currentx and currenty are without resizing of the surface stack = [] # keeps track of offset needed because of resizing the surface resizeoffset = (0, 0) for i in range(head_node.repeatnumseparate): stack.append(head_node) firstx = potwidth * random.random() * head_node.brancharea + rootpos[0] stack.append(firstx) stack.append(rootpos[1]) stack.append(math.pi/2) # base angle strait up to start with callcount = 0 while len(stack) != 0 and callcount < 1000: callcount += 1 base_angle = stack.pop() currenty = stack.pop() currentx = stack.pop() node = stack.pop() randomspacings = [0] spacingLength = 0 for i in range(node.repeatnumcircle-1): randomspacings.append(random.uniform(node.anglespace-node.anglevariance*node.anglespace, node.anglespace+node.anglevariance*node.anglespace)) spacingLength += randomspacings[i+1] startspacing = random.uniform(-node.anglevariance*node.anglespace, node.anglevariance*node.anglespace)/2 * random.choice((-1, 1)) # start angle so that it points up on average angle = base_angle + startspacing - (spacingLength/2) + node.angleoffset*random.choice((-1, 1)) # update the random spacing to be final angles for i in range(len(randomspacings)): angle = angle + randomspacings[i] randomspacings[i] = angle for i in range(node.repeatnumcircle): # draw all the plantshapes at this angle # pick a random angle out of the list angle = randomspacings.pop(random.randint(0, len(randomspacings)-1)) widthscalar = 1 + random.random()*node.widthvariance heightscalar = 1 + random.random()*node.heightvariance # now add the current node surface, mainltranslated, mainloffset, new_resize_offset = surface_with_node(surface, node, angle, (currentx, currenty), resizeoffset, widthscalar, heightscalar) resizeoffset = new_resize_offset # find the new currentx and currenty mainlistlen = len(mainltranslated) # add all the children at the current position for childnode in node.children: futureindexpositions = getfuturenodeindexpositions(childnode.repeatnumseparate, mainlistlen, childnode.brancharea) for i in range(childnode.repeatnumseparate): futurex = mainltranslated[futureindexpositions[i]][0]+mainloffset[0] futurey = mainltranslated[futureindexpositions[i]][1]+mainloffset[1] stack.append(childnode) stack.append(futurex) stack.append(futurey) futureangle = listangleatindex(mainltranslated, futureindexpositions[i]) stack.append(futureangle) finalsurfaceanchor = (rootpos[0] + resizeoffset[0], rootpos[1]+resizeoffset[1]) # draw dirt clumps at bottom clumpradius = 4 clumprange = 14 clumpnum = 4 for i in range(clumpnum): gfxdraw.filled_circle(surface, int(finalsurfaceanchor[0] + i * clumprange/clumpnum - clumprange/2)+1, int(finalsurfaceanchor[1]), int(random.uniform(clumpradius/3, clumpradius)), brighten(dirtcolor, -10)) return surface, finalsurfaceanchor
def surface_with_node(surface, node, angle, offset_in, current_resize_offset, widthscalar, heightscalar): transformedlists = transformtopointlists(node.plantshapelist, node.shiftchance, angle, widthscalar, heightscalar) mainloffset = None mainltranslated = None def currentoffset(): return (offset_in[0] + current_resize_offset[0], offset_in[1] + current_resize_offset[1]) def surface_offset(pointlist_bounds): return Rect(currentoffset()[0]-node.anchor[0]+pointlist_bounds[0], currentoffset()[1]-node.anchor[1]+pointlist_bounds[1], pointlist_bounds.width, pointlist_bounds.height) # go through all the plantshapes and their corresponding transformed lists for i in range(len(transformedlists)): currentlist = transformedlists[i] bounds = getlistbounds(currentlist) # make the surface shape_surface = Surface((bounds.width, bounds.height), SRCALPHA) # translate points into this surface shiftedlist = offsetpointlist(currentlist, (-bounds[0], -bounds[1])) # draw the plant shape onto the new surface plantshape = node.plantshapelist[i] if plantshape.fillcolor != None: gfxdraw.filled_polygon(shape_surface, shiftedlist, plantshape.fillcolor) if plantshape.outlinecolor != None: gfxdraw.polygon(shape_surface, shiftedlist, plantshape.outlinecolor) # apply the texture if any for ptexture in plantshape.textures: addtexture(shape_surface, ptexture) # now check if resizing is needed newsurfacerect = surface.get_rect().union(surface_offset(bounds)) if not newsurfacerect == surface.get_rect(): new_surface = Surface((newsurfacerect.width, newsurfacerect.height), SRCALPHA) new_surface.blit(surface, (-newsurfacerect.x, -newsurfacerect.y)) current_resize_offset = (current_resize_offset[0]-newsurfacerect.x, current_resize_offset[1]-newsurfacerect.y) surface = new_surface devprint("Resized surface to " + str(new_surface.get_width()) + " by " + str(new_surface.get_height())) surface.blit(shape_surface, surface_offset(bounds)) # also save the first list for other nodes to go off of if i == 0: # save the offset of l without the resizing mainloffset = surface_offset(bounds) # also remove the current resize offset mainloffset = (mainloffset[0] - current_resize_offset[0], mainloffset[1]-current_resize_offset[1]) mainltranslated = shiftedlist return surface, mainltranslated, mainloffset, current_resize_offset
mdx = randint(-2048,2048) mdy = randint(-2048,2048) def spouses(x, y): global mdx global mdy m = noise.snoise2((x+mdx),(y+mdy),1,1) m = max(0, m) return int(4*m) + 1 shownoise = '-shownoise' in [a.lower() for a in argv] background = Surface(screen.get_size()) if shownoise: background.lock() for y in range(0, background.get_height()): for x in range(0, background.get_width()): background.set_at((x,y), grayvalue(noiseat(x,y))) background.unlock() else: background.fill((255,255,255)) screen.blit(background, (0,0)) sprites = Group() def personat(x,y): return noiseat(x*8,y*8) <= 0.95 for x in range(0, background.get_width(), 8): for y in range(0, background.get_height(), 8):
from factions import * pygame.init() screen = display.set_mode((800,600),HWSURFACE) display.set_caption('Regime Change') background = Surface(screen.get_size()) background.fill((128,128,128)) text = font.SysFont('Courier', 10) plot = background.subsurface(Rect(0, 0, background.get_width(), background.get_height()/2)) chart = background.subsurface(Rect(0, plot.get_height(), background.get_width(), background.get_height()-plot.get_height())) values = 'militarism', 'moralism' society = Society([Faction('aristocracy', (0,0,255), random(), values), Faction('merchant class', (0,255,0), random(), values), Faction('populace', (255,0,0), random(), values)]) for f in society.factions: for v in f.values.keys(): f.values[v] = random() charts = [chart.subsurface(Rect(i * chart.get_width()/len(society.factions), 0,
class TowerFrame(): """ Creates a frame full of information for the selected tower """ def __init__(self, tower, extra_attributes=None): self.tower = tower self.image = Surface((200, 300)).convert() self.image.fill((200, 115, 0)) self.s_width = self.image.get_width() self.s_height = self.image.get_height() # Can't divide by 0 if self.tower.fire_rate == 0: dps_calc = 0 else: dps_calc = self.tower.damage/self.tower.fire_rate tower_attributes = {"Name": self.tower.name, "Fire Rate": self.tower.fire_rate, "Damage": self.tower.damage, "DPS": dps_calc, "Damage Done": self.tower.damage_done} if extra_attributes is None: extra_attributes = dict() self.t_attributes = dict(tower_attributes.items() + extra_attributes.items()) # Upgrades self.font = font.Font(None, 18) self.upgrade_button = Surface((100, 50)).convert() self.upgrade_button.fill((0, 255, 0)) self.upgrade_button.blit(self.font.render("Upgrade", 1, (0, 0, 0)), (self.upgrade_button.get_width()/2 - self.font.size("Upgrade")[0]/2, self.upgrade_button.get_height()/2 - self.font.size("Upgrade")[1]/2)) self.image.blit(self.upgrade_button, (self.image.get_width() - self.upgrade_button.get_width(), self.image.get_height() - self.upgrade_button.get_height())) level_text = "Level: " + str(self.tower.level) self.image.blit(self.font.render(level_text, 1, (0, 0, 0)), (self.image.get_width() - self.upgrade_button.get_width(), self.image.get_height() - self.upgrade_button.get_height() - self.font.size(level_text)[1])) self.image.blit(self.tower.image, (self.s_width/2 - self.tower.image.get_width()/2, 2)) y_value = self.tower.image.get_width() + 7 # Blits the tower description for desc in self.length_splitter(self.font, self.tower.description, self.image.get_width() - 5): self.image.blit(self.font.render(desc, 1, (0, 0, 0)), (5, y_value)) y_value += self.font.get_height() + 1 y_value += 5 # Blits the tower's attributes in this order, tacking all extra stuff at the end for attr in ["Name", "Fire Rate", "Damage", "DPS", "Damage Done"]+extra_attributes.keys(): value = self.t_attributes[attr] self.image.blit(self.font.render(attr + ": " + str(value), 1, (0, 0, 0)), (5, y_value)) y_value += self.font.get_height() + 1 #self.image = OutlinedSurface(self.image, 5).surface @staticmethod # Used to split text up into lines that will fit the surface def length_splitter(font, text, maxlength): ret_list = [] explode = text.split() t_str = "" while len(explode) > 0: if font.size(t_str + explode[0])[0] > maxlength: ret_list.append(t_str) t_str = "" else: t_str += explode.pop(0) + " " if len(explode) == 0: ret_list.append(t_str) return ret_list
class Gameboard(object): ''' classdocs ''' def __init__(self, surface, width, height, song_filename): ''' Constructor ''' #progressively increase; must end with 1 self.PROB_HEALTH = 0.4 self.PROB_KI = 0.7 self.PROB_SHIELD = 0.9 self.PROB_SWORD = 1.0 self.windowSurface = surface self.width = width self.height = height self.song_filename = song_filename board_size = (width, height) self.gameSurface = Surface(board_size) # This will be drawn every frame to the window song_file = open(song_filename) self.song_name = song_file.readline().strip() self.song_length = float(song_file.readline()) self.pixels_per_second = float(song_file.readline()) self.level_filename = song_file.readline().strip() self.music_filename = song_file.readline().strip() self.background_filename = song_file.readline().strip() self.pixel_offset = 0 self.last_frame_time = -1 self.frac_scroll = 0 # print "{0}[{1}] : {2}".format(self.song_name, self.song_length, self.pixels_per_second) # self.background_width = (self.pixels_per_second * self.song_length) + width self.background_width = width + 96 # Jank scroll edition! background_size = (self.background_width, height) self.backgroundSurface = Surface(background_size) self.__render_background() self.backgroundSurface.set_colorkey((0,0,0),pygame.RLEACCEL) #self.backgroundSurface.set_colorkey((217,62,245),pygame.RLEACCEL) #self.backgroundSurface.set_alpha(100,pygame.RLEACCEL) self.mainScreenBackground,self.mainScreenBackgroundRect = load_image_from_folder('backgrounds', self.background_filename) #self.backgroundSurface.blit(mainScreenBackground, (0,0)) #self.__render_background() possible_samurai_positions = [] for i in range(0, 6): possible_samurai_positions.append(PATH_HEIGHT * i + 15) self.samurai = Samurai(possible_samurai_positions) self.samurai_sprite_group = Group(self.samurai) self.bridge_group = OrderedUpdates() self.mine_group = OrderedUpdates() self.enemy_group = OrderedUpdates() self.attack_group = OrderedUpdates() self.healthpack_group = OrderedUpdates() self.ki_potion_group = OrderedUpdates() self.shield_group = OrderedUpdates() self.sword_group = OrderedUpdates() self.explosion_group = OrderedUpdates() # tempSprite = self.samurai_sprite_group.sprites() # tempRect = tempSprite[0].get_rect() # self.testSword = VerticalSlash(tempRect.centerx,tempRect.centery, self.remove_attack) # self.attack_group.add(self.testSword) if sys.platform == "win32": # On Windows, the best timer is time.clock() self.default_timer = time.clock else: # On most other platforms, the best timer is time.time() self.default_timer = time.time def draw(self): self.gameSurface.fill((0,0,0)) #self.gameSurface.fill((217,62,245)) origin = (0, 0) # this_scroll = 0 self.scroll_amount = 0 if self.last_frame_time > 0: cur_time = self.default_timer() self.gap_time = cur_time - self.last_frame_time # print "Pixels per second: {0}\nGap Time: {1}\nScrollAmount: {2}".format(self.pixels_per_second, self.gap_time, this_scroll) self.last_frame_time = cur_time else: self.gap_time = 0 self.last_frame_time = self.default_timer() this_scroll = self.pixels_per_second * self.gap_time self.frac_scroll += this_scroll if self.frac_scroll >= 1: self.scroll_amount = math.floor(self.frac_scroll) self.pixel_offset += self.scroll_amount # print "Now scrolling {0} pixel(s)".format(whole_part) self.frac_scroll -= self.scroll_amount if self.pixel_offset > 96: self.pixel_offset = self.pixel_offset - 96 if self.pixel_offset < 0: self.pixel_offset = 0 self.gameSurface.blit(self.mainScreenBackground, origin) window_rect = Rect(self.pixel_offset, 0, self.gameSurface.get_width(), self.gameSurface.get_height()) # print window_rect self.gameSurface.blit(self.backgroundSurface, origin, window_rect) #All other drawing self.bridge_group.update(self.scroll_amount) self.bridge_group.draw(self.gameSurface) self.mine_group.update(self.scroll_amount) self.mine_group.draw(self.gameSurface) self.enemy_group.update(self.scroll_amount) self.enemy_group.draw(self.gameSurface) self.samurai_sprite_group.update() self.samurai_sprite_group.draw(self.gameSurface) self.healthpack_group.update(self.scroll_amount) self.healthpack_group.draw(self.gameSurface) self.ki_potion_group.update(self.scroll_amount) self.ki_potion_group.draw(self.gameSurface) self.shield_group.update(self.scroll_amount) self.shield_group.draw(self.gameSurface) self.sword_group.update(self.scroll_amount) self.sword_group.draw(self.gameSurface) #self.testSword = VerticalSlash(400,400) #self.attack_group.add(self.testSword) self.attack_group.update() self.attack_group.draw(self.gameSurface) self.explosion_group.update() self.explosion_group.draw(self.gameSurface) # self.testSword.draw(self.gameSurface) for bridge in self.bridge_group.sprites(): if bridge.rect.left < 0: self.bridge_group.remove(bridge) #Annnnd blast it back to the screen window_origin = (0, 60) self.windowSurface.blit(self.gameSurface, window_origin) def add_bridge(self, bridge_num): # print "FAKE BRIDGE" new_bridge = Bridge(1101, bridge_num * PATH_HEIGHT + 39) self.bridge_group.add(new_bridge) def add_mine(self, string_num): # print "CREATE ZE LANDMINE" new_mine = Mine(1101, PATH_HEIGHT * string_num + 42) self.mine_group.add(new_mine) def add_powerup(self, string_num): r = random.random() if r < self.PROB_HEALTH: self.add_healthpack(string_num) elif r < self.PROB_KI: self.add_kiboost(string_num) elif r < self.PROB_SHIELD: self.add_shield(string_num) elif r < self.PROB_SWORD: self.add_sword(string_num) def add_healthpack(self, string_num): # print "such a healthy young man!" new_healthpack = Healthpack(1101, PATH_HEIGHT * string_num + 42) self.healthpack_group.add(new_healthpack) def add_shield(self, string_num): new_shield = Shield(1101, PATH_HEIGHT * string_num + 42) self.shield_group.add(new_shield) def add_sword(self, string_num): new_sword = MegaSword(1101, PATH_HEIGHT * string_num + 42) self.sword_group.add(new_sword) def add_kiboost(self, string_num): new_ki_potion = KiPotion(1101, PATH_HEIGHT * string_num + 42) self.ki_potion_group.add(new_ki_potion) def add_enemy(self, string_num): new_enemy = Enemy(1111, PATH_HEIGHT * string_num + 42) self.enemy_group.add(new_enemy) def add_male_groupie(self, string_num): new_enemy = MaleGroupie(1111, PATH_HEIGHT * string_num + 15) self.enemy_group.add(new_enemy) def add_lawyer(self, string_num): new_lawyer = Lawyer(1111, PATH_HEIGHT * string_num + 15) self.enemy_group.add(new_lawyer) def add_bodyguard(self, string_num): new_bodyguard = Bodyguard(1111, PATH_HEIGHT * string_num + 15) self.enemy_group.add(new_bodyguard) def remove_attack(self, attack): self.attack_group.remove(attack) def add_attack(self, attack): self.attack_group.add(attack) def add_explosion(self, y_val): new_explosion = Explosion(20, y_val, self.explosion_group) def __render_background(self): # Jank implementation that just uses that one sprite over and over again! # Jay's jank dirtBlockThingy is 96x48 pixels num_blocks = int(math.ceil(self.background_width / 96.0)) cur_width = 0 for bI in range(0, num_blocks): for hI in range(0, 6): my_location = (cur_width, (PATH_HEIGHT * hI + 35)) dp = DirtPath(my_location) # print "DirtPath at {0}".format(my_location) self.backgroundSurface.blit(dp.image, my_location) cur_width += 96
class Buffalo(): """ Buffalo object used in the Hunting minigame """ def __init__(self, pos_x, pos_y, picture, size, resource_path): self.picture = picture self.size = size self.resource_path = resource_path self.max_health = 100 * self.size self.health = self.max_health self.preimage = image.load(self.resource_path+"Images/"+self.picture+"_buffalo.png") self.image = scale(self.preimage, (int(self.preimage.get_width()*self.size), int(self.preimage.get_height()*self.size))) self.health_font = font.Font(None, 20) self.health_bar_container = Surface((int(75*self.size), int(12*self.size))).convert() self.health_bar_shader = Surface((self.health_bar_container.get_width() + 6, self.health_bar_container.get_height() + 6)).convert() self.health_number = self.health_font.render(str(self.health), 1, (0, 0, 0)) self.health_bar_shader.fill((175, 175, 175)) self.health_bar = Surface(self.health_bar_container.get_size()).convert() self.health_color = () if self.health >= 50: self.health_color = (float((self.max_health-self.health)*2/self.max_health*255), 255, 0) else: self.health_color = (255, float(self.health*2/self.max_health*255), 0) try: self.health_bar.fill(self.health_color) except TypeError: self.health_bar.fill((0, 0, 0)) self.health_bar_container.blit(self.health_bar, (0, 0)) self.value = 20 * self.size self.rect = Rect((0, 0), self.image.get_size()) self.rect.x = pos_x self.rect.y = pos_y self.status = "alive" self.target_y = pos_y def update(self): # Checks the health and updates the health bar self.preimage = image.load(self.resource_path+"Images/"+self.status+"_buffalo.png") self.image = scale(self.preimage, (int(self.preimage.get_width()*self.size), int(self.preimage.get_height()*self.size))) #Create health bar + shader + container self.health_bar_container = Surface((int(75*self.size), int(12*self.size))).convert() self.health_number = self.health_font.render(str(int(self.health)), 1, (255, 255, 255)) self.health_bar_shader = Surface((self.health_bar_container.get_width() + 6, self.health_bar_container.get_height() + 6)).convert() self.health_bar_shader.fill((175, 175, 175)) if self.health <= 0: self.health_bar = Surface((0, 0)).convert() else: self.health_bar = Surface((int(self.health_bar_container.get_width()/self.max_health*self.health), self.health_bar_container.get_height())).convert() # Set the color of the health_bar_container Red->Yellow->Red based on HP if self.health >= 50: self.health_color = (float((self.max_health-self.health)*2/self.max_health*255), 255, 0) else: self.health_color = (255, float(self.health*2/self.max_health*255), 0) # Band-aid solution # It tends to crash here when self.health_color isn't a valid RGB for some reason try: self.health_bar.fill(self.health_color) except TypeError: self.health_bar.fill((0, 0, 0)) self.health_bar_container.blit(self.health_bar, (0, 0)) self.health_bar_container.blit(self.health_number, (self.health_bar_container.get_width()/2 - self.health_number.get_width()/2, self.health_bar_container.get_height()/2 - self.health_number.get_height()/2)) self.health_bar_shader.blit(self.health_bar_container, (3, 3)) # Defines movement if self.status == "alive": # If buffalo is alive, move them until they reach their target X and Y positions # TODO: this logic should be reworked self.rect.x += float(3 - self.size) if self.rect.y != self.target_y: if self.rect.y < self.target_y: self.rect.y += float(3 - self.size) elif self.rect.y > self.target_y: self.rect.y -= float(3 - self.size) return self.rect.center
class Shop(): def __init__(self, name, inventory, price_mod, group_inventory, group_money, item_prices, position, blit_position, money, resource_path): self.yvalue = 40 self.group_inventory = group_inventory self.group_money = group_money self.price_mod = price_mod self.item_prices = item_prices self.inventory = inventory self.position = position self.blit_position = blit_position self.resource_path = resource_path self.buy_button_list = [] self.sell_button_list = [] # TODO: figure out what these magic numbers mean self.x_pos = (-self.position * 40) + 1280 # Gui stuff # # Main Window self.shop_surface = Surface((500, 300)).convert() # Separator Line self.sep_line = Surface((self.shop_surface.get_width(), 10)).convert() self.sep_line.fill((0, 0, 0)) # Inventory container box self.inv_container = Surface((self.shop_surface.get_width()-20, self.shop_surface.get_height()/2 - 35)).convert() self.inv_container.fill((255, 255, 255)) # Font creation self.title_font = font.Font(None, 30) self.text_font = font.Font(None, 20) # Random name generation if name == "": self.name = capitalize(choice(SHOP_NAME_PREFIX) + "'s " + choice(SHOP_NAME_SUFFIX)) else: self.name = name # Random inventory generation if self.inventory == {}: # TODO: The shop should have random items, not just what the group currently has inventory_random = copy(self.group_inventory) # Assign a random value between 1,10 to each inventory item for key in list(inventory_random.keys()): inventory_random[key] = randint(0, 10) # Inflate food count inventory_random["Food"] *= 20 self.inventory = inventory_random # Random money generation if money is None: self.money = randint(200, 500) else: self.name = name self.render() # Used to get the surface created in self.render() def get_surface(self): self.render() return self.shop_surface # Updates the group_inv and group_money to blit in self.render def update(self, group_inv, group_m): self.group_inventory = group_inv self.group_money = group_m self.render() def move(self, move_value): self.x_pos += (2 * move_value) self.render() def render(self): self.yvalue = 40 self.shop_surface.fill((133, 94, 66)) self.shop_surface.blit(self.title_font.render(self.name + " - $"+str(self.money), 1, (0, 0, 255)), (10, 5)) self.shop_surface.blit(self.inv_container, (10, 25)) self.shop_surface.blit(self.inv_container, (10, self.shop_surface.get_height()/2 + 30)) self.shop_surface.blit(self.text_font.render("Inventory", 1, (255, 0, 0)), (10, 25)) self.shop_surface.blit(self.text_font.render("Amount", 1, (255, 0, 0)), (130, 25)) self.shop_surface.blit(self.text_font.render("Price", 1, (255, 0, 0)), (200, 25)) #Blit the shop's inventory for key in list(self.inventory.keys()): self.shop_surface.blit(self.text_font.render(key+":", 1, (0, 0, 0)), (10, self.yvalue)) self.shop_surface.blit(self.text_font.render(str(self.inventory[key]), 1, (0, 0, 0)), (150, self.yvalue)) self.shop_surface.blit(self.text_font.render("$"+str(self.item_prices[key]*self.price_mod), 1, (0, 0, 0)), (200, self.yvalue)) if len(self.buy_button_list) < len(self.inventory.keys()): button_pos = tuple(map(sum, zip(self.blit_position, (250, self.yvalue)))) self.buy_button_list.append(TransactionButton(transaction="buy", item=key, image_position=(250, self.yvalue), rect_position=button_pos, resource_path=self.resource_path)) self.yvalue += 30 # Shows each button for button in self.buy_button_list: self.shop_surface.blit(button.image, button.image_position) self.shop_surface.blit(self.sep_line, (0, float(self.shop_surface.get_height())/2)) self.shop_surface.blit(self.title_font.render("You - $"+str(self.group_money), 1, (0, 0, 255)), (10, float(self.shop_surface.get_height()) / 2 + 10)) self.shop_surface.blit(self.text_font.render("Inventory", 1, (255, 0, 0)), (10, float(self.shop_surface.get_height()) / 2 + 30)) self.shop_surface.blit(self.text_font.render("Amount", 1, (255, 0, 0)), (130, float(self.shop_surface.get_height()) / 2 + 30)) self.shop_surface.blit(self.text_font.render("Price", 1, (255, 0, 0)), (200, float(self.shop_surface.get_height()) / 2 + 30)) self.yvalue = (float(self.shop_surface.get_height())/2) + 45 #Blit the player's inventory for key in list(self.group_inventory.keys()): self.shop_surface.blit(self.text_font.render(key+":", 1, (0, 0, 0)), (10, self.yvalue)) self.shop_surface.blit(self.text_font.render(str(self.group_inventory[key]), 1, (0, 0, 0)), (150, self.yvalue)) self.shop_surface.blit(self.text_font.render("$"+str(self.item_prices[key]*self.price_mod), 1, (0, 0, 0)), (200, self.yvalue)) if len(self.sell_button_list) < len(self.inventory.keys()): button_pos = tuple(map(sum, zip(self.blit_position, (250, self.yvalue)))) self.sell_button_list.append(TransactionButton(transaction="sell", item=key, image_position=(250, self.yvalue), rect_position=button_pos, resource_path=self.resource_path)) self.yvalue += 30 for button in self.sell_button_list: self.shop_surface.blit(button.image, button.image_position)
def change_vaus_behavior(state, vaus): if state == 'C': pass elif state == 'L': ''' VAUS LASER ''' surfaces = [] laser_sheet_area = Surface((160, 8)) # 32 * 5 laser1_posx = 0 laser2_posx = 32 laser3_posx = 64 laser4_posx = 96 laser5_posx = 128 # En este caso el área 1 coincide con el área del recuadro para el estado inicial area1 = (0, 0, 32, 8) surfaces.append(area1) area2 = Surface((32, 8)) area2_borderlaser = (64, 8, 8, 8) area2_normalbody = (80, 0, 8, 7) area2_borderright = (112, 0, 8, 8) # borde izquierdo vaus láser area2.blit(vaus.animation_sheet.subsurface(area2_borderlaser), (0, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_normalbody), (8, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_normalbody), (16, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_borderright), (24, 0)) surfaces.append((laser2_posx, 0, area2.get_width(), area2.get_height())) area3 = Surface((32, 8)) # Vamos reciclando piezas del vaus láser de áreas anteriores (por ejemplo, podemos reusar el borde del láser) area3_laserbody = (80, 8, 8, 7) area3.blit(vaus.animation_sheet.subsurface(area2_borderlaser), (0, 0)) area3.blit(vaus.animation_sheet.subsurface(area3_laserbody), (8, 0)) area3.blit(vaus.animation_sheet.subsurface(area2_normalbody), (16, 0)) area3.blit(vaus.animation_sheet.subsurface(area2_borderright), (24, 0)) surfaces.append((laser3_posx, 0, area3.get_width(), area3.get_height())) area4 = Surface((32, 8)) area4.blit(vaus.animation_sheet.subsurface(area2_borderlaser), (0, 0)) area4.blit(vaus.animation_sheet.subsurface(area3_laserbody), (8, 0)) area4.blit(vaus.animation_sheet.subsurface(area3_laserbody), (16, 0)) area4.blit(vaus.animation_sheet.subsurface(area2_borderright), (24, 0)) surfaces.append((laser4_posx, 0, area4.get_width(), area4.get_height())) area5 = (0, 16, 32, 8) surfaces.append((laser5_posx, 0, area5[2], area5[3])) laser_sheet_area.blit(vaus.animation_sheet.subsurface(area1), (laser1_posx, 0)) laser_sheet_area.blit(area2, (laser2_posx, 0)) laser_sheet_area.blit(area3, (laser3_posx, 0)) laser_sheet_area.blit(area4, (laser4_posx, 0)) laser_sheet_area.blit(vaus.animation_sheet.subsurface(area5), (laser5_posx, 0)) vaus.animation_sheet = laser_sheet_area vaus.frames = 5 vaus.current_frame = 0 vaus.animate = True vaus.shoot = True return surfaces elif state == 'E': ''' VAUS ELONGATED ''' # Creamos superficie uniendo subsuperficies de una misma sprite sheet # 4 fotogramas # Listado en blanco de áreas, sobre el que se iterará en play_animation() (sprite_factory.py) surfaces = [] elongated_sheet_area = Surface((120, 8)) elongated1_posx = 0 elongated2_posx = 32 # Ancho elongated1 elongated3_posx = 72 # Ancho elongated1 más ancho elongated2 (32 + 40 = 72) # areax = área calculada DE LA SPRITE SHEET ORIGINAL # Original: 32x8 # Esta primera área vale tanto para el sprite en la original como para el sprite en la nueva sprite sheet area1 = (0, 0, 32, 8) surfaces.append(area1) # Elongated 1: 40x8 area2 = Surface((40, 8)) area2_borderleft = (64, 0, 8, 8) area2_center = (80, 0, 8, 7) # x3 area2_borderright = (112, 0, 8, 8) area2.blit(vaus.animation_sheet.subsurface(area2_borderleft), (0, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_center), (8, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_center), (16, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_center), (24, 0)) area2.blit(vaus.animation_sheet.subsurface(area2_borderright), (32, 0)) # Ubicación del segundo sprite en la nueva sprite sheet surfaces.append((elongated2_posx, 0, area2.get_width(), area2.get_height())) # Elongated final: 48x8 area3 = (0, 8, 48, 8) # Ubicación del tercer sprite en la nueva sprite sheet surfaces.append((elongated3_posx, 0, area3[2], area3[3])) # Pintamos las áreas en la superficie en blanco elongated_sheet_area.blit(vaus.animation_sheet.subsurface(area1), (elongated1_posx, 0)) elongated_sheet_area.blit(area2, (elongated2_posx, 0)) elongated_sheet_area.blit(vaus.animation_sheet.subsurface(area3), (elongated3_posx, 0)) vaus.animation_sheet = elongated_sheet_area vaus.frames = 3 vaus.current_frame = 0 vaus.animate = True return surfaces elif state == 'D': pass
try: draw.rect(screen, (100, 100, 100), (5, 100, 630, 360), 0) pos_first_point = first_point(l1, w, t) pos_second_point = second_point(l1, l2, w, t) x1 = pos_first_point[0]+h y1 = pos_first_point[1]+v x2 = pos_second_point[0]+h_for_red_point y2 = pos_second_point[1]+v_for_red_point draw.line(screen, (0, 255, 0), (int(x1), int(y1)), (h, v), width_lines) draw.line(screen, (255, 255, 0), (int(x1), int(y1)), (int(x2), v_for_red_point), width_lines) draw.circle(screen, (0,255,0), (int(x1), int(y1)), radius, 0) draw.circle(screen, (0,255,0), (h, v), radius, 0) draw.circle(screen, (255,0,0), (int(x2), v_for_red_point), radius, 0) except: screen.blit(FF.render('Error in mathematical calculations: change the value of the long arm.', 1, (255, 255, 50)), (10, screen.get_height()/2)) # vyvod inf screen.blit(FF.render('green', 1, (0, 255, 0)), (5, 0)) screen.blit(FF.render('x: ', 1, (255, 255, 0)), (60, 0)) screen.blit(FF.render('%.8f' % pos_first_point[0], 1, (0, 255, 100)), (75, 0)) screen.blit(FF.render(',y: ', 1, (255, 255, 0)), (180, 0)) screen.blit(FF.render('%.8f' % pos_first_point[1], 1, (0, 255, 100)), (200, 0)) ############## screen.blit(FF.render('red', 1, (255, 0, 0)), (5, 20)) screen.blit(FF.render('x: ', 1, (255, 255, 0)), (60, 20)) screen.blit(FF.render('%.8f' % pos_second_point[0], 1, (0, 255, 100)), (75, 20)) screen.blit(FF.render(',y: ', 1, (255, 255, 0)), (180, 20)) screen.blit(FF.render('%.8f' % pos_second_point[1], 1, (0, 255, 100)), (200, 20)) ############## screen.blit(FF.render('the distance between points: ', 1, (255, 255, 255)), (5, 40)) distance_between_points = sqrt((x2-x1)**2 + (v_for_red_point-y1)**2)
class Buffalo(): def __init__(self, posX, posY, picture, size, resourcePath): self.picture = picture self.size = size self.resourcePath = resourcePath self.maxHealth = 100 * self.size self.health = self.maxHealth self.preimage = image.load(self.resourcePath + "img/" + self.picture + "_buffalo.png") self.image = scale(self.preimage, (int(self.preimage.get_width() * self.size), int(self.preimage.get_height() * self.size))) self.healthFont = font.Font(None, 20) self.healthBarContainer = Surface((int(75 * self.size), int(12 * self.size))).convert() self.healthBarShader = Surface((self.healthBarContainer.get_width() + 6, self.healthBarContainer.get_height() + 6)).convert() self.healthNumber = self.healthFont.render(str(self.health), 1, (0, 0, 0)) self.healthBarShader.fill((175, 175, 175)) self.healthBar = Surface(self.healthBarContainer.get_size()).convert() self.healthColour = () if (self.health >= 50): self.healthColour = (float((self.maxHealth - self.health) * 2 / self.maxHealth * 255), 255, 0) else: self.healthColour = (255, float(self.health * 2 / self.maxHealth * 255), 0) try: self.healthBar.fill(self.healthColour) except TypeError: self.healthBar.fill((0, 0, 0)) self.healthBarContainer.blit(self.healthBar, (0, 0)) self.value = 20 * self.size self.rect = Rect((0, 0), self.image.get_size()) self.rect.x = posX self.rect.y = posY self.status = "alive" self.targetY = posY def update(self): self.preimage = image.load(self.resourcePath + "img/" + self.status + "_buffalo.png") self.image = scale(self.preimage, (int(self.preimage.get_width() * self.size), int(self.preimage.get_height() * self.size))) self.healthBarContainer = Surface((int(75 * self.size), int(12 * self.size))).convert() self.healthNumber = self.healthFont.render(str(int(self.health)), 1, (255, 255, 255)) self.healthBarShader = Surface((self.healthBarContainer.get_width() + 6, self.healthBarContainer.get_height() + 6)).convert() self.healthBarShader.fill((175, 175, 175)) if (self.health <= 0): self.healthBar = Surface((0, 0)).convert() else: self.healthBar = Surface((int(self.healthBarContainer.get_width() / self.maxHealth * self.health), self.healthBarContainer.get_height())).convert() if (self.health >= 50): self.healthColour = (float((self.maxHealth - self.health) * 2 / self.maxHealth * 255), 255, 0) else: self.healthColour = (255, float(self.health * 2 / self.maxHealth * 255), 0) try: self.healthBar.fill(self.healthColour) except TypeError: self.healthBar.fill((0, 0, 0)) self.healthBarContainer.blit(self.healthBar, (0, 0)) self.healthBarContainer.blit(self.healthNumber, (self.healthBarContainer.get_width() / 2 - self.healthNumber.get_width() / 2, self.healthBarContainer.get_height() / 2 - self.healthNumber.get_height() / 2)) self.healthBarShader.blit(self.healthBarContainer, (3, 3)) if (self.status == "alive"): self.rect.x += float(3 - self.size) if (self.rect.y != self.targetY): if (self.rect.y < self.targetY): self.rect.y += float(3 - self.size) elif (self.rect.y > self.targetY): self.rect.y -= float(3 - self.size) return self.rect.center
class Shop(): def __init__(self, name, inventory, priceModifier, groupInventory, groupMoney, itemPrices, position, blitPosition, money, resourcePath): self.yValue = 40 self.groupInventory = groupInventory self.groupMoney = groupMoney self.priceModifier = priceModifier self.itemPrices = itemPrices self.inventory = inventory self.position = position self.blitPosition = blitPosition self.resourcePath = resourcePath self.buyButtonList = [] self.sellButtonList = [] self.xPos = (-self.position * 40) + 1280 self.shopSurface = Surface((500, 300)).convert() self.sepLine = Surface((self.shopSurface.get_width(), 10)).convert() self.sepLine.fill((0, 0, 0)) self.invContainer = Surface((self.shopSurface.get_width() - 20, self.shopSurface.get_height() / 2 - 35)).convert() self.invContainer.fill((255, 255, 255)) self.titleFont = font.Font("res/fonts/west.ttf", 17) self.textFont = font.Font("res/fonts/west.ttf", 15) if (name == ""): self.name = (choice(SHOP_PREFIX) + "'s " + choice(SHOP_SUFFIX)).capitalize() else: self.name = name if (self.inventory == {}): inventoryRandom = copy(self.groupInventory) for key in list(inventoryRandom.keys()): inventoryRandom[key] = randint(0, 10) inventoryRandom["Food"] *= 20 self.inventory = inventoryRandom if (money is None): self.money = randint(200, 500) else: self.name = name self.render() def get_surface(self): self.render() return self.shopSurface def update(self, groupInv, groupMoney): self.groupInventory = groupInv self.groupMoney = groupMoney self.render() def move(self, moveValue): self.xPos += (2 * moveValue) self.render() def render(self): self.yValue = 40 self.shopSurface.fill((133, 94, 66)) self.shopSurface.blit(self.titleFont.render(self.name + " - $" + str(self.money), 1, (0, 0, 255)), (10, 5)) self.shopSurface.blit(self.invContainer, (10, 25)) self.shopSurface.blit(self.invContainer, (10, self.shopSurface.get_height() / 2 + 30)) self.shopSurface.blit(self.textFont.render("Inventory", 1, (255, 0, 0)), (10, 25)) self.shopSurface.blit(self.textFont.render("Amount", 1, (255, 0, 0)), (130, 25)) self.shopSurface.blit(self.textFont.render("Price", 1, (255, 0, 0)), (200, 25)) for key in list(self.inventory.keys()): self.shopSurface.blit(self.textFont.render(key + ":", 1, (0, 0, 0)), (10, self.yValue)) self.shopSurface.blit(self.textFont.render(str(self.inventory[key]), 1, (0, 0, 0)), (150, self.yValue)) self.shopSurface.blit(self.textFont.render("$"+str(self.itemPrices[key] * self.priceModifier), 1, (0, 0, 0)), (200, self.yValue)) if (len(self.buyButtonList) < len(self.inventory.keys())): buttonPos = tuple(map(sum, zip(self.blitPosition, (250, self.yValue)))) self.buyButtonList.append(TransactionButton(transaction = "buy", item = key, imagePosition = (250, self.yValue), rectPosition = buttonPos, resourcePath = self.resourcePath)) self.yValue += 30 for button in self.buyButtonList: self.shopSurface.blit(button.image, button.imagePosition) self.shopSurface.blit(self.sepLine, (0, float(self.shopSurface.get_height()) / 2)) self.shopSurface.blit(self.titleFont.render("You - $" + str(self.groupMoney), 1, (0, 0, 255)), (10, float(self.shopSurface.get_height()) / 2 + 10)) self.shopSurface.blit(self.titleFont.render("Inventory", 1, (255, 0, 0)), (10, float(self.shopSurface.get_height()) / 2 + 30)) self.shopSurface.blit(self.titleFont.render("Amount", 1, (255, 0, 0)), (130, float(self.shopSurface.get_height()) / 2 + 30)) self.shopSurface.blit(self.titleFont.render("Price", 1, (255, 0, 0)), (200, float(self.shopSurface.get_height()) / 2 + 30)) self.yValue = (float(self.shopSurface.get_height()) / 2) + 45 for key in list(self.groupInventory.keys()): self.shopSurface.blit(self.textFont.render(key + ":", 1, (0, 0, 0)), (10, self.yValue)) self.shopSurface.blit(self.textFont.render(str(self.groupInventory[key]), 1, (0, 0, 0)), (150, self.yValue)) self.shopSurface.blit(self.textFont.render("$" + str(self.itemPrices[key] * self.priceModifier), 1, (0, 0, 0)), (200, self.yValue)) if (len(self.sellButtonList) < len(self.inventory.keys())): buttonPos = tuple(map(sum, zip(self.blitPosition, (250, self.yValue)))) self.sellButtonList.append(TransactionButton(transaction = "sell", item = key, imagePosition = (250, self.yValue), rectPosition = buttonPos, resourcePath = self.resourcePath)) self.yValue += 30 for button in self.sellButtonList: self.shopSurface.blit(button.image, button.imagePosition)
class SnakeUI: """Snake's game menu """ def __init__(self, main_ui, game=None): if game != None: self.snake_game = game else: level_manager = LevelManager(LEVELS_DIRECTORY) self.snake_game = Game(level_manager) self.last_move = GameMoves.PASS self.main_ui = main_ui level = self.snake_game.current_level self.maze_size = (level.maze_height, level.maze_width) self.game_surface = Surface(transform(self.maze_size, 2, 2)) #colors and images self.green_color = Color(151, 255, 148) self.white_color = Color(255, 255, 255) self.black_color = Color(0, 0, 0) self.apple = image.load('images/apple.png') self.block = image.load('images/block.png') self.brick = image.load('images/brick.jpg') #fonts self.info_font = font.Font(None, 23) self.is_running = True def draw(self): if self.is_running and self.main_ui.frame % GUI_GAME_SPEED == 0: self.snake_game.move(self.last_move) self.last_move = GameMoves.PASS level = self.snake_game.current_level if self.maze_size != (level.maze_width, level.maze_height): self.maze_size = (level.maze_height, level.maze_width) self.game_surface = Surface(transform(self.maze_size, 2, 2)) self.game_surface.fill(self.green_color) self.__draw_apple() self.__draw_snake() self.__draw_barrier() self.__draw_level_info() surface_width = self.main_ui.surface.get_width() surface_height = self.main_ui.surface.get_height() game_width = self.game_surface.get_width() game_height = self.game_surface.get_height() y_pos = surface_width / 2 - game_width / 2 x_pos = surface_height / 2 - game_height / 2 game_surface_pos = (y_pos, x_pos) self.main_ui.surface.blit(self.game_surface, game_surface_pos) def __draw_apple(self): apple_position = transform(self.snake_game.current_level.apple, 1, 1) self.game_surface.blit(self.apple, apple_position) def __draw_snake(self): level = self.snake_game.current_level for block in level.snake: self.game_surface.blit(self.block, transform(block, 1, 1)) def __draw_barrier(self): level = self.snake_game.current_level for brick in level.barrier: self.game_surface.blit(self.brick, transform(brick, 1, 1)) brick_height = self.brick.get_height() brick_width = self.brick.get_width() maze_height = self.game_surface.get_height() maze_width = self.game_surface.get_width() for x in range(0, maze_width, brick_width): self.game_surface.blit(self.brick, (x, 0)) for x in range(0, maze_width, brick_width): self.game_surface.blit(self.brick, (x, maze_height - brick_height)) for y in range(0, maze_height, brick_height): self.game_surface.blit(self.brick, (0, y)) for y in range(0, maze_height, brick_height): self.game_surface.blit(self.brick, (maze_width - brick_width, y)) def __draw_level_info(self): level = self.snake_game.current_level current_level = level.level snake_len = level.snake_length snake_max_len = level.snake_max_length info ='Level: {0} Snake Length: {1}/{2}'\ .format(current_level, snake_len, snake_max_len) info_surface = self.info_font.render(info, False, self.black_color) self.main_ui.surface.blit(info_surface, (10, 10)) def handle_events(self): for current_event in pygame.event.get(): if current_event.type == QUIT: pygame.quit() sys.exit() elif current_event.type == KEYDOWN: if current_event.key == K_LEFT: self.last_move = GameMoves.LEFT elif current_event.key == K_RIGHT: self.last_move = GameMoves.RIGHT elif current_event.key == K_UP: self.last_move = GameMoves.UP elif current_event.key == K_DOWN: self.last_move = GameMoves.DOWN elif current_event.key == K_ESCAPE: self.main_ui.state = GameMenuUI(self.main_ui, self)
class Weapon(Item): def __init__(self, game, name): """ Slightly depreciated weapon class. Will need major rewriting. Used for loading and applying weapon characteristics to the player. """ self.game = game #setup base vars of all weapon(s) self.type = None self.shown = True self.range = 10 self.damage = 1 self.cooldown = 500 # in MS self.speed = 4 self.projectile = None self.loadWeapon(name) # attack based vars self.attacking = False def loadWeapon(self, name): """ Uses the weapon config file to load all weapon characteristics. """ config_file = open(os.path.join('rec', 'weapon', name, 'config.py')).read() exec(config_file) self.hold_image = img_load(os.path.join('rec', 'weapon', name, 'hold.png')).convert_alpha() if os.path.exists(os.path.join('rec', 'weapon', name, 'attack.png')): self.attack_image = img_load(os.path.join('rec', 'weapon', name, 'attack.png')).convert_alpha() else: self.attack_image = Surface([1, 1]) def getSurface(self, name): fi_name = name.lower().replace(' ', '_') + '.png' return img_load(os.path.join(self.game.main_path, 'rec', 'weapon', name, fi_name)) def preUpdate(self, ttime): """ Called before the update function, can be overriden for new functionality. """ pass def update(self, ttime): """ Main weapon update, should not be overriden. """ self.preUpdate(ttime) if self.type == 'short': self.shortUpdate() elif self.type == 'long': self.longUpdate() elif self.type == 'ranged': self.rangedUpdate() else: pass def shortAttack(self): self.attacking = True if self.game.Player.player_face == 'front': # I do not know why this vector needs to be 0 while the others are like, 1 self.directional_attack_image = rotate(self.attack_image, 180) self.sub_vector = [0, 0] elif self.game.Player.player_face == 'left': self.directional_attack_image = rotate(self.attack_image, 90) self.sub_vector = [-1, 0] elif self.game.Player.player_face == 'back': self.directional_attack_image = rotate(self.attack_image, 0) self.sub_vector = [0, -1] elif self.game.Player.player_face == 'right': self.directional_attack_image = rotate(self.attack_image, 270) self.sub_vector = [0.8, 0] # editing this seems to change the speed of the right dagger swing a bit self.game.Player.can_move = False self.receding = False self.potent = True self.weapon_rect = Rect(1, 1, 1, 1) p_coords = [self.game.Player.player_r.x, self.game.Player.player_r.y] a_coords = [p_coords[0] + self.game.Player.getRigging()[0], p_coords[1] + self.game.Player.getRigging()[1]] if self.game.Player.player_face == 'right' or self.game.Player.player_face == 'left': a_coords = [a_coords[0] - self.attack_image.get_height(), a_coords[1] - self.attack_image.get_width()] self.blit_pos = a_coords self.attack_ticks = self.range def shortUpdate(self): if self.attacking: for repeats in xrange(self.speed): self.game.Player.player_state = 3 self.blit_pos[0] += self.sub_vector[0] self.blit_pos[1] += self.sub_vector[1] if self.receding: self.attack_ticks += 1 elif not self.receding: self.attack_ticks -= 1 # check all monsters for touching weapon for index, monster in enumerate(self.game.EntityHandler.monsters): if monster.rect.colliderect(self.weapon_rect): if self.potent: monster.takeDamage(index, self.damage) self.potent = False if self.attacking and self.attack_ticks == self.range and self.receding: self.attacking = False self.game.Player.can_move = True elif self.attacking and self.attack_ticks <= 0 and not self.receding: self.receding = True self.sub_vector[0] *= -1 self.sub_vector[1] *= -1 def shortBlit(self): if self.attacking: if self.game.Player.player_face == 'front' or self.game.Player.player_face == 'back': height = self.directional_attack_image.get_rect().height d_rect = Rect([0, height - (self.range - self.attack_ticks)], [100, 100]) self.weapon_rect = self.game.screen.blit(self.directional_attack_image, self.game.off([self.blit_pos[0], self.blit_pos[1]]), d_rect) unoff_pos = self.game.unoff([self.weapon_rect.x, self.weapon_rect.y]) self.weapon_rect.x = unoff_pos[0] self.weapon_rect.y = unoff_pos[1] elif self.game.Player.player_face == 'right' or self.game.Player.player_face == 'left': pos = self.game.off([self.blit_pos[0] + self.rigging[1], self.blit_pos[1]]) if self.game.Player.player_face == 'left': #this prevents the "hover" look of the dagger off the default player body pos[0] += 7 width = self.directional_attack_image.get_rect().width d_rect = Rect([width - (self.range - self.attack_ticks), 0], [100, 100]) self.weapon_rect = self.game.screen.blit(self.directional_attack_image, pos, d_rect) unoff_pos = self.game.unoff([self.weapon_rect.x, self.weapon_rect.y]) self.weapon_rect.x = unoff_pos[0] self.weapon_rect.y = unoff_pos[1] def longAttack(self): self.attacking = True self.y_offset = 0 self.x_offset = 0 if self.game.Player.player_face == "front": self.init_angle = 180 elif self.game.Player.player_face == "back": self.init_angle = 0 self.y_offset = -self.game.Player.getSize()[1]*0.60 - self.attack_image.get_height() self.x_offset = -self.game.Player.getSize()[0]*0.60 elif self.game.Player.player_face == "left": self.init_angle = 90 self.x_offset = -self.game.Player.getSize()[0] - self.attack_image.get_height() elif self.game.Player.player_face == "right": self.init_angle = 270 self.directional_attack_image = rotate(self.attack_image, self.init_angle) self.attack_rect = self.directional_attack_image.get_rect() self.angle = 0 def longUpdate(self): if self.attacking: for x in xrange(5): attack_size = self.directional_attack_image.get_size() turn_point = [0, 0] if self.game.Player.isVertical(): turn_point = [attack_size[0]/2, 0] elif self.game.Player.isHorizontal(): turn_point = [0, attack_size[1]/2] self.mod_DAT = rotate(self.directional_attack_image, self.angle + 45) if self.angle < -90: self.attacking = False self.angle -= 1 def longBlit(self): if self.attacking: blit_pos = self.game.off(self.game.Player.getPos()) blit_pos = vector.add(blit_pos, self.game.Player.getRigging()) blit_pos = vector.sub(blit_pos, self.attack_image.get_size()) #offset for left/back blit_pos[0] += self.x_offset blit_pos[1] += self.y_offset self.new_rect = self.game.screen.blit(self.mod_DAT, blit_pos) self.new_rect.center = self.attack_rect.center self.attack_rect = self.new_rect def rangedAttack(self): pass def rangedUpdate(self): pass def rangedBlit(self): pass def blit(self): """ Called before the player is blitted """ if self.game.Player.player_face == 'back' and not self.attacking: self.drawInHand() if self.type == 'short': self.shortBlit() elif self.type == 'long': self.longBlit() elif self.type == 'ranged': self.rangedBlit() def blitAfter(self): if self.game.Player.player_face == 'front' and not self.attacking: self.drawInHand() def drawInHand(self): p_coords = [self.game.Player.player_r.x, self.game.Player.player_r.y] a_coords = [p_coords[0] + self.game.Player.getRigging()[0] - self.game.Player.equipment['weapon'].rigging[0], p_coords[1] + self.game.Player.getRigging()[1] - self.game.Player.equipment['weapon'].rigging[1]] self.game.screen.blit(self.hold_image, self.game.off(a_coords)) def onClick(self, game, vector): """ Called when the world is clicked. Activates the weapon. """ if self.projectile: game.Projectile(game, self.projectile, vector) if self.type == 'short': self.shortAttack() elif self.type == 'long': self.longAttack() elif self.type == 'ranged': self.rangedAttack()