BorderlessVectorTemplate¶

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

    # 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)
        return [*super().post_text_methods, *funcs, self.text_layer_fx]

    """
    * Settings
    """

    @cached_property
    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 self.layout.flavor_text:
                num += 1
            if num < 5:
                return BorderlessTextbox.Short
            if num < 6:
                return BorderlessTextbox.Medium
            if num < 7:
                return BorderlessTextbox.Normal
            return BorderlessTextbox.Tall
        return size

    @cached_property
    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

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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))

    @cached_property
    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
    """

    @cached_property
    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

    @cached_property
    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

    @cached_property
    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))

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

    @cached_property
    def is_colored_nickname(self) -> bool:
        """Return True if nickname plate should be colored."""
        return CFG.get_setting(section="COLORS", key="Nickname", default=False)

    @cached_property
    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)

    @cached_property
    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
                ]))

    @cached_property
    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)

    @cached_property
    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))

    @cached_property
    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
    """

    @cached_property
    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
    """

    @cached_property
    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)

    @cached_property
    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)

    @cached_property
    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)

    @cached_property
    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)

    @cached_property
    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
    """

    @cached_property
    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 cast(super().pt_group, Optional[LayerSet])

    @cached_property
    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)

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

    """
    * Text Layers
    """

    @cached_property
    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

    @cached_property
    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])

    """
    * References
    """

    @cached_property
    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
    """

    @cached_property
    def textbox_shape(self) -> Union[LayerObjectTypes, list[LayerObjectTypes], None]:
        """Support a size appropriate textbox shape and Transform Front addition."""

        # Return None if textless
        if self.is_textless:
            return []
        _shape_group = psd.getLayerSet(LAYERS.SHAPE, self.textbox_group)

        # Enable Transform Front addition if required
        layers = [psd.getLayer(self.size, _shape_group)]
        if self.is_transform and self.is_front:
            layers.append(psd.getLayer(LAYERS.TRANSFORM_FRONT, _shape_group))
        return layers

    @cached_property
    def pinlines_shape(self) -> Union[LayerObjectTypes, list[LayerObjectTypes], None]:
        """Support a variety of pinlines shapes including Transform, MDFC, Textless, Nickname, etc."""
        _shape_group = psd.getLayerSet(LAYERS.SHAPE, self.pinlines_group)

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

        # Add nickname pinlines if required
        if self.is_nickname and not self.is_legendary:
            layers.append(psd.getLayerSet(LAYERS.NICKNAME, _shape_group))

        # Skip others for textless
        if self.is_textless:
            return layers

        # Add appropriately sized box
        layers.append(psd.getLayer(self.size, [_shape_group, LAYERS.TEXTBOX]))

        # Add Transform Front cutout if required
        if self.is_transform and self.is_front:
            layers.append(
                psd.getLayer(LAYERS.TRANSFORM_FRONT, [_shape_group, LAYERS.TEXTBOX]))
        return layers

    @cached_property
    def twins_shape(self) -> Union[LayerObjectTypes, list[LayerObjectTypes], None]:
        """Separate shapes for Name and Typeline box."""
        _shape_group = psd.getLayerSet(LAYERS.SHAPE, self.twins_group)
        return [
            psd.getLayer(
                LAYERS.TRANSFORM if self.is_transform or self.is_mdfc else LAYERS.NORMAL,
                [_shape_group, LAYERS.NAME]),
            psd.getLayer(
                LAYERS.TEXTLESS if self.is_textless else self.size,
                [_shape_group, LAYERS.TYPE_LINE])
        ]

    @cached_property
    def crown_shape(self) -> Union[LayerObjectTypes, list[LayerObjectTypes], None]:
        """Vector shape for Legendary Crown."""
        if not self.is_legendary:
            return []
        return [psd.getLayer(
            LAYERS.NICKNAME if self.is_nickname else LAYERS.NORMAL,
            [self.crown_group, LAYERS.SHAPE]
        )]

    """
    * Masks
    """

    @cached_property
    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

    @cached_property
    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]
        }

    @cached_property
    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
        }

    @cached_property
    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]}

    @cached_property
    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
    """

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

    """
    * Watermarks
    """

    @cached_property
    def basic_watermark_fx(self) -> list[LayerEffects]:
        """Defines the layer effects used on the Basic Land Watermark."""
        return [
            EffectColorOverlay(
                color=self.basic_watermark_color,
                opacity=100),
            EffectBevel(
                size=self.watermark_bevel_map.get(self.size),
                highlight_opacity=70,
                shadow_opacity=72,
                softness=14,
                rotation=45,
                altitude=22,
                depth=100)
        ]

    """Maps watermark bevel size to textbox size."""
    watermark_bevel_map: dict[str, int] = {
        BorderlessTextbox.Short: 20,
        BorderlessTextbox.Medium: 22,
        BorderlessTextbox.Normal: 25,
        BorderlessTextbox.Tall: 28
    }

    """
    * Frame Layer Methods
    """

    def enable_frame_layers(self) -> None:
        """Hook this step to optionally add color to Nickname plate."""
        super().enable_frame_layers()

        # Color the nickname plate if enabled in settings
        if self.is_nickname and self.is_colored_nickname:
            self.generate_layer(
                group=self.nickname_group,
                colors=self.twins_colors)

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

        # Enable Legendary Crown group and layers
        self.generate_layer(
            group=self.crown_group,
            colors=self.crown_colors,
            masks=self.crown_masks)

        # Enable Hollow Crown
        if self.is_hollow_crown:
            self.enable_hollow_crown(
                masks=[self.crown_group],
                vector_masks=[self.pinlines_group])

        # 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
            )
        ])

        # Prompt for and add nickname if required
        _card_name = str(self.layout.name)
        if self.is_nickname:
            self.prompt_nickname_text()
            self.text.append(
                ScaledWidthTextField(
                    layer=self.text_layer_nickname,
                    contents=self.layout.name,
                    reference=self.nickname_shape))
            _card_name = self.layout.nickname

        # Add regular card name
        self.text.append(
            ScaledTextField(
                layer=self.text_layer_name,
                contents=_card_name,
                reference=self.name_reference
            ))

    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_shape[0])

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

    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_shape[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)

    """
    * Nickname Methods
    """

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

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

    """
    * 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