def test_calculate_points():
texture = arcade.load_texture(":resources:images/items/coinGold.png")
result = arcade.calculate_points(texture.image)
print(result)
texture = arcade.load_texture(":resources:images/animated_characters/female_person/femalePerson_idle.png")
result = arcade.calculate_points(texture.image)
print(result)
def load_texture(file_name: str,
x: float = 0,
y: float = 0,
width: float = 0,
height: float = 0,
mirrored: bool = False,
flipped: bool = False,
can_cache: bool = True) -> Texture:
"""
Load an image from disk and create a texture.
Note: If the code is to load only part of the image, the given `x`, `y`
coordinates will start with the origin `(0, 0)` in the upper left of the
image. When drawing, Arcade uses `(0, 0)` in the lower left corner.
Be careful with this reversal.
For a longer explanation of why computers sometimes start in the upper
left, see:
http://programarcadegames.com/index.php?chapter=introduction_to_graphics&lang=en#section_5
:param str file_name: Name of the file to that holds the texture.
:param float x: X position of the crop area of the texture.
:param float y: Y position of the crop area of the texture.
:param float width: Width of the crop area of the texture.
:param float height: Height of the crop area of the texture.
:param bool mirrored: If set to `True`, the image is mirrored left to right.
:param bool flipped: If set to `True`, the image is flipped upside down.
:param bool can_cache: If a texture has already been loaded, load_texture will return the same texture in order \
to save time. Somtimes this is not desirable, as resizine a cached texture will cause all other textures to \
resize with it. Setting can_cache to false will prevent this issue at the expence of additional resources.
:returns: New :class:`Texture` object.
:raises: ValueError
"""
# See if we already loaded this texture, and we can just use a cached version.
cache_name = "{}{}{}{}{}{}{}".format(file_name, x, y, width, height,
flipped, mirrored)
if can_cache and cache_name in load_texture.texture_cache: # type: ignore # dynamic attribute on function obj
return load_texture.texture_cache[
cache_name] # type: ignore # dynamic attribute on function obj
# See if we already loaded this texture file, and we can just use a cached version.
cache_file_name = f"{file_name}"
if cache_file_name in load_texture.texture_cache: # type: ignore # dynamic attribute on function obj
texture = load_texture.texture_cache[
cache_file_name] # type: ignore # dynamic attribute on function obj
source_image = texture.image
else:
# If we should pull from local resources, replace with proper path
if isinstance(file_name,
str) and str(file_name).startswith(":resources:"):
import os
path = os.path.dirname(os.path.abspath(__file__))
file_name = f"{path}/resources/{file_name[11:]}"
source_image = PIL.Image.open(file_name).convert('RGBA')
result = Texture(cache_file_name, source_image)
load_texture.texture_cache[
cache_file_name] = result # type: ignore # dynamic attribute on function obj
source_image_width, source_image_height = source_image.size
if x != 0 or y != 0 or width != 0 or height != 0:
if x > source_image_width:
raise ValueError("Can't load texture starting at an x of {} "
"when the image is only {} across.".format(
x, source_image_width))
if y > source_image_height:
raise ValueError("Can't load texture starting at an y of {} "
"when the image is only {} high.".format(
y, source_image_height))
if x + width > source_image_width:
raise ValueError("Can't load texture ending at an x of {} "
"when the image is only {} wide.".format(
x + width, source_image_width))
if y + height > source_image_height:
raise ValueError("Can't load texture ending at an y of {} "
"when the image is only {} high.".format(
y + height, source_image_height))
image = source_image.crop((x, y, x + width, y + height))
else:
image = source_image
# image = _trim_image(image)
if mirrored:
image = PIL.ImageOps.mirror(image)
if flipped:
image = PIL.ImageOps.flip(image)
result = Texture(cache_name, image)
load_texture.texture_cache[
cache_name] = result # type: ignore # dynamic attribute on function obj
result.hit_box_points = calculate_points(image)
return result