mtg_card_maker 0.1.0

data/lib/mtg_card_maker/metallic_renderer.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # Mixin for metallic rendering logic shared by multiple layers
+  module MetallicRenderer
+    # Parameter validation and sharing class for metallic rendering
+    class MetallicRenderParams
+      attr_reader :mask, :corners, :bottom_margin, :opacity, :geometry_params
+
+      def initialize(config_params = {})
+        @mask = config_params[:mask]
+        @corners = config_params[:corners] || LayerConfig.default.corner_radius(:inner)
+        @bottom_margin = config_params[:bottom_margin] || 0
+        @opacity = config_params[:opacity] || {}
+        @geometry_params = config_params[:geometry] || {}
+      end
+
+      def texture_opacity
+        opacity[:texture] || 0.05
+      end
+
+      def shadow_opacity
+        opacity[:shadow] || 0.08
+      end
+
+      def shadow_offset
+        2
+      end
+
+      def shadow_corners
+        {
+          x: [corners[:x] - shadow_offset, 0].max,
+          y: [corners[:y] - shadow_offset, 0].max
+        }
+      end
+    end
+
+    # Entrypoint for metallic rendering
+    def render_metallic_elements(config_params = {})
+      params = MetallicRenderParams.new(config_params)
+
+      render_base_frame(params)
+      render_texture_overlay(params)
+      render_shadow(params)
+    end
+
+    private
+
+    def render_base_frame(params)
+      create_rect(
+        params.geometry_params,
+        params.bottom_margin,
+        params.mask,
+        params.corners,
+        fill: "url(##{SvgGradientService.metallic_highlight_gradient_id(color_scheme)})",
+        stroke: color_scheme.primary_color,
+        stroke_width: LayerConfig.default.stroke_width
+      )
+    end
+
+    def render_texture_overlay(params)
+      create_rect(
+        params.geometry_params,
+        params.bottom_margin,
+        params.mask,
+        params.corners,
+        fill: "url(##{SvgGradientService.metallic_pattern_id(color_scheme)})",
+        opacity: params.texture_opacity
+      )
+    end
+
+    def render_shadow(params)
+      shadow_attrs = shadow_attributes(params)
+      create_rect(
+        params.geometry_params,
+        params.bottom_margin,
+        params.mask,
+        params.corners,
+        **shadow_attrs
+      )
+    end
+
+    def shadow_attributes(params)
+      {
+        fill: "url(##{SvgGradientService.metallic_shadow_gradient_id(color_scheme)})",
+        opacity: params.shadow_opacity,
+        x_offset: params.shadow_offset,
+        y_offset: params.shadow_offset,
+        width_offset: params.shadow_offset * 2,
+        height_offset: params.shadow_offset * 2,
+        rx: params.shadow_corners[:x],
+        ry: params.shadow_corners[:y]
+      }
+    end
+
+    def create_rect(geometry_params, bottom_margin, mask, corners, **attributes)
+      rect_attributes = build_rect_attributes(geometry_params, bottom_margin, mask, corners, attributes)
+      svg.rect(**rect_attributes)
+    end
+
+    def build_rect_attributes(geometry_params, bottom_margin, mask, corners, attributes)
+      geometry = extract_geometry(geometry_params)
+      offsets = extract_offsets(attributes)
+      base_attrs = {
+        x: rect_x(geometry, offsets),
+        y: rect_y(geometry, offsets),
+        width: rect_width(geometry, offsets),
+        height: rect_height(geometry, bottom_margin, offsets),
+        mask: mask ? "url(##{mask})" : nil,
+        rx: attributes[:rx] || corners[:x],
+        ry: attributes[:ry] || corners[:y]
+      }.compact
+      # Merge in all other SVG attributes (fill, opacity, stroke, etc.)
+      base_attrs.merge!(attributes)
+      base_attrs
+    end
+
+    def rect_x(geometry, offsets)
+      geometry[:x] + geometry[:padding] + offsets[:x]
+    end
+
+    def rect_y(geometry, offsets)
+      geometry[:y] + geometry[:padding] + offsets[:y]
+    end
+
+    def rect_width(geometry, offsets)
+      geometry[:width] - (geometry[:padding] * 2) - offsets[:width]
+    end
+
+    def rect_height(geometry, bottom_margin, offsets)
+      geometry[:height] - bottom_margin - offsets[:height]
+    end
+
+    def extract_geometry(geometry_params)
+      layer_config = LayerConfig.default
+      {
+        x: geometry_x(geometry_params),
+        y: geometry_y(geometry_params),
+        width: geometry_width(geometry_params),
+        height: geometry_height(geometry_params),
+        padding: geometry_padding(geometry_params, layer_config)
+      }
+    end
+
+    def geometry_x(geometry_params)
+      geometry_params[:x] || (respond_to?(:x) ? x : 0)
+    end
+
+    def geometry_y(geometry_params)
+      geometry_params[:y] || (respond_to?(:y) ? y : 0)
+    end
+
+    def geometry_width(geometry_params)
+      geometry_params[:width] || (respond_to?(:width) ? width : 0)
+    end
+
+    def geometry_height(geometry_params)
+      geometry_params[:height] || (respond_to?(:height) ? height : 0)
+    end
+
+    def geometry_padding(geometry_params, layer_config)
+      geometry_params[:padding] || layer_config.horizontal_padding
+    end
+
+    def extract_offsets(attributes)
+      {
+        x: attributes.delete(:x_offset) || 0,
+        y: attributes.delete(:y_offset) || 0,
+        width: attributes.delete(:width_offset) || 0,
+        height: attributes.delete(:height_offset) || 0
+      }
+    end
+  end
+end

data/lib/mtg_card_maker/sprite_sheet_assets.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # Handles the creation of shared assets (fonts, gradients, masks) for sprite sheets
+  class SpriteSheetAssets
+    def initialize
+      @color_schemes = build_color_schemes
+    end
+
+    # Add all shared assets to the sprite sheet XML
+    def add_assets_to_sprite(xml)
+      add_sprite_styles(xml)
+      add_sprite_masks(xml)
+      add_sprite_gradients(xml)
+    end
+
+    private
+
+    def add_sprite_styles(xml)
+      xml.defs do
+        xml.style(type: 'text/css') do
+          xml.cdata <<~CSS
+            @font-face {
+              font-family: 'Goudy Mediaeval DemiBold';
+              src: url('fonts/Goudy Mediaeval DemiBold.ttf') format('truetype');
+              font-weight: normal;
+              font-style: normal;
+            }
+
+            .card-name {
+              font-family: 'Goudy Mediaeval DemiBold', serif;
+              font-weight: normal;
+              font-style: normal;
+            }
+
+            .card-type {
+              font-family: 'Goudy Mediaeval DemiBold', serif;
+              font-weight: normal;
+              font-style: normal;
+            }
+
+            .card-description {
+              font-family: serif;
+              font-weight: normal;
+              font-style: normal;
+            }
+
+            .card-flavor-text {
+              font-family: serif;
+              font-weight: normal;
+              font-style: italic;
+            }
+
+            .card-power-toughness {
+              font-family: serif;
+              font-weight: bold;
+              font-style: normal;
+            }
+
+            .mana-cost-text {
+              font-family: serif;
+              font-weight: normal;
+              font-style: normal;
+            }
+
+            .mana-cost-text-large {
+              font-family: serif;
+              font-weight: semibold;
+              font-style: normal;
+            }
+          CSS
+        end
+      end
+    end
+
+    def add_sprite_masks(xml)
+      xml.defs do
+        # Define the art window mask once for the entire sprite sheet
+        xml.mask(id: 'artWindowMask') do
+          # White rectangle covers the entire card (opaque)
+          xml.rect(x: 0, y: 0, width: '100%', height: '100%', fill: '#FFF')
+          # Black rectangle creates the transparent window at art position
+          art_config = BaseCard::DEFAULTS[:layers][:art_layer]
+          xml.rect(x: art_config[:x], y: art_config[:y],
+                   width: art_config[:width], height: art_config[:height],
+                   fill: '#000', rx: art_config[:corner_radius][:x], ry: art_config[:corner_radius][:y])
+        end
+      end
+    end
+
+    def add_sprite_gradients(xml)
+      # Define gradients for all color schemes using SvgGradientService
+      @color_schemes.each do |color_scheme|
+        SvgGradientService.define_standard_gradients(xml, color_scheme)
+        if SvgGradientService.metallic_properties?(color_scheme)
+          SvgGradientService.define_metallic_gradients(xml,
+                                                       color_scheme)
+        end
+      end
+    end
+
+    # Test compatibility methods - delegate to SvgGradientService
+    def define_gradient(xml, color_scheme, scheme_name, gradient_type, _color_methods)
+      case gradient_type
+      when 'card'
+        SvgGradientService.define_card_gradient(xml, color_scheme, scheme_name)
+      when 'frame'
+        SvgGradientService.define_frame_gradient(xml, color_scheme, scheme_name)
+      when 'name'
+        SvgGradientService.define_name_gradient(xml, color_scheme, scheme_name)
+      when 'description'
+        SvgGradientService.define_description_gradient(xml, color_scheme, scheme_name)
+      end
+    end
+
+    def define_metallic_gradients(xml, color_scheme, _scheme_name)
+      SvgGradientService.define_metallic_gradients(xml, color_scheme)
+    end
+
+    def define_metallic_highlight_gradient(xml, color_scheme, scheme_name)
+      SvgGradientService.define_metallic_highlight_gradient(xml, color_scheme, scheme_name)
+    end
+
+    def define_metallic_shadow_gradient(xml, color_scheme, scheme_name)
+      SvgGradientService.define_metallic_shadow_gradient(xml, color_scheme, scheme_name)
+    end
+
+    def define_metallic_pattern(xml, color_scheme, scheme_name)
+      SvgGradientService.define_metallic_pattern(xml, color_scheme, scheme_name)
+    end
+
+    def add_metallic_pattern_lines(xml, color_scheme)
+      SvgGradientService.add_metallic_pattern_lines(xml, color_scheme)
+    end
+
+    def add_metallic_pattern_circles(xml, color_scheme)
+      SvgGradientService.add_metallic_pattern_circles(xml, color_scheme)
+    end
+
+    def metallic_properties?(color_scheme)
+      SvgGradientService.metallic_properties?(color_scheme)
+    end
+
+    def build_color_schemes
+      # Define all possible color schemes to ensure coverage
+      [
+        ColorScheme.new(:colorless),
+        ColorScheme.new(:white),
+        ColorScheme.new(:blue),
+        ColorScheme.new(:black),
+        ColorScheme.new(:red),
+        ColorScheme.new(:green),
+        ColorScheme.new(:gold),
+        ColorScheme.new(:artifact)
+      ]
+    end
+  end
+end

data/lib/mtg_card_maker/sprite_sheet_builder.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module MtgCardMaker
+  # Handles the core construction of sprite sheets from individual card files
+  class SpriteSheetBuilder
+    attr_reader :cards_per_row, :spacing
+
+    def initialize(cards_per_row: 5, spacing: 30)
+      @cards_per_row = cards_per_row
+      @spacing = spacing
+    end
+
+    # Calculate sprite sheet dimensions
+    def sprite_dimensions(card_count)
+      return [0, 0] if card_count.zero?
+
+      cols = [card_count, @cards_per_row].min
+      rows = (card_count.to_f / @cards_per_row).ceil
+
+      width = (cols * CARD_WIDTH) + ((cols - 1) * @spacing)
+      height = (rows * CARD_HEIGHT) + ((rows - 1) * @spacing)
+
+      [width, height]
+    end
+
+    # Create the sprite sheet XML builder with assets and cards
+    def create_sprite_builder(width, height, card_files, assets)
+      Nokogiri::XML::Builder.new do |xml|
+        xml.svg(xmlns: 'http://www.w3.org/2000/svg',
+                viewBox: "0 0 #{width} #{height}",
+                width: width,
+                height: height) do
+          assets.add_assets_to_sprite(xml)
+          add_cards_to_sprite(xml, card_files)
+        end
+      end
+    end
+
+    # Write the sprite sheet to file
+    def write_sprite_file(output_file, builder)
+      File.write(output_file, builder.to_xml)
+    end
+
+    private
+
+    def add_cards_to_sprite(xml, card_files)
+      card_files.each_with_index do |file, index|
+        add_card_to_sprite(xml, file, index)
+      end
+    end
+
+    def add_card_to_sprite(xml, card_file, index)
+      position = calculate_card_position(index)
+      doc = load_card_document(card_file)
+      svg_element = doc.at_css('svg')
+
+      return unless svg_element
+
+      xml.g(transform: "translate(#{position[:x]}, #{position[:y]})") do
+        add_card_children(xml, svg_element)
+      end
+    end
+
+    def calculate_card_position(index)
+      row = index / @cards_per_row
+      col = index % @cards_per_row
+
+      {
+        x: col * (CARD_WIDTH + @spacing),
+        y: row * (CARD_HEIGHT + @spacing)
+      }
+    end
+
+    def load_card_document(card_file)
+      Nokogiri::XML(File.read(card_file.path))
+    end
+
+    def add_card_children(xml, svg_element)
+      excluded_elements = ['defs', 'style']
+      svg_element.children.each do |child|
+        next if excluded_elements.include?(child.name)
+        next if child.name&.start_with?('linearGradient', 'radialGradient', 'pattern')
+
+        xml.parent.add_child(child.dup)
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/sprite_sheet_service.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module MtgCardMaker
+  # Service for creating sprite sheets by generating individual cards
+  # and stitching them together using SpriteSheetBuilder and SpriteSheetAssets.
+  # This service handles the complete workflow from card configurations to
+  # final sprite sheet output, including temporary file management.
+  #
+  # @example
+  #   service = MtgCardMaker::SpriteSheetService.new(cards_per_row: 4, spacing: 30)
+  #   success = service.create_sprite_sheet(card_configs, 'output.svg')
+  #   width, height = service.sprite_dimensions(card_configs.length)
+  #
+  # @since 0.1.0
+  class SpriteSheetService
+    # @return [Integer] the number of cards per row in the sprite sheet
+    attr_reader :cards_per_row
+
+    # @return [Integer] the spacing between cards in pixels
+    attr_reader :spacing
+
+    # Initialize a new sprite sheet service
+    #
+    # @param cards_per_row [Integer] the number of cards per row (default: 5)
+    # @param spacing [Integer] the spacing between cards in pixels (default: 30)
+    def initialize(cards_per_row: 5, spacing: 30)
+      @cards_per_row = cards_per_row
+      @spacing = spacing
+      @builder = SpriteSheetBuilder.new(cards_per_row: cards_per_row, spacing: spacing)
+      @assets = SpriteSheetAssets.new
+    end
+
+    # Create a sprite sheet from an array of card configurations
+    #
+    # @param card_configs [Hash] the card configurations
+    # @param output_file [String] the output file path
+    # @return [Boolean] true if successful, false if no cards provided
+    # @raise [StandardError] if card generation or sprite creation fails
+    def create_sprite_sheet(card_configs, output_file)
+      return false if card_configs.empty?
+
+      begin
+        # Generate individual cards first
+        card_files = generate_individual_cards(card_configs)
+
+        # Stitch them together into a sprite sheet
+        stitch_cards_into_sprite(card_files, output_file)
+      ensure
+        # Clean up temporary files
+        cleanup_temp_files(card_files)
+      end
+    end
+
+    # Calculate sprite sheet dimensions for a given number of cards
+    #
+    # @param card_count [Integer] the number of cards in the sprite sheet
+    # @return [Array<Integer>] the width and height of the sprite sheet
+    def sprite_dimensions(card_count)
+      @builder.sprite_dimensions(card_count)
+    end
+
+    private
+
+    def generate_individual_cards(card_configs)
+      card_files = []
+
+      card_configs.values.each_with_index do |config, index|
+        card = card_from_config(config)
+        temp_file = save_card_to_temp_file(card, index)
+        card_files << temp_file
+      rescue StandardError => e
+        handle_card_generation_error(e, index, card_files)
+      end
+
+      card_files
+    end
+
+    def handle_card_generation_error(error, index, card_files)
+      cleanup_temp_files(card_files)
+      raise "❌ Error generating card #{index}: #{error.message}"
+    end
+
+    def card_from_config(config)
+      BaseCard.new(
+        name: config['name'],
+        mana_cost: config['mana_cost'],
+        type_line: config['type_line'],
+        rules_text: config['rules_text'],
+        flavor_text: config['flavor_text'],
+        power: config['power'],
+        toughness: config['toughness'],
+        color: config['color'],
+        border_color: config['border_color'],
+        art: config['art']
+      )
+    end
+
+    def save_card_to_temp_file(card, index)
+      temp_file = Tempfile.new(["card_#{index}", '.svg'])
+      card.save(temp_file.path)
+      temp_file
+    end
+
+    def stitch_cards_into_sprite(card_files, output_file)
+      width, height = sprite_dimensions(card_files.length)
+      builder = @builder.create_sprite_builder(width, height, card_files, @assets)
+      @builder.write_sprite_file(output_file, builder)
+      true
+    rescue StandardError => e
+      raise "❌ Error creating sprite sheet: #{e.message}"
+    end
+
+    def cleanup_temp_files(card_files)
+      return if card_files.nil?
+
+      card_files.each do |file|
+        file.close
+        file.unlink
+      rescue StandardError => e
+        warn "Warning: Could not clean up temp file #{file.path}: #{e.message}"
+      end
+    end
+  end
+end