UniversesBeyondTemplate

class UniversesBeyondTemplate(VectorTransformMod, VectorTemplate):
    """
    Template used for crossover sets like WH40K, Transformers, Street Fighter, etc.
    This template is built using the Silvan style of creating vector shapes and applying the colors
    and textures in the form of clipping masks. It's a little more involved, but it demonstrates
    an alternative way to build a highly complex template which can work for multiple card types.
    Credit to Kyle of Card Conjurer, WarpDandy, SilvanMTG, Chilli and MrTeferi.
    """
    template_suffix = 'Universes Beyond'

    # Color Maps
    pinlines_color_map = {
        **pinlines_color_map.copy(),
        'W': [246, 247, 241],
        'U': [0, 131, 193],
        'B': [44, 40, 33],
        'R': [237, 66, 31],
        'G': [5, 129, 64],
        'Gold': [239, 209, 107],
        'Land': [165, 150, 132],
        'Artifact': [227, 228, 230],
        'Colorless': [227, 228, 230]}

    """
    * Colors
    """

    @auto_prop_cached
    def pt_colors(self) -> str:
        """str: Layer texture name, supports Vehicle PT but doesn't need white text."""
        return LAYERS.VEHICLE if self.is_vehicle == LAYERS.VEHICLE else self.twins

    @auto_prop_cached
    def crown_colors(self) -> Union[list[int], list[dict]]:
        """list[int] | list[dict]: Solid color or gradient adjustment layer notation."""
        return psd.get_pinline_gradient(self.pinlines, color_map=self.crown_color_map)

    """
    * Groups
    """

    @auto_prop_cached
    def background_group(self) -> Optional[LayerSet]:
        """Optional[LayerSet]: No background for 'Colorless' cards."""
        if self.is_colorless:
            return
        return super().background_group

    """
    * Masks
    """

    @auto_prop_cached
    def enabled_masks(self) -> list[Union[dict, list, ArtLayer, LayerSet, None]]:
        """Masks enabled or copied."""
        return [
            # Pinlines mask, supports Transform Front
            [psd.getLayer(
                LAYERS.TRANSFORM_FRONT if self.is_transform and self.is_front else LAYERS.NORMAL,
                [self.mask_group, LAYERS.PINLINES]
            ), self.pinlines_group]
        ]

    """
    * Shapes
    """

    @auto_prop_cached
    def pinlines_shape(self) -> Optional[LayerSet]:
        # Support Normal and Transform Front
        name = (
            LAYERS.TRANSFORM_FRONT if self.is_front else LAYERS.TRANSFORM_BACK
        ) if self.is_transform else LAYERS.NORMAL
        return psd.getLayerSet(name, [self.pinlines_group, LAYERS.SHAPE])

    """
    * Methods
    """

    def enable_frame_layers(self) -> None:
        super().enable_frame_layers()

        # Translucent colorless shapes
        if self.is_colorless and self.twins_shape and self.textbox_shape:
            psd.set_fill_opacity(60, self.twins_group)
            psd.set_fill_opacity(60, self.textbox_group)

    def enable_crown(self) -> None:

        # Generate a solid color or gradient layer for the crown group
        self.crown_group.visible = True
        self.generate_layer(
            group=self.crown_group,
            colors=self.crown_colors)

        # Enable Legendary pinline connector
        psd.getLayerSet(
            LAYERS.LEGENDARY,
            self.pinlines_shape.parent
        ).visible = True

    """
    * Transform Methods
    """

    def enable_transform_layers_back(self) -> None:
        super().enable_transform_layers_back()

        # Enable brightness shift on back face layers
        psd.getLayerSet(LAYERS.BACK, self.pt_group).visible = True
        psd.getLayerSet(LAYERS.BACK, self.twins_group).visible = True
        psd.getLayer(LAYERS.BACK, self.textbox_group).visible = True