def __drawLines(self, x1, y1, x2, y2): """ Draws lines in the target area. """ for x in range(x1, x2, self.LINE_SPACING): line = rect.Rect(x, y1, self.LINE_SIZE, y2 - y1) draw.rect(self.__surface, self.__colors[1], line) for y in range(y1, y2, self.LINE_SPACING): line = rect.Rect(x1, y, x2 - x1, self.LINE_SIZE) draw.rect(self.__surface, self.__colors[1], line)
def redraw_tile(self, tile): self.map_sprite.blit(self.map.map_set[tile].surface, rect.Rect(((tile[0] - self.map.x_min) * TILE_SIZE[0], (tile[1] - self.map.y_min) * TILE_SIZE[1]), TILE_SIZE)) for object in self.map.map_set[tile].objects: new_surface = surface.Surface((16, 16)) new_surface.set_colorkey(new_surface.get_at((0, 0))) if object.id == "FLAGS[0]": transform.scale(FLAGS[0].image, (16, 16), new_surface) self.map_sprite.blit(new_surface, rect.Rect(((tile[0] - self.map.x_min) * TILE_SIZE[0] + TILE_SIZE[0] / 4, (tile[1] - self.map.y_min) * TILE_SIZE[1] + TILE_SIZE[1] * 3 / 5), TILE_SIZE)) elif object.id == "FLAGS[1]": transform.scale(FLAGS[1].image, (16, 16), new_surface) self.map_sprite.blit(new_surface, rect.Rect(((tile[0] - self.map.x_min) * TILE_SIZE[0] + TILE_SIZE[0] * 2 / 3, (tile[1] - self.map.y_min) * TILE_SIZE[1] + TILE_SIZE[1] / 2), TILE_SIZE)) elif object.id == "FLAGS[2]": transform.scale(FLAGS[2].image, (16, 16), new_surface) self.map_sprite.blit(new_surface, rect.Rect(((tile[0] - self.map.x_min) * TILE_SIZE[0] + TILE_SIZE[0] / 3, (tile[1] - self.map.y_min) * TILE_SIZE[1] + TILE_SIZE[1] / 3), TILE_SIZE)) draw.rect(self.map_sprite, BROWN, rect.Rect(((tile[0] - self.map.x_min) * TILE_SIZE[0], (tile[1] - self.map.y_min) * TILE_SIZE[1]), TILE_SIZE), 1)
def __init__(self, screen, position, text, img1, img2=None, is_active=True): """ :param screen: :param img1: :param img2: :param position: :param text: """ self.img_active = image.load(img1) if img2: self.img_inactive = image.load(img2) self.width = self.img_active.get_width() self.height = self.img_active.get_height() self.left = position[0] - self.width // 2 self.top = position[1] - self.height // 2 self.text = text self.screen = screen self.font = font.Font('freesansbold.ttf', 32) self.rect = rect.Rect(self.left, self.top, self.width, self.height) self.is_active = is_active
class RsImage(object): """ RsImage(image_path) Raw image of a sprite that contains single image or multiple images. """ number: int = -1 raw_data: list[PySurface] boundbox = PyRect.Rect(0, 0, 0, 0) def __init__(self, filepath: Union[list[str], str]) -> None: if type(filepath) is str: self.number = 0 self.raw_data.append(PyImage.load(filepath)) self.filename = os.path.splitext(filepath)[0] else: self.number = len(filepath) for file in filepath: self.raw_data.append(PyImage.load(file)) self.filename = os.path.splitext(filepath[0])[0] self.boundbox.width = self.raw_data[0].get_width() self.boundbox.height = self.raw_data[0].get_height() def draw(self, x: float, y: float, index: int): if self.number == 0: Temp = self.raw_data[0] Temp.get_rect() else: pass
def __drawBorder(self): """ Method to draw borders on the final scoreboard screen. """ b1 = rect.Rect(self.__geometry[0], self.__geometry[1], self.__border, self.__geometry[3] - self.__geometry[1]) b2 = rect.Rect(self.__geometry[2] - self.__border, self.__geometry[1], self.__border, self.__geometry[3] - self.__geometry[1]) b3 = rect.Rect(self.__geometry[0], self.__geometry[1], self.__geometry[2] - self.__geometry[0], self.__border) b4 = rect.Rect(self.__geometry[0], self.__geometry[3] - self.__border, self.__geometry[2] - self.__geometry[0], self.__border) for border in [b1, b2, b3, b4]: draw.rect(self.__surface, self.__border_color, border)
def __init__(self, screen, x, y, w=30, h=140, value=0): self.screen = screen self.w = w self.h = h self.volume_bar_x = x self.y = y - self.h self.rect = rect.Rect(x, self.y, self.w, self.h) self.value = value
def update(self): draw.rect(self.screen, (240, 240, 240), self.rect, width=0, border_radius=2) value = self.value * self.h // 100 value_rect = rect.Rect(self.volume_bar_x, self.y + self.h - value, self.w, value) draw.rect(self.screen, (100, 240, 240), value_rect, width=0, border_radius=2) draw.rect(self.screen, (170, 170, 170), self.rect, width=2, border_radius=2)
def surface_setup(image, image_size, image_offset=(0, 0), color_key=None, scaling=None): return_surface = surface.Surface(image_size) return_surface.blit(image, (0, 0), rect.Rect(image_offset, image_size)) if scaling is not None: return_surface = transform.scale(return_surface, (int(image_size[0] * scaling), int(image_size[1] * scaling))) if color_key is not None: return_surface.set_colorkey(color_key) return_surface = return_surface.convert() return return_surface
def test_rect(test_surf): """Draw several rectangles.""" for y in range(10, 200, 45): x = 10 for width in range(10, 30, 3): for height in range(10, 40, 7): r = rect.Rect(x, y, width, height) x += width + 2 draw.rect(test_surf, (255, 255, 255, 255), r)
def __init__(self, rangel, ranger, length): self.range = (rangel, ranger) _tempRect = rect.Rect(settings.drawing_area[0][0]+int(((rangel)/length) * (settings.drawing_area[1][0]-settings.drawing_area[0][0])) - settings.numbers_gap, settings.drawing_area[0][1], int((settings.drawing_area[1][0] - settings.drawing_area[0][0])/length) * (ranger - rangel + 1), (settings.drawing_area[1][1]-settings.drawing_area[0][1])) super().__init__(_tempRect)
def make_paint_helper(self, surf, color_map): for i, arr in enumerate(self.data): for j, el in enumerate(arr): rect = rec.Rect(i * (Board.WIDTH + Board.PADDING), j * (Board.WIDTH + Board.PADDING), Board.WIDTH, Board.WIDTH) col = color_map[el] if (el != None): col = Board.brighten(col) pydraw.rect(surf, col, rect)
def drawArea(self): """ Draws the target area. """ background = rect.Rect(self.__geometry[0], self.__geometry[1], self.__geometry[2] - self.__geometry[0], self.__geometry[3] - self.__geometry[1]) draw.rect(self.__surface, self.__colors[0], background) self.__drawLines(*self.__geometry)
def __init__(self, number, index, length, use_custom_color=False, customColor=(0, 0, 0)): if use_custom_color: self.mode = "custom" else: self.mode = "unsolved" self.selected = False self.number = number self.preNumber = None self.customColor = customColor self.starting_pos = rect.Rect(0, 0, 0, 0) self.destination = rect.Rect(0, 0, 0, 0) self.animation = anim.Animation() self.colorAnimation = None self.UpdateNumberRect(index, length)
def update_surface(self, new_surface, overwrite=True): if surface is not None: if overwrite: self.surface = new_surface else: self.surface.blit(new_surface, (0, 0)) self.rect = rect.Rect(self.location[0] * self.surface.get_width(), self.location[1] * self.surface.get_height(), self.surface.get_width(), self.surface.get_height())
def __init__(self, displayContext, *args): ws = displayContext.getWindowSize() r = rect.Rect(0, 0, ws[0], ws[1]) GLViewport.__init__(self, r) self.displayContext = displayContext self.bg_color = (0, 0, 0, 1) self.anchor = 'tlbr' if not config.config.has_section("Recent Worlds"): config.config.add_section("Recent Worlds") self.setRecentWorlds([""] * 5) self.optionsPanel = panels.OptionsPanel(self) if not albow.translate.buildTemplate: self.optionsPanel.getLanguageChoices() lng = config.settings.langCode.get() if lng not in self.optionsPanel.sgnal: lng = "en_US" config.settings.langCode.set(lng) albow.translate.setLang(lng) self.optionsPanel.initComponents() self.graphicsPanel = panels.GraphicsPanel(self) #&# Prototype for blocks/items names mclangres.buildResources(lang=albow.translate.getLang()) #&# #.# self.keyConfigPanel = keys.KeyConfigPanel(self) #.# self.droppedLevel = None self.nbtCopyBuffer = None self.reloadEditor() """ check command line for files dropped from explorer """ if len(sys.argv) > 1: for arg in sys.argv[1:]: f = arg.decode(sys.getfilesystemencoding()) if os.path.isdir( os.path.join(pymclevel.minecraftSaveFileDir, f)): f = os.path.join(pymclevel.minecraftSaveFileDir, f) self.droppedLevel = f break if os.path.exists(f): self.droppedLevel = f break self.fileOpener = albow.FileOpener(self) self.add(self.fileOpener) self.fileOpener.focus()
def createNewApple(self): """ Método para criar uma nova maçã. """ width, height = self.__surface.get_size() x = random.randint(self.__size + self.__margin[0] , width - self.__size - self.__margin[0]) y = random.randint(self.__size + self.__margin[1] , height - self.__size - self.__margin[1]) self.__rect = rect.Rect(x, y, self.__size, self.__size)
def fit_text_lines_to_surface(surface, text, color, max_size_rect, font, rows, anti_aliasing=False, background=None): size_rect = rect.Rect(max_size_rect) y = size_rect.top line_spacing = -2
def UpdateNumberRect(self, index, length): self.rect = rect.Rect( settings.drawing_area[0][0] + int( ((index) / length) * (settings.drawing_area[1][0] - settings.drawing_area[0][0])), settings.drawing_area[1][1] - int( (self.number / settings.random_range[1]) * (settings.drawing_area[1][1] - settings.drawing_area[0][1])), int((settings.drawing_area[1][0] - settings.drawing_area[0][0]) / length) - settings.numbers_gap, int((self.number / settings.random_range[1]) * (settings.drawing_area[1][1] - settings.drawing_area[0][1])))
def increase(self, callback=lambda: None): """ Método para crescer o corpo da cobra. """ if not self.__body: width, height = self.__surface.get_size() x, y = width / 2 - self.__size / 2, height / 2 - self.__size / 2 else: x, y = self.__body[-1].x, self.__body[-1].y self.__body.append(rect.Rect(x, y, self.__size, self.__size)) callback()
def __init__(self, drawFont: font.Font, width=750, height=550): self.current_page = 0 self.pages = [Surface((width, height))] self.pages[0].fill(colour.WHITE) drawArea = rect.Rect(5, 5, width - 5, height - 5) wordHorizontalSpacing = 5 wordVerticalSpacing = 2 leftMargin = 10 topMargin = 7 wordXOffset = leftMargin wordYOffset = topMargin for line in help_text.split('\n'): for word in line.split(): if word == '[p]': wordXOffset = leftMargin wordYOffset = topMargin self.pages.append(Surface((width, height))) self.pages[-1].fill(colour.WHITE) continue renderedWord = drawFont.render(word, True, colour.BLACK) if wordXOffset + renderedWord.get_width( ) + wordHorizontalSpacing > drawArea.width: wordXOffset = leftMargin wordYOffset += wordVerticalSpacing + renderedWord.get_height( ) if wordYOffset + renderedWord.get_height( ) + wordVerticalSpacing > drawArea.height: wordYOffset = topMargin self.pages.append(Surface((width, height))) self.pages[-1].fill(colour.WHITE) self.pages[-1].blit(renderedWord, (wordXOffset, wordYOffset)) wordXOffset += wordHorizontalSpacing + renderedWord.get_width() wordYOffset += drawFont.get_height() + wordVerticalSpacing wordXOffset = leftMargin for i, v in enumerate(self.pages): pageNumberRender = drawFont.render( "<- Page %d of %d ->" % (i + 1, len(self.pages)), True, colour.BLACK) v.blit(pageNumberRender, (v.get_width() - pageNumberRender.get_width() - 3, v.get_height() - pageNumberRender.get_height() - 3))
def drawFinalScoreboard(self, hits, accuracy, targets_per_second, time, shots): """ Method to draw the final scoreboard. The "shots" argument must be a list containing the position (x, y) of each hit in percent. """ background = rect.Rect(self.__geometry[0], self.__geometry[1], self.__geometry[2] - self.__geometry[0], self.__geometry[3] - self.__geometry[1]) draw.rect(self.__surface, self.__background_color, background) # Cria um espaçamento entre as informações, com base no tamanho da tela do placar final. spacing_x = int(0.07 * (self.__geometry[2] - self.__geometry[0])) spacing_y = int(0.12 * (self.__geometry[3] - self.__geometry[1])) Text(self.__surface, self.__geometry[0] + spacing_x, self.__geometry[1] + spacing_y, text="Hits: %i" % hits, text_font=self.__font, text_color=self.__text_color).drawText() Text(self.__surface, self.__geometry[0] + spacing_x, self.__geometry[1] + int(spacing_y / 2) * 5, text="Accuracy: %.1f%%" % accuracy, text_font=self.__font, text_color=self.__text_color).drawText() Text(self.__surface, self.__geometry[0] + spacing_x, self.__geometry[1] + int(spacing_y / 2) * 8, text="Targets: %.2f/s" % targets_per_second, text_font=self.__font, text_color=self.__text_color).drawText() Text(self.__surface, self.__geometry[0] + spacing_x, self.__geometry[1] + int(spacing_y / 2) * 11, text="Time: %s" % time, text_font=self.__font, text_color=self.__text_color).drawText() # Desenha a borda e o alvo com os tiros acertados. self.__drawBorder() self.__drawTarget([ self.__geometry[0] + self.TARGET_RADIUS + spacing_x * 9, self.__geometry[1] + int(self.TARGET_RADIUS / 2) * 3 ], shots, self.__target_colors)
def __init__(self, filename, tile_size): tileset_image = image.load(filename) (self.image_width, self.image_height) = tileset_image.get_size() self.tile_size = tile_size self.cols = self.image_width / self.tile_size self.rows = self.image_height / self.tile_size self.tiles = [] y = 0 for r in range(self.rows): x = 0 for c in range(self.cols): tile_rect = rect.Rect(x, y, self.tile_size, self.tile_size) self.tiles.append(tileset_image.subsurface(tile_rect)) x += self.tile_size y += self.tile_size
def NumberAnimationUpdate(self, index, length, accel_mode=0): if not (self.animation.in_animation): return animation_rate = self.animation.Flash(accel_mode) if animation_rate == 1.0: self.UpdateNumberRect(index, length) return self.rect = rect.Rect( int(self.starting_pos.left * (1 - animation_rate) + self.destination.left * animation_rate), int(self.starting_pos.top * (1 - animation_rate) + self.destination.top * animation_rate), int(self.starting_pos.width * (1 - animation_rate) + self.destination.width * animation_rate), int(self.starting_pos.height * (1 - animation_rate) + self.destination.height * animation_rate))
def __init__(self, camera, rect1, color, LINE_THICK=0, rect2=None): self.camera = camera sprite.Sprite.__init__(self) self.posInWorld = rect1 if (rect2 != None): self.posCamera = self.rect = rect2 else: self.posCamera = self.rect = \ rect.Rect(rect1.x, rect1.y, rect1.w, rect1.h) # Create the self.image self.image = surface.Surface((rect1.w, rect1.h)) self.image.set_colorkey((0, 0, 0)) draw.rect(self.image, color, (0, 0, rect1.w, rect1.h), LINE_THICK)
def test_filled_ellipses_2(test_surf): """Draw several filled circles""" for cent_x, color in ((100, (0, 0, 255, 255)), (400, (0, 255, 255, 255)), (600, (255, 0, 255, 255))): cent_y = 10 div = 9 for radius in range(10, 100, 10): cent_y += radius + 1 if div > 3: div = div // 3 else: div = div * 3 e_rect = rect.Rect(cent_x - radius // div, cent_y - radius, div * radius, radius) draw.ellipse(test_surf, color, e_rect)
def test_filled_ellipses_1(test_surf): """Draw several filled circles""" for cent_x, color in ((100, (0, 0, 255, 255)), (300, (0, 255, 255, 255)), (500, (255, 0, 255, 255))): cent_y = 10 div = 8 offset = 0 for radius in range(10, 100, 10): if div > 2: div = div // 2 else: div = div * 2 cent_y += radius // div + 1 offset += 35 e_rect = rect.Rect(cent_x - radius + offset, cent_y - radius // div, radius, div * radius) draw.ellipse(test_surf, color, e_rect)
def __init__(self, loading=False): self.map = MapObject() self.highlight_tile = (0, 0) self.highlight_rect = pygame.rect.Rect(SCREEN_CENTER[0] - int(TILE_SIZE[0] / 2), SCREEN_CENTER[1] - int(TILE_SIZE[1] / 2), TILE_SIZE[0], TILE_SIZE[1]) self.map_offset = None self.mode = None self.quest = None self.active = False self.__set_up_selected_menu__() self.__set_up_selected_submenus__() self.__set_up_path_mode__() self.__set_up_charting_mode__() self.map_sprite = surface.Surface(TILE_SIZE) if not loading: self.add_tile((0, 0), TILE_SIZE, "town", "home") self.set_highlight_tile((0, 0)) self.help_text_location = rect.Rect(16, SCREEN_SIZE[1] - 96, 384, 128)
def update(self, cursor, buttons, world_map=None): global FILL_COLOR if FILL_COLOR != BLACK: set_fill_color(BLACK) clear_buffer() self.redraw_map() draw_to_buffer([[self.map_sprite, self.map_offset]]) if self.mode == "selected": self.selected_mode(cursor, buttons) elif self.mode == "path": cursor = self.path_mode(cursor, world_map) else: cursor = self.charting_mode(cursor) if buttons[2] is True and self.mode != "path": self.mode = None self.active = False if buttons[1] is True and self.mode == "path": self.end_path_mode() self.mode = None draw.rect(buffer_surface, WHITE, rect.Rect(cursor[0], (4, 4))) return cursor[0]
def set_up_player(self): self.collide_image = surface.Surface( (self.rect.width, self.rect.width)) self.collide_image.set_colorkey(self.collide_image.get_at((0, 0))) draw.rect(self.collide_image, WHITE, self.collide_image.get_rect(), 4, 4) self.collision_image = surface.Surface( (self.rect.width, self.rect.width)) self.collision_image.set_colorkey(self.collision_image.get_at((0, 0))) draw.circle(self.collision_image, BLACK, (self.collision_image.get_width() / 2, self.collision_image.get_height() / 2), 16) self.mask = mask.from_surface(self.collision_image) self.collide_rect = rect.Rect(self.rect.left, self.rect.top + self.rect.width, self.rect.width, self.rect.width) self.facing_direction = (0, 1) self.interact_rect = self.collide_rect.move(0, self.collide_rect.height)
def __init__(self, location, size, terrain=None, improvement=None, feature=None, animal=None, depleted=False, objects=None): self.location = location self.terrain = terrain self.improvement = improvement self.feature = feature self.animals = animal self.surface = surface.Surface(size) self.surface.fill(BROWN) self.rect = rect.Rect(location[0] * size[0], location[1] * size[1], size[0], size[1]) self.depleted = depleted self.update_tile(terrain, improvement, feature, animal) if objects is not None: self.objects = objects else: self.objects = []