mtg_card_maker 0.1.0

data/lib/mtg_card_maker/layers/name_layer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../mana_cost'
+
+module MtgCardMaker
+  # NameLayer is a specialized layer
+  # This is the area that surrounds the name and cost of the card
+  class NameLayer < BaseLayer
+    include LayerInitializer
+    attr_reader :name, :cost, :color_scheme
+
+    def initialize(dimensions:, name:, cost:, color: nil, color_scheme: DEFAULT_COLOR_SCHEME)
+      frame_color = initialize_layer_color(color, color_scheme, :background_color)
+      super(dimensions: dimensions, color: frame_color)
+      @name = name
+      @cost = cost
+      @color_scheme = color_scheme
+    end
+
+    def render
+      # Ensure gradients are defined for this color scheme
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+
+      svg.g do
+        render_name_area
+        render_card_name
+        render_mana_cost if cost && !cost.empty?
+      end
+    end
+
+    private
+
+    def render_name_area
+      layer_config = LayerConfig.default
+      stroke_width = layer_config.stroke_width
+      corners = layer_config.corner_radius(:name)
+
+      svg.rect x: x, y: y, width: width, height: height,
+               fill: "url(##{SvgGradientService.name_gradient_id(color_scheme)})",
+               stroke: ColorPalette::FRAME_STROKE_COLOR,
+               stroke_width: stroke_width,
+               rx: corners[:x], ry: corners[:y], mask: "url(##{@mask_id})"
+    end
+
+    def render_card_name
+      layer_config = LayerConfig.default
+      text_service = TextRenderingService.new(
+        text: name,
+        layer_config: layer_config,
+        x: layer_config.text_x_position(x),
+        y: layer_config.text_y_position(y, :name_area, height),
+        font_size: layer_config.font_size(:name),
+        available_width: layer_config.text_width(width, :name_area),
+        css_class: layer_config.css_class(:card_name)
+      )
+      lines = text_service.wrapped_text_lines
+      lines.each do |line, attrs|
+        svg.text line, attrs
+      end
+    end
+
+    def render_mana_cost
+      mana_cost = ManaCost.new(cost)
+      cost_x = cost_position_x(mana_cost)
+      cost_y = cost_position_y
+      svg.g transform: "translate(#{cost_x}, #{cost_y})" do
+        svg << mana_cost.to_svg
+      end
+    end
+
+    def cost_position_x(mana_cost)
+      layer_config = LayerConfig.default
+      config = layer_config.mana_cost_config
+      base_x = x + width - config[:margin] - config[:circle_radius]
+      base_x - (config[:circle_spacing] * (mana_cost.elements.length - 1))
+    end
+
+    def cost_position_y
+      y + (height / 2) - 2
+    end
+  end
+end

data/lib/mtg_card_maker/layers/power_layer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # PowerLayer is a specialized layer
+  # This is the area that surrounds the power and toughness of the card
+  class PowerLayer < BaseLayer
+    include LayerInitializer
+    attr_reader :power, :toughness, :color_scheme
+
+    def initialize(dimensions:, power:, toughness:, color: nil, color_scheme: DEFAULT_COLOR_SCHEME)
+      frame_color = initialize_layer_color(color, color_scheme, :background_color)
+      super(dimensions: dimensions, color: frame_color)
+      @power = power
+      @toughness = toughness
+      @color_scheme = color_scheme
+    end
+
+    def render
+      # Don't render if power or toughness are nil, empty, or invalid
+      return if power.nil? || toughness.nil? || power.to_s.strip.empty? || toughness.to_s.strip.empty?
+
+      # Ensure gradients are defined for this color scheme
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+
+      layer_config = LayerConfig.default
+      stroke_width = layer_config.stroke_width
+      corners = layer_config.corner_radius(:power)
+
+      svg.g do
+        # P/T box with ornate frame
+        svg.rect x: x_position, y: y, width: dynamic_width, height: height,
+                 fill: "url(##{SvgGradientService.name_gradient_id(color_scheme)})",
+                 stroke: ColorPalette::FRAME_STROKE_COLOR,
+                 stroke_width: stroke_width, rx: corners[:x], ry: corners[:y]
+
+        # P/T text with bold styling
+        cost_attrs = {
+          x:           x_position + (dynamic_width / 2),
+          y:           y + (height / 2) + layer_config.positioning(:power_area)[:y_offset],
+          fill:        DEFAULT_TEXT_COLOR,
+          font_size:   layer_config.font_size(:power_area),
+          text_anchor: 'middle',
+          class:       'card-power-toughness'
+        }
+        svg.text "#{power}/#{toughness}", cost_attrs
+      end
+    end
+
+    private
+
+    def dynamic_width
+      # Calculate total character count: power + toughness + "/"
+      total_chars = power.to_s.length + toughness.to_s.length + 1
+
+      # Base width for 3 characters, with steady increase per additional character
+      base_width = 60
+      width_per_char = 13
+      base_width + ((total_chars - 3) * width_per_char)
+    end
+
+    def x_position
+      # Anchor right side to card width (630px) with 35px margin
+      # Right edge should be at 595px (630 - 35)
+      margin = 35
+      right_edge = CARD_WIDTH - margin
+      right_edge - dynamic_width
+    end
+  end
+end

data/lib/mtg_card_maker/layers/text_box_layer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # TextBoxLayer is a specialized layer for the rules and flavor text
+  class TextBoxLayer < BaseLayer
+    include LayerInitializer
+    attr_reader :rules_text, :flavor_text, :color_scheme
+
+    def initialize(dimensions:, rules_text:, flavor_text: nil, color: nil, color_scheme: DEFAULT_COLOR_SCHEME)
+      frame_color = initialize_layer_color(color, color_scheme, :background_color)
+      super(dimensions: dimensions, color: frame_color)
+      @rules_text = rules_text
+      @flavor_text = flavor_text
+      @color_scheme = color_scheme
+    end
+
+    # Render the rules text and flavor text in a text box with a background and highlight
+    def render
+      # Ensure gradients are defined for this color scheme
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+
+      render_text_box
+    end
+
+    private
+
+    def render_text_box
+      layer_config = LayerConfig.default
+      stroke_width = layer_config.stroke_width
+
+      svg.g do
+        # Text box background with mask for transparent window
+        svg.rect x: x, y: y, width: width, height: height,
+                 fill: "url(##{SvgGradientService.description_gradient_id(color_scheme)})",
+                 stroke: color_scheme.primary_color,
+                 stroke_width: stroke_width
+
+        render_text_content
+      end
+    end
+
+    def render_text_content
+      render_rules_text
+      render_flavor_text if flavor_text
+    end
+
+    def render_rules_text
+      layer_config = LayerConfig.default
+      text_service = create_text_service(layer_config, rules_text, :description, :card_description)
+      render_text_lines(text_service)
+    end
+
+    def render_flavor_text
+      return unless flavor_text && !flavor_text.strip.empty?
+
+      render_flavor_separator
+      layer_config = LayerConfig.default
+      text_service = create_text_service(layer_config, flavor_text, :flavor_text, :flavor_text)
+      render_text_lines(text_service)
+    end
+
+    def create_text_service(layer_config, text, text_type, css_class)
+      TextRenderingService.new(
+        text: text,
+        layer_config: layer_config,
+        x: layer_config.text_x_position(x),
+        y: calculate_text_y_position(layer_config, text_type),
+        font_size: layer_config.font_size(text_type),
+        color: color_scheme.text_color,
+        available_width: layer_config.text_width(width, text_type),
+        css_class: layer_config.css_class(css_class)
+      )
+    end
+
+    def calculate_text_y_position(layer_config, text_type)
+      if text_type == :flavor_text
+        y + height - layer_config.positioning(:flavor_text)[:y_offset]
+      else
+        layer_config.text_y_position(y, :description)
+      end
+    end
+
+    def render_text_lines(text_service)
+      text_service.wrapped_text_lines.each do |line, attrs|
+        svg.text line, attrs
+      end
+    end
+
+    def render_flavor_separator
+      svg.line(**separator_config)
+    end
+
+    def separator_config
+      layer_config = LayerConfig.default
+      separator_offset = layer_config.positioning(:flavor_text)[:separator_offset]
+      separator_y = y + height - separator_offset
+      {
+        x1: layer_config.text_x_position(x),
+        y1: separator_y,
+        x2: x + width - layer_config.horizontal_padding,
+        y2: separator_y,
+        stroke: color_scheme.primary_color,
+        stroke_width: 1
+      }
+    end
+  end
+end

data/lib/mtg_card_maker/layers/type_line_layer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # TypeLineLayer is a specialized layer for the type of the card
+  # This is the small area in the center of the card below the artwork
+  class TypeLineLayer < BaseLayer
+    include LayerInitializer
+    attr_reader :type_line, :color_scheme
+
+    def initialize(dimensions:, type_line:, color: nil, color_scheme: DEFAULT_COLOR_SCHEME)
+      frame_color = initialize_layer_color(color, color_scheme, :background_color)
+      super(dimensions: dimensions, color: frame_color)
+      @type_line = type_line
+      @color_scheme = color_scheme
+    end
+
+    def render
+      # Ensure gradients are defined for this color scheme
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+
+      svg.g do
+        render_type_background
+        render_type_line
+        render_type_icon
+      end
+    end
+
+    private
+
+    def render_type_background
+      layer_config = LayerConfig.default
+      stroke_width = layer_config.stroke_width
+      corners = layer_config.corner_radius(:type)
+
+      svg.rect x: x, y: y, width: width, height: height,
+               fill: "url(##{color_scheme.scheme_name}_name_gradient)",
+               stroke: ColorPalette::FRAME_STROKE_COLOR,
+               stroke_width: stroke_width,
+               rx: corners[:x], ry: corners[:y]
+    end
+
+    def render_type_icon
+      layer_config = LayerConfig.default
+      icon_config = layer_config.type_icon_config
+
+      svg.path stroke_width: 3,
+               d: jsharp_path_data,
+               fill: 'none',
+               stroke: ColorPalette::FRAME_STROKE_COLOR,
+               transform: build_icon_transform(icon_config),
+               'aria-label': 'J#'
+    end
+
+    def jsharp_path_data
+      jsharp_svg = IconService.new.jsharp_svg
+      raise 'J# icon not found' unless jsharp_svg
+
+      path_match = jsharp_svg.match(/<path[^>]*d="([^"]*)"[^>]*>/)
+      path_match&.[](1)
+    end
+
+    def build_icon_transform(icon_config)
+      translate_part = "translate(#{width - icon_config[:x_offset]},#{y + icon_config[:y_offset]})"
+      scale_part = "scale(#{icon_config[:scale]})"
+      aspect_part = "scale(#{icon_config[:aspect_ratio][:x]},#{icon_config[:aspect_ratio][:y]})"
+
+      "#{translate_part} #{scale_part} #{aspect_part}"
+    end
+
+    def render_type_line
+      layer_config = LayerConfig.default
+      text_service = TextRenderingService.new(
+        text: type_line,
+        layer_config: layer_config,
+        x: layer_config.text_x_position(x),
+        y: layer_config.text_y_position(y, :type_area, height),
+        font_size: layer_config.font_size(:type),
+        available_width: layer_config.text_width(width, :type_area),
+        css_class: layer_config.css_class(:card_type)
+      )
+      text_service.wrapped_text_lines.each do |line, attrs|
+        svg.text line, attrs
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/mana_cost.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative 'icon_service'
+
+module MtgCardMaker
+  # Mana cost class that generates SVG for the mana cost of a card.
+  # This class parses mana cost strings (e.g., "2UR", "XG") and generates
+  # SVG circles with appropriate colors and icons for each mana symbol.
+  #
+  # @example
+  #   mana_cost = MtgCardMaker::ManaCost.new("2UR")
+  #   svg = mana_cost.to_svg
+  #
+  # @example
+  #   mana_cost = MtgCardMaker::ManaCost.new("XG", icon_set: :custom)
+  #   svg = mana_cost.to_svg
+  #
+  # @since 0.1.0
+  # rubocop:disable Metrics/ClassLength
+  class ManaCost
+    # Mapping of letters to colors
+    # @return [Hash] the color mapping for mana symbols
+    COLOR_MAP = {
+      'B' => :black, 'S' => :black,
+      'U' => :blue,  'I' => :blue,
+      'G' => :green, 'F' => :green,
+      'W' => :white, 'P' => :white,
+      'R' => :red,   'M' => :red,
+      'C' => :colorless
+    }.freeze
+
+    # @return [Array<Symbol>] the parsed mana elements
+    attr_reader :elements
+
+    # @return [Integer, nil] the integer value for generic mana
+    attr_reader :int_val
+
+    # Initialize a new mana cost parser
+    #
+    # @param mana_string [String, nil] the mana cost string (e.g., "2UR", "XG")
+    # @param icon_set [Symbol] the icon set to use (default: :default)
+    def initialize(mana_string = nil, icon_set = :default) # rubocop:disable Metrics/MethodLength
+      @elements = []
+      @origins = [] # :numeric, :C, or color symbol
+      @int_val = nil
+      @original_string = mana_string
+      @icon_service = IconService.new(icon_set)
+
+      return if mana_string.nil? || mana_string.empty?
+
+      # Convert to uppercase for consistency
+      mana_string = mana_string.to_s.upcase
+
+      # Parse the mana string
+      parse_mana_string(mana_string)
+
+      # Limit to maximum circles
+      layer_config = LayerConfig.default
+      max_circles = layer_config.mana_cost_config[:max_circles]
+      @elements = @elements.first(max_circles)
+      @origins = @origins.first(max_circles)
+    end
+
+    # Returns SVG string for the mana cost circles with drop shadow
+    #
+    # @return [String] the SVG markup for the mana cost
+    def to_svg
+      layer_config = LayerConfig.default
+      circle_spacing = layer_config.mana_cost_config[:circle_spacing]
+
+      # Build mana cost circles SVG
+      mana_circles = @elements.each_with_index.map do |color, i|
+        x = i * circle_spacing
+        y = 0
+        mana_element_svg(x, y, color, @origins[i])
+      end.join
+
+      <<~SVG.delete("\n")
+        #{drop_shadow_filter}
+        <g filter="url(#mana-cost-drop-shadow)">
+        #{mana_circles}
+        </g>
+      SVG
+    end
+
+    private
+
+    def parse_mana_string(mana_string)
+      return if mana_string.nil?
+
+      if numeric_cost?(mana_string) || mana_string.start_with?('X')
+        parse_numeric_cost(mana_string)
+      else
+        parse_colored_mana(mana_string)
+      end
+    end
+
+    def numeric_cost?(mana_string)
+      mana_string.match?(/^\d+/)
+    end
+
+    def parse_numeric_cost(mana_string)
+      mana_string = mana_string.gsub(/^X/, '10')
+
+      int_match = mana_string.match(/^(\d+)/)
+      @int_val = int_match[1].to_i
+
+      # If it's a double-digit number, treat as X
+      @int_val = 10 if @int_val >= 10
+
+      @elements << :colorless
+      @origins << :numeric
+
+      # Remove the integer and parse remaining colored mana
+      remaining = mana_string[int_match[1].length..]
+      parse_colored_mana(remaining)
+    end
+
+    def parse_colored_mana(mana_string)
+      return if mana_string.nil? || mana_string.empty?
+
+      mana_string.chars.each do |char|
+        process_colored_character(char)
+      end
+    end
+
+    def process_colored_character(char)
+      color = COLOR_MAP[char]
+      if colorless_symbol?(color, char)
+        @elements << :colorless
+        @origins << :C
+      elsif color
+        @elements << color
+        @origins << color
+      end
+    end
+
+    def colorless_symbol?(color, char)
+      color == :colorless && char == 'C'
+    end
+
+    def drop_shadow_filter
+      layer_config = LayerConfig.default
+      drop_shadow = layer_config.drop_shadow_config
+      <<~SVG.delete("\n")
+        <defs>
+        <filter id="mana-cost-drop-shadow"
+                x="-50%"
+                y="-50%"
+                width="200%"
+                height="200%">
+        <feDropShadow dx="#{drop_shadow[:dx]}"
+                      dy="#{drop_shadow[:dy]}"
+                      stdDeviation="#{drop_shadow[:std_deviation]}"
+                      flood-color="black"
+                      flood-opacity="#{drop_shadow[:flood_opacity]}"/>
+        </filter>
+        </defs>
+      SVG
+    end
+
+    def mana_element_svg(x, y, color, origin) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      layer_config = LayerConfig.default
+      circle_radius = layer_config.mana_cost_config[:circle_radius]
+      icon_size = layer_config.mana_cost_config[:icon_size]
+
+      fill = svg_color(color)
+      svg = "<circle cx='#{x}' cy='#{y}' r='#{circle_radius}' fill='#{fill}' />"
+
+      if color == :colorless && origin == :numeric
+        # Add text for numeric colorless mana circles
+        svg << colorless_text(x, y, origin)
+      else
+        # Add icon inside colored mana circles, smaller and with opacity
+        icon_svg = @icon_service.icon_svg(color, size: icon_size)
+        if icon_svg
+          icon_x = x - (icon_size / 2)
+          icon_y = y - (icon_size / 2)
+          layer_config = LayerConfig.default
+          opacity = layer_config.mana_cost_icon_opacity
+          svg << "<g transform='translate(#{icon_x}, #{icon_y})' opacity='#{opacity}'>#{icon_svg}</g>"
+        end
+      end
+
+      svg
+    end
+
+    def colorless_text(x, y, origin)
+      if origin == :numeric && @int_val
+        text = @int_val == 10 ? 'X' : @int_val.to_s
+        text_svg(x, y, text)
+      else
+        ''
+      end
+    end
+
+    def text_svg(x, y, text)
+      # Position text in the center of the circle with appropriate styling
+      layer_config = LayerConfig.default
+      font_size = layer_config.mana_cost_font_size
+      font_weight = text == 'X' ? 'normal' : 'semibold'
+      y_offset = layer_config.mana_cost_text_y_offset
+
+      "<text x='#{x}' y='#{y + y_offset}' fill='#000' text-anchor='middle' " \
+        "font-weight='#{font_weight}' font-size='#{font_size}' font-family='serif'>#{text}</text>"
+    end
+
+    def svg_color(color)
+      case color
+      when :white then '#FFF9C4'  # White primary color
+      when :blue then '#90CAF9'   # Blue primary color (from fixture)
+      when :black then '#BDBDBD'  # Black primary color (from fixture)
+      when :red then '#EF9A9A'    # Red primary color (from fixture)
+      when :green then '#A5D6A7'  # Green primary color (from fixture)
+      else '#DDD'
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end