AdventureVectorMod

class AdventureVectorMod(AdventureMod, VectorTemplate):
    """
    * A vector template modifier for adding steps required for Adventure type cards introduced in Throne of Eldraine.

    Adds:
        * AdventureMod features.
        * Adventure textbox, pinline, wings, and titles.
    """

    # Color Maps
    """Maps color values to adventure name box."""
    adventure_name_color_map = {
        'W': [179, 172, 156],
        'U': [43, 126, 167],
        'B': [104, 103, 102],
        'R': [159, 83, 59],
        'G': [68, 96, 63],
        'Colorless': [],
        'Gold': [166, 145, 80],
        'Land': [177, 166, 169]
    }
    """Maps color values to adventure typeline box."""
    adventure_typeline_color_map = {
        'W': [129, 120, 103],
        'U': [3, 94, 127],
        'B': [44, 41, 40],
        'R': [124, 51, 33],
        'G': [11, 53, 30],
        'Colorless': [],
        'Gold': [117, 90, 40],
        'Land': [154, 137, 130]
    }
    """Maps color values to adventure typeline accent box."""
    adventure_typeline_accent_color_map = {
        'W': [90, 82, 71],
        'U': [2, 67, 96],
        'B': [20, 17, 19],
        'R': [81, 34, 22],
        'G': [2, 34, 16],
        'Colorless': [],
        'Gold': [75, 62, 37],
        'Land': [115, 98, 89]
    }
    """Maps color values to adventure wings."""
    adventure_wings_color_map = {
        'W': [213, 203, 181],
        'U': [181, 198, 213],
        'B': [162, 155, 152],
        'R': [192, 142, 115],
        'G': [174, 174, 155],
        'Colorless': [],
        'Gold': [196, 172, 131],
        'Land': [194, 178, 177]
    }

    """
    * Mixin Methods
    """

    @auto_prop_cached
    def frame_layer_methods(self) -> list[Callable]:
        """Add Adventure frame layers step."""
        funcs = [self.enable_adventure_layers] if isinstance(self.layout, AdventureLayout) else []
        return [*super().frame_layer_methods, *funcs]

    """
    * Groups
    """

    @auto_prop_cached
    def textbox_group(self) -> LayerSet:
        """LayerSet: Use right page of storybook as main textbox group."""
        return psd.getLayerSet(LAYERS.RIGHT, self.adventure_group)

    """
    * Adventure Groups
    """

    @auto_prop_cached
    def adventure_group(self) -> LayerSet:
        """Adventure storybook group."""
        return psd.getLayerSet(LAYERS.STORYBOOK)

    @auto_prop_cached
    def adventure_pinlines_group(self) -> LayerSet:
        """Pinline at the bottom of adventure storybook."""
        return psd.getLayerSet(LAYERS.PINLINES, self.adventure_group)

    @auto_prop_cached
    def adventure_textbox_group(self) -> LayerSet:
        """Left side storybook page, contains adventure text."""
        return psd.getLayerSet(LAYERS.LEFT, self.adventure_group)

    @auto_prop_cached
    def adventure_name_group(self) -> LayerSet:
        """Plate to color for adventure name."""
        return psd.getLayerSet(LAYERS.ADVENTURE_NAME, self.adventure_group)

    @auto_prop_cached
    def adventure_typeline_group(self) -> LayerSet:
        """Plate to color for adventure typeline."""
        return psd.getLayerSet(LAYERS.ADVENTURE_TYPELINE, self.adventure_group)

    @auto_prop_cached
    def adventure_typeline_accent_group(self) -> LayerSet:
        """Plate to color for adventure typeline accent."""
        return psd.getLayerSet(LAYERS.ADVENTURE_TYPELINE_ACCENT, self.adventure_group)

    @auto_prop_cached
    def adventure_wings_group(self) -> LayerSet:
        """Group containing wings on each side of adventure storybook."""
        return psd.getLayerSet(LAYERS.WINGS, self.adventure_group)

    """
    * Adventure Colors
    """

    @auto_prop_cached
    def adventure_textbox_colors(self) -> str:
        """Colors to use for adventure textbox textures."""
        return self.layout.adventure_colors

    @auto_prop_cached
    def adventure_name_colors(self) -> list[int]:
        """Colors to use for adventure name box."""
        return self.adventure_name_color_map.get(self.layout.adventure_colors)

    @auto_prop_cached
    def adventure_typeline_colors(self) -> list[int]:
        """Colors to use for adventure typeline box."""
        return self.adventure_typeline_color_map.get(self.layout.adventure_colors)

    @auto_prop_cached
    def adventure_typeline_accent_colors(self) -> list[int]:
        """Colors to use for adventure typeline accent box."""
        return self.adventure_typeline_accent_color_map.get(self.layout.adventure_colors)

    @auto_prop_cached
    def adventure_wings_colors(self) -> Union[list[int], list[dict]]:
        """Colors to use for adventure wings."""
        return psd.get_pinline_gradient(
            self.identity if 1 < len(self.identity) < self.color_limit else self.pinlines,
            color_map=self.adventure_wings_color_map)

    """
    * Adventure Blending Masks
    """

    @auto_prop_cached
    def adventure_textbox_masks(self) -> list[ArtLayer]:
        """Masks to use for adventure textbox texture blending."""
        return []

    @auto_prop_cached
    def textbox_masks(self) -> list[ArtLayer]:
        return [psd.getLayer(LAYERS.HALF, [LAYERS.MASKS, LAYERS.RIGHT])]

    """
    * Adventure Frame Methods
    """

    def enable_adventure_layers(self) -> None:
        """Add and modify layers required for Adventure cards."""

        # Pinlines
        self.generate_layer(
            group=self.adventure_pinlines_group,
            colors=self.pinlines_colors)

        # Wings
        self.generate_layer(
            group=self.adventure_wings_group,
            colors=self.adventure_wings_colors)

        # textbox
        self.generate_layer(
            group=self.adventure_textbox_group,
            colors=self.adventure_textbox_colors,
            masks=self.adventure_textbox_masks)

        # Adventure Name
        self.generate_layer(
            group=self.adventure_name_group,
            colors=self.adventure_name_colors)

        # Adventure Typeline
        self.generate_layer(
            group=self.adventure_typeline_group,
            colors=self.adventure_typeline_colors)

        # Adventure Accent
        self.generate_layer(
            group=self.adventure_typeline_accent_group,
            colors=self.adventure_typeline_accent_colors)