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 = []
