BorderlessVectorTemplate

class BorderlessVectorTemplate(VectorBorderlessMod, VectorMDFCMod, VectorTransformMod, VectorTemplate):
    """Borderless template first used in the Womens Day Secret Lair, redone with vector shapes."""

    def __init__(self, layout, **kwargs):
        if not CFG.exit_early:
            CFG.exit_early = self.is_nickname
        super().__init__(layout, **kwargs)

    # Color Maps
    light_color_map = {
        'W': "#faf8f2",
        'U': "#d2edfa",
        'B': "#c9c2be",
        'R': "#f8c7b0",
        'G': "#dbfadc",
        'Gold': "#f5e5a4",
        'Land': "#f0ddce",
        'Hybrid': "f#0ddce",
        'Artifact': "#cde0e9",
        'Colorless': "#e2d8d4",
        'Vehicle': "#4c3314"}
    crown_color_map = {
        'W': "#f8f4f0",
        'U': "#006dae",
        'B': "#393431",
        'R': "#de3c23",
        'G': "#006d42",
        'Gold': "#efd16b",
        'Land': "#a59684",
        'Artifact': "#b5c5cd",
        'Colorless': "#d6d6dc"}
    gradient_location_map = {
        2: [.40, .60],
        3: [.29, .40, .60, .71],
        4: [.20, .30, .45, .55, .70, .80],
        5: [.20, .25, .35, .45, .55, .65, .75, .80]}

    # Static Properties
    mask_layers = []
    background_group = None

    """
    * Mixin Methods
    """

    @property
    def post_text_methods(self):
        """Add post-text adjustments method."""
        funcs = []
        if self.size != BorderlessTextbox.Tall:
            funcs.append(self.textbox_positioning)
        if self.is_token:
            funcs.append(self.token_adjustments)
        if self.is_textless:
            funcs.append(self.textless_adjustments)
        if self.is_nickname:
            funcs.append(self.nickname_adjustments)
        return [*super().post_text_methods, *funcs, self.text_layer_fx]

    """
    * Settings
    """

    @auto_prop_cached
    def size(self) -> str:
        """Layer name associated with the size of the textbox."""

        # Check for textless
        if self.is_textless:
            return BorderlessTextbox.Textless

        # Get the user's preferred setting
        size = str(CFG.get_option(
            section="FRAME",
            key="Textbox.Size",
            enum_class=BorderlessTextbox,
            default=BorderlessTextbox.Automatic
        ))

        # Determine the automatic size
        if size == BorderlessTextbox.Automatic:

            # Check for basic land
            if self.is_basic_land:
                return BorderlessTextbox.Short

            # Set up our test text layer
            test_layer = psd.getLayer(self.text_layer_rules_name, [self.text_group, "Tall"])
            test_text = self.layout.oracle_text
            if self.layout.flavor_text:
                test_text += f'\r{self.layout.flavor_text}'
            test_layer.textItem.contents = test_text.replace('\n', '\r')

            # Get the number of lines in our test text and decide what size
            num = get_line_count(test_layer, self.docref)
            if num < 5:
                return BorderlessTextbox.Short
            if num < 6:
                return BorderlessTextbox.Medium
            if num < 7:
                return BorderlessTextbox.Normal
            return BorderlessTextbox.Tall
        return size

    @auto_prop_cached
    def color_limit(self) -> int:
        # Built in setting, dual and triple color split
        return int(CFG.get_setting(
            section="COLORS",
            key="Max.Colors",
            default="2",
            is_bool=False)) + 1

    @auto_prop_cached
    def drop_shadow_enabled(self) -> bool:
        """Returns True if Drop Shadow text setting is enabled."""
        return bool(CFG.get_setting(
            section="TEXT",
            key="Drop.Shadow",
            default=True))

    @auto_prop_cached
    def crown_texture_enabled(self) -> bool:
        """Returns True if Legendary crown clipping texture should be enabled."""
        return bool(CFG.get_setting(
            section="FRAME",
            key="Crown.Texture",
            default=True))

    @auto_prop_cached
    def multicolor_textbox(self) -> bool:
        """Returns True if Textbox for multicolored cards should use blended colors."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Multicolor.Textbox",
            default=True))

    @auto_prop_cached
    def multicolor_pinlines(self) -> bool:
        """Returns True if Pinlines and Crown for multicolored cards should use blended colors."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Multicolor.Pinlines",
            default=True))

    @auto_prop_cached
    def multicolor_twins(self) -> bool:
        """Returns True if Twins for multicolored cards should use blended colors."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Multicolor.Twins",
            default=False))

    @auto_prop_cached
    def multicolor_pt(self) -> bool:
        """Returns True if PT Box for multicolored cards should use the last color."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Multicolor.PT",
            default=False))

    @auto_prop_cached
    def hybrid_colored(self) -> bool:
        """Returns True if Twins and PT should be colored on Hybrid cards."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Hybrid.Colored",
            default=True))

    @auto_prop_cached
    def front_face_colors(self) -> bool:
        """Returns True if lighter color map should be used on front face DFC cards."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Front.Face.Colors",
            default=True))

    @auto_prop_cached
    def land_colorshift(self) -> bool:
        """Returns True if Land cards should use the darker brown color."""
        return bool(CFG.get_setting(
            section="COLORS",
            key="Land.Colorshift",
            default=False))

    @auto_prop_cached
    def artifact_color_mode(self) -> str:
        """Setting determining what elements to color for colored artifacts.."""
        return CFG.get_option(
            section="COLORS",
            key="Artifact.Color.Mode",
            enum_class=BorderlessColorMode)

    """
    * Frame Details
    """

    @auto_prop_cached
    def frame_type(self) -> str:
        """Layer name associated with the holistic frame type."""
        if self.is_textless:
            # Textless / Textless Transform
            return f"{self.size} {LAYERS.TRANSFORM}" if (
                    self.is_transform or self.is_mdfc
            ) else self.size
        if self.is_transform and self.is_front:
            # Size TF Front
            return f"{self.size} {LAYERS.TRANSFORM_FRONT}"
        if self.is_transform or self.is_mdfc:
            # Size TF Back
            return f"{self.size} {LAYERS.TRANSFORM_BACK}"
        return self.size

    @auto_prop_cached
    def art_frame(self) -> str:
        # Use different positioning based on textbox size
        return f"{LAYERS.ART_FRAME} {self.size}"

    """
    * Bool
    """

    @property
    def is_basic_land(self):
        """Disable basic land watermark if Textless is enabled."""
        if bool(CFG.get_setting(section="FRAME", key="Textless", default=False)):
            return False
        return super().is_basic_land

    @auto_prop_cached
    def is_textless(self) -> bool:
        """Return True if this a textless render."""
        if not any([self.layout.oracle_text, self.layout.flavor_text, self.is_basic_land]):
            return True
        return bool(CFG.get_setting(section="FRAME", key="Textless", default=False))

    @auto_prop_cached
    def is_nickname(self) -> bool:
        """Return True if this a nickname render."""
        return CFG.get_setting(section="TEXT", key="Nickname", default=False)

    @auto_prop_cached
    def is_multicolor(self) -> bool:
        """Whether the card is multicolor and within the color limit range."""
        return bool(1 <= len(self.identity) < self.color_limit)

    @auto_prop_cached
    def is_centered(self) -> bool:
        """Conditions for rules text centering, avoid the flipside PT cutout."""
        return bool(
            len(self.layout.flavor_text) <= 1
            and len(self.layout.oracle_text) <= 70
            and "\n" not in self.layout.oracle_text
            and not (
                # Not centered if using a small textbox with Flipside PT
                self.is_flipside_creature and self.is_front and self.size in [
                    BorderlessTextbox.Automatic,
                    BorderlessTextbox.Medium,
                    BorderlessTextbox.Short
                ]))

    @auto_prop_cached
    def is_pt_enabled(self) -> bool:
        """Return True if a separate Power/Toughness text layer is used for this render."""
        return self.is_creature and (not self.is_textless or not CFG.symbol_enabled)

    @auto_prop_cached
    def is_drop_shadow(self) -> bool:
        """Return True if drop shadow setting is enabled."""
        return bool(
            self.drop_shadow_enabled and not
            ((self.is_mdfc or self.is_transform) and self.is_front and self.front_face_colors))

    @auto_prop_cached
    def is_authentic_front(self) -> bool:
        """Return True if rendering a front face DFC card with authentic lighter colors."""
        return bool((self.is_mdfc or self.is_transform) and self.is_front and self.front_face_colors)

    """
    * Color Maps
    """

    @auto_prop_cached
    def dark_color_map(self) -> dict:
        return {
            'W': "#958676",
            'U': "#045482",
            'B': "#282523",
            'R': "#93362a",
            'G': "#134f23",
            'Gold': "#9a883f",
            'Land': "#684e30" if self.land_colorshift else "#a79c8e",
            'Hybrid': "#a79c8e",
            'Artifact': "#48555c",
            'Colorless': "#74726b",
            'Vehicle': "#4c3314"
        }

    """
    * Colors
    """

    @auto_prop_cached
    def twins_colors(self) -> Union[list[int], list[dict]]:

        # Default to twins
        colors = self.twins

        # Color enabled hybrid OR color enabled multicolor
        if (self.is_hybrid and self.hybrid_colored) or (self.is_multicolor and self.multicolor_twins):
            colors = self.identity
        # Color disabled hybrid cards
        elif self.is_hybrid:
            colors = LAYERS.HYBRID

        # Use artifact twins if artifact mode isn't colored
        if self.is_artifact and not self.is_land and self.artifact_color_mode not in [
            BorderlessColorMode.Twins_And_PT,
            BorderlessColorMode.Twins,
            BorderlessColorMode.All
        ]:
            colors = LAYERS.ARTIFACT

        # Return Solid Color or Gradient notation
        return psd.get_pinline_gradient(
            colors=colors,
            color_map=self.light_color_map if self.is_authentic_front else self.dark_color_map,
            location_map=self.gradient_location_map)

    @auto_prop_cached
    def pt_colors(self) -> Union[list[int], list[dict]]:

        # Default to twins, or Vehicle for non-colored vehicle artifacts
        colors = self.twins

        # Color enabled hybrid OR color enabled multicolor
        if (self.is_hybrid and self.hybrid_colored) or (self.is_multicolor and self.multicolor_pt):
            colors = self.identity[-1]
        # Use Hybrid color for color-disabled hybrid cards
        elif self.is_hybrid:
            colors = LAYERS.HYBRID

        # Use artifact twins color if artifact mode isn't colored
        if self.is_artifact and not self.is_land and self.artifact_color_mode not in [
            BorderlessColorMode.Twins_And_PT,
            BorderlessColorMode.All,
            BorderlessColorMode.PT
        ]:
            colors = LAYERS.ARTIFACT

        # Use Vehicle for non-colored artifacts
        if colors == LAYERS.ARTIFACT and self.is_vehicle:
            colors = LAYERS.VEHICLE

        # Return Solid Color or Gradient notation
        return psd.get_pinline_gradient(
            colors=colors,
            color_map=self.light_color_map if self.is_authentic_front else self.dark_color_map)

    @auto_prop_cached
    def textbox_colors(self) -> Union[list[int], list[dict]]:

        # Default to twins
        colors = self.twins

        # Hybrid OR color enabled multicolor
        if self.is_hybrid or (self.is_multicolor and self.multicolor_textbox):
            colors = self.identity

        # Use artifact textbox color if artifact mod isn't colored
        if self.is_artifact and self.artifact_color_mode not in [
            BorderlessColorMode.Textbox,
            BorderlessColorMode.All
        ]:
            colors = LAYERS.ARTIFACT

        # Return Solid Color or Gradient notation
        return psd.get_pinline_gradient(
            colors=colors,
            color_map=self.light_color_map if self.is_authentic_front else self.dark_color_map,
            location_map=self.gradient_location_map)

    @auto_prop_cached
    def crown_colors(self) -> Union[list[int], list[dict]]:
        # Use Solid Color or Gradient adjustment layer for Crown colors
        return psd.get_pinline_gradient(
            # Use identity for hybrid OR color enabled multicolor
            colors=self.identity if self.is_hybrid or (self.is_multicolor and self.multicolor_pinlines) else (
                # Use pinlines if not a color code
                self.pinlines if not is_multicolor_string(self.pinlines) else LAYERS.GOLD),
            color_map=self.crown_color_map,
            location_map=self.gradient_location_map)

    @auto_prop_cached
    def pinlines_colors(self) -> Union[list[int], list[dict]]:
        # Use alternate gradient location map
        return psd.get_pinline_gradient(
            # Use identity for hybrid OR color enabled multicolor
            colors=self.identity if self.is_hybrid or (self.is_multicolor and self.multicolor_pinlines) else (
                # Use pinlines if not a color code
                self.pinlines if not is_multicolor_string(self.pinlines) else LAYERS.GOLD),
            color_map=self.pinlines_color_map,
            location_map=self.gradient_location_map)

    """
    * Groups
    """

    @auto_prop_cached
    def pt_group(self) -> Optional[LayerSet]:
        """PT Box group, alternative Textless option used when Expansion Symbol is disabled."""
        if self.is_textless and CFG.symbol_enabled:
            return
        if self.is_textless and self.is_pt_enabled:
            return psd.getLayerSet(f'{LAYERS.PT_BOX} {LAYERS.TEXTLESS}')
        return super().pt_group

    @auto_prop_cached
    def crown_group(self) -> LayerSet:
        """Legendary Crown group, use inner group to allow textured overlays above."""
        return psd.getLayerSet(LAYERS.LEGENDARY_CROWN, LAYERS.LEGENDARY_CROWN)

    @auto_prop_cached
    def nickname_group(self) -> LayerSet:
        """Nickname frame element group."""
        return psd.getLayerSet(LAYERS.NICKNAME)

    @auto_prop_cached
    def textbox_group(self) -> Optional[LayerSet]:
        """Optional[LayerSet]: Textbox group if not a 'Textless' render."""
        if self.is_textless:
            return
        return super().textbox_group

    """
    * Text Layers
    """

    @auto_prop_cached
    def text_layer_rules_name(self) -> str:
        """Compute the name of this layer separately, so we can use it for automatic textbox sizing."""
        if self.is_creature:
            # Is a creature, Flipside P/T?
            return LAYERS.RULES_TEXT_CREATURE_FLIP if (
                    self.is_transform and self.is_flipside_creature
            ) else LAYERS.RULES_TEXT_CREATURE

        # Not a creature, Flipside P/T?
        return LAYERS.RULES_TEXT_NONCREATURE_FLIP if (
                self.is_transform and self.is_flipside_creature
        ) else LAYERS.RULES_TEXT_NONCREATURE

    @auto_prop_cached
    def text_layer_rules(self) -> Optional[ArtLayer]:
        """Card rules text layer, use pre-computed layer name."""
        return psd.getLayer(self.text_layer_rules_name, [self.text_group, self.size])

    @auto_prop_cached
    def text_layer_name(self) -> Optional[ArtLayer]:
        """Card name text layer, allow support for Nickname."""
        if self.is_nickname:
            layer = psd.getLayer(LAYERS.NICKNAME, self.text_group)
            super().text_layer_name.textItem.contents = "ENTER NAME HERE"
            layer.visible = True
            return layer
        return super().text_layer_name

    """
    * References
    """

    @auto_prop_cached
    def textbox_reference(self) -> Optional[ReferenceLayer]:
        """Use size appropriate textbox reference."""
        ref = psd.get_reference_layer(self.size, psd.getLayerSet(LAYERS.TEXTBOX_REFERENCE, self.text_group))
        if self.is_mdfc:
            psd.copy_layer_mask(
                layer_from=psd.getLayer(LAYERS.MDFC, [self.mask_group, LAYERS.TEXTBOX_REFERENCE]),
                layer_to=ref)
            psd.apply_mask(ref)
            ref.visible = False
        return ref

    """
    * Shapes
    """

    @auto_prop_cached
    def textbox_shapes(self) -> list[Union[ArtLayer, LayerSet]]:
        """Support a size appropriate textbox shape and Transform Front addition."""

        # Return None if textless
        if self.is_textless:
            return []

        # Enable Transform Front addition if required
        names = [self.size, LAYERS.TRANSFORM_FRONT] if self.is_transform and self.is_front else [self.size]
        return [psd.getLayer(n, [self.textbox_group, LAYERS.SHAPE]) for n in names]

    @auto_prop_cached
    def pinlines_shapes(self) -> list[Union[ArtLayer, LayerSet]]:
        """Support a variety of pinlines shapes including Transform, MDFC, Textless, Nickname, etc."""

        # Name and typeline
        layers = [
            psd.getLayerSet(
                LAYERS.TRANSFORM if self.is_transform else (LAYERS.MDFC if self.is_mdfc else LAYERS.NORMAL),
                [self.pinlines_group, LAYERS.SHAPE, LAYERS.NAME]),
            psd.getLayer(
                LAYERS.TEXTLESS if self.is_textless else self.size,
                [self.pinlines_group, LAYERS.SHAPE, LAYERS.TYPE_LINE])
        ]

        # Add nickname if needed
        if self.is_nickname:
            layers.append(psd.getLayerSet(
                LAYERS.NICKNAME, [self.crown_group if self.is_legendary else self.pinlines_group, LAYERS.SHAPE])
            )

        # If textless return just the name and title
        if self.is_textless:
            return layers

        # Add Transform Front addition if required
        names = [self.size, LAYERS.TRANSFORM_FRONT] if self.is_transform and self.is_front else [self.size]
        return [*layers, *[psd.getLayer(n, [self.pinlines_group, LAYERS.SHAPE, LAYERS.TEXTBOX]) for n in names]]

    @auto_prop_cached
    def twins_shapes(self) -> list[Union[ArtLayer, LayerSet]]:
        """Separate shapes for Name and Typeline box."""
        return [
            psd.getLayer(
                LAYERS.TRANSFORM if self.is_transform or self.is_mdfc else LAYERS.NORMAL,
                [self.twins_group, LAYERS.SHAPE, LAYERS.NAME]),
            psd.getLayer(
                LAYERS.TEXTLESS if self.is_textless else self.size,
                [self.twins_group, LAYERS.SHAPE, LAYERS.TYPE_LINE])
        ]

    @auto_prop_cached
    def nickname_shape(self) -> ArtLayer:
        """Vector shape for Nickname box."""
        return psd.getLayer(
            LAYERS.LEGENDARY if self.is_legendary else LAYERS.NORMAL,
            [self.nickname_group, LAYERS.SHAPE]
        )

    @auto_prop_cached
    def enabled_shapes(self) -> list[Union[ArtLayer, LayerSet, None]]:
        """Add Nickname vector shape if needed."""
        shapes = [self.nickname_shape] if self.is_nickname else []
        return [
            *self.pinlines_shapes,
            *self.twins_shapes,
            *self.textbox_shapes,
            *shapes,
        ]

    """
    * Masks
    """

    @auto_prop_cached
    def border_mask(self) -> Optional[list]:
        """Support border mask for Textless and front face Transform modifications."""
        if self.is_textless:
            return [psd.getLayer(LAYERS.TEXTLESS, [self.mask_group, LAYERS.BORDER]), self.border_group]
        if self.is_transform and self.is_front:
            return [psd.getLayer(LAYERS.TRANSFORM_FRONT, [self.mask_group, LAYERS.BORDER]), self.border_group]
        return

    @auto_prop_cached
    def pinlines_mask(self) -> dict:
        """Use pre-calculated frame type to find pinlines mask. This mask hides overlapping layer effects."""
        return {
            'mask': psd.getLayer(self.frame_type, [self.mask_group, LAYERS.PINLINES]),
            'layer': self.pinlines_group,
            'funcs': [psd.apply_mask_to_layer_fx]
        }

    @auto_prop_cached
    def pinlines_vector_mask(self) -> Optional[dict]:
        """Enable the pinlines vector mask if card is Legendary. """
        if not self.is_legendary:
            return
        return {
            'mask': self.pinlines_group,
            'vector': True
        }

    @auto_prop_cached
    def crown_mask(self) -> Optional[dict]:
        """Copy the pinlines mask to Legendary crown if card is Legendary."""
        if not self.is_legendary:
            return
        return {
            'mask': self.pinlines_mask['mask'],
            'layer': self.crown_group.parent,
            'funcs': [psd.apply_mask_to_layer_fx]}

    @auto_prop_cached
    def enabled_masks(self) -> list[Union[dict, list, ArtLayer, LayerSet, None]]:
        """Masks that should be copied or enabled."""
        return [
            self.crown_mask,
            self.border_mask,
            self.pinlines_mask,
            self.pinlines_vector_mask]

    """
    * Effects
    """

    @auto_prop_cached
    def nickname_fx(self) -> ArtLayer:
        """ArtLayer: Layer containing nickname effects."""
        return psd.getLayer(LAYERS.NICKNAME, LAYERS.EFFECTS)

    """
    * Watermarks
    """

    @auto_prop_cached
    def basic_watermark_fx(self) -> list[LayerEffects]:
        """Defines the layer effects used on the Basic Land Watermark."""
        sizes = {
            # Bevel thickness based on textbox size
            BorderlessTextbox.Short: 20,
            BorderlessTextbox.Medium: 22,
            BorderlessTextbox.Normal: 25,
            BorderlessTextbox.Tall: 28}
        return [
            {'type': 'color-overlay', 'opacity': 100, 'color': self.basic_watermark_color},
            {
                'size': sizes.get(self.size),
                'type': 'bevel', 'softness': 14, 'depth': 100,
                'shadow_opacity': 72, 'highlight_opacity': 70,
                'rotation': 45, 'altitude': 22
            }
        ]

    """
    * Frame Layer Methods
    """

    def enable_crown(self) -> None:
        """Allow modifying crown texture based on setting."""
        super().enable_crown()

        # Remove crown textures if disabled
        if not self.crown_texture_enabled:
            for n in ["Shading", "Highlight", "Overlay"]:
                psd.getLayer(n, self.crown_group.parent).visible = False

    """
    * Text Layer Methods
    """

    def basic_text_layers(self) -> None:

        # Establish whether this is a textless creature render with no symbol
        self.text.extend([
            FormattedTextField(
                layer=self.text_layer_mana,
                contents=self.layout.mana_cost
            ),
            ScaledTextField(
                layer=self.text_layer_type,
                # Add Power/Toughness if rendering textless creature WITH symbol
                contents=f"{self.layout.type_line} — {self.layout.power}/{self.layout.toughness}" if
                self.is_creature and not self.is_pt_enabled else self.layout.type_line,
                # Use PT box as right reference if rendering textless creature WITHOUT symbol
                reference=psd.getLayer(LAYERS.PT_BOX, [self.pt_group, LAYERS.SHAPE])
                if self.is_textless and self.is_pt_enabled else self.type_reference
            )
        ])

        # Add nickname or regular name
        self.text.append(
            ScaledTextField(
                layer=self.text_layer_name,
                contents=self.layout.name,
                reference=self.name_reference
            ) if not self.is_nickname else
            ScaledWidthTextField(
                layer=self.text_layer_name,
                contents=self.layout.name,
                reference=self.nickname_shape
            ))

    def rules_text_and_pt_layers(self) -> None:
        """Skip this step for 'Textless' renders."""
        if self.is_textless:
            if self.is_pt_enabled:
                self.text.append(
                    TextField(
                        layer=self.text_layer_pt,
                        contents=f'{self.layout.power}/'
                                 f'{self.layout.toughness}'))
            return
        super().rules_text_and_pt_layers()

    """
    * Post Text Methods
    """

    def textless_adjustments(self) -> None:
        """Actions taken if this is a 'Textless' render."""

        # Make positioning adjustments
        if self.is_type_shifted:
            self.indicator_group.translate(-10, 0)
        self.text_layer_type.translate(-10, 0)

        # Align and add PT text for creatures with no expansion symbol
        if self.is_pt_enabled:
            psd.align_all(
                layer=self.text_layer_pt,
                ref=psd.getLayer(LAYERS.PT_BOX, [
                    self.pt_group, LAYERS.SHAPE]))
            return

        # Otherwise just shift the symbol over
        if self.expansion_symbol_layer:
            self.expansion_symbol_layer.translate(10, 0)

    def token_adjustments(self) -> None:
        """Actions taken if this is a 'Token' card."""

        # Change name font and center it
        self.text_layer_name.textItem.font = CON.font_artist
        psd.align_horizontal(self.text_layer_name, self.twins_shapes[0])

        # Add name plate shadow
        psd.getLayer(LAYERS.TOKEN, self.text_group).visible = True

    def nickname_adjustments(self) -> None:
        """Actions taken if this is a 'Nickname' render."""

        # Nickname plate -> Solid color or gradient layer
        if self.is_nickname:
            self.generate_layer(
                group=self.nickname_group,
                colors=self.twins_colors)

        # Center the name
        psd.align_vertical(self.text_layer_name, self.nickname_shape)

        # Copy effects to legendary crown
        if self.is_legendary:
            psd.copy_layer_fx(self.nickname_fx, self.crown_group.parent)

    def textbox_positioning(self) -> None:
        """Reposition various elements when textbox size isn't 'Tall' (the default)."""

        # Get the delta between the highest box and the target box
        shape = psd.getLayer(LAYERS.TALL, [
            self.pinlines_group,
            LAYERS.SHAPE,
            LAYERS.TYPE_LINE])
        dims_ref = psd.get_layer_dimensions(shape)
        dims_obj = psd.get_layer_dimensions(self.pinlines_shapes[1])
        delta = dims_obj[Dimensions.CenterY] - dims_ref[Dimensions.CenterY]
        self.text_layer_type.translate(0, delta)

        # Shift expansion symbol
        if CFG.symbol_enabled and self.expansion_symbol_layer:
            self.expansion_symbol_layer.translate(0, delta)

        # Shift indicator
        if self.is_type_shifted:
            self.indicator_group.parent.translate(0, delta)

    def text_layer_fx(self) -> None:
        """Handles all specialized text adjustments for a variety of render settings."""

        # Add drop shadow if enabled and allowed
        if self.is_drop_shadow:

            # Name and Typeline
            psd.enable_layer_fx(self.text_layer_name)
            psd.enable_layer_fx(self.text_layer_type)

            # Rules text if not textless
            if not self.is_textless and not self.is_basic_land:
                psd.enable_layer_fx(self.text_layer_rules)

            # Flipside PT for front face Transform
            if self.is_flipside_creature and self.is_front and self.is_transform:
                psd.enable_layer_fx(self.text_layer_flipside_pt)

        # Allow exception for PT drop shadow on front face Vehicle cards
        if (self.is_drop_shadow or (self.drop_shadow_enabled and self.is_vehicle)) and self.is_pt_enabled:
            psd.enable_layer_fx(self.text_layer_pt)

    """
    * Transform Methods
    """

    def text_layers_transform_front(self) -> None:
        """Switch font colors on 'Authentic' front face cards."""
        super().text_layers_transform_front()

        # Use black text
        if self.is_authentic_front:
            self.swap_font_color()

        # Switch flipside PT to light gray
        if not self.is_authentic_front and self.is_flipside_creature:
            self.text_layer_flipside_pt.textItem.color = psd.get_rgb(*[186, 186, 186])

    def text_layers_transform_back(self):
        """No back-side Transform changes."""
        pass

    """
    * MDFC Methods
    """

    def text_layers_mdfc_front(self) -> None:
        """Switch font colors on 'Authentic' front face cards."""
        if self.is_authentic_front:
            self.swap_font_color()

    """
    * Util Methods
    """

    def swap_font_color(self, color: SolidColor = None) -> None:
        """Switch the font color of each key text layer.

        Args:
            color: SolidColor object, will use black if not provided.
        """

        # Ensure a color is chosen
        color = color or self.RGB_BLACK

        # Name and Typeline
        self.text_layer_name.textItem.color = color
        self.text_layer_type.textItem.color = color

        # Rules text if not textless
        if not self.is_textless:
            self.text_layer_rules.textItem.color = color

        # PT if card is a non-vehicle creature
        if self.is_pt_enabled and not self.is_vehicle:
            self.text_layer_pt.textItem.color = color