LOTRTemplate

class LOTRTemplate(VectorTemplate):
    """
    * Lord of the Rings template introduced in Lord of The Rings: Tales of Middle Earth.
    * Credit to Tupinambá (Pedro Neves) for the master template
    * With additional support from CompC and MrTeferi
    """
    template_suffix = 'Lord of the Rings'

    # Static Properties
    enabled_shapes = []

    # Color Maps
    pinlines_color_map = {
        **pinlines_color_map.copy(),
        'W': [230, 220, 185],
        'U': [72, 142, 191],
        'B': [126, 128, 127],
        'R': [217, 94, 76],
        'G': [97, 143, 102],
        'Gold': [246, 213, 125],
        'Land': [181, 162, 149],
        'Artifact': [210, 219, 227],
        'Colorless': [210, 219, 227]}
    dark_color_map = {
        **pinlines_color_map.copy(),
        'W': [134, 123, 105],
        'U': [44, 51, 103],
        'B': [44, 43, 39],
        'R': [118, 34, 34],
        'G': [13, 68, 45],
        'Gold': [158, 124, 78],
        'Land': [103, 90, 74],
        'Artifact': [61, 88, 109],
        'Colorless': [78, 91, 101],
        'Vehicle': [76, 51, 20]}

    """
    * Colors
    """

    @auto_prop_cached
    def crown_colors(self) -> Union[SolidColor, list[dict]]:
        """Must be returned as SolidColor or gradient notation."""
        return psd.get_pinline_gradient(
            self.identity if 1 < len(self.identity) < self.color_limit else self.pinlines,
            color_map=self.pinlines_color_map)

    @auto_prop_cached
    def twins_colors(self) -> Union[SolidColor, list[dict]]:
        """Must be returned as SolidColor or gradient notation."""
        return psd.get_pinline_gradient(
            colors=self.twins,
            color_map=self.dark_color_map)

    @auto_prop_cached
    def pt_colors(self) -> Union[SolidColor, list[dict]]:
        """Must be returned as SolidColor or gradient notation."""
        return psd.get_pinline_gradient(
            colors=LAYERS.VEHICLE if self.is_vehicle else self.twins,
            color_map=self.dark_color_map)

    @auto_prop_cached
    def textbox_colors(self) -> str:
        """str: Just use twins value for texture name."""
        return self.twins

    @auto_prop_cached
    def background_colors(self) -> str:
        """str: Just use pinlines value for texture name."""
        return self.pinlines

    """
    * Groups
    """

    @auto_prop_cached
    def pinlines_groups(self) -> list[LayerSet]:
        """Pinlines and crown pinlines addon."""
        groups = [self.pinlines_group]
        if self.is_legendary:
            groups.append(self.crown_group)
        return groups

    """
    * Masks
    """

    @auto_prop_cached
    def enabled_masks(self) -> list[Union[dict, list, ArtLayer, LayerSet, None]]:
        """Mask Pinlines if Legendary."""
        if self.is_legendary:
            return [self.pinlines_group]
        return []

    """
    * Frame Layer Methods
    """

    def enable_crown(self) -> None:
        """Enable the Legendary crown group only."""
        self.crown_group.visible = True