NormalTemplate

class NormalTemplate(StarterTemplate):
    """Utility Template containing the most common "batteries included" functionality.

    Notes:
        - Adds remaining logic that is required for any normal M15 style card, including:
            - Rules and PT text.
            - Enabling typical frame layers.
            - Enabling the legendary crown / hollow crown if supported.
        - Extend this template for broad support of most typical card functionality.
    """

    @auto_prop_cached
    def is_fullart(self) -> bool:
        """Colorless cards use Fullart reference."""
        return self.is_colorless

    """
    * Text Layer Methods
    """

    def rules_text_and_pt_layers(self) -> None:
        """Add rules and power/toughness text."""
        self.text.extend([
            FormattedTextArea(
                layer=self.text_layer_rules,
                contents=self.layout.oracle_text,
                flavor=self.layout.flavor_text,
                reference=self.textbox_reference,
                divider=self.divider_layer,
                pt_reference=self.pt_reference,
                centered=self.is_centered
            ),
            TextField(
                layer=self.text_layer_pt,
                contents=f"{self.layout.power}/{self.layout.toughness}"
            ) if self.is_creature else None
        ])

    """
    * Frame Layer Methods
    """

    def enable_frame_layers(self) -> None:
        """Enable layers which make-up the frame of the card."""

        # Twins
        if self.twins_layer:
            self.twins_layer.visible = True

        # PT Box
        if self.is_creature and self.pt_layer:
            self.pt_layer.visible = True

        # Pinlines
        if self.pinlines_layer:
            self.pinlines_layer.visible = True

        # Color Indicator
        if self.is_type_shifted and self.color_indicator_layer:
            self.color_indicator_layer.visible = True

        # Background
        if self.background_layer:
            self.background_layer.visible = True

        # Legendary crown
        if self.is_legendary and self.crown_layer:
            self.enable_crown()

    def enable_crown(self) -> None:
        """Enable layers which make-up the Legendary crown."""

        # Enable crown and legendary border
        self.crown_layer.visible = True
        if self.border_group and isinstance(self.border_group, LayerContainer):
            psd.getLayer(LAYERS.NORMAL_BORDER, self.border_group).visible = False
            psd.getLayer(LAYERS.LEGENDARY_BORDER, self.border_group).visible = True

        # Call hollow crown step
        if self.is_hollow_crown:
            self.enable_hollow_crown(
                psd.getLayer(LAYERS.SHADOWS))

    def enable_hollow_crown(self, shadows: Optional[ArtLayer] = None) -> None:
        """Enable the hollow legendary crown."""
        if shadows:
            psd.enable_mask(shadows)
        psd.enable_mask(self.crown_layer.parent)
        psd.enable_mask(self.pinlines_layer.parent)
        self.crown_shadow_layer.visible = True